diff --git a/res/drawable-nodpi/auto_awesome_battery b/res/drawable-nodpi/auto_awesome_battery
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/res/drawable-nodpi/auto_awesome_battery
diff --git a/res/drawable/ic_settings_aod.xml b/res/drawable/ic_settings_aod.xml
new file mode 100644
index 0000000..8d91349
--- /dev/null
+++ b/res/drawable/ic_settings_aod.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Copyright (C) 2018 The Android Open Source Project
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+  -->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+        android:width="24dp"
+        android:height="24dp"
+        android:viewportWidth="24"
+        android:viewportHeight="24">
+
+    <path
+        android:fillColor="#000000"
+        android:pathData="M17,1.01L7,1C5.9,1,5,1.9,5,3v18c0,1.1,0.9,2,2,2h10c1.1,0,2-0.9,2-2V3C19,1.9,18.1,1.01,17,1.01z M17,21H7l0-1h10V21z M17,18H7V6h10V18z M17,4H7V3h10V4z" />
+    <path
+        android:fillColor="#000000"
+        android:pathData="M 8 10 H 16 V 11.5 H 8 V 10 Z" />
+    <path
+        android:fillColor="#000000"
+        android:pathData="M 9 13 H 15 V 14.5 H 9 V 13 Z" />
+    <path
+        android:pathData="M 0 0 H 24 V 24 H 0 V 0 Z" />
+</vector>
\ No newline at end of file
diff --git a/res/layout/smart_battery_header.xml b/res/layout/smart_battery_header.xml
deleted file mode 100644
index 960f04a..0000000
--- a/res/layout/smart_battery_header.xml
+++ /dev/null
@@ -1,30 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  Copyright (C) 2018 The Android Open Source Project
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-  -->
-
-<!-- Entity header -->
-<LinearLayout
-    xmlns:android="http://schemas.android.com/apk/res/android"
-    android:id="@+id/entity_header"
-    style="@style/EntityHeader"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent"
-    android:minHeight="200dp"
-    android:paddingBottom="32dp"
-    android:paddingStart="@dimen/preference_no_icon_padding_start"
-    android:paddingTop="24dp">
-
-</LinearLayout>
diff --git a/res/layout/video_preference.xml b/res/layout/video_preference.xml
index 9ab52ae..55bc7a5 100644
--- a/res/layout/video_preference.xml
+++ b/res/layout/video_preference.xml
@@ -23,11 +23,11 @@
     android:clipToPadding="false"
     android:gravity="center"
     android:minHeight="?android:attr/listPreferredItemHeightSmall"
-    android:paddingEnd="?android:attr/listPreferredItemPaddingEnd"
     android:orientation="horizontal">
 
     <com.android.settings.widget.AspectRatioFrameLayout
-        android:layout_width="240dp"
+        android:id="@+id/video_container"
+        android:layout_width="wrap_content"
         android:layout_height="240dp"
         android:padding="@dimen/gesture_animation_padding">
 
diff --git a/res/raw/auto_awesome_battery.mp4 b/res/raw/auto_awesome_battery.mp4
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/res/raw/auto_awesome_battery.mp4
diff --git a/res/values/strings.xml b/res/values/strings.xml
index 15e399d..bb61612 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -8769,9 +8769,9 @@
     <string name="android_version_pending_update_summary">Update available</string>
 
     <!-- Title for dialog displayed when user selects on a setting locked by an admin [CHAR LIMIT=30] -->
-    <string name="disabled_by_policy_title">Can\'t change this setting</string>
+    <string name="disabled_by_policy_title">Can’t change this setting</string>
     <!-- Title for dialog displayed to tell user that changing volume was disallowed by an admin [CHAR LIMIT=50] -->
-    <string name="disabled_by_policy_title_adjust_volume">Can\'t change volume</string>
+    <string name="disabled_by_policy_title_adjust_volume">Can’t change volume</string>
     <!-- Title for dialog displayed to tell user that outgoing calls were disabled by an admin [CHAR LIMIT=50] -->
     <string name="disabled_by_policy_title_outgoing_calls">Calling not allowed</string>
     <!-- Title for dialog displayed to tell user that sending SMS were disabled by an admin [CHAR LIMIT=50] -->
@@ -8781,9 +8781,9 @@
     <!-- Title for dialog displayed to tell user that screenshots are disabled by an admin [CHAR LIMIT=50] -->
     <string name="disabled_by_policy_title_screen_capture">Screenshot not allowed</string>
     <!-- Title for dialog displayed to tell user that turning off backups is disallowed by an admin [CHAR LIMIT=50] -->
-    <string name="disabled_by_policy_title_turn_off_backups">Can\'t turn off backups</string>
+    <string name="disabled_by_policy_title_turn_off_backups">Can’t turn off backups</string>
     <!-- Title for dialog displayed to tell user that the app was suspended by an admin [CHAR LIMIT=50] -->
-    <string name="disabled_by_policy_title_suspend_packages">Can\'t open this app</string>
+    <string name="disabled_by_policy_title_suspend_packages">Can’t open this app</string>
     <!-- Shown when the user tries to change a settings locked by an admin [CHAR LIMIT=200] -->
     <string name="default_admin_support_msg">If you have questions, contact your IT admin</string>
     <!-- Shown in dialog to allow user to see more information about the device admin [CHAR LIMIT=30] -->
