Extract remainining ChooserActivity logging

This especially covers other kinds of logging in ChooserActivity that
hadn't previously been a responsibility of ChooserActivityLogger (e.g.
because they instead went directly through MetricsLogger).

There's a few reasons to make these changes, in rough priority order:

 1. Tests can make assertions about the high-level logging methods we
    expect to call; the implementation of those methods (in terms of
    low-level event streams) is unit-tested for the logger itself.

 2. We can encapsulate all the types of loggers (UiEventLogger,
    MetricsLogger, etc.) in a single object, which is easier to inject
    as a dependency as we continue decomposing ChooserActivity
    responsibilities into other components.

 3. High-level logger APIs reduce the clutter that clients previously
    spent building up the low-level event data that's now abstracted
    away.

Test: atest IntentResolverUnitTests
Bug: 202167050
Change-Id: Ib3197bca12ec5ea3c925946c0f6d37a6be19d8fa

4 files changed, 261 insertions, 157 deletions

diff --git a/java/tests/src/com/android/intentresolver/ChooserActivityLoggerTest.java b/java/tests/src/com/android/intentresolver/ChooserActivityLoggerTest.java
index 702e725a..705a3228 100644
--- a/java/tests/src/com/android/intentresolver/ChooserActivityLoggerTest.java
+++ b/java/tests/src/com/android/intentresolver/ChooserActivityLoggerTest.java
@@ -30,14 +30,17 @@ import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 
 import android.content.Intent;
+import android.metrics.LogMaker;
 
 import com.android.intentresolver.ChooserActivityLogger.FrameworkStatsLogger;
 import com.android.intentresolver.ChooserActivityLogger.SharesheetStandardEvent;
 import com.android.intentresolver.ChooserActivityLogger.SharesheetStartedEvent;
 import com.android.intentresolver.ChooserActivityLogger.SharesheetTargetSelectedEvent;
 import com.android.internal.logging.InstanceId;
+import com.android.internal.logging.MetricsLogger;
 import com.android.internal.logging.UiEventLogger;
 import com.android.internal.logging.UiEventLogger.UiEventEnum;
+import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
 import com.android.internal.util.FrameworkStatsLog;
 
 import org.junit.After;
