Impl the detect & show pipeline for PowerAnomalyEventList.

Test: make SettingsLibRoboTests
Bug: 293813663
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:4c6f81c41e2806f384d2e465e89dadb7383048e8)
Change-Id: I0c477dc546ec4d00e4c4133afb61bf7d574be9f8

src/com/android/settings/fuelgauge/batteryusage/BatteryChartPreferenceController.java

@@ -36,6 +36,7 @@ import androidx.preference.PreferenceScreen;
 import com.android.settings.R;
 import com.android.settings.SettingsActivity;
 import com.android.settings.core.PreferenceControllerMixin;
+import com.android.settings.fuelgauge.PowerUsageFeatureProvider;
 import com.android.settings.overlay.FeatureFactory;
 import com.android.settingslib.core.AbstractPreferenceController;
 import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
@@ -52,6 +53,8 @@ import java.util.ArrayList;
 import java.util.Calendar;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 
 /** Controls the update for chart graph and the list items. */
 public class BatteryChartPreferenceController extends AbstractPreferenceController
@@ -136,11 +139,13 @@ public class BatteryChartPreferenceController extends AbstractPreferenceControll
 
     private final SettingsActivity mActivity;
     private final MetricsFeatureProvider mMetricsFeatureProvider;
+    private final PowerUsageFeatureProvider mPowerUsageFeatureProvider;
     private final Handler mHandler = new Handler(Looper.getMainLooper());
     private final AnimatorListenerAdapter mHourlyChartFadeInAdapter =
             createHourlyChartAnimatorListenerAdapter(/*visible=*/ true);
     private final AnimatorListenerAdapter mHourlyChartFadeOutAdapter =
             createHourlyChartAnimatorListenerAdapter(/*visible=*/ false);
+    private final ExecutorService mExecutor = Executors.newSingleThreadExecutor();
 
     @VisibleForTesting
     final DailyChartLabelTextGenerator mDailyChartLabelTextGenerator =
@@ -156,6 +161,8 @@ public class BatteryChartPreferenceController extends AbstractPreferenceControll
         mIs24HourFormat = DateFormat.is24HourFormat(context);
         mMetricsFeatureProvider =
                 FeatureFactory.getFeatureFactory().getMetricsFeatureProvider();
+        mPowerUsageFeatureProvider =
+                FeatureFactory.getFeatureFactory().getPowerUsageFeatureProvider();
         if (lifecycle != null) {
             lifecycle.addObserver(this);
         }
@@ -364,13 +371,32 @@ public class BatteryChartPreferenceController extends AbstractPreferenceControll
                     slotUsageData, getSlotInformation(), isBatteryUsageMapNullOrEmpty());
 
             if (mOnBatteryTipsUpdatedListener != null) {
-                // TODO: replace with a selected powerAnomalyEvent with highest score
+                mExecutor.execute(() -> {
-                mOnBatteryTipsUpdatedListener.onBatteryTipsUpdated(null);
+                    final PowerAnomalyEventList anomalyEventList = mPowerUsageFeatureProvider
+                            .detectSettingsAnomaly(mContext, /* displayDrain= */ 0);
+                    final PowerAnomalyEvent displayEvent =
+                            getHighestScoreAnomalyEvent(anomalyEventList);
+                    mHandler.post(()
+                            -> mOnBatteryTipsUpdatedListener.onBatteryTipsUpdated(displayEvent));
+                });
             }
         }
         return true;
     }
 
+    private PowerAnomalyEvent getHighestScoreAnomalyEvent(PowerAnomalyEventList anomalyEventList) {
+        if (anomalyEventList == null || anomalyEventList.getPowerAnomalyEventsCount() == 0) {
+            return null;
+        }
+        PowerAnomalyEvent highestScoreEvent = null;
+        for (PowerAnomalyEvent event : anomalyEventList.getPowerAnomalyEventsList()) {
+            if (highestScoreEvent == null || event.getScore() > highestScoreEvent.getScore()) {
+                highestScoreEvent = event;
+            }
+        }
+        return highestScoreEvent;
+    }
+
     private boolean refreshUiWithNoLevelDataCase() {
         setChartSummaryVisible(false);
         if (mBatteryUsageMap == null) {

tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryTipsCardPreferenceTest.java

@@ -18,15 +18,30 @@ package com.android.settings.fuelgauge.batteryusage;
 
 import static com.google.common.truth.Truth.assertThat;
 
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
+import android.app.settings.SettingsEnums;
 import android.content.Context;
+import android.content.Intent;
+import android.view.View;
 
 import com.android.settings.R;
+import com.android.settings.SettingsActivity;
+import com.android.settings.display.AutoBrightnessSettings;
+import com.android.settings.fuelgauge.PowerUsageFeatureProvider;
+import com.android.settings.testutils.BatteryTestUtils;
+import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
 
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.RuntimeEnvironment;
 
@@ -36,13 +51,19 @@ public final class BatteryTipsCardPreferenceTest {
     private Context mContext;
     private BatteryTipsCardPreference mBatteryTipsCardPreference;
     private BatteryTipsController mBatteryTipsController;
+    @Mock
+    private View mFakeView;
+    @Mock
+    private PowerUsageFeatureProvider mPowerUsageFeatureProvider;
 
     @Before
     public void setUp() {
+        MockitoAnnotations.initMocks(this);
         mContext = spy(RuntimeEnvironment.application);
         mBatteryTipsCardPreference = new BatteryTipsCardPreference(mContext, /*attrs=*/ null);
         mBatteryTipsController = new BatteryTipsController(mContext);
         mBatteryTipsController.mCardPreference = mBatteryTipsCardPreference;
+        mBatteryTipsController.mPowerUsageFeatureProvider = mPowerUsageFeatureProvider;
     }
 
     @Test
@@ -50,4 +71,23 @@ public final class BatteryTipsCardPreferenceTest {
         assertThat(mBatteryTipsCardPreference.getLayoutResource()).isEqualTo(
                 R.layout.battery_tips_card);
     }
+    @Test
+    public void onClick_actionBtn_getAdaptiveBrightnessLauncher() {
+        final ArgumentCaptor<Intent> captor = ArgumentCaptor.forClass(Intent.class);
+        PowerAnomalyEvent adaptiveBrightnessAnomaly =
+                BatteryTestUtils.createAdaptiveBrightnessAnomalyEvent();
+        when(mPowerUsageFeatureProvider.isBatteryTipsEnabled()).thenReturn(true);
+        when(mFakeView.getId()).thenReturn(R.id.main_button);
+        doNothing().when(mContext).startActivity(captor.capture());
+
+        mBatteryTipsController.handleBatteryTipsCardUpdated(adaptiveBrightnessAnomaly);
+        mBatteryTipsCardPreference.onClick(mFakeView);
+
+        verify(mContext).startActivity(any(Intent.class));
+        final Intent intent = captor.getValue();
+        assertThat(intent.getStringExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT))
+                .isEqualTo(AutoBrightnessSettings.class.getName());
+        assertThat(intent.getIntExtra(MetricsFeatureProvider.EXTRA_SOURCE_METRICS_CATEGORY, -1))
+                .isEqualTo(SettingsEnums.SETTINGS_AUTO_BRIGHTNESS);
+    }
 }