io.realm.RealmChangeListener Java Examples

public static void queryAllConversation(final QueryDbCallBack<ConversationDbObject> callBack) {

        mainHandler.post(new Runnable() {
            @Override
            public void run() {

                final RealmResults<ConversationDbObject> results = mRealm.where(ConversationDbObject.class).findAllAsync();
                results.addChangeListener(new RealmChangeListener<RealmResults<ConversationDbObject>>() {
                    @Override
                    public void onChange(RealmResults<ConversationDbObject> element) {

                        element = element.sort("latestmsgtimestamp");

                        List<ConversationDbObject> objects = mRealm.copyFromRealm(element);

                        callBack.querySuccess(objects, false);
                        results.removeAllChangeListeners();
                    }
                });
            }
        });
    }
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setupActionBar();

    realm = ((App)getApplication()).getDatabaseManager().getInstance();
    Log.d("REALM_PATH", realm.getPath());
    user = DatabaseHelper.getSessionUser(realm);

    user.addChangeListener(new RealmChangeListener() {
        @Override
        public void onChange() {
            if(!userChanged){
                userChanged = true;
            }
        }
    });

}
 

private <T extends RealmObject> void readAllAsync(@NonNull final ReadAction<T> readAction) {
    Realm realm = null;
    try {
        realm = Realm.getDefaultInstance();
        RealmQuery<T> query = readAction.getQuery(realm);
        final RealmResults<T> results = query.findAllAsync();
        results.addChangeListener(new RealmChangeListener() {
            @Override
            public void onChange() {
                results.removeChangeListener(this);
                readAction.onResults(results);
            }
        });
    } finally {
        if (realm != null) {
            realm.close();
        }
    }
}
 

public static void fetchNotDeliveredMessages(final OnActivityMainStart callback) {
    // if client get message and before send status lost connection, will be need to this method
    // and this step is very uncommon so don't need to do this action and get performance,if client
    // needed this method will be used in ActivityMain later
    final Realm realm = Realm.getDefaultInstance();
    RealmResults<RealmRoomMessage> sentMessages = realm.where(RealmRoomMessage.class).notEqualTo(RealmRoomMessageFields.USER_ID, G.userId).equalTo(RealmRoomMessageFields.STATUS, ProtoGlobal.RoomMessageStatus.SENT.toString()).findAllAsync().sort(new String[]{RealmRoomMessageFields.ROOM_ID, RealmRoomMessageFields.MESSAGE_ID}, new Sort[]{Sort.DESCENDING, Sort.ASCENDING});
    sentMessages.addChangeListener(new RealmChangeListener<RealmResults<RealmRoomMessage>>() {
        @Override
        public void onChange(RealmResults<RealmRoomMessage> element) {
            for (RealmRoomMessage roomMessage : element) {
                if (roomMessage == null) {
                    return;
                }
                final RealmRoom realmRoom = realm.where(RealmRoom.class).equalTo(RealmRoomFields.ID, roomMessage.getRoomId()).findFirst();
                if (realmRoom == null) {
                    return;
                }

                callback.sendDeliveredStatus(realmRoom, roomMessage);
            }

            element.removeAllChangeListeners();
            realm.close();
        }
    });
}
 

public void onResume() {
    mRoom = getRealm().where(RealmRoom.class).equalTo(RealmRoomFields.ID, shearedId).findFirst();
    if (mRoom != null) {
        if (changeListener == null) {
            changeListener = new RealmChangeListener<RealmModel>() {
                @Override
                public void onChange(final RealmModel element) {
                    G.handler.post(new Runnable() {
                        @Override
                        public void run() {
                            if (!((RealmRoom) element).isValid()) {
                                return;
                            }

                            sharedMedia.set(((RealmRoom) element).getSharedMediaCount());
                        }
                    });
                }
            };
        }
        mRoom.addChangeListener(changeListener);
        changeListener.onChange(mRoom);
    } else {
        sharedMedia.set(context.getString(R.string.there_is_no_sheared_media));
    }
}
 

<T extends RealmModel> void createAndObserveRealmQuery(final LiveResults<T> liveResults) {
    Realm realm = realmThreadLocal.get();
    checkRealmValid(realm);
    if(liveResults == null) {
        return;
    }
    RealmResults<T> results = liveResults.createQuery(realm);
    resultsRefs.get().put(liveResults, results);
    results.addChangeListener(new RealmChangeListener<RealmResults<T>>() {
        @Override
        public void onChange(@Nonnull RealmResults<T> realmResults) {
            liveResults.updateResults(realmResults);
        }
    });
}
 

