Java – How do I limit the number of listeners added and removed from the Firestore?

I’m creating a quiz app. The problems in the application are based on some changing view of value. So I use addSnapshotListener() to get every change made in the database. docs is still I should remove the listener, which is fine, but the problem is in my application, The direction changes frequently. This means I’m attaching and removing listeners too many times. Is this a bad approach? How to solve it?

Is this a bad approach?

No, it’s not! Once you no longer need a listener, you should definitely delete it. I’m assuming you’re adding the listener in the onStart() method and removing it in the onStop() method of the activity, right? If so, note that this is normal behavior, as both methods are part of the activity lifecycle and are called every time the direction changes. Therefore, each time a redirection occurs, the activity is destroyed and recreated. See more information:

• https://developer.android.com/guide/components/activities/activity-lifecycle .

If you want a more elegant way to remove listeners, you should see the last part of my answer from this post. Strong >. Therefore, you can use an activity as addSnapshotListener() The first parameter in the Pass method and the listener are automatically removed for you.

Edit:

According to your comments, you are right. Even if you are using the solution, attach and remove listeners the same number of times. In this case, I have a solution that can reduce this number.

private boolean pending = false;
private Handler handler = new Handler();
private Runnable runnable = new Runnable() {
    @Override
    public void run() {
        Remove listener
        pending = false;
    }
};

@Override
protected void onStart() {
    super.onStart();
    if (pending) {
        handler.removeCallbacks(runnable);
    } else {
        Attach listener
    }
    pending = false;
}

@Override
protected void onStop() {
    super.onStop();
    handler.postDelayed(runnable, 3000);
    pending = true;
}

This basically means that the handler will schedule the removal of your listener using a Runnable callback that will actually perform the removal >onStop() three seconds after the call. I’ve set the delay for orientation changes to three seconds, but in real-world situations it’s usually much faster even on older phones.

So, if the direction is faster than those three seconds, we simply remove the callback and allow the listener to continue listening. This obviously means that you are removing the listener less often.

This would also be very useful, as there would be no round trip to the Firestore backend to pull the data a second round trip, even if the results didn’t change.