Remove SingleLiveEvent from BlockedUsersActivity.

app/src/main/java/org/thoughtcrime/securesms/blocked/BlockedUsersActivity.java

@@ -24,6 +24,7 @@ import org.thoughtcrime.securesms.recipients.Recipient;
 import org.thoughtcrime.securesms.recipients.RecipientId;
 import org.thoughtcrime.securesms.util.DynamicNoActionBarTheme;
 import org.thoughtcrime.securesms.util.DynamicTheme;
+import org.thoughtcrime.securesms.util.LifecycleDisposable;
 import org.thoughtcrime.securesms.util.ViewUtil;
 
 import java.util.Optional;
@@ -37,10 +38,13 @@ public class BlockedUsersActivity extends PassphraseRequiredActivity implements
 
   private BlockedUsersViewModel viewModel;
 
+  private final LifecycleDisposable lifecycleDisposable = new LifecycleDisposable();
+
   @Override
   protected void onCreate(Bundle savedInstanceState, boolean ready) {
     super.onCreate(savedInstanceState, ready);
 
+    lifecycleDisposable.bindTo(this);
     dynamicTheme.onCreate(this);
 
     setContentView(R.layout.blocked_users_activity);
@@ -78,7 +82,11 @@ public class BlockedUsersActivity extends PassphraseRequiredActivity implements
                                .add(R.id.fragment_container, new BlockedUsersFragment())
                                .commit();
 
-    viewModel.getEvents().observe(this, event -> handleEvent(container, event));
+    lifecycleDisposable.add(
+        viewModel
+            .getEvents()
+            .subscribe(event -> handleEvent(container, event))
+    );
   }
 
   @Override

app/src/main/java/org/thoughtcrime/securesms/blocked/BlockedUsersFragment.java

@@ -15,12 +15,15 @@ import androidx.recyclerview.widget.RecyclerView;
 import org.thoughtcrime.securesms.BlockUnblockDialog;
 import org.thoughtcrime.securesms.R;
 import org.thoughtcrime.securesms.recipients.Recipient;
+import org.thoughtcrime.securesms.util.LifecycleDisposable;
 
 public class BlockedUsersFragment extends Fragment {
 
   private BlockedUsersViewModel viewModel;
   private Listener              listener;
 
+  private final LifecycleDisposable lifecycleDisposable = new LifecycleDisposable();
+
   @Override
   public void onAttach(@NonNull Context context) {
     super.onAttach(context);
@@ -59,16 +62,19 @@ public class BlockedUsersFragment extends Fragment {
       }
     });
 
+    lifecycleDisposable.bindTo(getViewLifecycleOwner());
     viewModel = new ViewModelProvider(requireActivity()).get(BlockedUsersViewModel.class);
-    viewModel.getRecipients().observe(getViewLifecycleOwner(), list -> {
+    lifecycleDisposable.add(
-      if (list.isEmpty()) {
+        viewModel.getRecipients().subscribe(list -> {
-        empty.setVisibility(View.VISIBLE);
+          if (list.isEmpty()) {
-      } else {
+            empty.setVisibility(View.VISIBLE);
-        empty.setVisibility(View.GONE);
+          } else {
-      }
+            empty.setVisibility(View.GONE);
+          }
 
-      adapter.submitList(list);
+          adapter.submitList(list);
-    });
+        })
+    );
   }
 
   private void handleRecipientClicked(@NonNull Recipient recipient) {

app/src/main/java/org/thoughtcrime/securesms/blocked/BlockedUsersViewModel.java

@@ -2,64 +2,66 @@ package org.thoughtcrime.securesms.blocked;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
-import androidx.lifecycle.LiveData;
-import androidx.lifecycle.MutableLiveData;
 import androidx.lifecycle.ViewModel;
 import androidx.lifecycle.ViewModelProvider;
 
 import org.thoughtcrime.securesms.recipients.Recipient;
 import org.thoughtcrime.securesms.recipients.RecipientId;
-import org.thoughtcrime.securesms.util.SingleLiveEvent;
 
 import java.util.List;
 import java.util.Objects;
 
+import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
+import io.reactivex.rxjava3.core.Observable;
+import io.reactivex.rxjava3.subjects.BehaviorSubject;
+import io.reactivex.rxjava3.subjects.PublishSubject;
+import io.reactivex.rxjava3.subjects.Subject;
+
 public class BlockedUsersViewModel extends ViewModel {
 
-  private final BlockedUsersRepository           repository;
+  private final BlockedUsersRepository   repository;
-  private final MutableLiveData<List<Recipient>> recipients;
+  private final Subject<List<Recipient>> recipients = BehaviorSubject.create();
-  private final SingleLiveEvent<Event>           events = new SingleLiveEvent<>();
+  private final Subject<Event>           events     = PublishSubject.create();
 
   private BlockedUsersViewModel(@NonNull BlockedUsersRepository repository) {
     this.repository  = repository;
-    this.recipients = new MutableLiveData<>();
 
     loadRecipients();
    }
 
-  public LiveData<List<Recipient>> getRecipients() {
+  public Observable<List<Recipient>> getRecipients() {
-    return recipients;
+    return recipients.observeOn(AndroidSchedulers.mainThread());
   }
 
-  public LiveData<Event> getEvents() {
+  public Observable<Event> getEvents() {
-    return events;
+    return events.observeOn(AndroidSchedulers.mainThread());
   }
 
   void block(@NonNull RecipientId recipientId) {
     repository.block(recipientId,
                      () -> {
                        loadRecipients();
-                       events.postValue(new Event(EventType.BLOCK_SUCCEEDED, Recipient.resolved(recipientId)));
+                       events.onNext(new Event(EventType.BLOCK_SUCCEEDED, Recipient.resolved(recipientId)));
                      },
-                     () -> events.postValue(new Event(EventType.BLOCK_FAILED, Recipient.resolved(recipientId))));
+                     () -> events.onNext(new Event(EventType.BLOCK_FAILED, Recipient.resolved(recipientId))));
   }
 
   void createAndBlock(@NonNull String number) {
     repository.createAndBlock(number, () -> {
       loadRecipients();
-      events.postValue(new Event(EventType.BLOCK_SUCCEEDED, number));
+      events.onNext(new Event(EventType.BLOCK_SUCCEEDED, number));
     });
   }
 
   void unblock(@NonNull RecipientId recipientId) {
     repository.unblock(recipientId, () -> {
       loadRecipients();
-      events.postValue(new Event(EventType.UNBLOCK_SUCCEEDED, Recipient.resolved(recipientId)));
+      events.onNext(new Event(EventType.UNBLOCK_SUCCEEDED, Recipient.resolved(recipientId)));
     });
   }
 
   private void loadRecipients() {
-    repository.getBlocked(recipients::postValue);
+    repository.getBlocked(recipients::onNext);
   }
 
   enum EventType {