diff --git a/res/xml/smart_battery_detail.xml b/res/xml/smart_battery_detail.xml
index e7fb9f7..e1246ed 100644
--- a/res/xml/smart_battery_detail.xml
+++ b/res/xml/smart_battery_detail.xml
@@ -21,18 +21,16 @@
     android:key="smart_battery_detail"
     android:title="@string/smart_battery_manager_title">
 
-    <!-- TODO(b/71722498): Add header back, otherwise also remove smart_battery_header
-    <com.android.settings.applications.LayoutPreference
-        android:key="header_view"
-        android:layout="@layout/smart_battery_header"
-        android:selectable="false"
-        android:order="-10000"/>
-     -->
+    <com.android.settings.widget.VideoPreference
+        android:key="auto_awesome_battery"
+        settings:animation="@raw/auto_awesome_battery"
+        settings:preview="@drawable/auto_awesome_battery"/>
 
     <SwitchPreference
         android:key="smart_battery"
         android:title="@string/smart_battery_title"
-        android:summary="@string/smart_battery_summary"/>
+        android:summary="@string/smart_battery_summary"
+        settings:allowDividerAbove="true"/>
 
     <SwitchPreference
         android:key="auto_restriction"
diff --git a/src/com/android/settings/SettingsDumpService.java b/src/com/android/settings/SettingsDumpService.java
index 67a8f50..07ea73e 100644
--- a/src/com/android/settings/SettingsDumpService.java
+++ b/src/com/android/settings/SettingsDumpService.java
@@ -15,7 +15,9 @@
 package com.android.settings;
 
 import android.app.Service;
+import android.content.Context;
 import android.content.Intent;
+import android.content.SharedPreferences;
 import android.content.pm.PackageManager;
 import android.content.pm.ResolveInfo;
 import android.net.ConnectivityManager;
@@ -27,9 +29,12 @@
 import android.telephony.SubscriptionInfo;
 import android.telephony.SubscriptionManager;
 import android.telephony.TelephonyManager;
+
 import com.android.internal.annotations.VisibleForTesting;
 import com.android.settings.applications.ProcStatsData;
+import com.android.settings.fuelgauge.batterytip.AnomalyConfigJobService;
 import com.android.settingslib.net.DataUsageController;
+
 import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
@@ -39,12 +44,20 @@
 import java.io.PrintWriter;
 
 public class SettingsDumpService extends Service {
-    @VisibleForTesting static final String KEY_SERVICE = "service";
-    @VisibleForTesting static final String KEY_STORAGE = "storage";
-    @VisibleForTesting static final String KEY_DATAUSAGE = "datausage";
-    @VisibleForTesting static final String KEY_MEMORY = "memory";
-    @VisibleForTesting static final String KEY_DEFAULT_BROWSER_APP = "default_browser_app";
-    @VisibleForTesting static final Intent BROWSER_INTENT =
+    @VisibleForTesting
+    static final String KEY_SERVICE = "service";
+    @VisibleForTesting
+    static final String KEY_STORAGE = "storage";
+    @VisibleForTesting
+    static final String KEY_DATAUSAGE = "datausage";
+    @VisibleForTesting
+    static final String KEY_MEMORY = "memory";
+    @VisibleForTesting
+    static final String KEY_DEFAULT_BROWSER_APP = "default_browser_app";
+    @VisibleForTesting
+    static final String KEY_ANOMALY_DETECTION = "anomaly_detection";
+    @VisibleForTesting
+    static final Intent BROWSER_INTENT =
             new Intent("android.intent.action.VIEW", Uri.parse("http://"));
 
     @Override
@@ -62,6 +75,7 @@
             dump.put(KEY_DATAUSAGE, dumpDataUsage());
             dump.put(KEY_MEMORY, dumpMemory());
             dump.put(KEY_DEFAULT_BROWSER_APP, dumpDefaultBrowser());
+            dump.put(KEY_ANOMALY_DETECTION, dumpAnomalyDetection());
         } catch (Exception e) {
             e.printStackTrace();
         }
@@ -151,4 +165,18 @@
             return resolveInfo.activityInfo.packageName;
         }
     }
+
+    @VisibleForTesting
+    JSONObject dumpAnomalyDetection() throws JSONException {
+        final JSONObject obj = new JSONObject();
+        final SharedPreferences sharedPreferences = getSharedPreferences(
+                AnomalyConfigJobService.PREF_DB,
+                Context.MODE_PRIVATE);
+        final int currentVersion = sharedPreferences.getInt(
+                AnomalyConfigJobService.KEY_ANOMALY_CONFIG_VERSION,
+                0 /* defValue */);
+        obj.put("anomaly_config_version", String.valueOf(currentVersion));
+
+        return obj;
+    }
 }
diff --git a/src/com/android/settings/display/ColorModePreferenceFragment.java b/src/com/android/settings/display/ColorModePreferenceFragment.java
index 5f5445b..6e4bd1f 100644
--- a/src/com/android/settings/display/ColorModePreferenceFragment.java
+++ b/src/com/android/settings/display/ColorModePreferenceFragment.java
@@ -16,6 +16,7 @@
 import android.content.Context;
 import android.graphics.drawable.Drawable;
 import android.support.annotation.VisibleForTesting;
+import android.support.v7.preference.Preference;
 import android.support.v7.preference.PreferenceScreen;
 
 import com.android.internal.app.ColorDisplayController;
@@ -24,13 +25,15 @@
 import com.android.settings.applications.LayoutPreference;
 import com.android.settings.R;
 import com.android.settings.widget.RadioButtonPickerFragment;