@@ -52,18 +55,59 @@ import org.mockito.junit.MockitoJUnitRunner;
 public final class ChooserActivityLoggerTest {
     @Mock private UiEventLogger mUiEventLog;
     @Mock private FrameworkStatsLogger mFrameworkLog;
+    @Mock private MetricsLogger mMetricsLogger;
 
     private ChooserActivityLogger mChooserLogger;
 
     @Before
     public void setUp() {
-        mChooserLogger = new ChooserActivityLogger(mUiEventLog, mFrameworkLog);
+        //Mockito.reset(mUiEventLog, mFrameworkLog, mMetricsLogger);
+        mChooserLogger = new ChooserActivityLogger(mUiEventLog, mFrameworkLog, mMetricsLogger);
     }
 
     @After
     public void tearDown() {
         verifyNoMoreInteractions(mUiEventLog);
         verifyNoMoreInteractions(mFrameworkLog);
+        verifyNoMoreInteractions(mMetricsLogger);
+    }
+
+    @Test
+    public void testLogChooserActivityShown_personalProfile() {
+        final boolean isWorkProfile = false;
+        final String mimeType = "application/TestType";
+        final long systemCost = 456;
+
+        mChooserLogger.logChooserActivityShown(isWorkProfile, mimeType, systemCost);
+
+        ArgumentCaptor<LogMaker> eventCaptor = ArgumentCaptor.forClass(LogMaker.class);
+        verify(mMetricsLogger).write(eventCaptor.capture());
+        LogMaker event = eventCaptor.getValue();
+
+        assertThat(event.getCategory()).isEqualTo(MetricsEvent.ACTION_ACTIVITY_CHOOSER_SHOWN);
+        assertThat(event.getSubtype()).isEqualTo(MetricsEvent.PARENT_PROFILE);
+        assertThat(event.getTaggedData(MetricsEvent.FIELD_SHARESHEET_MIMETYPE)).isEqualTo(mimeType);
+        assertThat(event.getTaggedData(MetricsEvent.FIELD_TIME_TO_APP_TARGETS))
+                .isEqualTo(systemCost);
+    }
+
+    @Test
+    public void testLogChooserActivityShown_workProfile() {
+        final boolean isWorkProfile = true;
+        final String mimeType = "application/TestType";
+        final long systemCost = 456;
+
+        mChooserLogger.logChooserActivityShown(isWorkProfile, mimeType, systemCost);
+
+        ArgumentCaptor<LogMaker> eventCaptor = ArgumentCaptor.forClass(LogMaker.class);
+        verify(mMetricsLogger).write(eventCaptor.capture());
+        LogMaker event = eventCaptor.getValue();
+
+        assertThat(event.getCategory()).isEqualTo(MetricsEvent.ACTION_ACTIVITY_CHOOSER_SHOWN);
+        assertThat(event.getSubtype()).isEqualTo(MetricsEvent.MANAGED_PROFILE);
+        assertThat(event.getTaggedData(MetricsEvent.FIELD_SHARESHEET_MIMETYPE)).isEqualTo(mimeType);
+        assertThat(event.getTaggedData(MetricsEvent.FIELD_TIME_TO_APP_TARGETS))
+                .isEqualTo(systemCost);
     }
 
     @Test
@@ -102,20 +146,87 @@ public final class ChooserActivityLoggerTest {
 
     @Test
     public void testLogShareTargetSelected() {
-        final int targetType = ChooserActivity.SELECTION_TYPE_COPY;
+        final int targetType = ChooserActivityLogger.SELECTION_TYPE_SERVICE;
         final String packageName = "com.test.foo";
         final int positionPicked = 123;
-        final boolean pinned = true;
-
-        mChooserLogger.logShareTargetSelected(targetType, packageName, positionPicked, pinned);
+        final int directTargetAlsoRanked = -1;
+        final int callerTargetCount = 0;
+        final boolean isPinned = true;
+        final boolean isSuccessfullySelected = true;
+        final long selectionCost = 456;
+
+        mChooserLogger.logShareTargetSelected(
+                targetType,
+                packageName,
+                positionPicked,
+                directTargetAlsoRanked,
+                callerTargetCount,
+                /* directTargetHashed= */ null,
+                isPinned,
+                isSuccessfullySelected,
+                selectionCost);
 
         verify(mFrameworkLog).write(
                 eq(FrameworkStatsLog.RANKING_SELECTED),
-                eq(SharesheetTargetSelectedEvent.SHARESHEET_COPY_TARGET_SELECTED.getId()),
+                eq(SharesheetTargetSelectedEvent.SHARESHEET_SERVICE_TARGET_SELECTED.getId()),
                 eq(packageName),
                 /* instanceId=*/ gt(0),
                 eq(positionPicked),
-                eq(pinned));
+                eq(isPinned));
+
+        ArgumentCaptor<LogMaker> eventCaptor = ArgumentCaptor.forClass(LogMaker.class);
+        verify(mMetricsLogger).write(eventCaptor.capture());
+        LogMaker event = eventCaptor.getValue();
+        assertThat(event.getCategory()).isEqualTo(
+                MetricsEvent.ACTION_ACTIVITY_CHOOSER_PICKED_SERVICE_TARGET);
+        assertThat(event.getSubtype()).isEqualTo(positionPicked);
+    }
+
+    @Test
+    public void testLogActionSelected() {
+        mChooserLogger.logActionSelected(ChooserActivityLogger.SELECTION_TYPE_COPY);
+
+        verify(mFrameworkLog).write(
+                eq(FrameworkStatsLog.RANKING_SELECTED),
+                eq(SharesheetTargetSelectedEvent.SHARESHEET_COPY_TARGET_SELECTED.getId()),
+                eq(""),
+                /* instanceId=*/ gt(0),
+                eq(-1),
+                eq(false));
+
+        ArgumentCaptor<LogMaker> eventCaptor = ArgumentCaptor.forClass(LogMaker.class);
+        verify(mMetricsLogger).write(eventCaptor.capture());
+        LogMaker event = eventCaptor.getValue();
+        assertThat(event.getCategory()).isEqualTo(
+                MetricsEvent.ACTION_ACTIVITY_CHOOSER_PICKED_SYSTEM_TARGET);
+        assertThat(event.getSubtype()).isEqualTo(1);
+    }
+
+    @Test
+    public void testLogDirectShareTargetReceived() {
+        final int category = MetricsEvent.ACTION_DIRECT_SHARE_TARGETS_LOADED_SHORTCUT_MANAGER;
+        final int latency = 123;
+
+        mChooserLogger.logDirectShareTargetReceived(category, latency);
+
+        ArgumentCaptor<LogMaker> eventCaptor = ArgumentCaptor.forClass(LogMaker.class);
+        verify(mMetricsLogger).write(eventCaptor.capture());
+        LogMaker event = eventCaptor.getValue();
+        assertThat(event.getCategory()).isEqualTo(category);
+        assertThat(event.getSubtype()).isEqualTo(latency);
+    }
+
+    @Test
+    public void testLogActionShareWithPreview() {
+        final int previewType = ChooserContentPreviewUi.CONTENT_PREVIEW_TEXT;
+
+        mChooserLogger.logActionShareWithPreview(previewType);
+
+        ArgumentCaptor<LogMaker> eventCaptor = ArgumentCaptor.forClass(LogMaker.class);
+        verify(mMetricsLogger).write(eventCaptor.capture());
+        LogMaker event = eventCaptor.getValue();
+        assertThat(event.getCategory()).isEqualTo(MetricsEvent.ACTION_SHARE_WITH_PREVIEW);
+        assertThat(event.getSubtype()).isEqualTo(previewType);
     }
 
     @Test
@@ -194,15 +305,38 @@ public final class ChooserActivityLoggerTest {
     public void testDifferentLoggerInstancesUseDifferentInstanceIds() {
         ArgumentCaptor<Integer> idIntCaptor = ArgumentCaptor.forClass(Integer.class);
         ChooserActivityLogger chooserLogger2 =
-                new ChooserActivityLogger(mUiEventLog, mFrameworkLog);
+                new ChooserActivityLogger(mUiEventLog, mFrameworkLog, mMetricsLogger);
 
-        final int targetType = ChooserActivity.SELECTION_TYPE_COPY;
+        final int targetType = ChooserActivityLogger.SELECTION_TYPE_COPY;
         final String packageName = "com.test.foo";
         final int positionPicked = 123;
-        final boolean pinned = true;
-
-        mChooserLogger.logShareTargetSelected(targetType, packageName, positionPicked, pinned);
-        chooserLogger2.logShareTargetSelected(targetType, packageName, positionPicked, pinned);
+        final int directTargetAlsoRanked = -1;
+        final int callerTargetCount = 0;
+        final boolean isPinned = true;
+        final boolean isSuccessfullySelected = true;
+        final long selectionCost = 456;
+
+        mChooserLogger.logShareTargetSelected(
+                targetType,
+                packageName,
+                positionPicked,
+                directTargetAlsoRanked,
+                callerTargetCount,
+                /* directTargetHashed= */ null,
+                isPinned,
+                isSuccessfullySelected,
+                selectionCost);
+
+        chooserLogger2.logShareTargetSelected(
+                targetType,
+                packageName,
+                positionPicked,
+                directTargetAlsoRanked,
+                callerTargetCount,
+                /* directTargetHashed= */ null,
+                isPinned,
+                isSuccessfullySelected,
+                selectionCost);
 
         verify(mFrameworkLog, times(2)).write(
                 anyInt(), anyInt(), anyString(), idIntCaptor.capture(), anyInt(), anyBoolean());
@@ -220,12 +354,26 @@ public final class ChooserActivityLoggerTest {
         ArgumentCaptor<Integer> idIntCaptor = ArgumentCaptor.forClass(Integer.class);
         ArgumentCaptor<InstanceId> idObjectCaptor = ArgumentCaptor.forClass(InstanceId.class);
 
-        final int targetType = ChooserActivity.SELECTION_TYPE_COPY;
+        final int targetType = ChooserActivityLogger.SELECTION_TYPE_COPY;
         final String packageName = "com.test.foo";
         final int positionPicked = 123;
-        final boolean pinned = true;
+        final int directTargetAlsoRanked = -1;
+        final int callerTargetCount = 0;
+        final boolean isPinned = true;
+        final boolean isSuccessfullySelected = true;
+        final long selectionCost = 456;
+
+        mChooserLogger.logShareTargetSelected(
+                targetType,
+                packageName,
+                positionPicked,
+                directTargetAlsoRanked,
+                callerTargetCount,
+                /* directTargetHashed= */ null,
+                isPinned,
+                isSuccessfullySelected,
+                selectionCost);
 
-        mChooserLogger.logShareTargetSelected(targetType, packageName, positionPicked, pinned);
         verify(mFrameworkLog).write(
                 anyInt(), anyInt(), anyString(), idIntCaptor.capture(), anyInt(), anyBoolean());
 
@@ -236,4 +384,23 @@ public final class ChooserActivityLoggerTest {
         assertThat(idIntCaptor.getValue()).isGreaterThan(0);
         assertThat(idObjectCaptor.getValue().getId()).isEqualTo(idIntCaptor.getValue());
     }
+
+    @Test
+    public void testTargetSelectionCategories() {
+        assertThat(ChooserActivityLogger.getTargetSelectionCategory(
+                ChooserActivityLogger.SELECTION_TYPE_SERVICE))
+                        .isEqualTo(MetricsEvent.ACTION_ACTIVITY_CHOOSER_PICKED_SERVICE_TARGET);
+        assertThat(ChooserActivityLogger.getTargetSelectionCategory(
+                ChooserActivityLogger.SELECTION_TYPE_APP))
+                        .isEqualTo(MetricsEvent.ACTION_ACTIVITY_CHOOSER_PICKED_APP_TARGET);
+        assertThat(ChooserActivityLogger.getTargetSelectionCategory(
+                ChooserActivityLogger.SELECTION_TYPE_STANDARD))
+                        .isEqualTo(MetricsEvent.ACTION_ACTIVITY_CHOOSER_PICKED_STANDARD_TARGET);
+        assertThat(ChooserActivityLogger.getTargetSelectionCategory(
+                ChooserActivityLogger.SELECTION_TYPE_COPY)).isEqualTo(0);
+        assertThat(ChooserActivityLogger.getTargetSelectionCategory(
+                ChooserActivityLogger.SELECTION_TYPE_NEARBY)).isEqualTo(0);
+        assertThat(ChooserActivityLogger.getTargetSelectionCategory(
+                ChooserActivityLogger.SELECTION_TYPE_EDIT)).isEqualTo(0);
+    }
 }
diff --git a/java/tests/src/com/android/intentresolver/ChooserActivityOverrideData.java b/java/tests/src/com/android/intentresolver/ChooserActivityOverrideData.java
index 5acdb42c..5df0d4a2 100644
--- a/java/tests/src/com/android/intentresolver/ChooserActivityOverrideData.java
+++ b/java/tests/src/com/android/intentresolver/ChooserActivityOverrideData.java
@@ -32,7 +32,6 @@ import com.android.intentresolver.AbstractMultiProfilePagerAdapter.MyUserIdProvi
 import com.android.intentresolver.AbstractMultiProfilePagerAdapter.QuietModeManager;
 import com.android.intentresolver.chooser.TargetInfo;
 import com.android.intentresolver.shortcuts.ShortcutLoader;
-import com.android.internal.logging.MetricsLogger;
 
 import java.util.function.Consumer;
 import java.util.function.Function;
@@ -66,7 +65,6 @@ public class ChooserActivityOverrideData {
     public Cursor resolverCursor;
     public boolean resolverForceException;
     public Bitmap previewThumbnail;
-    public MetricsLogger metricsLogger;
     public ChooserActivityLogger chooserActivityLogger;
     public int alternateProfileSetting;
     public Resources resources;
@@ -89,7 +87,6 @@ public class ChooserActivityOverrideData {
         resolverForceException = false;
         resolverListController = mock(ResolverListController.class);
         workResolverListController = mock(ResolverListController.class);
-        metricsLogger = mock(MetricsLogger.class);
         chooserActivityLogger = mock(ChooserActivityLogger.class);
         alternateProfileSetting = 0;
         resources = null;
diff --git a/java/tests/src/com/android/intentresolver/ChooserWrapperActivity.java b/java/tests/src/com/android/intentresolver/ChooserWrapperActivity.java
index 04e727ba..9f1dab77 100644
--- a/java/tests/src/com/android/intentresolver/ChooserWrapperActivity.java
+++ b/java/tests/src/com/android/intentresolver/ChooserWrapperActivity.java
@@ -44,7 +44,6 @@ import com.android.intentresolver.chooser.NotSelectableTargetInfo;
 import com.android.intentresolver.chooser.TargetInfo;
 import com.android.intentresolver.grid.ChooserGridAdapter;
 import com.android.intentresolver.shortcuts.ShortcutLoader;
-import com.android.internal.logging.MetricsLogger;
 import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
 
 import java.util.List;
@@ -223,11 +222,6 @@ public class ChooserWrapperActivity
     }
 
     @Override
-    protected MetricsLogger getMetricsLogger() {
-        return sOverrides.metricsLogger;
-    }
-
-    @Override
     public ChooserActivityLogger getChooserActivityLogger() {
         return sOverrides.chooserActivityLogger;
     }
diff --git a/java/tests/src/com/android/intentresolver/UnbundledChooserActivityTest.java b/java/tests/src/com/android/intentresolver/UnbundledChooserActivityTest.java
index ff166fb7..af2557ef 100644
--- a/java/tests/src/com/android/intentresolver/UnbundledChooserActivityTest.java
+++ b/java/tests/src/com/android/intentresolver/UnbundledChooserActivityTest.java
@@ -43,15 +43,13 @@ import static junit.framework.Assert.assertNull;
 import static org.hamcrest.CoreMatchers.allOf;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.CoreMatchers.notNullValue;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyBoolean;
 import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.atLeastOnce;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
@@ -77,12 +75,12 @@ import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Paint;
 import android.graphics.drawable.Icon;
-import android.metrics.LogMaker;
 import android.net.Uri;
 import android.os.Bundle;
 import android.os.UserHandle;
 import android.provider.DeviceConfig;
 import android.service.chooser.ChooserTarget;
+import android.util.HashedStringCache;
 import android.util.Pair;
 import android.util.SparseArray;
 import android.view.View;
@@ -99,7 +97,6 @@ import com.android.intentresolver.ResolverActivity.ResolvedComponentInfo;
 import com.android.intentresolver.chooser.DisplayResolveInfo;
 import com.android.intentresolver.shortcuts.ShortcutLoader;
 import com.android.internal.config.sysui.SystemUiDeviceConfigFlags;
-import com.android.internal.logging.MetricsLogger;
 import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
 
 import org.hamcrest.Description;
@@ -786,26 +783,15 @@ public class UnbundledChooserActivityTest {
             Mockito.anyBoolean(),
             Mockito.isA(List.class))).thenReturn(resolvedComponentInfos);
 
-        MetricsLogger mockLogger = ChooserActivityOverrideData.getInstance().metricsLogger;
-        ArgumentCaptor<LogMaker> logMakerCaptor = ArgumentCaptor.forClass(LogMaker.class);
-
-        mActivityRule.launchActivity(Intent.createChooser(sendIntent, null));
+        final IChooserWrapper activity = (IChooserWrapper)
+                mActivityRule.launchActivity(Intent.createChooser(sendIntent, null));
         waitForIdle();
 
         onView(withId(com.android.internal.R.id.chooser_copy_button)).check(matches(isDisplayed()));
         onView(withId(com.android.internal.R.id.chooser_copy_button)).perform(click());
 
-        verify(mockLogger, atLeastOnce()).write(logMakerCaptor.capture());
-
-        // The last captured event is the selection of the target.
-        boolean containsTargetEvent = logMakerCaptor.getAllValues()
-                .stream()
-                .anyMatch(item ->
-                        item.getCategory()
-                                == MetricsEvent.ACTION_ACTIVITY_CHOOSER_PICKED_SYSTEM_TARGET);
-        assertTrue(
-                "ACTION_ACTIVITY_CHOOSER_PICKED_SYSTEM_TARGET is expected", containsTargetEvent);
-        assertThat(logMakerCaptor.getValue().getSubtype(), is(1));
+        ChooserActivityLogger logger = activity.getChooserActivityLogger();
+        verify(logger, times(1)).logActionSelected(eq(ChooserActivityLogger.SELECTION_TYPE_COPY));
     }
 
     @Test
@@ -979,25 +965,12 @@ public class UnbundledChooserActivityTest {
         Intent sendIntent = createSendTextIntent();
         sendIntent.setType(TEST_MIME_TYPE);
 
-        MetricsLogger mockLogger = ChooserActivityOverrideData.getInstance().metricsLogger;
-        ArgumentCaptor<LogMaker> logMakerCaptor = ArgumentCaptor.forClass(LogMaker.class);
-        mActivityRule.launchActivity(Intent.createChooser(sendIntent, "logger test"));
-        waitForIdle();
-        verify(mockLogger, atLeastOnce()).write(logMakerCaptor.capture());
-        assertThat(logMakerCaptor.getAllValues().get(0).getCategory(),
-                is(MetricsEvent.ACTION_ACTIVITY_CHOOSER_SHOWN));
-        assertThat(logMakerCaptor
-                .getAllValues().get(0)
-                .getTaggedData(MetricsEvent.FIELD_TIME_TO_APP_TARGETS),
-                is(notNullValue()));
-        assertThat(logMakerCaptor
-                .getAllValues().get(0)
-                .getTaggedData(MetricsEvent.FIELD_SHARESHEET_MIMETYPE),
-                is(TEST_MIME_TYPE));
-        assertThat(logMakerCaptor
-                        .getAllValues().get(0)
-                        .getSubtype(),
-                is(MetricsEvent.PARENT_PROFILE));
+        final IChooserWrapper activity = (IChooserWrapper)
+                mActivityRule.launchActivity(Intent.createChooser(sendIntent, "logger test"));
+        ChooserActivityLogger logger = activity.getChooserActivityLogger();
+        waitForIdle();
+
+        verify(logger).logChooserActivityShown(eq(false), eq(TEST_MIME_TYPE), anyLong());
     }
 
     @Test
@@ -1006,49 +979,32 @@ public class UnbundledChooserActivityTest {
         sendIntent.setType(TEST_MIME_TYPE);
         ChooserActivityOverrideData.getInstance().alternateProfileSetting =
                 MetricsEvent.MANAGED_PROFILE;
-        MetricsLogger mockLogger = ChooserActivityOverrideData.getInstance().metricsLogger;
-        ArgumentCaptor<LogMaker> logMakerCaptor = ArgumentCaptor.forClass(LogMaker.class);
-        mActivityRule.launchActivity(Intent.createChooser(sendIntent, "logger test"));
-        waitForIdle();
-        verify(mockLogger, atLeastOnce()).write(logMakerCaptor.capture());
-        assertThat(logMakerCaptor.getAllValues().get(0).getCategory(),
-                is(MetricsEvent.ACTION_ACTIVITY_CHOOSER_SHOWN));
-        assertThat(logMakerCaptor
-                        .getAllValues().get(0)
-                        .getTaggedData(MetricsEvent.FIELD_TIME_TO_APP_TARGETS),
-                is(notNullValue()));
-        assertThat(logMakerCaptor
-                        .getAllValues().get(0)
-                        .getTaggedData(MetricsEvent.FIELD_SHARESHEET_MIMETYPE),
-                is(TEST_MIME_TYPE));
-        assertThat(logMakerCaptor
-                        .getAllValues().get(0)
-                        .getSubtype(),
-                is(MetricsEvent.MANAGED_PROFILE));
+
+        final IChooserWrapper activity = (IChooserWrapper)
+                mActivityRule.launchActivity(Intent.createChooser(sendIntent, "logger test"));
+        ChooserActivityLogger logger = activity.getChooserActivityLogger();
+        waitForIdle();
+
+        verify(logger).logChooserActivityShown(eq(true), eq(TEST_MIME_TYPE), anyLong());
     }
 
     @Test
     public void testEmptyPreviewLogging() {
         Intent sendIntent = createSendTextIntentWithPreview(null, null);
 
-        MetricsLogger mockLogger = ChooserActivityOverrideData.getInstance().metricsLogger;
-        ArgumentCaptor<LogMaker> logMakerCaptor = ArgumentCaptor.forClass(LogMaker.class);
-        mActivityRule.launchActivity(Intent.createChooser(sendIntent, "empty preview logger test"));
+        final IChooserWrapper activity = (IChooserWrapper)
+                mActivityRule.launchActivity(
+                        Intent.createChooser(sendIntent, "empty preview logger test"));
+        ChooserActivityLogger logger = activity.getChooserActivityLogger();
         waitForIdle();
 
-        verify(mockLogger, Mockito.times(1)).write(logMakerCaptor.capture());
-        // First invocation is from onCreate
-        assertThat(logMakerCaptor.getAllValues().get(0).getCategory(),
-                is(MetricsEvent.ACTION_ACTIVITY_CHOOSER_SHOWN));
+        verify(logger).logChooserActivityShown(eq(false), eq(null), anyLong());
     }
 
     @Test
     public void testTitlePreviewLogging() {
         Intent sendIntent = createSendTextIntentWithPreview("TestTitle", null);
 
-        MetricsLogger mockLogger = ChooserActivityOverrideData.getInstance().metricsLogger;
-        ArgumentCaptor<LogMaker> logMakerCaptor = ArgumentCaptor.forClass(LogMaker.class);
-
         List<ResolvedComponentInfo> resolvedComponentInfos = createResolvedComponentsForTest(2);
 
         when(ChooserActivityOverrideData.getInstance().resolverListController.getResolversForIntent(
@@ -1057,14 +1013,13 @@ public class UnbundledChooserActivityTest {
             Mockito.anyBoolean(),
             Mockito.isA(List.class))).thenReturn(resolvedComponentInfos);
 
-        mActivityRule.launchActivity(Intent.createChooser(sendIntent, null));
+        final IChooserWrapper activity = (IChooserWrapper)
+                mActivityRule.launchActivity(Intent.createChooser(sendIntent, null));
         waitForIdle();
+
         // Second invocation is from onCreate
-        verify(mockLogger, Mockito.times(2)).write(logMakerCaptor.capture());
-        assertThat(logMakerCaptor.getAllValues().get(0).getSubtype(),
-                is(CONTENT_PREVIEW_TEXT));
-        assertThat(logMakerCaptor.getAllValues().get(0).getCategory(),
-                is(MetricsEvent.ACTION_SHARE_WITH_PREVIEW));
+        ChooserActivityLogger logger = activity.getChooserActivityLogger();
+        Mockito.verify(logger, times(1)).logActionShareWithPreview(eq(CONTENT_PREVIEW_TEXT));
     }
 
     @Test
@@ -1092,16 +1047,11 @@ public class UnbundledChooserActivityTest {
                                 Mockito.isA(List.class)))
                 .thenReturn(resolvedComponentInfos);
 
-        MetricsLogger mockLogger = ChooserActivityOverrideData.getInstance().metricsLogger;
-        ArgumentCaptor<LogMaker> logMakerCaptor = ArgumentCaptor.forClass(LogMaker.class);
-        mActivityRule.launchActivity(Intent.createChooser(sendIntent, null));
+        final IChooserWrapper activity = (IChooserWrapper)
+                mActivityRule.launchActivity(Intent.createChooser(sendIntent, null));
         waitForIdle();
-        verify(mockLogger, Mockito.times(2)).write(logMakerCaptor.capture());
-        // First invocation is from onCreate
-        assertThat(logMakerCaptor.getAllValues().get(0).getSubtype(),
-                is(CONTENT_PREVIEW_IMAGE));
-        assertThat(logMakerCaptor.getAllValues().get(0).getCategory(),
-                is(MetricsEvent.ACTION_SHARE_WITH_PREVIEW));
+        ChooserActivityLogger logger = activity.getChooserActivityLogger();
+        Mockito.verify(logger, times(1)).logActionShareWithPreview(eq(CONTENT_PREVIEW_IMAGE));
     }
 
     @Test
@@ -1302,10 +1252,6 @@ public class UnbundledChooserActivityTest {
                                 Mockito.isA(List.class)))
                 .thenReturn(resolvedComponentInfos);
 