private void loadUserListAsync() {
    final RealmResults<User> dataList = RealmManager.createUserDao().loadAllAsync();
    dataList.addChangeListener(new RealmChangeListener() {
        @Override
        public void onChange() {
            updateRecyclerView(dataList);
        }
    });
}
 

public void onResume() {

        mRoom = getRealm().where(RealmRoom.class).equalTo(RealmRoomFields.ID, roomId).findFirst();
        if (mRoom != null) {

            if (changeListener == null) {

                changeListener = new RealmChangeListener<RealmModel>() {
                    @Override
                    public void onChange(final RealmModel element) {
                        G.handler.post(new Runnable() {
                            @Override
                            public void run() {
                                if (((RealmRoom) element).isValid()) {
                                    String countText = ((RealmRoom) element).getSharedMediaCount();
                                    if (HelperCalander.isPersianUnicode) {
                                        callbackGroupShearedMedia.set(HelperCalander.convertToUnicodeFarsiNumber(countText));
                                    } else {
                                        callbackGroupShearedMedia.set(countText);
                                    }
                                }
                            }
                        });
                    }
                };
            }

            mRoom.addChangeListener(changeListener);
            changeListener.onChange(mRoom);
        } else {

            callbackGroupShearedMedia.set(context.getString(R.string.there_is_no_sheared_media));
        }
    }
 

public void onResume() {

        mRoom = getRealm().where(RealmRoom.class).equalTo(RealmRoomFields.ID, roomId).findFirst();
        if (mRoom != null) {

            if (changeListener == null) {
                changeListener = new RealmChangeListener<RealmModel>() {
                    @Override
                    public void onChange(final RealmModel element) {
                        G.handler.post(new Runnable() {
                            @Override
                            public void run() {
                                if (((RealmRoom) element).isValid()) {
                                    String countText = ((RealmRoom) element).getSharedMediaCount();
                                    if (HelperCalander.isPersianUnicode) {
                                        callbackChannelSharedMedia.set(HelperCalander.convertToUnicodeFarsiNumber(countText));
                                    } else {
                                        callbackChannelSharedMedia.set(countText);
                                    }
                                }
                            }
                        });
                    }
                };
            }

            mRoom.addChangeListener(changeListener);
            changeListener.onChange(mRoom);
        } else {
            if (callbackChannelSharedMedia.get() != null) {
                callbackChannelSharedMedia.set(context.getString(R.string.there_is_no_sheared_media));
            }
        }
    }
 

private void getInfo() {
    realmPrivacy = realm.where(RealmPrivacy.class).findFirst();
    realmUserInfo = realm.where(RealmUserInfo.class).findFirst();
    RealmPrivacy.getUpdatePrivacyFromServer();
    sharedPreferences = G.fragmentActivity.getSharedPreferences(SHP_SETTING.FILE_NAME, MODE_PRIVATE);
    poSelfRemove = sharedPreferences.getInt(SHP_SETTING.KEY_POSITION_SELF_REMOVE, 2);

    updatePrivacyUI(realmPrivacy);

    userInfoListener = new RealmChangeListener<RealmModel>() {
        @Override
        public void onChange(RealmModel element) {

            if (((RealmUserInfo) element).isValid()) {
                selfRemove = ((RealmUserInfo) element).getSelfRemove();
                setTextSelfDestructs();
            }
        }
    };

    privacyListener = new RealmChangeListener<RealmModel>() {
        @Override
        public void onChange(RealmModel element) {
            updatePrivacyUI((RealmPrivacy) element);
        }
    };
}
 

private void setListener() {
    changeListener = new RealmChangeListener<RealmResults<RealmRoomMessage>>() {
        @Override
        public void onChange(RealmResults<RealmRoomMessage> element) {
            getInfoRealm();
        }
    };

    if (changeListener != null) {
        mRealmList.addChangeListener(changeListener);
    }
}
 