+import com.android.settings.widget.RadioButtonPreference;
 import com.android.settingslib.widget.CandidateInfo;
 
 import java.util.Arrays;
 import java.util.List;
 
 @SuppressWarnings("WeakerAccess")
-public class ColorModePreferenceFragment extends RadioButtonPickerFragment {
+public class ColorModePreferenceFragment extends RadioButtonPickerFragment
+        implements ColorDisplayController.Callback {
 
     @VisibleForTesting
     static final String KEY_COLOR_MODE_NATURAL = "color_mode_natural";
@@ -48,6 +51,16 @@
     public void onAttach(Context context) {
         super.onAttach(context);
         mController = new ColorDisplayController(context);
+        mController.setListener(this);
+    }
+
+    @Override
+    public void onDetach() {
+        super.onDetach();
+        if (mController != null) {
+            mController.setListener(null);
+            mController = null;
+        }
     }
 
     @Override
@@ -71,15 +84,16 @@
     @Override
     protected List<? extends CandidateInfo> getCandidates() {
         Context c = getContext();
+        final boolean enabled = !mController.getAccessibilityTransformActivated();
         return Arrays.asList(
-            new ColorModeCandidateInfo(c.getString(R.string.color_mode_option_natural),
-                    KEY_COLOR_MODE_NATURAL),
-            new ColorModeCandidateInfo(c.getString(R.string.color_mode_option_boosted),
-                    KEY_COLOR_MODE_BOOSTED),
-            new ColorModeCandidateInfo(c.getString(R.string.color_mode_option_saturated),
-                    KEY_COLOR_MODE_SATURATED),
-            new ColorModeCandidateInfo(c.getString(R.string.color_mode_option_automatic),
-                    KEY_COLOR_MODE_AUTOMATIC)
+            new ColorModeCandidateInfo(c.getText(R.string.color_mode_option_natural),
+                    KEY_COLOR_MODE_NATURAL, enabled),
+            new ColorModeCandidateInfo(c.getText(R.string.color_mode_option_boosted),
+                    KEY_COLOR_MODE_BOOSTED, enabled),
+            new ColorModeCandidateInfo(c.getText(R.string.color_mode_option_saturated),
+                    KEY_COLOR_MODE_SATURATED, enabled),
+            new ColorModeCandidateInfo(c.getText(R.string.color_mode_option_automatic),
+                    KEY_COLOR_MODE_AUTOMATIC, enabled)
         );
     }
 
@@ -120,8 +134,8 @@
         private final CharSequence mLabel;
         private final String mKey;
 
-        ColorModeCandidateInfo(CharSequence label, String key) {
-            super(true);
+        ColorModeCandidateInfo(CharSequence label, String key, boolean enabled) {
+            super(enabled);
             mLabel = label;
             mKey = key;
         }
@@ -142,4 +156,18 @@
         }
     }
 
+    @Override
+    public void onAccessibilityTransformChanged(boolean state) {
+        // Disable controls when a11y transforms are enabled, and vice versa
+        final PreferenceScreen screen = getPreferenceScreen();
+        if (screen != null) {
+            final int count = screen.getPreferenceCount();
+            for (int i = 0; i < count; i++) {
+                final Preference pref = screen.getPreference(i);
+                if (pref instanceof RadioButtonPreference) {
+                    pref.setEnabled(!state);
+                }
+            }
+        }
+    }
 }
diff --git a/src/com/android/settings/fuelgauge/BatteryEntry.java b/src/com/android/settings/fuelgauge/BatteryEntry.java
index 1733a6e..a93d522 100644
--- a/src/com/android/settings/fuelgauge/BatteryEntry.java
+++ b/src/com/android/settings/fuelgauge/BatteryEntry.java
@@ -209,6 +209,10 @@
                 name = context.getResources().getString(R.string.power_camera);
                 iconId = R.drawable.ic_settings_camera;
                 break;
