io.reactivex.observers.DisposableCompletableObserver#io.realm.Realm源码实例Demo

/**
 * 是否常用联系人
 *
 * @param owner
 * @param person
 * @return
 */
public Observable<Boolean> isUsuallyPerson(final String owner, final String person) {
    return RealmObservable.object(new Func1<Realm, Boolean>() {
        @Override
        public Boolean call(Realm realm) {
            String unitId = O2SDKManager.Companion.instance().prefs().getString(O2.INSTANCE.getPRE_BIND_UNIT_ID_KEY(), "");
            RealmResults<UsuallyPersonRealmObject> results = realm
                    .where(UsuallyPersonRealmObject.class).equalTo("owner", owner)
                    .equalTo("person", person).equalTo("unitId", unitId).findAll();
            if (results != null && results.size() > 0) {
                return true;
            }
            return false;
        }
    });
}
 

/**
 * 查询所有不是归档的Room
 *
 * @return 查询到的所有数据
 */
public List<Room> getRoomOnNotArchivedWithCurrentThread() {
    List<Room> rooms = new ArrayList<>();
    Realm realm = RealmProvider.getInstance();
    try {
        realm.beginTransaction();
        RealmResults<Room> realmResults = realm.where(Room.class)
                .equalTo(Room.TEAM_ID, BizLogic.getTeamId())
                .equalTo(Room.IS_ARCHIVED, false)
                .findAll();
        realmResults.sort(Room.PINYIN, Sort.ASCENDING);
        for (int i = 0; i < realmResults.size(); i++) {
            Room room = new Room();
            copy(room, realmResults.get(i));
            rooms.add(room);
        }
        realm.commitTransaction();
    } catch (Exception e) {
        e.printStackTrace();
        realm.cancelTransaction();
    } finally {
        realm.close();
    }
    return rooms;
}
 

public static String report(String key) {
    if (LazyHolder.instance.open > 0) Log.w(TAG, "report called while stats are open [open=" + LazyHolder.instance.open + "]");

    StringBuilder sb = new StringBuilder();

    Class[] classes = STAT_CLASSES;

    Realm storeRealm = Realm.getInstance(UploaderApplication.getStoreConfiguration());

    for (Class clazz : classes) {
        StatInterface record = (StatInterface) storeRealm.where(clazz)
                .equalTo("key", key)
                .findFirst();
        if (record != null) {
            sb.append(sb.length() > 0 ? " [" : "[");
            sb.append(clazz.getSimpleName());
            sb.append("] ");
            sb.append(record.toString());
        }
    }

    storeRealm.close();
    return sb.toString();
}
 

public String getTokenImageUrl(int networkId, String address)
{
    String url = "";
    String instanceKey = address.toLowerCase() + "-" + networkId;
    try (Realm realm = realmManager.getAuxRealmInstance(IMAGES_DB))
    {
        RealmAuxData instance = realm.where(RealmAuxData.class)
                .equalTo("instanceKey", instanceKey)
                .findFirst();

        if (instance != null)
        {
            url = instance.getResult();
        }
    }
    catch (Exception ex)
    {
        ex.printStackTrace();
    }

    return url;
}
 

@Before
public void setUp() throws KeyStoreException {
    Realm.init(InstrumentationRegistry.getTargetContext());

    // This will set the 'm_metadata_manager' in 'sync_manager.cpp' to be 'null'
    // causing the SyncUser to remain in memory.
    // They're actually not persisted into disk.
    // move this call to `tearDown` to clean in-memory & on-disk users
    // once https://github.com/realm/realm-object-store/issues/207 is resolved
    TestHelper.resetSyncMetadata();

    RealmConfiguration realmConfig = configFactory.createConfiguration();
    realm = Realm.getInstance(realmConfig);

    userStore = new SecureUserStore(InstrumentationRegistry.getTargetContext());
    assertTrue("KeyStore Should be Unlocked before running tests on device!", userStore.isKeystoreUnlocked());
    SyncManager.setUserStore(userStore);
}
 

public static void executeTransaction(Action1<Realm> transaction, Action1<Throwable> onFailure) {
    Realm realm = null;

    try {
        realm = Realm.getDefaultInstance();
        realm.beginTransaction();

        transaction.call(realm);

        realm.commitTransaction();
    } catch (Exception e) {
        if (realm != null) {
            realm.cancelTransaction();
        }
        onFailure.call(e);
    } finally {
        if (realm != null) {
            realm.close();
        }
    }
}
 