-        // Set up resources
-        MetricsLogger mockLogger = ChooserActivityOverrideData.getInstance().metricsLogger;
-        ArgumentCaptor<LogMaker> logMakerCaptor = ArgumentCaptor.forClass(LogMaker.class);
-
         // create test shortcut loader factory, remember loaders and their callbacks
         SparseArray<Pair<ShortcutLoader, Consumer<ShortcutLoader.Result>>> shortcutLoaders =
                 createShortcutLoaderFactory();
@@ -1361,25 +1307,22 @@ public class UnbundledChooserActivityTest {
                 .perform(click());
         waitForIdle();
 
-        // Currently we're seeing 4 invocations
-        //      1. ChooserActivity.logActionShareWithPreview()
-        //      2. ChooserActivity.onCreate()
-        //      3. ChooserActivity.logDirectShareTargetReceived()
-        //      4. ChooserActivity.startSelected -- which is the one we're after
-        verify(mockLogger, Mockito.times(4)).write(logMakerCaptor.capture());
-        LogMaker selectionLog = logMakerCaptor.getAllValues().get(3);
-        assertThat(
-                selectionLog.getCategory(),
-                is(MetricsEvent.ACTION_ACTIVITY_CHOOSER_PICKED_SERVICE_TARGET));
-        String hashedName = (String) selectionLog.getTaggedData(
-                MetricsEvent.FIELD_HASHED_TARGET_NAME);
+        ArgumentCaptor<HashedStringCache.HashResult> hashCaptor =
+                ArgumentCaptor.forClass(HashedStringCache.HashResult.class);
+        verify(activity.getChooserActivityLogger(), times(1)).logShareTargetSelected(
+                eq(ChooserActivityLogger.SELECTION_TYPE_SERVICE),
+                /* packageName= */ any(),
+                /* positionPicked= */ anyInt(),
+                /* directTargetAlsoRanked= */ eq(-1),
+                /* numCallerProvided= */ anyInt(),
+                /* directTargetHashed= */ hashCaptor.capture(),
+                /* isPinned= */ anyBoolean(),
+                /* successfullySelected= */ anyBoolean(),
+                /* selectionCost= */ anyLong());
+        String hashedName = hashCaptor.getValue().hashedString;
         assertThat(
                 "Hash is not predictable but must be obfuscated",
                 hashedName, is(not(name)));
-        assertThat(
-                "The packages shouldn't match for app target and direct target",
-                selectionLog.getTaggedData(MetricsEvent.FIELD_RANKED_POSITION),
-                is(-1));
     }
 
     // This test is too long and too slow and should not be taken as an example for future tests.