+            case AMBIENT_DISPLAY:
+                name = context.getResources().getString(R.string.ambient_display_screen_title);
+                iconId = R.drawable.ic_settings_aod;
+                break;
         }
         if (iconId > 0) {
             icon = context.getDrawable(iconId);
diff --git a/src/com/android/settings/fuelgauge/batterytip/AnomalyConfigJobService.java b/src/com/android/settings/fuelgauge/batterytip/AnomalyConfigJobService.java
index 98eb23e..5686d6e 100644
--- a/src/com/android/settings/fuelgauge/batterytip/AnomalyConfigJobService.java
+++ b/src/com/android/settings/fuelgauge/batterytip/AnomalyConfigJobService.java
@@ -39,9 +39,8 @@
 public class AnomalyConfigJobService extends JobService {
     private static final String TAG = "AnomalyConfigJobService";
 
-    @VisibleForTesting
-    static final String PREF_DB = "anomaly_pref";
-    private static final String KEY_ANOMALY_CONFIG_VERSION = "anomaly_config_version";
+    public static final String PREF_DB = "anomaly_pref";
+    public static final String KEY_ANOMALY_CONFIG_VERSION = "anomaly_config_version";
     private static final int DEFAULT_VERSION = 0;
 
     @VisibleForTesting
diff --git a/src/com/android/settings/fuelgauge/batterytip/AnomalyDetectionJobService.java b/src/com/android/settings/fuelgauge/batterytip/AnomalyDetectionJobService.java
index 451b402..2b04173 100644
--- a/src/com/android/settings/fuelgauge/batterytip/AnomalyDetectionJobService.java
+++ b/src/com/android/settings/fuelgauge/batterytip/AnomalyDetectionJobService.java
@@ -30,6 +30,7 @@
 import android.content.ContentResolver;
 import android.content.Context;
 import android.content.Intent;
+import android.content.pm.PackageManager;
 import android.os.Bundle;
 import android.os.Process;
 import android.os.StatsDimensionsValue;
@@ -131,6 +132,7 @@
                 StatsManager.EXTRA_STATS_BROADCAST_SUBSCRIBER_COOKIES);
         final AnomalyInfo anomalyInfo = new AnomalyInfo(
                 !ArrayUtils.isEmpty(cookies) ? cookies.get(0) : "");
+        final PackageManager packageManager = context.getPackageManager();
         Log.i(TAG, "Extra stats value: " + intentDimsValue.toString());
 
         try {
@@ -141,8 +143,8 @@
                     : Settings.Global.getInt(contentResolver,
                             Settings.Global.APP_AUTO_RESTRICTION_ENABLED, ON) == ON;
             final String packageName = batteryUtils.getPackageName(uid);
-            if (!powerWhitelistBackend.isSysWhitelistedExceptIdle(packageName)
-                    && !isSystemUid(uid)) {
+            if (!isSystemUid(uid) && !powerWhitelistBackend.isSysWhitelistedExceptIdle(
+                    packageManager.getPackagesForUid(uid))) {
                 boolean anomalyDetected = true;
                 if (anomalyInfo.anomalyType
                         == StatsManagerConfig.AnomalyType.EXCESSIVE_BACKGROUND_SERVICE) {
diff --git a/src/com/android/settings/widget/AspectRatioFrameLayout.java b/src/com/android/settings/widget/AspectRatioFrameLayout.java
index bb4c28b..52dea0f 100644
--- a/src/com/android/settings/widget/AspectRatioFrameLayout.java
+++ b/src/com/android/settings/widget/AspectRatioFrameLayout.java
@@ -16,6 +16,7 @@
 
 import android.content.Context;
 import android.content.res.TypedArray;
+import android.support.annotation.VisibleForTesting;
 import android.util.AttributeSet;
 import android.widget.FrameLayout;
 
@@ -30,7 +31,8 @@
 
     private static final float ASPECT_RATIO_CHANGE_THREASHOLD = 0.01f;
 
-    private float mAspectRatio = 1.0f;
+    @VisibleForTesting
+    float mAspectRatio = 1.0f;
 
     public AspectRatioFrameLayout(Context context) {
         this(context, null);
@@ -51,6 +53,10 @@
         }
     }
 
+    public void setAspectRatio(float aspectRadio) {
+        mAspectRatio = aspectRadio;
+    }
+
     @Override
     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
         super.onMeasure(widthMeasureSpec, heightMeasureSpec);
@@ -65,11 +71,9 @@
             // Close enough, skip.
             return;
         }
-        if (aspectRatioDiff > 0) {
-            width = (int) (height * mAspectRatio);
-        } else {
-            height = (int) (width / mAspectRatio);
-        }
+
+        width = (int) (height * mAspectRatio);
+
         super.onMeasure(MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
                 MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY));
     }
diff --git a/src/com/android/settings/widget/VideoPreference.java b/src/com/android/settings/widget/VideoPreference.java
index a3ac6a3..03f8f0b 100644
--- a/src/com/android/settings/widget/VideoPreference.java
+++ b/src/com/android/settings/widget/VideoPreference.java
@@ -22,6 +22,7 @@
 import android.graphics.SurfaceTexture;
 import android.media.MediaPlayer;
 import android.net.Uri;
+import android.support.annotation.VisibleForTesting;
 import android.support.v7.preference.Preference;
 import android.support.v7.preference.PreferenceViewHolder;
 import android.util.AttributeSet;
@@ -42,10 +43,13 @@
     private final Context mContext;
 
     private Uri mVideoPath;
-    private MediaPlayer mMediaPlayer;
-    private boolean mAnimationAvailable;
+    @VisibleForTesting
+    MediaPlayer mMediaPlayer;
+    @VisibleForTesting
+    boolean mAnimationAvailable;
     private boolean mVideoReady;
     private boolean mVideoPaused;
+    private float mAspectRadio = 1.0f;
     private int mPreviewResource;
 
     public VideoPreference(Context context, AttributeSet attrs) {
@@ -73,6 +77,7 @@
 
                 mMediaPlayer.setOnPreparedListener(mediaPlayer -> mediaPlayer.setLooping(true));
                 mAnimationAvailable = true;
+                updateAspectRatio();
             } else {
                 setVisible(false);
             }
@@ -94,7 +99,11 @@
         final TextureView video = (TextureView) holder.findViewById(R.id.video_texture_view);
         final ImageView imageView = (ImageView) holder.findViewById(R.id.video_preview_image);
         final ImageView playButton = (ImageView) holder.findViewById(R.id.video_play_button);
+        final AspectRatioFrameLayout layout = (AspectRatioFrameLayout) holder.findViewById(
+                R.id.video_container);
+
         imageView.setImageResource(mPreviewResource);
+        layout.setAspectRatio(mAspectRadio);
 
         video.setOnClickListener(v -> {
             if (mMediaPlayer != null) {
@@ -178,4 +187,9 @@
         return mVideoPaused;
     }
 
+    @VisibleForTesting
+    void updateAspectRatio() {
+        mAspectRadio = mMediaPlayer.getVideoWidth() / (float)mMediaPlayer.getVideoHeight();
+    }
+
 }
diff --git a/tests/robotests/assets/grandfather_slice_controller_not_in_xml b/tests/robotests/assets/grandfather_slice_controller_not_in_xml
index 1a67726..ae1c86a 100644
--- a/tests/robotests/assets/grandfather_slice_controller_not_in_xml
+++ b/tests/robotests/assets/grandfather_slice_controller_not_in_xml
@@ -1,2 +1,2 @@
 com.android.settings.testutils.FakeToggleController
-com.android.settings.core.TogglePreferenceControllerTest$FakeToggle
+com.android.settings.testutils.FakeSliderController
diff --git a/tests/robotests/src/com/android/settings/SettingsDumpServiceTest.java b/tests/robotests/src/com/android/settings/SettingsDumpServiceTest.java
index 615d1e7..8178641 100644
--- a/tests/robotests/src/com/android/settings/SettingsDumpServiceTest.java
+++ b/tests/robotests/src/com/android/settings/SettingsDumpServiceTest.java
@@ -16,13 +16,21 @@
 package com.android.settings;
 
 import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.when;
 
+import android.content.Context;
+import android.content.SharedPreferences;
 import android.content.pm.ActivityInfo;
 import android.content.pm.PackageManager;
 import android.content.pm.ResolveInfo;
 import android.support.annotation.NonNull;
 
+import com.android.settings.fuelgauge.batterytip.AnomalyConfigJobService;
 import com.android.settings.testutils.SettingsRobolectricTestRunner;
 
 import org.json.JSONException;
@@ -32,6 +40,7 @@
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
 
 import java.io.OutputStream;
 import java.io.PrintWriter;
@@ -41,6 +50,7 @@
 
     private static final String PACKAGE_BROWSER = "com.android.test.browser";
     private static final String PACKAGE_NULL = "android";
+    private static final int ANOMALY_VERSION = 2;
 
     @Mock
     private PackageManager mPackageManager;
@@ -54,7 +64,7 @@
 
         when(mPackageManager.resolveActivity(TestService.BROWSER_INTENT,
                 PackageManager.MATCH_DEFAULT_ONLY)).thenReturn(mResolveInfo);
-        mTestService = new TestService();
+        mTestService = spy(new TestService());
         mTestService.setPackageManager(mPackageManager);
     }
 
@@ -75,13 +85,29 @@
     }
 
     @Test