public void reset() {
    historyRealm.executeTransaction(new Realm.Transaction() {
        @Override
        public void execute(@NonNull Realm realm) {

            int count = 0;
            for (DBitem dBitem : historyDB) {
                RealmResults<PumpHistoryInterface> records = dBitem.results.where().findAll();
                count += records.size();
                records.deleteAllFromRealm();
            }

            Log.d(TAG, "reset history database: deleted " + count + " history records");

            final RealmResults<HistorySegment> segment = historyRealm
                    .where(HistorySegment.class)
                    .findAll();
            segment.deleteAllFromRealm();

            Log.d(TAG, "reset history segments: deleted " + segment.size() + " segment records");
        }
    });
}
 

/**
 * Posts the RealmBlock to the Monarchy thread, and executes it there.
 *
 * @param realmBlock the Realm block
 * @throws IllegalStateException if the Monarchy thread is not open
 */
public void postToMonarchyThread(final RealmBlock realmBlock) {
    final Handler _handler = handler.get();
    if(_handler == null) {
        throw new IllegalStateException("Cannot post to Monarchy thread when the Monarchy thread is not open.");
    } else {
        _handler.post(new Runnable() {
            @Override
            public void run() {
                Realm realm = realmThreadLocal.get();
                checkRealmValid(realm);
                realmBlock.doWithRealm(realm);
            }
        });
    }
}
 

public void loadMovie(final int id, final ReadCallback<Movie> callback) {
    if (BuildConfig.DEBUG) {
        Log.d(TAG, "[READ ] Load Movie with id = " + id);
    }
    readAllAsync(new ReadAction<Movie>() {
        @NonNull
        @Override
        public RealmQuery<Movie> getQuery(@NonNull Realm realm) {
            return realm.where(Movie.class).equalTo("id", id);
        }

        @Override
        public void onResults(RealmResults<Movie> results) {
            if (!results.isEmpty()) {
                if (BuildConfig.DEBUG) {
                    Log.d(TAG, "[READ ] Success: Movie with id = " + id);
                }
                callback.done(AppUtil.copy(results.first(), Movie.class));
            } else {
                callback.failed(new RuntimeException("No Movie found with id = " + id));
            }
        }
    });
}
 

public List<Team> getTeamWithCurrentThread() {
    final List<Team> teams = new ArrayList<>();
    Realm realm = RealmProvider.getInstance();
    try {
        realm.beginTransaction();
        RealmResults<Team> realmResults = realm.where(Team.class).findAll();
        for (int i = 0; i < realmResults.size(); i++) {
            Team teamInfo = new Team();
            copy(teamInfo, realmResults.get(i));
            teams.add(teamInfo);
        }
        realm.commitTransaction();
    } catch (Exception e) {
        e.printStackTrace();
        realm.cancelTransaction();
    } finally {
        realm.close();
    }
    return teams;
}
 

public Observable<List<Room>> getToJoinRooms() {
    return Observable.create(new OnSubscribeRealm<List<Room>>() {
        @Override
        public List<Room> get(Realm realm) {
            List<Room> rooms = new ArrayList<>();
            RealmResults<Room> realmResults = realm.where(Room.class)
                    .equalTo(Room.TEAM_ID, BizLogic.getTeamId())
                    .equalTo(Room.IS_ARCHIVED, false)
                    .equalTo(Room.IS_QUIT, true)
                    .findAll();
            realmResults.sort(Room.PINYIN, Sort.ASCENDING);
            for (int i = 0; i < realmResults.size(); i++) {
                Room room = new Room();
                copy(room, realmResults.get(i));
                rooms.add(room);
            }
            return rooms;
        }
    });
}
 

@Override
public void onCreate() {
    super.onCreate();

    // initialize the database
    RealmConfiguration.Builder realmConfigurationBuilder = new RealmConfiguration.Builder(this)
            .name(Realm.DEFAULT_REALM_NAME)
            .schemaVersion(DB_SCHEMA_VERSION);
    if (BuildConfig.DEBUG) {
        realmConfigurationBuilder.deleteRealmIfMigrationNeeded();
    }
    RealmConfiguration realmConfiguration = realmConfigurationBuilder.build();
    Realm.setDefaultConfiguration(realmConfiguration);

    // setup the Model so it can listen for and handle requests for data
    // hold a reference to it, to save it from GC
    mModel = new Model();

    enableStrictMode();
}
 

