Mark calls as read in new call log.

Playing with the existing app, the missed call becomes unbolded when:

1) Expanding the row. The closest analog of this is in the new UI is opening the bottom sheet, I've done that.

2) Swiping away from the call history tab. This can't be done in NewCallLogFragment because it doesn't know if the user is selected a new tab or pressed Home. So, I implemented this in NewMainActivityPeer.

3) After viewing the call log for 3(ish) seconds and leaving the activity pressing Home/Back. This is best done in NewCallLogFragment#onResume since MainActivity doesn't always know when the fragment is being displayed (it could be done after the user comes back to the app after pressing Home for example).

Note that the notification is also removed in all of these cases.

Also note that dismissing the notification makes the call unbolded (but this case already appears to be handled via the system call log content observer).

Also, as part of writing tests for this, I made TestCallLogProvider more realistic.

Bug: 70989622
Test: manual
PiperOrigin-RevId: 185457438
Change-Id: Ib360d3bc73083bd1a018ed98e2b7d9a69fb7fafb

2 files changed, 52 insertions, 8 deletions

diff --git a/java/com/android/dialer/calllog/ui/NewCallLogFragment.java b/java/com/android/dialer/calllog/ui/NewCallLogFragment.java
index 10f75ef07..5e676f072 100644
--- a/java/com/android/dialer/calllog/ui/NewCallLogFragment.java
+++ b/java/com/android/dialer/calllog/ui/NewCallLogFragment.java
@@ -18,6 +18,7 @@ package com.android.dialer.calllog.ui;
 import android.database.Cursor;
 import android.os.Bundle;
 import android.support.annotation.Nullable;
+import android.support.annotation.VisibleForTesting;
 import android.support.v4.app.Fragment;
 import android.support.v4.app.LoaderManager.LoaderCallbacks;
 import android.support.v4.content.Loader;
@@ -31,10 +32,14 @@ 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.DefaultFutureCallback;
 import com.android.dialer.common.concurrent.DialerExecutorComponent;
 import com.android.dialer.common.concurrent.ThreadUtil;
 import com.android.dialer.common.concurrent.UiListener;
+import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import java.util.concurrent.TimeUnit;
 
 /** The "new" call log fragment implementation, which is built on top of the annotated call log. */
 public final class NewCallLogFragment extends Fragment
@@ -46,13 +51,19 @@ public final class NewCallLogFragment extends Fragment
    * 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 static final long REFRESH_ANNOTATED_CALL_LOG_WAIT_MILLIS = 100L;
+
+  @VisibleForTesting
+  static final long MARK_ALL_CALLS_READ_WAIT_MILLIS = TimeUnit.SECONDS.toMillis(3);
 
   private RefreshAnnotatedCallLogWorker refreshAnnotatedCallLogWorker;
   private UiListener<Void> refreshAnnotatedCallLogListener;
   private RecyclerView recyclerView;
   @Nullable private Runnable refreshAnnotatedCallLogRunnable;
 
+  private boolean shouldMarkCallsRead = false;
+  private final Runnable setShouldMarkCallsReadTrue = () -> shouldMarkCallsRead = true;
+
   public NewCallLogFragment() {
     LogUtil.enterBlock("NewCallLogFragment.NewCallLogFragment");
   }
@@ -103,6 +114,13 @@ public final class NewCallLogFragment extends Fragment
       ((NewCallLogAdapter) recyclerView.getAdapter()).clearCache();
       recyclerView.getAdapter().notifyDataSetChanged();
     }
+
+    // We shouldn't mark the calls as read immediately when the 3 second timer expires because we
+    // don't want to disrupt the UI; instead we set a bit indicating to mark them read when the user
+    // leaves the fragment (in onPause).
+    shouldMarkCallsRead = false;
+    ThreadUtil.getUiThreadHandler()
+        .postDelayed(setShouldMarkCallsReadTrue, MARK_ALL_CALLS_READ_WAIT_MILLIS);
   }
 
   @Override
@@ -113,9 +131,17 @@ public final class NewCallLogFragment extends Fragment
 
     // This is pending work that we don't actually need to follow through with.
     ThreadUtil.getUiThreadHandler().removeCallbacks(refreshAnnotatedCallLogRunnable);
+    ThreadUtil.getUiThreadHandler().removeCallbacks(setShouldMarkCallsReadTrue);
 
     CallLogFramework callLogFramework = CallLogComponent.get(getContext()).callLogFramework();
     callLogFramework.detachUi();
+
+    if (shouldMarkCallsRead) {
+      Futures.addCallback(
+          CallLogComponent.get(getContext()).getClearMissedCalls().clearAll(),
+          new DefaultFutureCallback<>(),
+          MoreExecutors.directExecutor());
+    }
   }
 
   @Override
@@ -159,7 +185,8 @@ public final class NewCallLogFragment extends Fragment
                 throw new RuntimeException(throwable);
               });
         };
-    ThreadUtil.getUiThreadHandler().postDelayed(refreshAnnotatedCallLogRunnable, WAIT_MILLIS);
+    ThreadUtil.getUiThreadHandler()
+        .postDelayed(refreshAnnotatedCallLogRunnable, REFRESH_ANNOTATED_CALL_LOG_WAIT_MILLIS);
   }
 
   @Override
diff --git a/java/com/android/dialer/calllog/ui/menu/NewCallLogMenu.java b/java/com/android/dialer/calllog/ui/menu/NewCallLogMenu.java
index 81c05135f..02724e628 100644
--- a/java/com/android/dialer/calllog/ui/menu/NewCallLogMenu.java
+++ b/java/com/android/dialer/calllog/ui/menu/NewCallLogMenu.java
@@ -17,10 +17,15 @@
 package com.android.dialer.calllog.ui.menu;
 
 import android.content.Context;
+import android.provider.CallLog.Calls;
 import android.view.View;
+import com.android.dialer.calllog.CallLogComponent;
 import com.android.dialer.calllog.model.CoalescedRow;
+import com.android.dialer.common.concurrent.DefaultFutureCallback;
 import com.android.dialer.contactactions.ContactActionBottomSheet;
 import com.android.dialer.glidephotomanager.GlidePhotoManager;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.MoreExecutors;
 
 /** Handles configuration of the bottom sheet menus for call log entries. */
 public final class NewCallLogMenu {
@@ -28,11 +33,23 @@ public final class NewCallLogMenu {
   /** Creates and returns the OnClickListener which opens the menu for the provided row. */
   public static View.OnClickListener createOnClickListener(
       Context context, CoalescedRow row, GlidePhotoManager glidePhotoManager) {
-    return (view) ->
-        ContactActionBottomSheet.show(
-            context,
-            PrimaryAction.fromRow(context, row),
-            Modules.fromRow(context, row),
-            glidePhotoManager);
+    return view -> {
+      ContactActionBottomSheet.show(
+          context,
+          PrimaryAction.fromRow(context, row),
+          Modules.fromRow(context, row),
+          glidePhotoManager);
+
+      // If the user opens the bottom sheet for a new call, clear the notifications and make the row
+      // not bold immediately. To do this, mark all of the calls in group as not new.
+      if (row.isNew() && row.callType() == Calls.MISSED_TYPE) {
+        Futures.addCallback(
+            CallLogComponent.get(context)
+                .getClearMissedCalls()
+                .clearBySystemCallLogId(row.coalescedIds().getCoalescedIdList()),
+            new DefaultFutureCallback<>(),
+            MoreExecutors.directExecutor());
+      }
+    };
   }
 }