+    public void testDumpAnomalyDetection_returnAnomalyInfo() throws JSONException {
+        final SharedPreferences sharedPreferences =
+                RuntimeEnvironment.application.getSharedPreferences(AnomalyConfigJobService.PREF_DB,
+                        Context.MODE_PRIVATE);
+        SharedPreferences.Editor editor = sharedPreferences.edit();
+        editor.putInt(AnomalyConfigJobService.KEY_ANOMALY_CONFIG_VERSION, ANOMALY_VERSION);
+        editor.commit();
+        doReturn(sharedPreferences).when(mTestService).getSharedPreferences(anyString(), anyInt());
+
+        final JSONObject jsonObject = mTestService.dumpAnomalyDetection();
+
+        assertThat(jsonObject.getInt(AnomalyConfigJobService.KEY_ANOMALY_CONFIG_VERSION)).isEqualTo(
+                ANOMALY_VERSION);
+    }
+
+    @Test
     public void testDump_ReturnJsonObject() throws JSONException {
         mResolveInfo.activityInfo = new ActivityInfo();
         mResolveInfo.activityInfo.packageName = PACKAGE_BROWSER;
         TestPrintWriter printWriter = new TestPrintWriter(System.out);
 
         mTestService.dump(null, printWriter, null);
-        JSONObject object = (JSONObject)printWriter.getPrintObject();
+        JSONObject object = (JSONObject) printWriter.getPrintObject();
 
         assertThat(object.get(TestService.KEY_SERVICE)).isNotNull();
     }
diff --git a/tests/robotests/src/com/android/settings/core/codeinspection/CodeInspectionTest.java b/tests/robotests/src/com/android/settings/core/codeinspection/CodeInspectionTest.java
index c8ad4d6..64412cf 100644
--- a/tests/robotests/src/com/android/settings/core/codeinspection/CodeInspectionTest.java
+++ b/tests/robotests/src/com/android/settings/core/codeinspection/CodeInspectionTest.java
@@ -21,6 +21,7 @@
 import com.android.settings.core.BasePreferenceControllerSignatureInspector;
 import com.android.settings.core.instrumentation.InstrumentableFragmentCodeInspector;
 import com.android.settings.search.SearchIndexProviderCodeInspector;
+import com.android.settings.slices.SliceControllerInXmlCodeInspector;
 import com.android.settings.testutils.SettingsRobolectricTestRunner;
 
 import org.junit.Before;
@@ -51,6 +52,11 @@
     }
 
     @Test
+    public void runSliceControllerInXmlInspection() throws Exception {
+        new SliceControllerInXmlCodeInspector(mClasses).run();
+    }
+
+    @Test
     public void runBasePreferenceControllerConstructorSignatureInspection() {
         new BasePreferenceControllerSignatureInspector(mClasses).run();
     }
diff --git a/tests/robotests/src/com/android/settings/display/ColorModePreferenceFragmentTest.java b/tests/robotests/src/com/android/settings/display/ColorModePreferenceFragmentTest.java
index e962441..6df0c04 100644
--- a/tests/robotests/src/com/android/settings/display/ColorModePreferenceFragmentTest.java
+++ b/tests/robotests/src/com/android/settings/display/ColorModePreferenceFragmentTest.java
@@ -16,8 +16,10 @@
 package com.android.settings.display;
 
 import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Answers.RETURNS_DEEP_STUBS;
 import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