public void addAndUpdateWithCurrentThread(final Team team) {
    Realm realm = RealmProvider.getInstance();
    try {
        realm.beginTransaction();
        Team realmTeam = realm.where(Team.class).equalTo(Team.ID, team.get_id()).findFirst();
        if (realmTeam == null) {
            realmTeam = realm.createObject(Team.class);
        }
        copy(realmTeam, team);
        realm.commitTransaction();
    } catch (Exception e) {
        e.printStackTrace();
        realm.cancelTransaction();
    } finally {
        realm.close();
    }
}
 

public List<Member> getNotQuitAndNotRobotMemberWithCurrentThread() {
    final List<Member> members = new ArrayList<>();
    Realm realm = RealmProvider.getInstance();
    try {
        realm.beginTransaction();
        RealmResults<Member> realmResults = realm.where(Member.class)
                .equalTo(Member.TEAM_ID, BizLogic.getTeamId())
                .equalTo(Member.IS_QUIT, false)
                .equalTo(Member.IS_ROBOT, false)
                .findAll();
        realmResults.sort(Member.ALIAS_PINYIN, Sort.ASCENDING);
        for (Member realmResult : realmResults) {
            Member member = new Member();
            copy(member, realmResult);
            members.add(member);
        }
        realm.commitTransaction();
    } catch (Exception e) {
        e.printStackTrace();
        realm.cancelTransaction();
    } finally {
        realm.close();
    }
    return members;
}
 

public static RealmRoomMessageWallet put(final ProtoGlobal.RoomMessageWallet input) {
    Realm realm = Realm.getDefaultInstance();
    RealmRoomMessageWallet messageWallet = null;
    messageWallet = realm.createObject(RealmRoomMessageWallet.class, AppUtils.makeRandomId());

    messageWallet.setType(input.getType().toString());
    messageWallet.setFromUserId(input.getMoneyTransfer().getFromUserId());
    messageWallet.setToUserId(input.getMoneyTransfer().getToUserId());
    messageWallet.setAmount(input.getMoneyTransfer().getAmount());
    messageWallet.setTraceNumber(input.getMoneyTransfer().getTraceNumber());
    messageWallet.setInvoiceNumber(input.getMoneyTransfer().getInvoiceNumber());
    messageWallet.setPayTime(input.getMoneyTransfer().getPayTime());
    messageWallet.setDescription(input.getMoneyTransfer().getDescription());

    realm.close();

    return messageWallet;
}
 

@SuppressWarnings("UnusedParameters")
    private void initInstances(View rootView, Bundle savedInstanceState) {
        // Init 'View' instance(s) with rootView.findViewById here
        // Note: State of variable initialized here could not be saved
        //       in onSavedInstanceState
        realm = Realm.getDefaultInstance();
        RealmResults<StudentModuleDao> studentModuleDao = realm.getDefaultInstance().where(StudentModuleDao.class).equalTo("day","Sat", Case.SENSITIVE).findAll();
        if (studentModuleDao.size()!=0) {

            LinearLayoutManager rvLayoutManager = new LinearLayoutManager(getContext());
            b.rvSaturdayTimeTable.setLayoutManager(rvLayoutManager);
            mTimeTableListAdapter = new TimeTableListAdapter(getContext(), studentModuleDao, true);
            b.rvSaturdayTimeTable.setAdapter(mTimeTableListAdapter);
            b.rvSaturdayTimeTable.setHasFixedSize(true);

        } else {

            b.rvSaturdayTimeTable.setVisibility(View.GONE);
            b.satNoModuleText.setText("You are free today");
            b.satNoModuleText.setVisibility(View.VISIBLE);

        }

//        connectToDataBase();

    }
 