@@ -1399,10 +1342,6 @@ public class UnbundledChooserActivityTest {
                                 Mockito.isA(List.class)))
                 .thenReturn(resolvedComponentInfos);
 
-        // Set up resources
-        MetricsLogger mockLogger = ChooserActivityOverrideData.getInstance().metricsLogger;
-        ArgumentCaptor<LogMaker> logMakerCaptor = ArgumentCaptor.forClass(LogMaker.class);
-
         // create test shortcut loader factory, remember loaders and their callbacks
         SparseArray<Pair<ShortcutLoader, Consumer<ShortcutLoader.Result>>> shortcutLoaders =
                 createShortcutLoaderFactory();
@@ -1460,16 +1399,16 @@ public class UnbundledChooserActivityTest {
                 .perform(click());
         waitForIdle();
 
-        // Currently we're seeing 4 invocations
-        //      1. ChooserActivity.logActionShareWithPreview()
-        //      2. ChooserActivity.onCreate()
-        //      3. ChooserActivity.logDirectShareTargetReceived()
-        //      4. ChooserActivity.startSelected -- which is the one we're after
-        verify(mockLogger, Mockito.times(4)).write(logMakerCaptor.capture());
-        assertThat(logMakerCaptor.getAllValues().get(3).getCategory(),
-                is(MetricsEvent.ACTION_ACTIVITY_CHOOSER_PICKED_SERVICE_TARGET));
-        assertThat("The packages should match for app target and direct target", logMakerCaptor
-                .getAllValues().get(3).getTaggedData(MetricsEvent.FIELD_RANKED_POSITION), is(0));
+        verify(activity.getChooserActivityLogger(), times(1)).logShareTargetSelected(
+                eq(ChooserActivityLogger.SELECTION_TYPE_SERVICE),
+                /* packageName= */ any(),
+                /* positionPicked= */ anyInt(),
+                /* directTargetAlsoRanked= */ eq(0),
+                /* numCallerProvided= */ anyInt(),
+                /* directTargetHashed= */ any(),
+                /* isPinned= */ anyBoolean(),
+                /* successfullySelected= */ anyBoolean(),
+                /* selectionCost= */ anyLong());
     }
 
     @Test
