Refresh annotated call log from the voicemail tab

This CL copies the code dealing with refreshing the annotated call log from the NewCallLogFragment and applies it to the NewVoicemailFragment. This is necessary since the NewVoicemailFragment should be able to refresh the annotated call log without depending on the user going to the call log fragment for the update. The only thing we don't copy over is the logic and handling when the CP2 info is incomplete for a number (INVALID number), however we do not expect any invalid numbers for voicemail and as such have added an assert for that.

Bug: 72523272
Test: Unit Tests
PiperOrigin-RevId: 184292549
Change-Id: I2994974fe60221a4854fed5f9d80d3d428449ae9

1 files changed, 113 insertions, 1 deletions

diff --git a/java/com/android/dialer/voicemail/listui/NewVoicemailFragment.java b/java/com/android/dialer/voicemail/listui/NewVoicemailFragment.java
index 0d91f0158..8812bcc2f 100644
--- a/java/com/android/dialer/voicemail/listui/NewVoicemailFragment.java
+++ b/java/com/android/dialer/voicemail/listui/NewVoicemailFragment.java
@@ -27,17 +27,92 @@ import android.support.v7.widget.RecyclerView;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import com.android.dialer.calllog.CallLogComponent;
+import com.android.dialer.calllog.CallLogFramework;
+import com.android.dialer.calllog.CallLogFramework.CallLogUi;
+import com.android.dialer.calllog.RefreshAnnotatedCallLogWorker;
 import com.android.dialer.common.LogUtil;
+import com.android.dialer.common.concurrent.DialerExecutorComponent;
+import com.android.dialer.common.concurrent.ThreadUtil;
+import com.android.dialer.common.concurrent.UiListener;
 import com.android.dialer.database.CallLogQueryHandler;
 import com.android.dialer.database.CallLogQueryHandler.Listener;
+import com.google.common.util.concurrent.ListenableFuture;
 
 // TODO(uabdullah): Register content observer for VoicemailContract.Status.CONTENT_URI in onStart
 /** Fragment for Dialer Voicemail Tab. */
-public final class NewVoicemailFragment extends Fragment implements LoaderCallbacks<Cursor> {
+public final class NewVoicemailFragment extends Fragment
+    implements LoaderCallbacks<Cursor>, CallLogUi {
+
+  /*
+   * This is a reasonable time that it might take between related call log writes, that also
+   * shouldn't slow down single-writes too much. For example, when populating the database using
+   * the simulator, using this value results in ~6 refresh cycles (on a release build) to write 120
+   * call log entries.
+   */
+  private static final long WAIT_MILLIS = 100L;
+
+  private RefreshAnnotatedCallLogWorker refreshAnnotatedCallLogWorker;
+  private UiListener<Void> refreshAnnotatedCallLogListener;
+  @Nullable private Runnable refreshAnnotatedCallLogRunnable;
 
   private RecyclerView recyclerView;
   private CallLogQueryHandler callLogQueryHandler;
 
+  public NewVoicemailFragment() {
+    LogUtil.enterBlock("NewVoicemailFragment.NewVoicemailFragment");
+  }
+
+  @Override
+  public void onActivityCreated(@Nullable Bundle savedInstanceState) {
+    super.onActivityCreated(savedInstanceState);
+
+    LogUtil.enterBlock("NewVoicemailFragment.onActivityCreated");
+
+    CallLogComponent component = CallLogComponent.get(getContext());
+    CallLogFramework callLogFramework = component.callLogFramework();
+    callLogFramework.attachUi(this);
+
+    // TODO(zachh): Use support fragment manager and add support for them in executors library.
+    refreshAnnotatedCallLogListener =
+        DialerExecutorComponent.get(getContext())
+            .createUiListener(
+                getActivity().getFragmentManager(), "NewVoicemailFragment.refreshAnnotatedCallLog");
+    refreshAnnotatedCallLogWorker = component.getRefreshAnnotatedCallLogWorker();
+  }
+
+  @Override
+  public void onStart() {
+    super.onStart();
+    LogUtil.enterBlock("NewVoicemailFragment.onStart");
+  }
+
+  @Override
+  public void onResume() {
+    super.onResume();
+
+    LogUtil.enterBlock("NewCallLogFragment.onResume");
+
+    CallLogFramework callLogFramework = CallLogComponent.get(getContext()).callLogFramework();
+    callLogFramework.attachUi(this);
+
+    // TODO(zachh): Consider doing this when fragment becomes visible.
+    refreshAnnotatedCallLog(true /* checkDirty */);
+  }
+
+  @Override
+  public void onPause() {
+    super.onPause();
+
+    LogUtil.enterBlock("NewVoicemailFragment.onPause");
+
+    // This is pending work that we don't actually need to follow through with.
+    ThreadUtil.getUiThreadHandler().removeCallbacks(refreshAnnotatedCallLogRunnable);
+
+    CallLogFramework callLogFramework = CallLogComponent.get(getContext()).callLogFramework();
+    callLogFramework.detachUi();
+  }
+
   @Nullable
   @Override
   public View onCreateView(
@@ -49,6 +124,43 @@ public final class NewVoicemailFragment extends Fragment implements LoaderCallba
     return view;
   }
 
+  private void refreshAnnotatedCallLog(boolean checkDirty) {
+    LogUtil.enterBlock("NewVoicemailFragment.refreshAnnotatedCallLog");
+
+    // If we already scheduled a refresh, cancel it and schedule a new one so that repeated requests
+    // in quick succession don't result in too much work. For example, if we get 10 requests in
+    // 10ms, and a complete refresh takes a constant 200ms, the refresh will take 300ms (100ms wait
+    // and 1 iteration @200ms) instead of 2 seconds (10 iterations @ 200ms) since the work requests
+    // are serialized in RefreshAnnotatedCallLogWorker.
+    //
+    // We might get many requests in quick succession, for example, when the simulator inserts
+    // hundreds of rows into the system call log, or when the data for a new call is incrementally
+    // written to different columns as it becomes available.
+    ThreadUtil.getUiThreadHandler().removeCallbacks(refreshAnnotatedCallLogRunnable);
+
+    refreshAnnotatedCallLogRunnable =
+        () -> {
+          ListenableFuture<Void> future =
+              checkDirty
+                  ? refreshAnnotatedCallLogWorker.refreshWithDirtyCheck()
+                  : refreshAnnotatedCallLogWorker.refreshWithoutDirtyCheck();
+          refreshAnnotatedCallLogListener.listen(
+              getContext(),
+              future,
+              unused -> {},
+              throwable -> {
+                throw new RuntimeException(throwable);
+              });
+        };
+    ThreadUtil.getUiThreadHandler().postDelayed(refreshAnnotatedCallLogRunnable, WAIT_MILLIS);
+  }
+
+  @Override
+  public void invalidateUi() {
+    LogUtil.enterBlock("NewVoicemailFragment.invalidateUi");
+    refreshAnnotatedCallLog(false /* checkDirty */);
+  }
+
   @Override
   public Loader<Cursor> onCreateLoader(int id, Bundle args) {
     LogUtil.enterBlock("NewVoicemailFragment.onCreateLoader");