@SuppressWarnings("unchecked")
@WorkerThread
@Override
public List<T> loadRange(final int startPosition, final int count) {
    final int countItems = countItems();
    if(countItems == 0) {
        return Collections.emptyList();
    }
    final List<T> list = new ArrayList<>(count);
    monarchy.doWithRealm(new Monarchy.RealmBlock() {
        @Override
        public void doWithRealm(Realm realm) {
            RealmResults<T> results = (RealmResults<T>) monarchy.resultsRefs.get().get(liveResults);
            for(int i = startPosition; i < startPosition + count && i < countItems; i++) {
                // noinspection ConstantConditions
                list.add(realm.copyFromRealm(results.get(i)));
            }
        }
    });

    return Collections.unmodifiableList(list);
}
 

public static boolean isPromote(Long id) {
    Realm realm = Realm.getDefaultInstance();
    RealmRoom realmRoom = realm.where(RealmRoom.class).equalTo(RealmRoomFields.ID, id).findFirst();
    if (realmRoom != null) {
        return realmRoom.isFromPromote();
    }
    realm.close();
    return false;
}
 

protected Realm getRealm() {
    try {
        if (mRealm.isClosed()) {
            mRealm = RealmManager.getInstance().getRealm();
        }
    } catch (Throwable e) {
        mRealm = RealmManager.getInstance().getRealm();
    }
    return mRealm;
}
 

public static Token getSessionToken(Realm instance) {
    User user = getSessionUser(instance);
    if(user != null){
        return user.getTokenInfo();
    }
    return null;
}
 

public <T extends RealmObject> void delete(Class<T> clazz, String field, String value) {
    Realm realm = getRealmInstance();
    RealmResults<T> models = realm.where(clazz).equalTo(field, value).findAll();
    realm.beginTransaction();
    models.deleteAllFromRealm();
    realm.commitTransaction();
}
 

private void generateAndSendEvents()
{
    List<Event> storedEvents = new ArrayList<>();
    try (Realm realm = realmManager.getAuxRealmInstance(tokensService.getCurrentAddress()))
    {
        RealmResults<RealmAuxData> realmEvents = realm.where(RealmAuxData.class)
                .endsWith("instanceKey", "-log")
                .sort("resultTime", Sort.ASCENDING)
                .findAll();

        for (RealmAuxData eventData : realmEvents)
        {
            String[] results = eventData.getResult().split(",");
            if (results.length != 2) continue;
            String result = results[0];
            BigInteger blockNumber = new BigInteger(results[1], 16);
            String eventText = "Event: " + eventData.getFunctionId() + " becomes " + result;
            Event ev = new Event(eventText, eventData.getResultTime(), eventData.getChainId());
            storedEvents.add(ev);

            //load event with top block value
            updateEventList(eventData, blockNumber);
        }
    }
    catch (Exception e)
    {
        e.printStackTrace();
    }

    if (eventCallback != null) eventCallback.eventsLoaded(storedEvents.toArray(new Event[0]));
}
 

public static String computeLastMessage(long roomId) {
    Realm realm = Realm.getDefaultInstance();
    String lastMessage = "";
    RealmResults<RealmRoomMessage> realmList = realm.where(RealmRoomMessage.class).equalTo(RealmRoomMessageFields.ROOM_ID, roomId).findAll().sort(RealmRoomMessageFields.MESSAGE_ID, Sort.DESCENDING);
    for (RealmRoomMessage realmRoomMessage : realmList) {
        if (realmRoomMessage != null && !realmRoomMessage.isDeleted()) {
            lastMessage = AppUtils.rightLastMessage(realmRoomMessage);
            break;
        }
    }
    realm.close();
    return lastMessage;
}
 

public static ProtoGlobal.GroupRoom.Role detectMineRole(long roomId) {
    ProtoGlobal.GroupRoom.Role role = ProtoGlobal.GroupRoom.Role.UNRECOGNIZED;

    Realm realm = Realm.getDefaultInstance();
    RealmRoom realmRoom = realm.where(RealmRoom.class).equalTo(RealmRoomFields.ID, roomId).findFirst();
    if (realmRoom != null) {
        RealmGroupRoom realmGroupRoom = realmRoom.getGroupRoom();
        if (realmGroupRoom != null) {
            role = realmGroupRoom.getMainRole();
        }
    }
    realm.close();

    return role;
}
 