@@ -1787,9 +1726,6 @@ public class UnbundledChooserActivityTest {
                                 Mockito.isA(List.class)))
                 .thenReturn(resolvedComponentInfos);
 
-        // Set up resources
-        MetricsLogger mockLogger = ChooserActivityOverrideData.getInstance().metricsLogger;
-        ArgumentCaptor<LogMaker> logMakerCaptor = ArgumentCaptor.forClass(LogMaker.class);
         // Create direct share target
         List<ChooserTarget> serviceTargets = createDirectShareTargets(1,
                 resolvedComponentInfos.get(14).getResolveInfoAt(0).activityInfo.packageName);
@@ -1830,15 +1766,18 @@ public class UnbundledChooserActivityTest {
                 .perform(click());
         waitForIdle();
 
-        // Currently we're seeing 3 invocations
-        //      1. ChooserActivity.onCreate()
-        //      2. ChooserActivity$ChooserRowAdapter.createContentPreviewView()
-        //      3. ChooserActivity.startSelected -- which is the one we're after
-        verify(mockLogger, Mockito.times(3)).write(logMakerCaptor.capture());
-        assertThat(logMakerCaptor.getAllValues().get(2).getCategory(),
-                is(MetricsEvent.ACTION_ACTIVITY_CHOOSER_PICKED_SERVICE_TARGET));
-        assertThat("The packages shouldn't match for app target and direct target", logMakerCaptor
-                .getAllValues().get(2).getTaggedData(MetricsEvent.FIELD_RANKED_POSITION), is(-1));
+        ChooserActivityLogger logger = wrapper.getChooserActivityLogger();
+        verify(logger, times(1)).logShareTargetSelected(
+                eq(ChooserActivityLogger.SELECTION_TYPE_SERVICE),
+                /* packageName= */ any(),
+                /* positionPicked= */ anyInt(),
+                // The packages sholdn't match for app target and direct target:
+                /* directTargetAlsoRanked= */ eq(-1),
+                /* numCallerProvided= */ anyInt(),
+                /* directTargetHashed= */ any(),
+                /* isPinned= */ anyBoolean(),
+                /* successfullySelected= */ anyBoolean(),
+                /* selectionCost= */ anyLong());
     }
 
     @Test
@@ -2179,9 +2118,16 @@ public class UnbundledChooserActivityTest {
 
         ChooserActivityLogger logger = activity.getChooserActivityLogger();
         ArgumentCaptor<Integer> typeCaptor = ArgumentCaptor.forClass(Integer.class);
-        Mockito.verify(logger, times(1))
-                .logShareTargetSelected(typeCaptor.capture(), any(), anyInt(), anyBoolean());
-        assertThat(typeCaptor.getValue(), is(ChooserActivity.SELECTION_TYPE_SERVICE));
+        verify(logger, times(1)).logShareTargetSelected(
+                eq(ChooserActivityLogger.SELECTION_TYPE_SERVICE),
+                /* packageName= */ any(),
+                /* positionPicked= */ anyInt(),
+                /* directTargetAlsoRanked= */ anyInt(),
+                /* numCallerProvided= */ anyInt(),
+                /* directTargetHashed= */ any(),
+                /* isPinned= */ anyBoolean(),
+                /* successfullySelected= */ anyBoolean(),
+                /* selectionCost= */ anyLong());
     }
 
     @Test @Ignore