@@ -32,6 +34,7 @@
 import com.android.settings.R;
 import com.android.settings.applications.LayoutPreference;
 import com.android.settings.testutils.SettingsRobolectricTestRunner;
+import com.android.settings.widget.RadioButtonPreference;
 import com.android.settingslib.widget.CandidateInfo;
 
 import org.junit.Before;
@@ -39,11 +42,11 @@
 import org.junit.runner.RunWith;
 import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
-import org.mockito.Mockito;
 import org.mockito.MockitoAnnotations;
 import org.robolectric.RuntimeEnvironment;
 import org.robolectric.util.ReflectionHelpers;
 
+import java.util.ArrayList;
 import java.util.List;
 
 @RunWith(SettingsRobolectricTestRunner.class)
@@ -54,11 +57,14 @@
     @Mock
     private ColorDisplayController mController;
 
+    @Mock
+    private PreferenceScreen mScreen;
+
     @Before
     public void setup() {
         MockitoAnnotations.initMocks(this);
 
-        mFragment = spy(new ColorModePreferenceFragment());
+        mFragment = spy(new ColorModePreferenceFragmentTestable(mScreen));
         ReflectionHelpers.setField(mFragment, "mController", mController);
     }
 
@@ -86,7 +92,7 @@
 
     @Test
     public void getKey_natural() {
-        Mockito.when(mController.getColorMode())
+        when(mController.getColorMode())
             .thenReturn(ColorDisplayController.COLOR_MODE_NATURAL);
 
         assertThat(mFragment.getDefaultKey())
@@ -95,7 +101,7 @@
 
     @Test
     public void getKey_boosted() {
-        Mockito.when(mController.getColorMode())
+        when(mController.getColorMode())
             .thenReturn(ColorDisplayController.COLOR_MODE_BOOSTED);
 
         assertThat(mFragment.getDefaultKey())
@@ -104,7 +110,7 @@
 
     @Test
     public void getKey_saturated() {
-        Mockito.when(mController.getColorMode())
+        when(mController.getColorMode())
             .thenReturn(ColorDisplayController.COLOR_MODE_SATURATED);
 
         assertThat(mFragment.getDefaultKey())
@@ -141,15 +147,64 @@
 
     @Test
     public void addStaticPreferences_shouldAddPreviewImage() {
-        PreferenceScreen mockPreferenceScreen = Mockito.mock(PreferenceScreen.class);
-        LayoutPreference mockPreview = Mockito.mock(LayoutPreference.class);
+        PreferenceScreen mockPreferenceScreen = mock(PreferenceScreen.class);
+        LayoutPreference mockPreview = mock(LayoutPreference.class);
 
         ArgumentCaptor<Preference> preferenceCaptor = ArgumentCaptor.forClass(Preference.class);
 
         mFragment.configureAndInstallPreview(mockPreview, mockPreferenceScreen);
-        Mockito.verify(mockPreview, times(1)).setSelectable(false);
-        Mockito.verify(mockPreferenceScreen, times(1)).addPreference(preferenceCaptor.capture());
+        verify(mockPreview, times(1)).setSelectable(false);
+        verify(mockPreferenceScreen, times(1)).addPreference(preferenceCaptor.capture());
 
         assertThat(preferenceCaptor.getValue()).isEqualTo(mockPreview);
     }
+
+    @Test
+    public void onAccessibilityTransformChanged_toggles() {
+        final int radioPrefsCount = 3;
+        List<RadioButtonPreference> radioPrefs = new ArrayList<>();
+        for (int i = 0; i < radioPrefsCount; i++) {
+            radioPrefs.add(mock(RadioButtonPreference.class));
+        }
+
+        when(mScreen.getPreferenceCount()).thenReturn(radioPrefs.size());
+        when(mScreen.getPreference(anyInt())).thenAnswer(invocation -> {
+            final Object[] args = invocation.getArguments();
+            return radioPrefs.get((int) args[0]);
+        });
+
+        mFragment.onAccessibilityTransformChanged(true /* state */);
+        for (int i = 0; i < radioPrefsCount; i++) {
+            verify(radioPrefs.get(i)).setEnabled(false);
+        }
+
+        mFragment.onAccessibilityTransformChanged(false /* state */);
+        for (int i = 0; i < radioPrefsCount; i++) {
+            verify(radioPrefs.get(i)).setEnabled(true);
+        }
+    }
+
+    private static class ColorModePreferenceFragmentTestable
+            extends ColorModePreferenceFragment {
+
+        private final PreferenceScreen mPreferenceScreen;
+
+        private ColorModePreferenceFragmentTestable(PreferenceScreen screen) {
+            mPreferenceScreen = screen;
+        }
+
+        /**
+         * A method to return a mock PreferenceScreen.
+         * A real ColorModePreferenceFragment calls super.getPreferenceScreen() to get its
+         * PreferenceScreen handle, which internally dereferenced a PreferenceManager. But in this
+         * test scenario, the PreferenceManager object is uninitialized, so we need to supply the
+         * PreferenceScreen directly.
+         *
+         * @return a mock PreferenceScreen
+         */
+        @Override
+        public PreferenceScreen getPreferenceScreen() {
+            return mPreferenceScreen;
+        }
+    }
 }
diff --git a/tests/robotests/src/com/android/settings/fuelgauge/BatteryEntryTest.java b/tests/robotests/src/com/android/settings/fuelgauge/BatteryEntryTest.java
index b6be9ee..b89a3f0 100644
--- a/tests/robotests/src/com/android/settings/fuelgauge/BatteryEntryTest.java
+++ b/tests/robotests/src/com/android/settings/fuelgauge/BatteryEntryTest.java
@@ -29,6 +29,7 @@
 
 import com.android.internal.os.BatterySipper;
 import com.android.internal.os.BatterySipper.DrainType;
+import com.android.settings.R;
 
 import org.junit.Before;
 import org.junit.Rule;
@@ -38,6 +39,7 @@
 import org.mockito.junit.MockitoJUnit;
 import org.mockito.junit.MockitoRule;
 import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
 
 import java.util.Locale;
 
@@ -137,6 +139,17 @@
     }
 
     @Test
+    public void batteryEntryForAOD_containCorrectInfo() {
+        final BatterySipper batterySipper = mock(BatterySipper.class);
+        batterySipper.drainType = DrainType.AMBIENT_DISPLAY;
+        final BatteryEntry entry = new BatteryEntry(RuntimeEnvironment.application, mockHandler,
+                mockUserManager, batterySipper);
+
+        assertThat(entry.iconId).isEqualTo(R.drawable.ic_settings_aod);
+        assertThat(entry.name).isEqualTo("Ambient display");
+    }
+
+    @Test
     public void extractPackageFromSipper_systemSipper_returnSystemPackage() {
         BatteryEntry entry = createBatteryEntryForSystem();
 
diff --git a/tests/robotests/src/com/android/settings/fuelgauge/batterytip/AnomalyDetectionJobServiceTest.java b/tests/robotests/src/com/android/settings/fuelgauge/batterytip/AnomalyDetectionJobServiceTest.java
index 0894b66..dbca602 100644
--- a/tests/robotests/src/com/android/settings/fuelgauge/batterytip/AnomalyDetectionJobServiceTest.java
+++ b/tests/robotests/src/com/android/settings/fuelgauge/batterytip/AnomalyDetectionJobServiceTest.java
@@ -64,7 +64,7 @@
 
 @RunWith(SettingsRobolectricTestRunner.class)
 public class AnomalyDetectionJobServiceTest {
-    private static final int UID = 123;
+    private static final int UID = 12345;
     private static final String SYSTEM_PACKAGE = "com.android.system";
     private static final String SUBSCRIBER_COOKIES_AUTO_RESTRICTION =
             "anomaly_type=6,auto_restriction=true";
@@ -120,8 +120,8 @@
 
     @Test
     public void testSaveAnomalyToDatabase_systemWhitelisted_doNotSave() {
-        doReturn(SYSTEM_PACKAGE).when(mBatteryUtils).getPackageName(anyInt());
-        doReturn(true).when(mPowerWhitelistBackend).isSysWhitelisted(SYSTEM_PACKAGE);
+        doReturn(UID).when(mAnomalyDetectionJobService).extractUidFromStatsDimensionsValue(any());
+        doReturn(true).when(mPowerWhitelistBackend).isSysWhitelistedExceptIdle(any(String[].class));
 
         mAnomalyDetectionJobService.saveAnomalyToDatabase(mContext, mBatteryStatsHelper,
                 mUserManager, mBatteryDatabaseManager, mBatteryUtils, mPolicy,
diff --git a/tests/robotests/src/com/android/settings/slices/SliceControllerInXmlTest.java b/tests/robotests/src/com/android/settings/slices/SliceControllerInXmlCodeInspector.java
similarity index 85%
rename from tests/robotests/src/com/android/settings/slices/SliceControllerInXmlTest.java
rename to tests/robotests/src/com/android/settings/slices/SliceControllerInXmlCodeInspector.java
index 7de9c2b..9c8b946 100644
--- a/tests/robotests/src/com/android/settings/slices/SliceControllerInXmlTest.java
+++ b/tests/robotests/src/com/android/settings/slices/SliceControllerInXmlCodeInspector.java
@@ -19,7 +19,6 @@
 import static com.android.settings.core.PreferenceXmlParserUtils.METADATA_CONTROLLER;
 import static com.google.common.truth.Truth.assertThat;
 import static com.google.common.truth.Truth.assertWithMessage;
-import static org.mockito.Mockito.spy;
 
 import android.content.Context;
 import android.os.Bundle;
@@ -27,8 +26,8 @@
 import android.text.TextUtils;
 
 import com.android.settings.core.PreferenceXmlParserUtils;
+import com.android.settings.core.SliderPreferenceController;
 import com.android.settings.core.TogglePreferenceController;
-import com.android.settings.core.codeinspection.ClassScanner;
 import com.android.settings.core.codeinspection.CodeInspector;
 import com.android.settings.overlay.FeatureFactory;
 import com.android.settings.search.DatabaseIndexingUtils;
@@ -36,25 +35,21 @@
 import com.android.settings.search.SearchFeatureProvider;
 import com.android.settings.search.SearchFeatureProviderImpl;
 import com.android.settings.testutils.FakeFeatureFactory;
-import com.android.settings.testutils.SettingsRobolectricTestRunner;
 
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
 import org.robolectric.RuntimeEnvironment;
 import org.xmlpull.v1.XmlPullParserException;
 
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.List;
 
-@RunWith(SettingsRobolectricTestRunner.class)
-public class SliceControllerInXmlTest {
+public class SliceControllerInXmlCodeInspector extends CodeInspector {
 
-    private static final List<Class> mSliceControllerClasses = Collections.singletonList(
-            TogglePreferenceController.class
+    private static final List<Class> mSliceControllerClasses = Arrays.asList(
+            TogglePreferenceController.class,
+            SliderPreferenceController.class
     );
 
     private final List<String> mXmlDeclaredControllers = new ArrayList<>();
@@ -66,15 +61,13 @@
                     + "If it should not appear in XML, add the controller's classname to "
                     + "grandfather_slice_controller_not_in_xml. Controllers:\n";
 
-    private Context mContext;
+    private final Context mContext;
+    private final SearchFeatureProvider mSearchProvider;
+    private final FakeFeatureFactory mFakeFeatureFactory;
 
-    private SearchFeatureProvider mSearchProvider;
-    private FakeFeatureFactory mFakeFeatureFactory;
-
-    @Before
-    public void setUp() throws IOException, XmlPullParserException {
-        mContext = spy(RuntimeEnvironment.application);
-
+    public SliceControllerInXmlCodeInspector(List<Class<?>> classes) throws Exception {
+        super(classes);
+        mContext = RuntimeEnvironment.application;
         mSearchProvider = new SearchFeatureProviderImpl();
         mFakeFeatureFactory = FakeFeatureFactory.setupForTest();
         mFakeFeatureFactory.searchFeatureProvider = mSearchProvider;
@@ -102,13 +95,15 @@
         assertThat(mXmlDeclaredControllers).isNotEmpty();
     }
 
-    @Test
-    public void testAllControllersDeclaredInXml() throws Exception {
-        final List<Class<?>> classes =
-                new ClassScanner().getClassesForPackage(mContext.getPackageName());
+    @Override
+    public void run() {
         final List<String> missingControllersInXml = new ArrayList<>();
 
-        for (Class<?> clazz : classes) {
+        for (Class<?> clazz : mClasses) {
+            if (!isConcreteSettingsClass(clazz)) {
+                // Only care about non-abstract classes.
+                continue;
+            }
             if (!isInlineSliceClass(clazz)) {
                 // Only care about inline-slice controller classes.
                 continue;
diff --git a/tests/robotests/src/com/android/settings/widget/AspectRatioFrameLayoutTest.java b/tests/robotests/src/com/android/settings/widget/AspectRatioFrameLayoutTest.java
index bb55692..59a90c5 100644
--- a/tests/robotests/src/com/android/settings/widget/AspectRatioFrameLayoutTest.java
+++ b/tests/robotests/src/com/android/settings/widget/AspectRatioFrameLayoutTest.java
@@ -41,7 +41,7 @@
     }
 
     @Test
-    public void measure_squareAspectRatio_stretchHeight() {
+    public void measure_squareAspectRatio_squeezeWidth() {
         mLayout = new AspectRatioFrameLayout(mContext);
 
         int widthMeasureSpec = View.MeasureSpec.makeMeasureSpec(100, View.MeasureSpec.EXACTLY);
@@ -49,8 +49,8 @@
 
         mLayout.measure(widthMeasureSpec, heightMeasureSpec);
 
-        assertThat(mLayout.getMeasuredWidth()).isEqualTo(100);
-        assertThat(mLayout.getMeasuredHeight()).isEqualTo(100);
+        assertThat(mLayout.getMeasuredWidth()).isEqualTo(50);
+        assertThat(mLayout.getMeasuredHeight()).isEqualTo(50);
     }
 
     @Test
diff --git a/tests/robotests/src/com/android/settings/widget/VideoPreferenceTest.java b/tests/robotests/src/com/android/settings/widget/VideoPreferenceTest.java
new file mode 100644
index 0000000..fee7bcc
--- /dev/null
+++ b/tests/robotests/src/com/android/settings/widget/VideoPreferenceTest.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.settings.widget;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import android.media.MediaPlayer;
+import android.support.v7.preference.PreferenceViewHolder;
+import android.view.LayoutInflater;
+
+import com.android.settings.R;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+public class VideoPreferenceTest {
+    private static final int VIDEO_WIDTH = 100;
+    private static final int VIDEO_HEIGHT = 150;
+    @Mock
+    private MediaPlayer mMediaPlayer;
+    private Context mContext;
+    private VideoPreference mVideoPreference;
+    private PreferenceViewHolder mPreferenceViewHolder;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+
+        mContext = RuntimeEnvironment.application;
+        mVideoPreference = new VideoPreference(mContext, null /* attrs */);
+        mVideoPreference.mMediaPlayer = mMediaPlayer;
+        when(mMediaPlayer.getVideoWidth()).thenReturn(VIDEO_WIDTH);
+        when(mMediaPlayer.getVideoHeight()).thenReturn(VIDEO_HEIGHT);
+
+        mPreferenceViewHolder = PreferenceViewHolder.createInstanceForTests(
+                LayoutInflater.from(mContext).inflate(R.layout.video_preference, null));
+    }
+
+    @Test
+    public void onBindViewHolder_hasCorrectRatio() {
+        mVideoPreference.mAnimationAvailable = true;
+
+        mVideoPreference.updateAspectRatio();
+        mVideoPreference.onBindViewHolder(mPreferenceViewHolder);
+
+        final AspectRatioFrameLayout layout =
+                (AspectRatioFrameLayout) mPreferenceViewHolder.findViewById(R.id.video_container);
+        assertThat(layout.mAspectRatio).isWithin(0.01f).of(VIDEO_WIDTH / (float) VIDEO_HEIGHT);
+    }
+}