public static void  setSession(Realm realm, AuthWrapper wrapper) {
    if(wrapper.getAccessToken() != null){
        Token token = buildToken(wrapper.getAccessToken());
        AuthPrefs authPrefs = null;
        AuthUser authUser = null;
        if(User.USER_AUTH.equalsIgnoreCase(wrapper.getType())){
            authPrefs = wrapper.getAuthPrefs();
            authUser = wrapper.getAuthUser();
            token.setHolderType(User.USER_AUTH);
        }else if(User.USER_GUEST.equalsIgnoreCase(wrapper.getType())){
            authPrefs = new AuthPrefs();
            authPrefs.setToDefault();
            authUser = new AuthUser();
            authUser.setToDefault();
            token.setHolderType(User.USER_GUEST);
        }
        if(authPrefs != null && authUser != null){
            Prefs prefs = buildPrefs(authPrefs);

            //set id to be equal to the user's
            token.setId(authUser.getId());
            prefs.setId(authUser.getId());

            User user = buildUser(authUser, token, prefs);
            user.setUserType(wrapper.getType());
            setSession(realm, buildSession(user));
        }
    }
}
 

private static void addContactToDB(final StructListOfContact item, Realm realm) {
        try {
            RealmPhoneContacts realmPhoneContacts = new RealmPhoneContacts();
            realmPhoneContacts.setPhone(checkString(item));
//            realmPhoneContacts.setFirstName(item.firstName);
//            realmPhoneContacts.setLastName(item.lastName);
            realm.copyToRealmOrUpdate(realmPhoneContacts);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 

private static boolean isInCurrentChat(String userName) {
    if (FragmentChat.lastChatRoomId > 0) {
        Realm realm = Realm.getDefaultInstance();
        RealmRoom realmRoom = realm.where(RealmRoom.class).equalTo(RealmRoomFields.ID, FragmentChat.lastChatRoomId).findFirst();
        String currentChatUserName = "";
        String currentChatInviteLink = "";
        if (realmRoom != null) {
            if (realmRoom.getChannelRoom() != null) {
                currentChatUserName = realmRoom.getChannelRoom().getUsername();
                currentChatInviteLink = realmRoom.getChannelRoom().getInviteLink();
            } else if (realmRoom.getGroupRoom() != null) {
                currentChatUserName = realmRoom.getGroupRoom().getUsername();
                currentChatInviteLink = realmRoom.getGroupRoom().getInvite_link();
            } else if (realmRoom.getChatRoom() != null) {
                RealmRegisteredInfo registeredInfo = RealmRegisteredInfo.getRegistrationInfo(realm, realmRoom.getChatRoom().getPeerId());
                if (registeredInfo != null) {
                    currentChatUserName = registeredInfo.getUsername();
                }
            }
        }
        realm.close();
        if (currentChatUserName != null && currentChatUserName.toLowerCase().equals(userName.toLowerCase())) {
            return true;
        }

        if (currentChatInviteLink != null && currentChatInviteLink.length() > 0) {
            int index = currentChatInviteLink.lastIndexOf("/");
            if (index != -1) {
                String st = currentChatInviteLink.toLowerCase().substring(index + 1);
                if (st.equals(userName.toLowerCase())) {
                    return true;
                }
            }
        }

    }
    return false;
}
 

public static List<Integration> getIntegrationsFor(String local_object, String local_object_id, Realm realm) {
    RealmResults<Integration> results = realm.where(Integration.class)
            .equalTo("local_object", local_object)
            .equalTo("local_object_id", local_object_id)
            .findAllSorted("date_updated", Sort.DESCENDING);
    return results;
}
 

@Override
	public void onCreate() {
		super.onCreate();
        Realm.init(this);
        DaggerAppComponent
				.builder()
				.application(this)
				.build()
				.inject(this);

		// enable pin code for the application
//		LockManager<CustomPinActivity> lockManager = LockManager.getInstance();
//		lockManager.enableAppLock(this, CustomPinActivity.class);
//		lockManager.getAppLock().setShouldShowForgot(false);
	}
 

public static boolean showSignature(long roomId) {
    boolean signature = false;

    Realm realm = Realm.getDefaultInstance();
    RealmRoom realmRoom = realm.where(RealmRoom.class).equalTo(RealmRoomFields.ID, roomId).findFirst();
    if (realmRoom != null && realmRoom.getChannelRoom() != null && realmRoom.getChannelRoom().isSignature()) {
        signature = true;
    }
    realm.close();

    return signature;
}