private void fillListAvatar(From from) {

        realm = Realm.getDefaultInstance();

        boolean isRoomExist = false;

        switch (from) {
            case chat:
            case setting:
                RealmRegisteredInfo user = RealmRegisteredInfo.getRegistrationInfo(realm, mPeerId);
                if (user != null) {
                    new RequestUserAvatarGetList().userAvatarGetList(mPeerId);
                    isRoomExist = true;
                }
                break;
            case group:
                RealmRoom roomGroup = realm.where(RealmRoom.class).equalTo(RealmRoomFields.ID, mPeerId).findFirst();
                if (roomGroup != null) {
                    new RequestGroupAvatarGetList().groupAvatarGetList(mPeerId);
                    isRoomExist = true;
                    roleGroup = roomGroup.getGroupRoom().getRole();
                }
                break;
            case channel:
                RealmRoom roomChannel = realm.where(RealmRoom.class).equalTo(RealmRoomFields.ID, mPeerId).findFirst();
                if (roomChannel != null) {
                    new RequestChannelAvatarGetList().channelAvatarGetList(mPeerId);
                    isRoomExist = true;
                    roleChannel = roomChannel.getChannelRoom().getRole();
                }
                break;
        }

        if (isRoomExist) {

            avatarList = realm.where(RealmAvatar.class).equalTo(RealmAvatarFields.OWNER_ID, mPeerId).findAll().sort(RealmAvatarFields.ID, Sort.DESCENDING);
            avatarList.addChangeListener(new RealmChangeListener<RealmResults<RealmAvatar>>() {
                @Override
                public void onChange(RealmResults<RealmAvatar> element) {

                    if (avatarListSize != element.size()) {

                        avatarListSize = element.size();

                        viewPager.setAdapter(new FragmentShowAvatars.AdapterViewPager());

                        if (avatarListSize > 0) {
                            viewPager.getAdapter().notifyDataSetChanged();
                            txtImageNumber.setText(viewPager.getCurrentItem() + 1 + " " + G.fragmentActivity.getResources().getString(R.string.of) + " " + avatarListSize);
                            if (HelperCalander.isPersianUnicode) {
                                txtImageNumber.setText(HelperCalander.convertToUnicodeFarsiNumber(txtImageNumber.getText().toString()));
                            }
                        } else {
                            //  G.fragmentActivity.getSupportFragmentManager().beginTransaction().remove(FragmentShowAvatars.this).commit();

                            popBackStackFragment();
                        }
                    }
                }
            });

            avatarListSize = avatarList.size();
        }
    }
 

@Override
protected RealmChangeListener getRealmSessionChangeListener() {
    return null;
}
 

@Override
protected RealmChangeListener getRealmSessionChangeListener() {
    return null;
}
 

private void setListener() {

        changeListener = new RealmChangeListener<RealmResults<RealmRoomMessage>>() {
            @Override
            public void onChange(RealmResults<RealmRoomMessage> element) {

                if (isChangeSelectType) {
                    return;
                }

                if (changeSize - element.size() != 0) {

                    mNewList.clear();
                    mNewList.addAll(addTimeToList(element));

                    int position = ((LinearLayoutManager) recyclerView.getLayoutManager()).findFirstVisibleItemPosition();

                    if (adapter instanceof ImageAdapter) {
                        adapter = new ImageAdapter(fragmentActivity, mNewList);
                    } else if (adapter instanceof VideoAdapter) {
                        adapter = new VideoAdapter(fragmentActivity, mNewList);
                    } else if (adapter instanceof VoiceAdapter) {
                        adapter = new VoiceAdapter(fragmentActivity, mNewList);
                    } else if (adapter instanceof GifAdapter) {
                        adapter = new GifAdapter(fragmentActivity, mNewList);
                    } else if (adapter instanceof FileAdapter) {
                        adapter = new FileAdapter(fragmentActivity, mNewList);
                    } else if (adapter instanceof LinkAdapter) {
                        adapter = new LinkAdapter(fragmentActivity, mNewList);
                    }

                    recyclerView.setAdapter(adapter);

                    recyclerView.scrollToPosition(position);

                    listCount = element.size();
                    changeSize = element.size();
                }
            }
        };

        mRealmList.addChangeListener(changeListener);
    }
 

@Override
protected RealmChangeListener getRealmSessionChangeListener() {
    //keep null as
    return realmSessionListener;
}
 

@Override
protected RealmChangeListener getRealmSessionChangeListener() {
    return null;
}
 

@Override
protected RealmChangeListener getRealmSessionChangeListener() {
    return null;
}
 

protected abstract RealmChangeListener getRealmSessionChangeListener();