diff --git a/res/values/strings.xml b/res/values/strings.xml
index 3ac14eb..45d6e9c 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -4914,6 +4914,11 @@
         <item quantity="other">%1$d apps</item>
     </plurals>
 
+    <!-- Title for auto restriction toggle -->
+    <string name="battery_auto_restriction_title">Restrict apps automatically</string>
+    <!-- Summary for auto restriction toggle -->
+    <string name="battery_auto_restriction_summary">Prevent apps from using extra battery in the background</string>
+
     <!-- Title for force stop dialog [CHAR LIMIT=30] -->
     <string name="dialog_stop_title">Stop app?</string>
     <!-- Message body for force stop dialog [CHAR LIMIT=NONE] -->
@@ -7544,10 +7549,10 @@
     <string name="zen_mode_alarms">Alarms</string>
 
     <!-- [CHAR LIMIT=50] Zen mode settings: Media option -->
-    <string name="zen_mode_media_system_other">Media</string>
+    <string name="zen_mode_media">Media</string>
 
-    <!-- [CHAR LIMIT=120] Zen mode settings: Media secondary text explaining sounds include system feedback such as system tapping sounds, haptic feedback, etc. -->
-    <string name="zen_mode_media_system_other_secondary_text">Includes system feedback like touch and charging sounds</string>
+    <!-- [CHAR LIMIT=50] Zen mode settings: System option which includes sounds such as touch and charging sounds -->
+    <string name="zen_mode_system">Touch and charging sounds</string>
 
     <!-- [CHAR LIMIT=50] Zen mode settings: Reminders option -->
     <string name="zen_mode_reminders">Reminders</string>
@@ -9403,4 +9408,22 @@
     <!-- Apps > App Details > Wifi access > Description. [CHAR LIMIT=NONE] -->
     <string name="change_wifi_state_app_detail_summary">Allow this app to change wifi state including connecting to wifi and turing wifi on and off.</string>
 
+    <!-- Title for media output settings -->
+    <string name="media_output_title">Play media to</string>
+
+    <!-- Summary for media output settings. (phone) -->
+    <string name="media_output_summary" product="default">Phone</string>
+
+    <!-- Summary for media output settings. (tablet) -->
+    <string name="media_output_summary" product="tablet">Tablet</string>
+
+    <!-- Summary for media output settings. (device) -->
+    <string name="media_output_summary" product="device">Device</string>
+
+    <!-- Summary for media output settings when device is in ongoing call state. -->
+    <string name="media_out_summary_ongoing_call_state">Unavailable during calls</string>
+
+    <!-- Summary for media output settings when the media stream is being captured by something else. -->
+    <string name="media_output_summary_unavailable">Unavailable</string>
+
 </resources>
diff --git a/res/values/styles_preference.xml b/res/values/styles_preference.xml
index 5fe1ef4..6b632ca 100644
--- a/res/values/styles_preference.xml
+++ b/res/values/styles_preference.xml
@@ -40,4 +40,9 @@
         <item name="android:layout">@layout/two_state_button</item>
     </style>
 
+    <style name="SettingsMultiSelectListPreference" parent="Preference.SettingsBase">
+        <item name="android:positiveButtonText">@android:string/ok</item>
+        <item name="android:negativeButtonText">@android:string/cancel</item>
+    </style>
+
 </resources>
\ No newline at end of file
diff --git a/res/xml/apn_editor.xml b/res/xml/apn_editor.xml
index b1e332b..742a436 100644
--- a/res/xml/apn_editor.xml
+++ b/res/xml/apn_editor.xml
@@ -157,6 +157,7 @@
         android:entries="@array/bearer_entries"
         android:entryValues="@array/bearer_values"
         android:persistent="false"
+        style="@style/SettingsMultiSelectListPreference"
         />
     <ListPreference
         android:title="@string/mvno_type"
diff --git a/res/xml/power_usage_advanced.xml b/res/xml/power_usage_advanced.xml
index b31eb40..d32611c 100644
--- a/res/xml/power_usage_advanced.xml
+++ b/res/xml/power_usage_advanced.xml
@@ -25,7 +25,7 @@
         android:key="battery_graph"/>
 
     <PreferenceCategory
-        android:key="battery_usage_list"
-        android:title="@string/battery_detail_since_full_charge"/>
+        android:key="app_list"
+        android:title="@string/power_usage_list_summary"/>
 
 </PreferenceScreen>
diff --git a/res/xml/power_usage_advanced_legacy.xml b/res/xml/power_usage_advanced_legacy.xml
new file mode 100644
index 0000000..26be727
--- /dev/null
+++ b/res/xml/power_usage_advanced_legacy.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2017 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.
+-->
+
+<PreferenceScreen
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:settings="http://schemas.android.com/apk/res-auto"
+    android:key="power_usage_advanced_screen_legacy"
+    android:title="@string/advanced_battery_title"
+    settings:keywords="@string/keywords_battery">
+
+    <com.android.settings.fuelgauge.BatteryHistoryPreference
+        android:key="battery_graph_legacy"/>
+
+    <PreferenceCategory
+        android:key="battery_usage_list_legacy"
+        android:title="@string/battery_detail_since_full_charge"/>
+
+</PreferenceScreen>
diff --git a/res/xml/power_usage_summary.xml b/res/xml/power_usage_summary.xml
index d89653a..ac96151 100644
--- a/res/xml/power_usage_summary.xml
+++ b/res/xml/power_usage_summary.xml
@@ -66,8 +66,4 @@
 
     </PreferenceCategory>
 
-    <PreferenceCategory
-        android:key="app_list"
-        android:title="@string/power_usage_list_summary"/>
-
 </PreferenceScreen>
diff --git a/res/xml/smart_battery_detail.xml b/res/xml/smart_battery_detail.xml
index a236cb8..e7fb9f7 100644
--- a/res/xml/smart_battery_detail.xml
+++ b/res/xml/smart_battery_detail.xml
@@ -15,7 +15,9 @@
   limitations under the License.
   -->
 
-<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android"
+<PreferenceScreen
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:settings="http://schemas.android.com/apk/res-auto"
     android:key="smart_battery_detail"
     android:title="@string/smart_battery_manager_title">
 
@@ -32,6 +34,12 @@
         android:title="@string/smart_battery_title"
         android:summary="@string/smart_battery_summary"/>
 
+    <SwitchPreference
+        android:key="auto_restriction"
+        android:title="@string/battery_auto_restriction_title"
+        android:summary="@string/battery_auto_restriction_summary"
+        settings:controller="com.android.settings.fuelgauge.AutoRestrictionPreferenceController"/>
+
     <Preference
         android:key="restricted_app"
         android:title="@string/restricted_app_title"/>
diff --git a/res/xml/time_zone_prefs.xml b/res/xml/time_zone_prefs.xml
new file mode 100644
index 0000000..f80de8c
--- /dev/null
+++ b/res/xml/time_zone_prefs.xml
@@ -0,0 +1,42 @@
+<?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.
+-->
+
+<PreferenceScreen
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:key="time_zone_settings_screen"
+    android:title="@string/date_time_set_timezone">
+
+    <PreferenceCategory
+        android:key="time_zone_region_preference_category">
+        <com.android.settingslib.RestrictedPreference
+            android:key="region"
+            android:title="@string/date_time_select_region"
+            android:summary="@string/summary_placeholder" />
+        <com.android.settingslib.RestrictedPreference
+            android:key="region_zone"
+            android:title="@string/date_time_select_zone"
+            android:summary="@string/summary_placeholder" />
+        <com.android.settingslib.widget.FooterPreference/>
+    </PreferenceCategory>
+
+    <PreferenceCategory
+        android:key="time_zone_fixed_offset_preference_category">
+        <com.android.settingslib.RestrictedPreference
+            android:key="fixed_offset"
+            android:title="@string/date_time_select_fixed_offset_time_zones"
+            android:summary="@string/summary_placeholder"/>
+    </PreferenceCategory>
+</PreferenceScreen>
diff --git a/res/xml/zen_mode_behavior_settings.xml b/res/xml/zen_mode_behavior_settings.xml
index 8d2c28c..084b78d 100644
--- a/res/xml/zen_mode_behavior_settings.xml
+++ b/res/xml/zen_mode_behavior_settings.xml
@@ -20,7 +20,7 @@
     xmlns:settings="http://schemas.android.com/apk/res-auto"
     android:key="zen_mode_behavior_settings_page"
     android:title="@string/zen_mode_behavior_settings_title"
-    settings:initialExpandedChildrenCount="7">
+    settings:initialExpandedChildrenCount="8">
 
    <PreferenceCategory
        android:title="@string/zen_mode_behavior_allow_title"
@@ -34,8 +34,12 @@
        <!-- Media -->
        <SwitchPreference
            android:key="zen_mode_media"
-           android:title="@string/zen_mode_media_system_other"
-           android:summary="@string/zen_mode_media_system_other_secondary_text"/>
+           android:title="@string/zen_mode_media"/>
+
+       <!-- System -->
+       <SwitchPreference
+           android:key="zen_mode_system"
+           android:title="@string/zen_mode_system"/>
 
        <!-- Reminders -->
        <SwitchPreference
diff --git a/src/com/android/settings/applications/appinfo/InstantAppButtonsPreferenceController.java b/src/com/android/settings/applications/appinfo/InstantAppButtonsPreferenceController.java
index df64d76..d2515a3 100644
--- a/src/com/android/settings/applications/appinfo/InstantAppButtonsPreferenceController.java
+++ b/src/com/android/settings/applications/appinfo/InstantAppButtonsPreferenceController.java
@@ -147,7 +147,10 @@
         if (!TextUtils.isEmpty(mLaunchUri)) {
             installButton.setVisibility(View.GONE);
             final Intent intent = new Intent(Intent.ACTION_VIEW);
+            intent.addCategory(Intent.CATEGORY_BROWSABLE);
+            intent.setPackage(mPackageName);
             intent.setData(Uri.parse(mLaunchUri));
+            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
             launchButton.setOnClickListener(v -> mParent.startActivity(intent));
         } else {
             launchButton.setVisibility(View.GONE);
diff --git a/src/com/android/settings/backup/BackupSettingsActivity.java b/src/com/android/settings/backup/BackupSettingsActivity.java
index 7ffc6cd..d78af32 100644
--- a/src/com/android/settings/backup/BackupSettingsActivity.java
+++ b/src/com/android/settings/backup/BackupSettingsActivity.java
@@ -58,9 +58,17 @@
                         "No manufacturer settings found, launching the backup settings directly");
             }
             Intent intent = backupHelper.getIntentForBackupSettings();
-            // enable the activity before launching it
-            getPackageManager().setComponentEnabledSetting(intent.getComponent(),
-                    PackageManager.COMPONENT_ENABLED_STATE_ENABLED, PackageManager.DONT_KILL_APP);
+            try {
+                // enable the activity before launching it
+                getPackageManager().setComponentEnabledSetting(
+                        intent.getComponent(),
+                        PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
+                        PackageManager.DONT_KILL_APP);
+            } catch (SecurityException e) {
+                Log.w(TAG, "Trying to enable activity " + intent.getComponent() + " but couldn't: "
+                        + e.getMessage());
+                // the activity may already be enabled
+            }
 
             // use startActivityForResult to let the activity check the caller signature
             startActivityForResult(intent, 1);
diff --git a/src/com/android/settings/dashboard/DashboardAdapter.java b/src/com/android/settings/dashboard/DashboardAdapter.java
index 9d9058d..879a4b8 100644
--- a/src/com/android/settings/dashboard/DashboardAdapter.java
+++ b/src/com/android/settings/dashboard/DashboardAdapter.java
@@ -17,7 +17,6 @@
 
 import android.app.Activity;
 import android.content.Context;
-import android.graphics.Typeface;
 import android.graphics.drawable.Drawable;
 import android.graphics.drawable.Icon;
 import android.os.Bundle;
@@ -27,7 +26,6 @@
 import android.support.v7.widget.LinearLayoutManager;
 import android.support.v7.widget.RecyclerView;
 import android.text.TextUtils;
-import android.util.ArrayMap;
 import android.util.Log;
 import android.view.LayoutInflater;
 import android.view.View;
@@ -56,8 +54,8 @@
 import java.util.List;
 
 public class DashboardAdapter extends RecyclerView.Adapter<DashboardAdapter.DashboardItemHolder>
-    implements SummaryLoader.SummaryConsumer, SuggestionAdapter.Callback, LifecycleObserver,
-    OnSaveInstanceState {
+        implements SummaryLoader.SummaryConsumer, SuggestionAdapter.Callback, LifecycleObserver,
+        OnSaveInstanceState {
     public static final String TAG = "DashboardAdapter";
     private static final String STATE_CATEGORY_LIST = "category_list";
 
@@ -84,8 +82,8 @@
     };
 
     public DashboardAdapter(Context context, Bundle savedInstanceState,
-        List<Condition> conditions, SuggestionControllerMixin suggestionControllerMixin,
-        Lifecycle lifecycle) {
+            List<Condition> conditions, SuggestionControllerMixin suggestionControllerMixin,
+            Lifecycle lifecycle) {
 
         DashboardCategory category = null;
         boolean conditionExpanded = false;
@@ -96,14 +94,14 @@
         mDashboardFeatureProvider = factory.getDashboardFeatureProvider(context);
         mCache = new IconCache(context);
         mSuggestionAdapter = new SuggestionAdapter(mContext, suggestionControllerMixin,
-            savedInstanceState, this /* callback */, lifecycle);
+                savedInstanceState, this /* callback */, lifecycle);
 
         setHasStableIds(true);
 
         if (savedInstanceState != null) {
             category = savedInstanceState.getParcelable(STATE_CATEGORY_LIST);
             conditionExpanded = savedInstanceState.getBoolean(
-                STATE_CONDITION_EXPANDED, conditionExpanded);
+                    STATE_CONDITION_EXPANDED, conditionExpanded);
         }
 
         if (lifecycle != null) {
@@ -111,18 +109,18 @@
         }
 
         mDashboardData = new DashboardData.Builder()
-            .setConditions(conditions)
-            .setSuggestions(mSuggestionAdapter.getSuggestions())
-            .setCategory(category)
-            .setConditionExpanded(conditionExpanded)
-            .build();
+                .setConditions(conditions)
+                .setSuggestions(mSuggestionAdapter.getSuggestions())
+                .setCategory(category)
+                .setConditionExpanded(conditionExpanded)
+                .build();
     }
 
     public void setSuggestions(List<Suggestion> data) {
         final DashboardData prevData = mDashboardData;
         mDashboardData = new DashboardData.Builder(prevData)
-            .setSuggestions(data)
-            .build();
+                .setSuggestions(data)
+                .build();
         notifyDashboardDataChanged(prevData);
     }
 
@@ -130,8 +128,8 @@
         final DashboardData prevData = mDashboardData;
         Log.d(TAG, "adapter setCategory called");
         mDashboardData = new DashboardData.Builder(prevData)
-            .setCategory(category)
-            .build();
+                .setCategory(category)
+                .build();
         notifyDashboardDataChanged(prevData);
     }
 
@@ -139,8 +137,8 @@
         final DashboardData prevData = mDashboardData;
         Log.d(TAG, "adapter setConditions called");
         mDashboardData = new DashboardData.Builder(prevData)
-            .setConditions(conditions)
-            .build();
+                .setConditions(conditions)
+                .build();
         notifyDashboardDataChanged(prevData);
     }
 
@@ -203,15 +201,15 @@
                 break;
             case R.layout.condition_header:
                 onBindConditionHeader((ConditionHeaderHolder) holder,
-                    (ConditionHeaderData) mDashboardData.getItemEntityByPosition(position));
+                        (ConditionHeaderData) mDashboardData.getItemEntityByPosition(position));
                 break;
             case R.layout.condition_footer:
                 holder.itemView.setOnClickListener(v -> {
                     mMetricsFeatureProvider.action(mContext,
-                        MetricsEvent.ACTION_SETTINGS_CONDITION_EXPAND, false);
+                            MetricsEvent.ACTION_SETTINGS_CONDITION_EXPAND, false);
                     DashboardData prevData = mDashboardData;
                     mDashboardData = new DashboardData.Builder(prevData).
-                        setConditionExpanded(false).build();
+                            setConditionExpanded(false).build();
                     notifyDashboardDataChanged(prevData);
                     scrollToTopOfConditions();
                 });
@@ -254,7 +252,7 @@
     void notifyDashboardDataChanged(DashboardData prevData) {
         if (mFirstFrameDrawn && prevData != null) {
             final DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(new DashboardData
-                .ItemsDataDiffCallback(prevData.getItemList(), mDashboardData.getItemList()));
+                    .ItemsDataDiffCallback(prevData.getItemList(), mDashboardData.getItemList()));
             diffResult.dispatchUpdatesTo(this);
         } else {
             mFirstFrameDrawn = true;
@@ -272,17 +270,17 @@
         } else {
             holder.title.setText(null);
             holder.summary.setText(
-                mContext.getString(R.string.condition_summary, data.conditionCount));
+                    mContext.getString(R.string.condition_summary, data.conditionCount));
             updateConditionIcons(data.conditionIcons, holder.icons);
             holder.icons.setVisibility(View.VISIBLE);
         }
 
         holder.itemView.setOnClickListener(v -> {
             mMetricsFeatureProvider.action(mContext,
-                MetricsEvent.ACTION_SETTINGS_CONDITION_EXPAND, true);
+                    MetricsEvent.ACTION_SETTINGS_CONDITION_EXPAND, true);
             final DashboardData prevData = mDashboardData;
             mDashboardData = new DashboardData.Builder(prevData)
-                .setConditionExpanded(true).build();
+                    .setConditionExpanded(true).build();
             notifyDashboardDataChanged(prevData);
             scrollToTopOfConditions();
         });
@@ -291,8 +289,8 @@
     @VisibleForTesting
     void onBindCondition(final ConditionContainerHolder holder, int position) {
         final ConditionAdapter adapter = new ConditionAdapter(mContext,
-            (List<Condition>) mDashboardData.getItemEntityByPosition(position),
-            mDashboardData.isConditionExpanded());
+                (List<Condition>) mDashboardData.getItemEntityByPosition(position),
+                mDashboardData.isConditionExpanded());
         adapter.addDismissHandling(holder.data);
         holder.data.setAdapter(adapter);
         holder.data.setLayoutManager(new LinearLayoutManager(mContext));
@@ -303,7 +301,7 @@
         // If there is suggestions to show, it will be at position 0 as we don't show the suggestion
         // header anymore.
         final List<Suggestion> suggestions =
-            (List<Suggestion>) mDashboardData.getItemEntityByPosition(position);
+                (List<Suggestion>) mDashboardData.getItemEntityByPosition(position);
         if (suggestions != null && suggestions.size() > 0) {
             mSuggestionAdapter.setSuggestions(suggestions);
             holder.data.setAdapter(mSuggestionAdapter);
@@ -316,7 +314,8 @@
     @VisibleForTesting
     void onBindTile(DashboardItemHolder holder, Tile tile) {
         Drawable icon = mCache.getIcon(tile.icon);
-        if (!TextUtils.equals(tile.icon.getResPackage(), mContext.getPackageName())) {
+        if (!TextUtils.equals(tile.icon.getResPackage(), mContext.getPackageName())
+                && !(icon instanceof RoundedHomepageIcon)) {
             icon = new RoundedHomepageIcon(mContext, icon);
             mCache.updateIcon(tile.icon, icon);
         }
diff --git a/src/com/android/settings/datetime/TimeZonePreferenceController.java b/src/com/android/settings/datetime/TimeZonePreferenceController.java
index e29e245..aff204d 100644
--- a/src/com/android/settings/datetime/TimeZonePreferenceController.java
+++ b/src/com/android/settings/datetime/TimeZonePreferenceController.java
@@ -19,11 +19,11 @@
 import android.content.Context;
 import android.support.annotation.VisibleForTesting;
 import android.support.v7.preference.Preference;
-
 import android.util.FeatureFlagUtils;
+
 import com.android.settings.core.FeatureFlags;
 import com.android.settings.core.PreferenceControllerMixin;
-import com.android.settings.datetime.timezone.ZonePicker;
+import com.android.settings.datetime.timezone.TimeZoneSettings;
 import com.android.settingslib.RestrictedPreference;
 import com.android.settingslib.core.AbstractPreferenceController;
 import com.android.settingslib.datetime.ZoneGetter;
@@ -51,7 +51,7 @@
             return;
         }
         if (mZonePickerV2) {
-            preference.setFragment(ZonePicker.class.getName());
+            preference.setFragment(TimeZoneSettings.class.getName());
         }
         preference.setSummary(getTimeZoneOffsetAndName());
         if( !((RestrictedPreference) preference).isDisabledByAdmin()) {
diff --git a/src/com/android/settings/datetime/timezone/BaseTimeZonePreferenceController.java b/src/com/android/settings/datetime/timezone/BaseTimeZonePreferenceController.java
new file mode 100644
index 0000000..846fce0
--- /dev/null
+++ b/src/com/android/settings/datetime/timezone/BaseTimeZonePreferenceController.java
@@ -0,0 +1,51 @@
+/*
+ * 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.datetime.timezone;
+
+import android.content.Context;
+import android.support.v7.preference.Preference;
+
+import com.android.settings.core.BasePreferenceController;
+
+import com.google.common.base.Objects;
+
+public abstract class BaseTimeZonePreferenceController extends BasePreferenceController {
+    private OnPreferenceClickListener mOnClickListener;
+
+    protected BaseTimeZonePreferenceController(Context context, String preferenceKey) {
+        super(context, preferenceKey);
+    }
+
+    @Override
+    public int getAvailabilityStatus() {
+        return AVAILABLE;
+    }
+
+    @Override
+    public boolean handlePreferenceTreeClick(Preference preference) {
+        if (mOnClickListener == null || !Objects.equal(getPreferenceKey(), preference.getKey())) {
+            return false;
+        }
+
+        mOnClickListener.onClick();
+        return true;
+    }
+
+    public void setOnClickListener(OnPreferenceClickListener listener) {
+        mOnClickListener = listener;
+    }
+}
diff --git a/src/com/android/settings/datetime/timezone/FixedOffsetPreferenceController.java b/src/com/android/settings/datetime/timezone/FixedOffsetPreferenceController.java
new file mode 100644
index 0000000..16c1f19
--- /dev/null
+++ b/src/com/android/settings/datetime/timezone/FixedOffsetPreferenceController.java
@@ -0,0 +1,46 @@
+/*
+ * 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.datetime.timezone;
+
+import android.content.Context;
+import android.support.v7.preference.Preference;
+
+public class FixedOffsetPreferenceController extends BaseTimeZonePreferenceController {
+
+    private static final String PREFERENCE_KEY = "fixed_offset";
+
+    private TimeZoneInfo mTimeZoneInfo;
+
+    public FixedOffsetPreferenceController(Context context) {
+        super(context, PREFERENCE_KEY);
+    }
+
+    @Override
+    public CharSequence getSummary() {
+        // This is a Spannable object, which contains TTS span. It shouldn't be converted to String.
+        return mTimeZoneInfo == null ? "" : mTimeZoneInfo.getGmtOffset();
+    }
+
+    public void setTimeZoneInfo(TimeZoneInfo timeZoneInfo) {
+        mTimeZoneInfo = timeZoneInfo;
+    }
+
+    public TimeZoneInfo getTimeZoneInfo() {
+        return mTimeZoneInfo;
+    }
+}
+
diff --git a/src/com/android/settings/datetime/timezone/OnPreferenceClickListener.java b/src/com/android/settings/datetime/timezone/OnPreferenceClickListener.java
new file mode 100644
index 0000000..3e4d715
--- /dev/null
+++ b/src/com/android/settings/datetime/timezone/OnPreferenceClickListener.java
@@ -0,0 +1,24 @@
+/*
+ * 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.datetime.timezone;
+
+/**
+ * Callback when a preference is clicked in {@class TimeZoneSettings}
+ */
+public interface OnPreferenceClickListener {
+    void onClick();
+}
diff --git a/src/com/android/settings/datetime/timezone/RegionPreferenceController.java b/src/com/android/settings/datetime/timezone/RegionPreferenceController.java
new file mode 100644
index 0000000..201b9bd
--- /dev/null
+++ b/src/com/android/settings/datetime/timezone/RegionPreferenceController.java
@@ -0,0 +1,49 @@
+/*
+ * 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.datetime.timezone;
+
+import android.content.Context;
+import android.icu.text.LocaleDisplayNames;
+import android.support.v7.preference.Preference;
+
+import java.util.Locale;
+
+public class RegionPreferenceController extends BaseTimeZonePreferenceController {
+    private static final String PREFERENCE_KEY = "region";
+
+    private final LocaleDisplayNames mLocaleDisplayNames;
+    private String mRegionId = "";
+
+    public RegionPreferenceController(Context context) {
+        super(context, PREFERENCE_KEY);
+        Locale locale = context.getResources().getConfiguration().getLocales().get(0);
+        mLocaleDisplayNames = LocaleDisplayNames.getInstance(locale);
+
+    }
+
+    @Override
+    public CharSequence getSummary() {
+        return mLocaleDisplayNames.regionDisplayName(mRegionId);
+    }
+
+    public void setRegionId(String regionId) {
+        mRegionId = regionId;
+    }
+
+    public String getRegionId() {
+        return mRegionId;
+    }
+}
diff --git a/src/com/android/settings/datetime/timezone/RegionZonePreferenceController.java b/src/com/android/settings/datetime/timezone/RegionZonePreferenceController.java
new file mode 100644
index 0000000..85f4165
--- /dev/null
+++ b/src/com/android/settings/datetime/timezone/RegionZonePreferenceController.java
@@ -0,0 +1,68 @@
+/*
+ * 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.datetime.timezone;
+
+import android.content.Context;
+import android.support.v7.preference.Preference;
+
+import com.android.settings.R;
+
+public class RegionZonePreferenceController extends BaseTimeZonePreferenceController {
+    private static final String PREFERENCE_KEY = "region_zone";
+
+    private TimeZoneInfo mTimeZoneInfo;
+    private boolean mIsClickable;
+
+    public RegionZonePreferenceController(Context context) {
+        super(context, PREFERENCE_KEY);
+    }
+
+    @Override
+    public int getAvailabilityStatus() {
+        return AVAILABLE;
+    }
+
+    @Override
+    public void updateState(Preference preference) {
+        super.updateState(preference);
+        preference.setEnabled(isClickable());
+    }
+
+    @Override
+    public CharSequence getSummary() {
+        return mTimeZoneInfo == null ? ""
+                : SpannableUtil.getResourcesText(mContext.getResources(),
+                        R.string.zone_info_exemplar_location_and_offset,
+                mTimeZoneInfo.getExemplarLocation(), mTimeZoneInfo.getGmtOffset());
+    }
+
+    public void setTimeZoneInfo(TimeZoneInfo timeZoneInfo) {
+        mTimeZoneInfo = timeZoneInfo;
+    }
+
+    public TimeZoneInfo getTimeZoneInfo() {
+        return mTimeZoneInfo;
+    }
+
+    public void setClickable(boolean clickable) {
+        mIsClickable = clickable;
+    }
+
+    public boolean isClickable() {
+        return mIsClickable;
+    }
+}
diff --git a/src/com/android/settings/datetime/timezone/TimeZoneInfoPreferenceController.java b/src/com/android/settings/datetime/timezone/TimeZoneInfoPreferenceController.java
new file mode 100644
index 0000000..0f0264f
--- /dev/null
+++ b/src/com/android/settings/datetime/timezone/TimeZoneInfoPreferenceController.java
@@ -0,0 +1,137 @@
+/*
+ * 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.datetime.timezone;
+
+import android.content.Context;
+import android.icu.impl.OlsonTimeZone;
+import android.icu.text.DateFormat;
+import android.icu.text.DisplayContext;
+import android.icu.text.SimpleDateFormat;
+import android.icu.util.Calendar;
+import android.icu.util.TimeZone;
+import android.icu.util.TimeZoneTransition;
+import android.support.annotation.VisibleForTesting;
+import android.support.v7.preference.Preference;
+
+import com.android.settings.R;
+import com.android.settingslib.widget.FooterPreference;
+
+import java.util.Date;
+
+public class TimeZoneInfoPreferenceController extends BaseTimeZonePreferenceController {
+    private static final String PREFERENCE_KEY = FooterPreference.KEY_FOOTER;
+
+    private TimeZoneInfo mTimeZoneInfo;
+    private final DateFormat mDateFormat;
+    private final Date mDate;
+
+    public TimeZoneInfoPreferenceController(Context context) {
+        this(context, new Date());
+    }
+
+    @VisibleForTesting
+    TimeZoneInfoPreferenceController(Context context, Date date) {
+        super(context, PREFERENCE_KEY);
+        mDateFormat = DateFormat.getDateInstance(SimpleDateFormat.LONG);
+        mDateFormat.setContext(DisplayContext.CAPITALIZATION_NONE);
+        mDate = date;
+    }
+
+    @Override
+    public int getAvailabilityStatus() {
+        return AVAILABLE;
+    }
+
+    @Override
+    public void updateState(Preference preference) {
+        CharSequence formattedTimeZone = mTimeZoneInfo == null ? "" : formatInfo(mTimeZoneInfo);
+        preference.setTitle(formattedTimeZone);
+        preference.setVisible(mTimeZoneInfo != null);
+    }
+
+    public void setTimeZoneInfo(TimeZoneInfo timeZoneInfo) {
+        mTimeZoneInfo = timeZoneInfo;
+    }
+
+    public TimeZoneInfo getTimeZoneInfo() {
+        return mTimeZoneInfo;
+    }
+
+    private CharSequence formatOffsetAndName(TimeZoneInfo item) {
+        String name = item.getGenericName();
+        if (name == null) {
+            if (item.getTimeZone().inDaylightTime(mDate)) {
+                name = item.getDaylightName();
+            } else {
+                name = item.getStandardName();
+            }
+        }
+        if (name == null) {
+            return item.getGmtOffset().toString();
+        } else {
+            return SpannableUtil.getResourcesText(mContext.getResources(),
+                    R.string.zone_info_offset_and_name, item.getGmtOffset(),
+                    name);
+        }
+    }
+
+    private CharSequence formatInfo(TimeZoneInfo item) {
+        final CharSequence offsetAndName = formatOffsetAndName(item);
+        final TimeZone timeZone = item.getTimeZone();
+        if (!timeZone.observesDaylightTime()) {
+            return mContext.getString(R.string.zone_info_footer_no_dst, offsetAndName);
+        }
+
+        final TimeZoneTransition nextDstTransition = findNextDstTransition(timeZone);
+        if (nextDstTransition == null) {
+            return null;
+        }
+        final boolean toDst = nextDstTransition.getTo().getDSTSavings() != 0;
+        String timeType = toDst ? item.getDaylightName() : item.getStandardName();
+        if (timeType == null) {
+            // Fall back to generic "summer time" and "standard time" if the time zone has no
+            // specific names.
+            timeType = toDst ?
+                    mContext.getString(R.string.zone_time_type_dst) :
+                    mContext.getString(R.string.zone_time_type_standard);
+
+        }
+        final Calendar transitionTime = Calendar.getInstance(timeZone);
+        transitionTime.setTimeInMillis(nextDstTransition.getTime());
+        final String date = mDateFormat.format(transitionTime);
+        return SpannableUtil.getResourcesText(mContext.getResources(),
+                R.string.zone_info_footer, offsetAndName, timeType, date);
+    }
+
+    private TimeZoneTransition findNextDstTransition(TimeZone timeZone) {
+        if (!(timeZone instanceof OlsonTimeZone)) {
+            return null;
+        }
+        final OlsonTimeZone olsonTimeZone = (OlsonTimeZone) timeZone;
+        TimeZoneTransition transition = olsonTimeZone.getNextTransition(
+                mDate.getTime(), /* inclusive */ false);
+        do {
+            if (transition.getTo().getDSTSavings() != transition.getFrom().getDSTSavings()) {
+                break;
+            }
+            transition = olsonTimeZone.getNextTransition(
+                    transition.getTime(), /*inclusive */ false);
+        } while (transition != null);
+        return transition;
+    }
+
+}
diff --git a/src/com/android/settings/datetime/timezone/TimeZoneSettings.java b/src/com/android/settings/datetime/timezone/TimeZoneSettings.java
new file mode 100644
index 0000000..aeb5a80
--- /dev/null
+++ b/src/com/android/settings/datetime/timezone/TimeZoneSettings.java
@@ -0,0 +1,372 @@
+/*
+ * 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.datetime.timezone;
+
+import android.app.Activity;
+import android.app.AlarmManager;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.icu.util.TimeZone;
+import android.os.Bundle;
+import android.support.annotation.VisibleForTesting;
+import android.support.v7.preference.PreferenceCategory;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+
+import com.android.internal.logging.nano.MetricsProto;
+import com.android.settings.R;
+import com.android.settings.core.SubSettingLauncher;
+import com.android.settings.dashboard.DashboardFragment;
+import com.android.settings.datetime.timezone.model.FilteredCountryTimeZones;
+import com.android.settings.datetime.timezone.model.TimeZoneData;
+import com.android.settings.datetime.timezone.model.TimeZoneDataLoader;
+import com.android.settingslib.core.AbstractPreferenceController;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.Set;
+
+/**
+ * The class displays a time zone picker either by regions or fixed offset time zones.
+ */
+public class TimeZoneSettings extends DashboardFragment {
+
+    private static final String TAG = "TimeZoneSettings";
+
+    private static final int MENU_BY_REGION = Menu.FIRST;
+    private static final int MENU_BY_OFFSET = Menu.FIRST + 1;
+
+    private static final int REQUEST_CODE_REGION_PICKER = 1;
+    private static final int REQUEST_CODE_ZONE_PICKER = 2;
+    private static final int REQUEST_CODE_FIXED_OFFSET_ZONE_PICKER = 3;
+
+    private static final String PREF_KEY_REGION = "time_zone_region";
+    private static final String PREF_KEY_REGION_CATEGORY = "time_zone_region_preference_category";
+    private static final String PREF_KEY_FIXED_OFFSET_CATEGORY =
+            "time_zone_fixed_offset_preference_category";
+
+    private Locale mLocale;
+    private boolean mSelectByRegion;
+    private TimeZoneData mTimeZoneData;
+
+    private String mSelectedTimeZoneId;
+    private TimeZoneInfo.Formatter mTimeZoneInfoFormatter;
+
+    @Override
+    public int getMetricsCategory() {
+        return MetricsProto.MetricsEvent.ZONE_PICKER;
+    }
+
+    @Override
+    protected int getPreferenceScreenResId() {
+        return R.xml.time_zone_prefs;
+    }
+
+    @Override
+    protected String getLogTag() {
+        return TAG;
+    }
+
+    /**
+     * Called during onAttach
+     */
+    @VisibleForTesting
+    @Override
+    public List<AbstractPreferenceController> createPreferenceControllers(Context context) {
+        mLocale = context.getResources().getConfiguration().getLocales().get(0);
+        mTimeZoneInfoFormatter = new TimeZoneInfo.Formatter(mLocale, new Date());
+        final List<AbstractPreferenceController> controllers = new ArrayList<>();
+        RegionPreferenceController regionPreferenceController =
+                new RegionPreferenceController(context);
+        regionPreferenceController.setOnClickListener(this::onRegionPreferenceClicked);
+        RegionZonePreferenceController regionZonePreferenceController =
+                new RegionZonePreferenceController(context);
+        regionZonePreferenceController.setOnClickListener(this::onRegionZonePreferenceClicked);
+        TimeZoneInfoPreferenceController timeZoneInfoPreferenceController =
+                new TimeZoneInfoPreferenceController(context);
+        FixedOffsetPreferenceController fixedOffsetPreferenceController =
+                new FixedOffsetPreferenceController(context);
+        fixedOffsetPreferenceController.setOnClickListener(this::onFixedOffsetPreferenceClicked);
+
+        controllers.add(regionPreferenceController);
+        controllers.add(regionZonePreferenceController);
+        controllers.add(timeZoneInfoPreferenceController);
+        controllers.add(fixedOffsetPreferenceController);
+        return controllers;
+    }
+
+    @Override
+    public void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+        // Hide all interactive preferences
+        setPreferenceCategoryVisible((PreferenceCategory) findPreference(
+            PREF_KEY_REGION_CATEGORY), false);
+        setPreferenceCategoryVisible((PreferenceCategory) findPreference(
+            PREF_KEY_FIXED_OFFSET_CATEGORY), false);
+
+        // Start loading TimeZoneData
+        getLoaderManager().initLoader(0, null, new TimeZoneDataLoader.LoaderCreator(
+                getContext(), this::onTimeZoneDataReady));
+    }
+
+    @Override
+    public void onActivityResult(int requestCode, int resultCode, Intent data) {
+        if (resultCode != Activity.RESULT_OK || data == null) {
+            return;
+        }
+
+        switch (requestCode) {
+            case REQUEST_CODE_REGION_PICKER:
+            case REQUEST_CODE_ZONE_PICKER: {
+                String regionId = data.getStringExtra(RegionSearchPicker.EXTRA_RESULT_REGION_ID);
+                String tzId = data.getStringExtra(RegionZonePicker.EXTRA_RESULT_TIME_ZONE_ID);
+                // Ignore the result if user didn't change the region or time zone.
+                if (!Objects.equals(regionId, use(RegionPreferenceController.class).getRegionId())
+                        || !Objects.equals(tzId, mSelectedTimeZoneId)) {
+                    onRegionZoneChanged(regionId, tzId);
+                }
+                break;
+            }
+            case REQUEST_CODE_FIXED_OFFSET_ZONE_PICKER: {
+                String tzId = data.getStringExtra(FixedOffsetPicker.EXTRA_RESULT_TIME_ZONE_ID);
+                // Ignore the result if user didn't change the time zone.
+                if (tzId != null && !tzId.equals(mSelectedTimeZoneId)) {
+                    onFixedOffsetZoneChanged(tzId);
+                }
+                break;
+            }
+        }
+    }
+
+    @VisibleForTesting
+    void setTimeZoneData(TimeZoneData timeZoneData) {
+        mTimeZoneData = timeZoneData;
+    }
+
+    private void onTimeZoneDataReady(TimeZoneData timeZoneData) {
+        if (mTimeZoneData == null && timeZoneData != null) {
+            mTimeZoneData = timeZoneData;
+            setupForCurrentTimeZone();
+            getActivity().invalidateOptionsMenu();
+        }
+
+    }
+
+    private void onRegionPreferenceClicked() {
+        startPickerFragment(RegionSearchPicker.class, new Bundle(), REQUEST_CODE_REGION_PICKER);
+    }
+
+    private void onRegionZonePreferenceClicked() {
+        final Bundle args = new Bundle();
+        args.putString(RegionZonePicker.EXTRA_REGION_ID,
+                use(RegionPreferenceController.class).getRegionId());
+        startPickerFragment(RegionZonePicker.class, args, REQUEST_CODE_ZONE_PICKER);
+    }
+
+    private void onFixedOffsetPreferenceClicked() {
+        startPickerFragment(FixedOffsetPicker.class, new Bundle(),
+                REQUEST_CODE_FIXED_OFFSET_ZONE_PICKER);
+    }
+
+    private void startPickerFragment(Class<? extends BaseTimeZonePicker> fragmentClass, Bundle args,
+            int resultRequestCode) {
+        new SubSettingLauncher(getContext())
+                .setDestination(fragmentClass.getCanonicalName())
+                .setArguments(args)
+                .setSourceMetricsCategory(getMetricsCategory())
+                .setResultListener(this, resultRequestCode)
+                .launch();
+    }
+
+    private void setDisplayedRegion(String regionId) {
+        use(RegionPreferenceController.class).setRegionId(regionId);
+        updatePreferenceStates();
+    }
+
+    private void setDisplayedTimeZoneInfo(String regionId, String tzId) {
+        final TimeZoneInfo tzInfo = tzId == null ? null : mTimeZoneInfoFormatter.format(tzId);
+        final FilteredCountryTimeZones countryTimeZones =
+                mTimeZoneData.lookupCountryTimeZones(regionId);
+
+        use(RegionZonePreferenceController.class).setTimeZoneInfo(tzInfo);
+        // Only clickable when the region has more than 1 time zones or no time zone is selected.
+
+        use(RegionZonePreferenceController.class).setClickable(tzInfo == null ||
+                (countryTimeZones != null && countryTimeZones.getTimeZoneIds().size() > 1));
+        use(TimeZoneInfoPreferenceController.class).setTimeZoneInfo(tzInfo);
+
+        updatePreferenceStates();
+    }
+
+    private void setDisplayedFixedOffsetTimeZoneInfo(String tzId) {
+        if (isFixedOffset(tzId)) {
+            use(FixedOffsetPreferenceController.class).setTimeZoneInfo(
+                    mTimeZoneInfoFormatter.format(tzId));
+        } else {
+            use(FixedOffsetPreferenceController.class).setTimeZoneInfo(null);
+        }
+        updatePreferenceStates();
+    }
+
+    private void onRegionZoneChanged(String regionId, String tzId) {
+        FilteredCountryTimeZones countryTimeZones =
+                mTimeZoneData.lookupCountryTimeZones(regionId);
+        if (countryTimeZones == null || !countryTimeZones.getTimeZoneIds().contains(tzId)) {
+            Log.e(TAG, "Unknown time zone id is selected: " + tzId);
+            return;
+        }
+
+        mSelectedTimeZoneId = tzId;
+        setDisplayedRegion(regionId);
+        setDisplayedTimeZoneInfo(regionId, mSelectedTimeZoneId);
+        saveTimeZone(regionId, mSelectedTimeZoneId);
+    }
+
+    private void onFixedOffsetZoneChanged(String tzId) {
+        mSelectedTimeZoneId = tzId;
+        setDisplayedFixedOffsetTimeZoneInfo(tzId);
+        saveTimeZone(null, mSelectedTimeZoneId);
+    }
+
+    private void saveTimeZone(String regionId, String tzId) {
+        SharedPreferences.Editor editor = getPreferenceManager().getSharedPreferences().edit();
+        if (regionId == null) {
+            editor.remove(PREF_KEY_REGION);
+        } else {
+            editor.putString(PREF_KEY_REGION, regionId);
+        }
+        editor.apply();
+        getActivity().getSystemService(AlarmManager.class).setTimeZone(tzId);
+    }
+
+    @Override
+    public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+        menu.add(0, MENU_BY_REGION, 0, R.string.zone_menu_by_region);
+        menu.add(0, MENU_BY_OFFSET, 0, R.string.zone_menu_by_offset);
+        super.onCreateOptionsMenu(menu, inflater);
+    }
+
+    @Override
+    public void onPrepareOptionsMenu(Menu menu) {
+        // Do not show menu when data is not ready,
+        menu.findItem(MENU_BY_REGION).setVisible(mTimeZoneData != null && !mSelectByRegion);
+        menu.findItem(MENU_BY_OFFSET).setVisible(mTimeZoneData != null && mSelectByRegion);
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+            case MENU_BY_REGION:
+                setSelectByRegion(true);
+                return true;
+
+            case MENU_BY_OFFSET:
+                setSelectByRegion(false);
+                return true;
+
+            default:
+                return false;
+        }
+    }
+
+    private void setupForCurrentTimeZone() {
+        mSelectedTimeZoneId = TimeZone.getDefault().getID();
+        setSelectByRegion(!isFixedOffset(mSelectedTimeZoneId));
+    }
+
+    private static boolean isFixedOffset(String tzId) {
+        return tzId.startsWith("Etc/GMT") || tzId.equals("Etc/UTC");
+    }
+
+    /**
+     * Switch the current view to select region or select fixed offset time zone.
+     * When showing the selected region, it guess the selected region from time zone id.
+     * See {@link #findRegionIdForTzId} for more info.
+     */
+    private void setSelectByRegion(boolean selectByRegion) {
+        mSelectByRegion = selectByRegion;
+        setPreferenceCategoryVisible((PreferenceCategory) findPreference(
+            PREF_KEY_REGION_CATEGORY), selectByRegion);
+        setPreferenceCategoryVisible((PreferenceCategory) findPreference(
+            PREF_KEY_FIXED_OFFSET_CATEGORY), !selectByRegion);
+        final String localeRegionId = getLocaleRegionId();
+        final Set<String> allCountryIsoCodes = mTimeZoneData.getRegionIds();
+
+        String displayRegion = allCountryIsoCodes.contains(localeRegionId) ? localeRegionId : null;
+        setDisplayedRegion(displayRegion);
+        setDisplayedTimeZoneInfo(displayRegion, null);
+
+        if (!mSelectByRegion) {
+            setDisplayedFixedOffsetTimeZoneInfo(mSelectedTimeZoneId);
+            return;
+        }
+
+        String regionId = findRegionIdForTzId(mSelectedTimeZoneId);
+        if (regionId != null) {
+            setDisplayedRegion(regionId);
+            setDisplayedTimeZoneInfo(regionId, mSelectedTimeZoneId);
+        }
+    }
+
+    /**
+     * Find the a region associated with the specified time zone, based on the time zone data.
+     * If there are multiple regions associated with the given time zone, the priority will be given
+     * to the region the user last picked and the country in user's locale.
+     * @return null if no region associated with the time zone
+     */
+    private String findRegionIdForTzId(String tzId) {
+        return findRegionIdForTzId(tzId,
+                getPreferenceManager().getSharedPreferences().getString(PREF_KEY_REGION, null),
+                getLocaleRegionId());
+    }
+
+    @VisibleForTesting
+    String findRegionIdForTzId(String tzId, String sharePrefRegionId, String localeRegionId) {
+        final Set<String> matchedRegions = mTimeZoneData.lookupCountryCodesForZoneId(tzId);
+        if (matchedRegions.size() == 0) {
+            return null;
+        }
+        if (sharePrefRegionId != null && matchedRegions.contains(sharePrefRegionId)) {
+            return sharePrefRegionId;
+        }
+        if (localeRegionId != null && matchedRegions.contains(localeRegionId)) {
+            return localeRegionId;
+        }
+
+        return matchedRegions.toArray(new String[matchedRegions.size()])[0];
+    }
+
+    private void setPreferenceCategoryVisible(PreferenceCategory category,
+        boolean isVisible) {
+        // Hiding category doesn't hide all the children preference. Set visibility of its children.
+        // Do not care grandchildren as time_zone_pref.xml has only 2 levels.
+        category.setVisible(isVisible);
+        for (int i = 0; i < category.getPreferenceCount(); i++) {
+            category.getPreference(i).setVisible(isVisible);
+        }
+    }
+
+    private String getLocaleRegionId() {
+        return mLocale.getCountry().toUpperCase(Locale.US);
+    }
+}
diff --git a/src/com/android/settings/fuelgauge/AppButtonsPreferenceController.java b/src/com/android/settings/fuelgauge/AppButtonsPreferenceController.java
index 4094e1f..854b855 100644
--- a/src/com/android/settings/fuelgauge/AppButtonsPreferenceController.java
+++ b/src/com/android/settings/fuelgauge/AppButtonsPreferenceController.java
@@ -297,7 +297,9 @@
 
     @Override
     public void onPackageListChanged() {
-        refreshUi();
+        if (isAvailable()) {
+            refreshUi();
+        }
     }
 
     @Override
diff --git a/src/com/android/settings/fuelgauge/AutoRestrictionPreferenceController.java b/src/com/android/settings/fuelgauge/AutoRestrictionPreferenceController.java
new file mode 100644
index 0000000..e8e5ad9
--- /dev/null
+++ b/src/com/android/settings/fuelgauge/AutoRestrictionPreferenceController.java
@@ -0,0 +1,65 @@
+/*
+ * 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.fuelgauge;
+
+import android.content.Context;
+import android.provider.Settings;
+import android.support.v14.preference.SwitchPreference;
+import android.support.v7.preference.Preference;
+
+import com.android.settings.core.BasePreferenceController;
+import com.android.settings.overlay.FeatureFactory;
+
+/**
+ * Controller to change and update the auto restriction toggle
+ */
+public class AutoRestrictionPreferenceController extends BasePreferenceController implements
+        Preference.OnPreferenceChangeListener {
+    private static final String KEY_SMART_BATTERY = "auto_restriction";
+    private static final int ON = 1;
+    private static final int OFF = 0;
+    private PowerUsageFeatureProvider mPowerUsageFeatureProvider;
+
+    public AutoRestrictionPreferenceController(Context context) {
+        super(context, KEY_SMART_BATTERY);
+        mPowerUsageFeatureProvider = FeatureFactory.getFactory(
+                context).getPowerUsageFeatureProvider(context);
+    }
+
+    @Override
+    public int getAvailabilityStatus() {
+        return mPowerUsageFeatureProvider.isSmartBatterySupported()
+                ? DISABLED_UNSUPPORTED
+                : AVAILABLE;
+    }
+
+    @Override
+    public void updateState(Preference preference) {
+        super.updateState(preference);
+        final boolean smartBatteryOn = Settings.Global.getInt(mContext.getContentResolver(),
+                Settings.Global.APP_AUTO_RESTRICTION_ENABLED, ON) == ON;
+        ((SwitchPreference) preference).setChecked(smartBatteryOn);
+    }
+
+    @Override
+    public boolean onPreferenceChange(Preference preference, Object newValue) {
+        final boolean smartBatteryOn = (Boolean) newValue;
+        Settings.Global.putInt(mContext.getContentResolver(),
+                Settings.Global.APP_AUTO_RESTRICTION_ENABLED,
+                smartBatteryOn ? ON : OFF);
+        return true;
+    }
+}
diff --git a/src/com/android/settings/fuelgauge/BatteryAppListPreferenceController.java b/src/com/android/settings/fuelgauge/BatteryAppListPreferenceController.java
index 3ba5ee4..de01533 100644
--- a/src/com/android/settings/fuelgauge/BatteryAppListPreferenceController.java
+++ b/src/com/android/settings/fuelgauge/BatteryAppListPreferenceController.java
@@ -22,6 +22,7 @@
 import android.graphics.drawable.Drawable;
 import android.os.BatteryStats;
 import android.os.Handler;
+import android.os.Looper;
 import android.os.Message;
 import android.os.Process;
 import android.os.UserHandle;
@@ -81,7 +82,7 @@
     private Context mPrefContext;
     SparseArray<List<Anomaly>> mAnomalySparseArray;
 
-    private Handler mHandler = new Handler() {
+    private Handler mHandler = new Handler(Looper.getMainLooper()) {
         @Override
         public void handleMessage(Message msg) {
             switch (msg.what) {
@@ -149,7 +150,7 @@
 
     @Override
     public boolean isAvailable() {
-        return FeatureFlagUtils.isEnabled(mContext, FeatureFlags.BATTERY_DISPLAY_APP_LIST);
+        return true;
     }
 
     @Override
@@ -186,12 +187,17 @@
         }
     }
 
-    public void refreshAppListGroup(BatteryStatsHelper statsHelper, boolean showAllApps,
-            CharSequence timeSequence) {
+    public void refreshAppListGroup(BatteryStatsHelper statsHelper, boolean showAllApps) {
         if (!isAvailable()) {
             return;
         }
+
         mBatteryStatsHelper = statsHelper;
+        final long lastFullChargeTime = mBatteryUtils.calculateLastFullChargeTime(
+                mBatteryStatsHelper, System.currentTimeMillis());
+        final CharSequence timeSequence = StringUtil.formatRelativeTime(mContext,
+                lastFullChargeTime,
+                false);
         final int resId = showAllApps ? R.string.power_usage_list_summary_device
                 : R.string.power_usage_list_summary;
         mAppListGroup.setTitle(TextUtils.expandTemplate(mContext.getText(resId), timeSequence));
@@ -361,7 +367,7 @@
         final long usageTimeMs = sipper.usageTimeMs;
         if (usageTimeMs >= DateUtils.MINUTE_IN_MILLIS) {
             final CharSequence timeSequence =
-                StringUtil.formatElapsedTime(mContext, usageTimeMs, false);
+                    StringUtil.formatElapsedTime(mContext, usageTimeMs, false);
             preference.setSummary(
                     (sipper.drainType != DrainType.APP || mBatteryUtils.shouldHideSipper(sipper))
                             ? timeSequence
diff --git a/src/com/android/settings/fuelgauge/PowerUsageAdvanced.java b/src/com/android/settings/fuelgauge/PowerUsageAdvanced.java
index 2e94e2c..327a6c5 100644
--- a/src/com/android/settings/fuelgauge/PowerUsageAdvanced.java
+++ b/src/com/android/settings/fuelgauge/PowerUsageAdvanced.java
@@ -13,134 +13,58 @@
  */
 package com.android.settings.fuelgauge;
 
-import android.app.Activity;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
-import android.content.pm.PackageManager;
-import android.content.pm.UserInfo;
 import android.os.BatteryManager;
-import android.os.BatteryStats;
 import android.os.Bundle;
-import android.os.Handler;
-import android.os.Message;
-import android.os.UserManager;
 import android.provider.SearchIndexableResource;
-import android.support.annotation.ColorInt;
-import android.support.annotation.IntDef;
-import android.support.annotation.NonNull;
-import android.support.annotation.StringRes;
 import android.support.annotation.VisibleForTesting;
-import android.support.v7.preference.Preference;
-import android.support.v7.preference.PreferenceGroup;
-import android.text.TextUtils;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
 
 import com.android.internal.logging.nano.MetricsProto;
-import com.android.internal.os.BatterySipper;
-import com.android.internal.os.BatterySipper.DrainType;
-import com.android.internal.os.BatteryStatsHelper;
 import com.android.settings.R;
-import com.android.settings.Utils;
-import com.android.settings.datausage.DataUsageUtils;
-import com.android.settings.fuelgauge.PowerUsageAdvanced.PowerUsageData.UsageType;
+import com.android.settings.SettingsActivity;
 import com.android.settings.overlay.FeatureFactory;
 import com.android.settings.search.BaseSearchIndexProvider;
 import com.android.settingslib.core.AbstractPreferenceController;
-
 import com.android.settingslib.utils.StringUtil;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
+
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 
 public class PowerUsageAdvanced extends PowerUsageBase {
     private static final String TAG = "AdvancedBatteryUsage";
     private static final String KEY_BATTERY_GRAPH = "battery_graph";
-    private static final String KEY_BATTERY_USAGE_LIST = "battery_usage_list";
-    private static final int STATUS_TYPE = BatteryStats.STATS_SINCE_CHARGED;
+    private static final String KEY_APP_LIST = "app_list";
+    private static final String KEY_SHOW_ALL_APPS = "show_all_apps";
+    @VisibleForTesting
+    static final int MENU_TOGGLE_APPS = Menu.FIRST + 1;
 
     @VisibleForTesting
-    final int[] mUsageTypes = {
-            UsageType.WIFI,
-            UsageType.CELL,
-            UsageType.SYSTEM,
-            UsageType.BLUETOOTH,
-            UsageType.USER,
-            UsageType.IDLE,
-            UsageType.APP,
-            UsageType.UNACCOUNTED,
-            UsageType.OVERCOUNTED};
-
-    @VisibleForTesting BatteryHistoryPreference mHistPref;
-    @VisibleForTesting PreferenceGroup mUsageListGroup;
+    BatteryHistoryPreference mHistPref;
     private BatteryUtils mBatteryUtils;
     private PowerUsageFeatureProvider mPowerUsageFeatureProvider;
-    private PackageManager mPackageManager;
-    private UserManager mUserManager;
-    private Map<Integer, PowerUsageData> mBatteryDataMap;
-
-    Handler mHandler = new Handler() {
-
-        @Override
-        public void handleMessage(Message msg) {
-            switch (msg.what) {
-                case BatteryEntry.MSG_UPDATE_NAME_ICON:
-                    final int dischargeAmount = mStatsHelper.getStats().getDischargeAmount(
-                            STATUS_TYPE);
-                    final double totalPower = mStatsHelper.getTotalPower();
-                    final BatteryEntry entry = (BatteryEntry) msg.obj;
-                    final int usageType = extractUsageType(entry.sipper);
-
-                    PowerUsageData usageData = mBatteryDataMap.get(usageType);
-                    Preference pref = findPreference(String.valueOf(usageType));
-                    if (pref != null && usageData != null) {
-                        updateUsageDataSummary(usageData, totalPower, dischargeAmount);
-                        pref.setSummary(usageData.summary);
-                    }
-                    break;
-                case BatteryEntry.MSG_REPORT_FULLY_DRAWN:
-                    Activity activity = getActivity();
-                    if (activity != null) {
-                        activity.reportFullyDrawn();
-                    }
-                    break;
-            }
-            super.handleMessage(msg);
-        }
-    };
+    private BatteryAppListPreferenceController mBatteryAppListPreferenceController;
+    @VisibleForTesting
+    boolean mShowAllApps = false;
 
     @Override
     public void onCreate(Bundle icicle) {
         super.onCreate(icicle);
+        final Context context = getContext();
 
         mHistPref = (BatteryHistoryPreference) findPreference(KEY_BATTERY_GRAPH);
-        mUsageListGroup = (PreferenceGroup) findPreference(KEY_BATTERY_USAGE_LIST);
-
-        final Context context = getContext();
         mPowerUsageFeatureProvider = FeatureFactory.getFactory(context)
                 .getPowerUsageFeatureProvider(context);
-        mPackageManager = context.getPackageManager();
-        mUserManager = (UserManager) context.getSystemService(Context.USER_SERVICE);
         mBatteryUtils = BatteryUtils.getInstance(context);
 
         // init the summary so other preferences won't have unnecessary move
         updateHistPrefSummary(context);
-    }
-
-    @Override
-    public void onResume() {
-        super.onResume();
-    }
-
-    @Override
-    public void onPause() {
-        BatteryEntry.stopRequestQueue();
-        mHandler.removeMessages(BatteryEntry.MSG_UPDATE_NAME_ICON);
-        super.onPause();
+        restoreSavedInstance(icicle);
     }
 
     @Override
@@ -167,23 +91,62 @@
     }
 
     @Override
+    public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+        menu.add(Menu.NONE, MENU_TOGGLE_APPS, Menu.NONE,
+                mShowAllApps ? R.string.hide_extra_apps : R.string.show_all_apps);
+        super.onCreateOptionsMenu(menu, inflater);
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+            case MENU_TOGGLE_APPS:
+                mShowAllApps = !mShowAllApps;
+                item.setTitle(mShowAllApps ? R.string.hide_extra_apps : R.string.show_all_apps);
+                mMetricsFeatureProvider.action(getContext(),
+                        MetricsProto.MetricsEvent.ACTION_SETTINGS_MENU_BATTERY_APPS_TOGGLE,
+                        mShowAllApps);
+                restartBatteryStatsLoader();
+                return true;
+            default:
+                return super.onOptionsItemSelected(item);
+        }
+    }
+
+    @VisibleForTesting
+    void restoreSavedInstance(Bundle savedInstance) {
+        if (savedInstance != null) {
+            mShowAllApps = savedInstance.getBoolean(KEY_SHOW_ALL_APPS, false);
+        }
+    }
+
+    @Override
+    public void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+        outState.putBoolean(KEY_SHOW_ALL_APPS, mShowAllApps);
+    }
+
+    @Override
     protected List<AbstractPreferenceController> createPreferenceControllers(Context context) {
-        return null;
+        final List<AbstractPreferenceController> controllers = new ArrayList<>();
+
+        mBatteryAppListPreferenceController = new BatteryAppListPreferenceController(context,
+                KEY_APP_LIST, getLifecycle(), (SettingsActivity) getActivity(), this);
+        controllers.add(mBatteryAppListPreferenceController);
+
+        return controllers;
     }
 
     @Override
     protected void refreshUi() {
-        final long startTime = System.currentTimeMillis();
         final Context context = getContext();
         if (context == null) {
             return;
         }
         updatePreference(mHistPref);
-        refreshPowerUsageDataList(mStatsHelper, mUsageListGroup);
         updateHistPrefSummary(context);
 
-        BatteryEntry.startRequestQueue();
-        BatteryUtils.logRuntime(TAG, "refreshUI", startTime);
+        mBatteryAppListPreferenceController.refreshAppListGroup(mStatsHelper, mShowAllApps);
     }
 
     private void updateHistPrefSummary(Context context) {
@@ -199,278 +162,6 @@
         }
     }
 
-    @VisibleForTesting
-    void refreshPowerUsageDataList(BatteryStatsHelper statsHelper,
-            PreferenceGroup preferenceGroup) {
-        List<PowerUsageData> dataList = parsePowerUsageData(statsHelper);
-        preferenceGroup.removeAll();
-        for (int i = 0, size = dataList.size(); i < size; i++) {
-            final PowerUsageData batteryData = dataList.get(i);
-            if (shouldHideCategory(batteryData)) {
-                continue;
-            }
-            final PowerGaugePreference pref = new PowerGaugePreference(getPrefContext());
-
-            pref.setKey(String.valueOf(batteryData.usageType));
-            pref.setTitle(batteryData.titleResId);
-            pref.setSummary(batteryData.summary);
-            pref.setPercent(batteryData.percentage);
-            pref.setSelectable(false);
-            preferenceGroup.addPreference(pref);
-        }
-    }
-
-    @VisibleForTesting
-    @UsageType
-    int extractUsageType(BatterySipper sipper) {
-        final DrainType drainType = sipper.drainType;
-        final int uid = sipper.getUid();
-
-        if (drainType == DrainType.WIFI) {
-            return UsageType.WIFI;
-        } else if (drainType == DrainType.BLUETOOTH) {
-            return UsageType.BLUETOOTH;
-        } else if (drainType == DrainType.IDLE) {
-            return UsageType.IDLE;
-        } else if (drainType == DrainType.USER) {
-            return UsageType.USER;
-        } else if (drainType == DrainType.CELL) {
-            return UsageType.CELL;
-        } else if (drainType == DrainType.UNACCOUNTED) {
-            return UsageType.UNACCOUNTED;
-        } else if (drainType == DrainType.OVERCOUNTED) {
-            return UsageType.OVERCOUNTED;
-        } else if (mPowerUsageFeatureProvider.isTypeSystem(sipper)
-                || mPowerUsageFeatureProvider.isTypeService(sipper)) {
-            return UsageType.SYSTEM;
-        } else {
-            return UsageType.APP;
-        }
-    }
-
-    @VisibleForTesting
-    boolean shouldHideCategory(PowerUsageData powerUsageData) {
-        return powerUsageData.usageType == UsageType.UNACCOUNTED
-                || powerUsageData.usageType == UsageType.OVERCOUNTED
-                || (powerUsageData.usageType == UsageType.USER && isSingleNormalUser())
-                || (powerUsageData.usageType == UsageType.CELL
-                && !DataUsageUtils.hasMobileData(getContext()));
-    }
-
-    @VisibleForTesting
-    boolean shouldShowBatterySipper(BatterySipper batterySipper) {
-        return batterySipper.drainType != DrainType.SCREEN;
-    }
-
-    @VisibleForTesting
-    List<PowerUsageData> parsePowerUsageData(BatteryStatsHelper statusHelper) {
-        final List<BatterySipper> batterySippers = statusHelper.getUsageList();
-        final Map<Integer, PowerUsageData> batteryDataMap = new HashMap<>();
-
-        for (final @UsageType Integer type : mUsageTypes) {
-            batteryDataMap.put(type, new PowerUsageData(type));
-        }
-
-        // Accumulate power usage based on usage type
-        for (final BatterySipper sipper : batterySippers) {
-            sipper.mPackages = mPackageManager.getPackagesForUid(sipper.getUid());
-            final PowerUsageData usageData = batteryDataMap.get(extractUsageType(sipper));
-            usageData.totalPowerMah += sipper.totalPowerMah;
-            if (sipper.drainType == DrainType.APP && sipper.usageTimeMs != 0) {
-                sipper.usageTimeMs = mBatteryUtils.getProcessTimeMs(
-                        BatteryUtils.StatusType.FOREGROUND, sipper.uidObj, STATUS_TYPE);
-            }
-            usageData.totalUsageTimeMs += sipper.usageTimeMs;
-            if (shouldShowBatterySipper(sipper)) {
-                usageData.usageList.add(sipper);
-            }
-        }
-
-        final List<PowerUsageData> batteryDataList = new ArrayList<>(batteryDataMap.values());
-        final int dischargeAmount = statusHelper.getStats().getDischargeAmount(STATUS_TYPE);
-        final double totalPower = statusHelper.getTotalPower();
-        final double hiddenPower = calculateHiddenPower(batteryDataList);
-        for (final PowerUsageData usageData : batteryDataList) {
-            usageData.percentage = mBatteryUtils.calculateBatteryPercent(usageData.totalPowerMah,
-                    totalPower, hiddenPower, dischargeAmount);
-            updateUsageDataSummary(usageData, totalPower, dischargeAmount);
-        }
-
-        Collections.sort(batteryDataList);
-
-        mBatteryDataMap = batteryDataMap;
-        return batteryDataList;
-    }
-
-    @VisibleForTesting
-    double calculateHiddenPower(List<PowerUsageData> batteryDataList) {
-        for (final PowerUsageData usageData : batteryDataList) {
-            if (usageData.usageType == UsageType.UNACCOUNTED) {
-                return usageData.totalPowerMah;
-            }
-        }
-
-        return 0;
-    }
-
-    @VisibleForTesting
-    void updateUsageDataSummary(PowerUsageData usageData, double totalPower, int dischargeAmount) {
-        if (shouldHideSummary(usageData)) {
-            return;
-        }
-        if (usageData.usageList.size() <= 1) {
-            CharSequence timeSequence = StringUtil.formatElapsedTime(getContext(),
-                    usageData.totalUsageTimeMs, false);
-            usageData.summary = usageData.usageType == UsageType.IDLE ? timeSequence
-                    : TextUtils.expandTemplate(getText(R.string.battery_used_for), timeSequence);
-        } else {
-            BatterySipper sipper = findBatterySipperWithMaxBatteryUsage(usageData.usageList);
-            BatteryEntry batteryEntry = new BatteryEntry(getContext(), mHandler, mUserManager,
-                    sipper);
-            final double percentage = (sipper.totalPowerMah / totalPower) * dischargeAmount;
-            usageData.summary = getString(R.string.battery_used_by,
-                    Utils.formatPercentage(percentage, true), batteryEntry.name);
-        }
-    }
-
-    @VisibleForTesting
-    boolean shouldHideSummary(PowerUsageData powerUsageData) {
-        @UsageType final int usageType = powerUsageData.usageType;
-
-        return usageType == UsageType.CELL
-                || usageType == UsageType.BLUETOOTH
-                || usageType == UsageType.WIFI
-                || usageType == UsageType.APP
-                || usageType == UsageType.SYSTEM;
-    }
-
-    @VisibleForTesting
-    BatterySipper findBatterySipperWithMaxBatteryUsage(List<BatterySipper> usageList) {
-        BatterySipper sipper = usageList.get(0);
-        for (int i = 1, size = usageList.size(); i < size; i++) {
-            final BatterySipper comparedSipper = usageList.get(i);
-            if (comparedSipper.totalPowerMah > sipper.totalPowerMah) {
-                sipper = comparedSipper;
-            }
-        }
-
-        return sipper;
-    }
-
-    @VisibleForTesting
-    void setPackageManager(PackageManager packageManager) {
-        mPackageManager = packageManager;
-    }
-
-    @VisibleForTesting
-    void setPowerUsageFeatureProvider(PowerUsageFeatureProvider provider) {
-        mPowerUsageFeatureProvider = provider;
-    }
-    @VisibleForTesting
-    void setUserManager(UserManager userManager) {
-        mUserManager = userManager;
-    }
-    @VisibleForTesting
-    void setBatteryUtils(BatteryUtils batteryUtils) {
-        mBatteryUtils = batteryUtils;
-    }
-
-    @VisibleForTesting
-    boolean isSingleNormalUser() {
-        int count = 0;
-        for (UserInfo userInfo : mUserManager.getUsers()) {
-            if (userInfo.isEnabled() && !userInfo.isManagedProfile()) {
-                count++;
-            }
-        }
-
-        return count == 1;
-    }
-
-    /**
-     * Class that contains data used in {@link PowerGaugePreference}.
-     */
-    @VisibleForTesting
-    static class PowerUsageData implements Comparable<PowerUsageData> {
-
-        @Retention(RetentionPolicy.SOURCE)
-        @IntDef({UsageType.APP,
-                UsageType.WIFI,
-                UsageType.CELL,
-                UsageType.SYSTEM,
-                UsageType.BLUETOOTH,
-                UsageType.USER,
-                UsageType.IDLE,
-                UsageType.UNACCOUNTED,
-                UsageType.OVERCOUNTED})
-        public @interface UsageType {
-            int APP = 0;
-            int WIFI = 1;
-            int CELL = 2;
-            int SYSTEM = 3;
-            int BLUETOOTH = 4;
-            int USER = 5;
-            int IDLE = 6;
-            int UNACCOUNTED = 7;
-            int OVERCOUNTED = 8;
-        }
-
-        @StringRes
-        public int titleResId;
-        public CharSequence summary;
-        public double percentage;
-        public double totalPowerMah;
-        public long totalUsageTimeMs;
-        @ColorInt
-        public int iconColor;
-        @UsageType
-        public int usageType;
-        public List<BatterySipper> usageList;
-
-        public PowerUsageData(@UsageType int usageType) {
-            this(usageType, 0);
-        }
-
-        public PowerUsageData(@UsageType int usageType, double totalPower) {
-            this.usageType = usageType;
-            totalPowerMah = 0;
-            totalUsageTimeMs = 0;
-            titleResId = getTitleResId(usageType);
-            totalPowerMah = totalPower;
-            usageList = new ArrayList<>();
-        }
-
-        private int getTitleResId(@UsageType int usageType) {
-            switch (usageType) {
-                case UsageType.WIFI:
-                    return R.string.power_wifi;
-                case UsageType.CELL:
-                    return R.string.power_cell;
-                case UsageType.SYSTEM:
-                    return R.string.power_system;
-                case UsageType.BLUETOOTH:
-                    return R.string.power_bluetooth;
-                case UsageType.USER:
-                    return R.string.power_user;
-                case UsageType.IDLE:
-                    return R.string.power_idle;
-                case UsageType.UNACCOUNTED:
-                    return R.string.power_unaccounted;
-                case UsageType.OVERCOUNTED:
-                    return R.string.power_overcounted;
-                case UsageType.APP:
-                default:
-                    return R.string.power_apps;
-            }
-        }
-
-        @Override
-        public int compareTo(@NonNull PowerUsageData powerUsageData) {
-            final int diff = Double.compare(powerUsageData.totalPowerMah, totalPowerMah);
-            return diff != 0 ? diff : usageType - powerUsageData.usageType;
-        }
-    }
-
     public static final SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
             new BaseSearchIndexProvider() {
                 @Override
@@ -480,6 +171,16 @@
                     sir.xmlResId = R.xml.power_usage_advanced;
                     return Arrays.asList(sir);
                 }
+
+                @Override
+                public List<AbstractPreferenceController> createPreferenceControllers(
+                        Context context) {
+                    final List<AbstractPreferenceController> controllers = new ArrayList<>();
+                    controllers.add(new BatteryAppListPreferenceController(context,
+                            KEY_APP_LIST, null /* lifecycle */, null /* activity */,
+                            null /* fragment */));
+                    return controllers;
+                }
             };
 
 }
diff --git a/src/com/android/settings/fuelgauge/PowerUsageAdvancedLegacy.java b/src/com/android/settings/fuelgauge/PowerUsageAdvancedLegacy.java
new file mode 100644
index 0000000..a4e3fef
--- /dev/null
+++ b/src/com/android/settings/fuelgauge/PowerUsageAdvancedLegacy.java
@@ -0,0 +1,485 @@
+/*
+ * Copyright (C) 2017 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.fuelgauge;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.pm.PackageManager;
+import android.content.pm.UserInfo;
+import android.os.BatteryManager;
+import android.os.BatteryStats;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Message;
+import android.os.UserManager;
+import android.provider.SearchIndexableResource;
+import android.support.annotation.ColorInt;
+import android.support.annotation.IntDef;
+import android.support.annotation.NonNull;
+import android.support.annotation.StringRes;
+import android.support.annotation.VisibleForTesting;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.PreferenceGroup;
+import android.text.TextUtils;
+
+import com.android.internal.logging.nano.MetricsProto;
+import com.android.internal.os.BatterySipper;
+import com.android.internal.os.BatterySipper.DrainType;
+import com.android.internal.os.BatteryStatsHelper;
+import com.android.settings.R;
+import com.android.settings.Utils;
+import com.android.settings.datausage.DataUsageUtils;
+import com.android.settings.fuelgauge.PowerUsageAdvancedLegacy.PowerUsageData.UsageType;
+import com.android.settings.overlay.FeatureFactory;
+import com.android.settings.search.BaseSearchIndexProvider;
+import com.android.settingslib.core.AbstractPreferenceController;
+
+import com.android.settingslib.utils.StringUtil;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class PowerUsageAdvancedLegacy extends PowerUsageBase {
+    private static final String TAG = "AdvancedBatteryUsage";
+    private static final String KEY_BATTERY_GRAPH = "battery_graph_legacy";
+    private static final String KEY_BATTERY_USAGE_LIST = "battery_usage_list_legacy";
+    private static final int STATUS_TYPE = BatteryStats.STATS_SINCE_CHARGED;
+
+    @VisibleForTesting
+    final int[] mUsageTypes = {
+            UsageType.WIFI,
+            UsageType.CELL,
+            UsageType.SYSTEM,
+            UsageType.BLUETOOTH,
+            UsageType.USER,
+            UsageType.IDLE,
+            UsageType.APP,
+            UsageType.UNACCOUNTED,
+            UsageType.OVERCOUNTED};
+
+    @VisibleForTesting BatteryHistoryPreference mHistPref;
+    @VisibleForTesting PreferenceGroup mUsageListGroup;
+    private BatteryUtils mBatteryUtils;
+    private PowerUsageFeatureProvider mPowerUsageFeatureProvider;
+    private PackageManager mPackageManager;
+    private UserManager mUserManager;
+    private Map<Integer, PowerUsageData> mBatteryDataMap;
+
+    Handler mHandler = new Handler() {
+
+        @Override
+        public void handleMessage(Message msg) {
+            switch (msg.what) {
+                case BatteryEntry.MSG_UPDATE_NAME_ICON:
+                    final int dischargeAmount = mStatsHelper.getStats().getDischargeAmount(
+                            STATUS_TYPE);
+                    final double totalPower = mStatsHelper.getTotalPower();
+                    final BatteryEntry entry = (BatteryEntry) msg.obj;
+                    final int usageType = extractUsageType(entry.sipper);
+
+                    PowerUsageData usageData = mBatteryDataMap.get(usageType);
+                    Preference pref = findPreference(String.valueOf(usageType));
+                    if (pref != null && usageData != null) {
+                        updateUsageDataSummary(usageData, totalPower, dischargeAmount);
+                        pref.setSummary(usageData.summary);
+                    }
+                    break;
+                case BatteryEntry.MSG_REPORT_FULLY_DRAWN:
+                    Activity activity = getActivity();
+                    if (activity != null) {
+                        activity.reportFullyDrawn();
+                    }
+                    break;
+            }
+            super.handleMessage(msg);
+        }
+    };
+
+    @Override
+    public void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+
+        mHistPref = (BatteryHistoryPreference) findPreference(KEY_BATTERY_GRAPH);
+        mUsageListGroup = (PreferenceGroup) findPreference(KEY_BATTERY_USAGE_LIST);
+
+        final Context context = getContext();
+        mPowerUsageFeatureProvider = FeatureFactory.getFactory(context)
+                .getPowerUsageFeatureProvider(context);
+        mPackageManager = context.getPackageManager();
+        mUserManager = (UserManager) context.getSystemService(Context.USER_SERVICE);
+        mBatteryUtils = BatteryUtils.getInstance(context);
+
+        // init the summary so other preferences won't have unnecessary move
+        updateHistPrefSummary(context);
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+    }
+
+    @Override
+    public void onPause() {
+        BatteryEntry.stopRequestQueue();
+        mHandler.removeMessages(BatteryEntry.MSG_UPDATE_NAME_ICON);
+        super.onPause();
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+        if (getActivity().isChangingConfigurations()) {
+            BatteryEntry.clearUidCache();
+        }
+    }
+
+    @Override
+    public int getMetricsCategory() {
+        return MetricsProto.MetricsEvent.FUELGAUGE_BATTERY_HISTORY_DETAIL;
+    }
+
+    @Override
+    protected String getLogTag() {
+        return TAG;
+    }
+
+    @Override
+    protected int getPreferenceScreenResId() {
+        return R.xml.power_usage_advanced_legacy;
+    }
+
+    @Override
+    protected List<AbstractPreferenceController> createPreferenceControllers(Context context) {
+        return null;
+    }
+
+    @Override
+    protected void refreshUi() {
+        final long startTime = System.currentTimeMillis();
+        final Context context = getContext();
+        if (context == null) {
+            return;
+        }
+        updatePreference(mHistPref);
+        refreshPowerUsageDataList(mStatsHelper, mUsageListGroup);
+        updateHistPrefSummary(context);
+
+        BatteryEntry.startRequestQueue();
+        BatteryUtils.logRuntime(TAG, "refreshUI", startTime);
+    }
+
+    private void updateHistPrefSummary(Context context) {
+        Intent batteryIntent =
+                context.registerReceiver(null, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
+        final boolean plugged = batteryIntent.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1) != 0;
+
+        if (mPowerUsageFeatureProvider.isEnhancedBatteryPredictionEnabled(context) && !plugged) {
+            mHistPref.setBottomSummary(
+                    mPowerUsageFeatureProvider.getAdvancedUsageScreenInfoString());
+        } else {
+            mHistPref.hideBottomSummary();
+        }
+    }
+
+    @VisibleForTesting
+    void refreshPowerUsageDataList(BatteryStatsHelper statsHelper,
+            PreferenceGroup preferenceGroup) {
+        List<PowerUsageData> dataList = parsePowerUsageData(statsHelper);
+        preferenceGroup.removeAll();
+        for (int i = 0, size = dataList.size(); i < size; i++) {
+            final PowerUsageData batteryData = dataList.get(i);
+            if (shouldHideCategory(batteryData)) {
+                continue;
+            }
+            final PowerGaugePreference pref = new PowerGaugePreference(getPrefContext());
+
+            pref.setKey(String.valueOf(batteryData.usageType));
+            pref.setTitle(batteryData.titleResId);
+            pref.setSummary(batteryData.summary);
+            pref.setPercent(batteryData.percentage);
+            pref.setSelectable(false);
+            preferenceGroup.addPreference(pref);
+        }
+    }
+
+    @VisibleForTesting
+    @UsageType
+    int extractUsageType(BatterySipper sipper) {
+        final DrainType drainType = sipper.drainType;
+        final int uid = sipper.getUid();
+
+        if (drainType == DrainType.WIFI) {
+            return UsageType.WIFI;
+        } else if (drainType == DrainType.BLUETOOTH) {
+            return UsageType.BLUETOOTH;
+        } else if (drainType == DrainType.IDLE) {
+            return UsageType.IDLE;
+        } else if (drainType == DrainType.USER) {
+            return UsageType.USER;
+        } else if (drainType == DrainType.CELL) {
+            return UsageType.CELL;
+        } else if (drainType == DrainType.UNACCOUNTED) {
+            return UsageType.UNACCOUNTED;
+        } else if (drainType == DrainType.OVERCOUNTED) {
+            return UsageType.OVERCOUNTED;
+        } else if (mPowerUsageFeatureProvider.isTypeSystem(sipper)
+                || mPowerUsageFeatureProvider.isTypeService(sipper)) {
+            return UsageType.SYSTEM;
+        } else {
+            return UsageType.APP;
+        }
+    }
+
+    @VisibleForTesting
+    boolean shouldHideCategory(PowerUsageData powerUsageData) {
+        return powerUsageData.usageType == UsageType.UNACCOUNTED
+                || powerUsageData.usageType == UsageType.OVERCOUNTED
+                || (powerUsageData.usageType == UsageType.USER && isSingleNormalUser())
+                || (powerUsageData.usageType == UsageType.CELL
+                && !DataUsageUtils.hasMobileData(getContext()));
+    }
+
+    @VisibleForTesting
+    boolean shouldShowBatterySipper(BatterySipper batterySipper) {
+        return batterySipper.drainType != DrainType.SCREEN;
+    }
+
+    @VisibleForTesting
+    List<PowerUsageData> parsePowerUsageData(BatteryStatsHelper statusHelper) {
+        final List<BatterySipper> batterySippers = statusHelper.getUsageList();
+        final Map<Integer, PowerUsageData> batteryDataMap = new HashMap<>();
+
+        for (final @UsageType Integer type : mUsageTypes) {
+            batteryDataMap.put(type, new PowerUsageData(type));
+        }
+
+        // Accumulate power usage based on usage type
+        for (final BatterySipper sipper : batterySippers) {
+            sipper.mPackages = mPackageManager.getPackagesForUid(sipper.getUid());
+            final PowerUsageData usageData = batteryDataMap.get(extractUsageType(sipper));
+            usageData.totalPowerMah += sipper.totalPowerMah;
+            if (sipper.drainType == DrainType.APP && sipper.usageTimeMs != 0) {
+                sipper.usageTimeMs = mBatteryUtils.getProcessTimeMs(
+                        BatteryUtils.StatusType.FOREGROUND, sipper.uidObj, STATUS_TYPE);
+            }
+            usageData.totalUsageTimeMs += sipper.usageTimeMs;
+            if (shouldShowBatterySipper(sipper)) {
+                usageData.usageList.add(sipper);
+            }
+        }
+
+        final List<PowerUsageData> batteryDataList = new ArrayList<>(batteryDataMap.values());
+        final int dischargeAmount = statusHelper.getStats().getDischargeAmount(STATUS_TYPE);
+        final double totalPower = statusHelper.getTotalPower();
+        final double hiddenPower = calculateHiddenPower(batteryDataList);
+        for (final PowerUsageData usageData : batteryDataList) {
+            usageData.percentage = mBatteryUtils.calculateBatteryPercent(usageData.totalPowerMah,
+                    totalPower, hiddenPower, dischargeAmount);
+            updateUsageDataSummary(usageData, totalPower, dischargeAmount);
+        }
+
+        Collections.sort(batteryDataList);
+
+        mBatteryDataMap = batteryDataMap;
+        return batteryDataList;
+    }
+
+    @VisibleForTesting
+    double calculateHiddenPower(List<PowerUsageData> batteryDataList) {
+        for (final PowerUsageData usageData : batteryDataList) {
+            if (usageData.usageType == UsageType.UNACCOUNTED) {
+                return usageData.totalPowerMah;
+            }
+        }
+
+        return 0;
+    }
+
+    @VisibleForTesting
+    void updateUsageDataSummary(PowerUsageData usageData, double totalPower, int dischargeAmount) {
+        if (shouldHideSummary(usageData)) {
+            return;
+        }
+        if (usageData.usageList.size() <= 1) {
+            CharSequence timeSequence = StringUtil.formatElapsedTime(getContext(),
+                    usageData.totalUsageTimeMs, false);
+            usageData.summary = usageData.usageType == UsageType.IDLE ? timeSequence
+                    : TextUtils.expandTemplate(getText(R.string.battery_used_for), timeSequence);
+        } else {
+            BatterySipper sipper = findBatterySipperWithMaxBatteryUsage(usageData.usageList);
+            BatteryEntry batteryEntry = new BatteryEntry(getContext(), mHandler, mUserManager,
+                    sipper);
+            final double percentage = (sipper.totalPowerMah / totalPower) * dischargeAmount;
+            usageData.summary = getString(R.string.battery_used_by,
+                    Utils.formatPercentage(percentage, true), batteryEntry.name);
+        }
+    }
+
+    @VisibleForTesting
+    boolean shouldHideSummary(PowerUsageData powerUsageData) {
+        @UsageType final int usageType = powerUsageData.usageType;
+
+        return usageType == UsageType.CELL
+                || usageType == UsageType.BLUETOOTH
+                || usageType == UsageType.WIFI
+                || usageType == UsageType.APP
+                || usageType == UsageType.SYSTEM;
+    }
+
+    @VisibleForTesting
+    BatterySipper findBatterySipperWithMaxBatteryUsage(List<BatterySipper> usageList) {
+        BatterySipper sipper = usageList.get(0);
+        for (int i = 1, size = usageList.size(); i < size; i++) {
+            final BatterySipper comparedSipper = usageList.get(i);
+            if (comparedSipper.totalPowerMah > sipper.totalPowerMah) {
+                sipper = comparedSipper;
+            }
+        }
+
+        return sipper;
+    }
+
+    @VisibleForTesting
+    void setPackageManager(PackageManager packageManager) {
+        mPackageManager = packageManager;
+    }
+
+    @VisibleForTesting
+    void setPowerUsageFeatureProvider(PowerUsageFeatureProvider provider) {
+        mPowerUsageFeatureProvider = provider;
+    }
+    @VisibleForTesting
+    void setUserManager(UserManager userManager) {
+        mUserManager = userManager;
+    }
+    @VisibleForTesting
+    void setBatteryUtils(BatteryUtils batteryUtils) {
+        mBatteryUtils = batteryUtils;
+    }
+
+    @VisibleForTesting
+    boolean isSingleNormalUser() {
+        int count = 0;
+        for (UserInfo userInfo : mUserManager.getUsers()) {
+            if (userInfo.isEnabled() && !userInfo.isManagedProfile()) {
+                count++;
+            }
+        }
+
+        return count == 1;
+    }
+
+    /**
+     * Class that contains data used in {@link PowerGaugePreference}.
+     */
+    @VisibleForTesting
+    static class PowerUsageData implements Comparable<PowerUsageData> {
+
+        @Retention(RetentionPolicy.SOURCE)
+        @IntDef({UsageType.APP,
+                UsageType.WIFI,
+                UsageType.CELL,
+                UsageType.SYSTEM,
+                UsageType.BLUETOOTH,
+                UsageType.USER,
+                UsageType.IDLE,
+                UsageType.UNACCOUNTED,
+                UsageType.OVERCOUNTED})
+        public @interface UsageType {
+            int APP = 0;
+            int WIFI = 1;
+            int CELL = 2;
+            int SYSTEM = 3;
+            int BLUETOOTH = 4;
+            int USER = 5;
+            int IDLE = 6;
+            int UNACCOUNTED = 7;
+            int OVERCOUNTED = 8;
+        }
+
+        @StringRes
+        public int titleResId;
+        public CharSequence summary;
+        public double percentage;
+        public double totalPowerMah;
+        public long totalUsageTimeMs;
+        @ColorInt
+        public int iconColor;
+        @UsageType
+        public int usageType;
+        public List<BatterySipper> usageList;
+
+        public PowerUsageData(@UsageType int usageType) {
+            this(usageType, 0);
+        }
+
+        public PowerUsageData(@UsageType int usageType, double totalPower) {
+            this.usageType = usageType;
+            totalPowerMah = 0;
+            totalUsageTimeMs = 0;
+            titleResId = getTitleResId(usageType);
+            totalPowerMah = totalPower;
+            usageList = new ArrayList<>();
+        }
+
+        private int getTitleResId(@UsageType int usageType) {
+            switch (usageType) {
+                case UsageType.WIFI:
+                    return R.string.power_wifi;
+                case UsageType.CELL:
+                    return R.string.power_cell;
+                case UsageType.SYSTEM:
+                    return R.string.power_system;
+                case UsageType.BLUETOOTH:
+                    return R.string.power_bluetooth;
+                case UsageType.USER:
+                    return R.string.power_user;
+                case UsageType.IDLE:
+                    return R.string.power_idle;
+                case UsageType.UNACCOUNTED:
+                    return R.string.power_unaccounted;
+                case UsageType.OVERCOUNTED:
+                    return R.string.power_overcounted;
+                case UsageType.APP:
+                default:
+                    return R.string.power_apps;
+            }
+        }
+
+        @Override
+        public int compareTo(@NonNull PowerUsageData powerUsageData) {
+            final int diff = Double.compare(powerUsageData.totalPowerMah, totalPowerMah);
+            return diff != 0 ? diff : usageType - powerUsageData.usageType;
+        }
+    }
+
+    public static final SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
+            new BaseSearchIndexProvider() {
+                @Override
+                public List<SearchIndexableResource> getXmlResourcesToIndex(
+                        Context context, boolean enabled) {
+                    final SearchIndexableResource sir = new SearchIndexableResource(context);
+                    sir.xmlResId = R.xml.power_usage_advanced_legacy;
+                    return Arrays.asList(sir);
+                }
+            };
+
+}
diff --git a/src/com/android/settings/fuelgauge/PowerUsageFeatureProvider.java b/src/com/android/settings/fuelgauge/PowerUsageFeatureProvider.java
index 79675cb..861ee56 100644
--- a/src/com/android/settings/fuelgauge/PowerUsageFeatureProvider.java
+++ b/src/com/android/settings/fuelgauge/PowerUsageFeatureProvider.java
@@ -118,4 +118,9 @@
      * the caller
      */
     boolean getEarlyWarningSignal(Context context, String id);
+
+    /**
+     * Checks whether smart battery feature is supported in this device
+     */
+    boolean isSmartBatterySupported();
 }
diff --git a/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImpl.java b/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImpl.java
index 93c4e03..6c3897d 100644
--- a/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImpl.java
+++ b/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImpl.java
@@ -136,4 +136,9 @@
     public boolean getEarlyWarningSignal(Context context, String id) {
         return false;
     }
+
+    @Override
+    public boolean isSmartBatterySupported() {
+        return false;
+    }
 }
diff --git a/src/com/android/settings/fuelgauge/PowerUsageSummary.java b/src/com/android/settings/fuelgauge/PowerUsageSummary.java
index bf0b627..b64dc52 100644
--- a/src/com/android/settings/fuelgauge/PowerUsageSummary.java
+++ b/src/com/android/settings/fuelgauge/PowerUsageSummary.java
@@ -39,6 +39,7 @@
 import com.android.settings.SettingsActivity;
 import com.android.settings.Utils;
 import com.android.settings.applications.LayoutPreference;
+import com.android.settings.core.SubSettingLauncher;
 import com.android.settings.dashboard.SummaryLoader;
 import com.android.settings.display.BatteryPercentagePreferenceController;
 import com.android.settings.fuelgauge.anomaly.Anomaly;
@@ -49,7 +50,6 @@
 import com.android.settings.overlay.FeatureFactory;
 import com.android.settings.search.BaseSearchIndexProvider;
 import com.android.settingslib.core.AbstractPreferenceController;
-import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
 import com.android.settingslib.core.lifecycle.Lifecycle;
 import com.android.settingslib.utils.PowerUtil;
 import com.android.settingslib.utils.StringUtil;
@@ -68,7 +68,6 @@
     static final String TAG = "PowerUsageSummary";
 
     private static final boolean DEBUG = false;
-    private static final String KEY_APP_LIST = "app_list";
     private static final String KEY_BATTERY_HEADER = "battery_header";
     private static final String KEY_BATTERY_TIP = "battery_tip";
 
@@ -80,7 +79,10 @@
     static final int BATTERY_INFO_LOADER = 1;
     @VisibleForTesting
     static final int BATTERY_TIP_LOADER = 2;
-    private static final int MENU_STATS_TYPE = Menu.FIRST;
+    @VisibleForTesting
+    static final int MENU_STATS_TYPE = Menu.FIRST;
+    @VisibleForTesting
+    static final int MENU_ADVANCED_BATTERY = Menu.FIRST + 1;
     public static final int DEBUG_INFO_LOADER = 3;
 
     @VisibleForTesting
@@ -101,7 +103,6 @@
     SparseArray<List<Anomaly>> mAnomalySparseArray;
     @VisibleForTesting
     BatteryHeaderPreferenceController mBatteryHeaderPreferenceController;
-    private BatteryAppListPreferenceController mBatteryAppListPreferenceController;
     private BatteryTipPreferenceController mBatteryTipPreferenceController;
     private int mStatsType = BatteryStats.STATS_SINCE_CHARGED;
 
@@ -231,9 +232,6 @@
         mBatteryHeaderPreferenceController = new BatteryHeaderPreferenceController(
                 context, activity, this /* host */, lifecycle);
         controllers.add(mBatteryHeaderPreferenceController);
-        mBatteryAppListPreferenceController = new BatteryAppListPreferenceController(context,
-                KEY_APP_LIST, lifecycle, activity, this);
-        controllers.add(mBatteryAppListPreferenceController);
         mBatteryTipPreferenceController = new BatteryTipPreferenceController(context,
                 KEY_BATTERY_TIP, (SettingsActivity) getActivity(), this /* fragment */, this /*
                 BatteryTipListener */);
@@ -250,6 +248,8 @@
                     .setAlphabeticShortcut('t');
         }
 
+        menu.add(Menu.NONE, MENU_ADVANCED_BATTERY, Menu.NONE, R.string.advanced_battery_title);
+
         super.onCreateOptionsMenu(menu, inflater);
     }
 
@@ -260,11 +260,6 @@
 
     @Override
     public boolean onOptionsItemSelected(MenuItem item) {
-        final SettingsActivity sa = (SettingsActivity) getActivity();
-        final Context context = getContext();
-        final MetricsFeatureProvider metricsFeatureProvider =
-                FeatureFactory.getFactory(context).getMetricsFeatureProvider();
-
         switch (item.getItemId()) {
             case MENU_STATS_TYPE:
                 if (mStatsType == BatteryStats.STATS_SINCE_CHARGED) {
@@ -274,6 +269,13 @@
                 }
                 refreshUi();
                 return true;
+            case MENU_ADVANCED_BATTERY:
+                new SubSettingLauncher(getContext())
+                        .setDestination(PowerUsageAdvanced.class.getName())
+                        .setSourceMetricsCategory(getMetricsCategory())
+                        .setTitle(R.string.advanced_battery_title)
+                        .launch();
+                return true;
             default:
                 return super.onOptionsItemSelected(item);
         }
@@ -294,11 +296,6 @@
         updateLastFullChargePreference(lastFullChargeTime);
         mScreenUsagePref.setSubtitle(StringUtil.formatElapsedTime(getContext(),
                 mBatteryUtils.calculateScreenUsageTime(mStatsHelper), false));
-
-        final CharSequence timeSequence = StringUtil.formatRelativeTime(context, lastFullChargeTime,
-                false);
-        mBatteryAppListPreferenceController.refreshAppListGroup(mStatsHelper,
-                false /* showAllApps */, timeSequence);
     }
 
     @VisibleForTesting
diff --git a/src/com/android/settings/fuelgauge/PowerUsageSummaryLegacy.java b/src/com/android/settings/fuelgauge/PowerUsageSummaryLegacy.java
index 79425cb..d321bb7 100644
--- a/src/com/android/settings/fuelgauge/PowerUsageSummaryLegacy.java
+++ b/src/com/android/settings/fuelgauge/PowerUsageSummaryLegacy.java
@@ -415,7 +415,7 @@
     private void performBatteryHeaderClick() {
         if (mPowerFeatureProvider.isAdvancedUiEnabled()) {
             new SubSettingLauncher(getContext())
-                    .setDestination(PowerUsageAdvanced.class.getName())
+                    .setDestination(PowerUsageAdvancedLegacy.class.getName())
                     .setSourceMetricsCategory(getMetricsCategory())
                     .setTitle(R.string.advanced_battery_title)
                     .launch();
diff --git a/src/com/android/settings/fuelgauge/SmartBatteryPreferenceController.java b/src/com/android/settings/fuelgauge/SmartBatteryPreferenceController.java
index ee5279e..8b99a43 100644
--- a/src/com/android/settings/fuelgauge/SmartBatteryPreferenceController.java
+++ b/src/com/android/settings/fuelgauge/SmartBatteryPreferenceController.java
@@ -19,12 +19,11 @@
 
 import android.content.Context;
 import android.provider.Settings;
-import android.support.annotation.VisibleForTesting;
 import android.support.v14.preference.SwitchPreference;
 import android.support.v7.preference.Preference;
 
-import com.android.settings.applications.LayoutPreference;
 import com.android.settings.core.BasePreferenceController;
+import com.android.settings.overlay.FeatureFactory;
 
 /**
  * Controller to change and update the smart battery toggle
@@ -34,15 +33,19 @@
     private static final String KEY_SMART_BATTERY = "smart_battery";
     private static final int ON = 1;
     private static final int OFF = 0;
+    private PowerUsageFeatureProvider mPowerUsageFeatureProvider;
 
     public SmartBatteryPreferenceController(Context context) {
         super(context, KEY_SMART_BATTERY);
+        mPowerUsageFeatureProvider = FeatureFactory.getFactory(context)
+                .getPowerUsageFeatureProvider(context);
     }
 
     @Override
     public int getAvailabilityStatus() {
-        // TODO(b/71502850): get Availability from API. The device may not support it.
-        return AVAILABLE;
+        return mPowerUsageFeatureProvider.isSmartBatterySupported()
+                ? AVAILABLE
+                : DISABLED_UNSUPPORTED;
     }
 
     @Override
diff --git a/src/com/android/settings/fuelgauge/batterytip/AnomalyDetectionJobService.java b/src/com/android/settings/fuelgauge/batterytip/AnomalyDetectionJobService.java
index 9d4f86f..ff71525 100644
--- a/src/com/android/settings/fuelgauge/batterytip/AnomalyDetectionJobService.java
+++ b/src/com/android/settings/fuelgauge/batterytip/AnomalyDetectionJobService.java
@@ -128,14 +128,14 @@
                     Log.e(TAG, "Excessive detected uid=" + uid);
                     batteryUtils.setForceAppStandby(uid, packageName,
                             AppOpsManager.MODE_IGNORED);
-                    databaseManager.insertAnomaly(packageName, anomalyType,
+                    databaseManager.insertAnomaly(uid, packageName, anomalyType,
                             smartBatteryOn
                                     ? AnomalyDatabaseHelper.State.AUTO_HANDLED
                                     : AnomalyDatabaseHelper.State.NEW,
                             timeMs);
                 }
             } else {
-                databaseManager.insertAnomaly(packageName, anomalyType,
+                databaseManager.insertAnomaly(uid, packageName, anomalyType,
                         AnomalyDatabaseHelper.State.NEW, timeMs);
             }
         } catch (NullPointerException | IndexOutOfBoundsException e) {
diff --git a/src/com/android/settings/fuelgauge/batterytip/AppInfo.java b/src/com/android/settings/fuelgauge/batterytip/AppInfo.java
index cf0376c..9557d9a 100644
--- a/src/com/android/settings/fuelgauge/batterytip/AppInfo.java
+++ b/src/com/android/settings/fuelgauge/batterytip/AppInfo.java
@@ -33,11 +33,13 @@
      */
     public final int anomalyType;
     public final long screenOnTimeMs;
+    public final int uid;
 
     private AppInfo(AppInfo.Builder builder) {
         packageName = builder.mPackageName;
         anomalyType = builder.mAnomalyType;
         screenOnTimeMs = builder.mScreenOnTimeMs;
+        uid = builder.mUid;
     }
 
     @VisibleForTesting
@@ -45,6 +47,7 @@
         packageName = in.readString();
         anomalyType = in.readInt();
         screenOnTimeMs = in.readLong();
+        uid = in.readInt();
     }
 
     @Override
@@ -62,6 +65,7 @@
         dest.writeString(packageName);
         dest.writeInt(anomalyType);
         dest.writeLong(screenOnTimeMs);
+        dest.writeInt(uid);
     }
 
     @Override
@@ -84,6 +88,7 @@
         private int mAnomalyType;
         private String mPackageName;
         private long mScreenOnTimeMs;
+        private int mUid;
 
         public Builder setAnomalyType(int type) {
             mAnomalyType = type;
@@ -100,6 +105,11 @@
             return this;
         }
 
+        public Builder setUid(int uid) {
+            mUid = uid;
+            return this;
+        }
+
         public AppInfo build() {
             return new AppInfo(this);
         }
diff --git a/src/com/android/settings/fuelgauge/batterytip/BatteryDatabaseManager.java b/src/com/android/settings/fuelgauge/batterytip/BatteryDatabaseManager.java
index 935d493..d0bddec 100644
--- a/src/com/android/settings/fuelgauge/batterytip/BatteryDatabaseManager.java
+++ b/src/com/android/settings/fuelgauge/batterytip/BatteryDatabaseManager.java
@@ -24,6 +24,7 @@
         .ANOMALY_TYPE;
 import static com.android.settings.fuelgauge.batterytip.AnomalyDatabaseHelper.AnomalyColumns
         .TIME_STAMP_MS;
+import static com.android.settings.fuelgauge.batterytip.AnomalyDatabaseHelper.AnomalyColumns.UID;
 import static com.android.settings.fuelgauge.batterytip.AnomalyDatabaseHelper.Tables.TABLE_ANOMALY;
 
 import android.content.ContentValues;
@@ -65,10 +66,11 @@
      * @param anomalyState  the state of the anomaly
      * @param timestampMs   the time when it is happened
      */
-    public synchronized void insertAnomaly(String packageName, int type, int anomalyState,
+    public synchronized void insertAnomaly(int uid, String packageName, int type, int anomalyState,
             long timestampMs) {
         try (SQLiteDatabase db = mDatabaseHelper.getWritableDatabase()) {
             ContentValues values = new ContentValues();
+            values.put(UID, uid);
             values.put(PACKAGE_NAME, packageName);
             values.put(ANOMALY_TYPE, type);
             values.put(ANOMALY_STATE, anomalyState);
@@ -83,7 +85,7 @@
     public synchronized List<AppInfo> queryAllAnomalies(long timestampMsAfter, int state) {
         final List<AppInfo> appInfos = new ArrayList<>();
         try (SQLiteDatabase db = mDatabaseHelper.getReadableDatabase()) {
-            final String[] projection = {PACKAGE_NAME, ANOMALY_TYPE};
+            final String[] projection = {PACKAGE_NAME, ANOMALY_TYPE, UID};
             final String orderBy = AnomalyDatabaseHelper.AnomalyColumns.TIME_STAMP_MS + " DESC";
 
             try (Cursor cursor = db.query(TABLE_ANOMALY, projection,
@@ -94,6 +96,7 @@
                     AppInfo appInfo = new AppInfo.Builder()
                             .setPackageName(cursor.getString(cursor.getColumnIndex(PACKAGE_NAME)))
                             .setAnomalyType(cursor.getInt(cursor.getColumnIndex(ANOMALY_TYPE)))
+                            .setUid(cursor.getInt(cursor.getColumnIndex(UID)))
                             .build();
                     appInfos.add(appInfo);
                 }
diff --git a/src/com/android/settings/notification/ZenModeBehaviorSettings.java b/src/com/android/settings/notification/ZenModeBehaviorSettings.java
index 2dd5ebd..7b5fa04 100644
--- a/src/com/android/settings/notification/ZenModeBehaviorSettings.java
+++ b/src/com/android/settings/notification/ZenModeBehaviorSettings.java
@@ -40,7 +40,8 @@
             Lifecycle lifecycle) {
         List<AbstractPreferenceController> controllers = new ArrayList<>();
         controllers.add(new ZenModeAlarmsPreferenceController(context, lifecycle));
-        controllers.add(new ZenModeMediaSystemOtherPreferenceController(context, lifecycle));
+        controllers.add(new ZenModeMediaPreferenceController(context, lifecycle));
+        controllers.add(new ZenModeSystemPreferenceController(context, lifecycle));
         controllers.add(new ZenModeEventsPreferenceController(context, lifecycle));
         controllers.add(new ZenModeRemindersPreferenceController(context, lifecycle));
         controllers.add(new ZenModeMessagesPreferenceController(context, lifecycle));
@@ -85,7 +86,7 @@
                 public List<String> getNonIndexableKeys(Context context) {
                     final List<String> keys = super.getNonIndexableKeys(context);
                     keys.add(ZenModeAlarmsPreferenceController.KEY);
-                    keys.add(ZenModeMediaSystemOtherPreferenceController.KEY);
+                    keys.add(ZenModeMediaPreferenceController.KEY);
                     keys.add(ZenModeEventsPreferenceController.KEY);
                     keys.add(ZenModeRemindersPreferenceController.KEY);
                     keys.add(ZenModeMessagesPreferenceController.KEY);
diff --git a/src/com/android/settings/notification/ZenModeMediaSystemOtherPreferenceController.java b/src/com/android/settings/notification/ZenModeMediaPreferenceController.java
similarity index 83%
rename from src/com/android/settings/notification/ZenModeMediaSystemOtherPreferenceController.java
rename to src/com/android/settings/notification/ZenModeMediaPreferenceController.java
index 8afe881..12cedf2 100644
--- a/src/com/android/settings/notification/ZenModeMediaSystemOtherPreferenceController.java
+++ b/src/com/android/settings/notification/ZenModeMediaPreferenceController.java
@@ -25,13 +25,13 @@
 
 import com.android.settingslib.core.lifecycle.Lifecycle;
 
-public class ZenModeMediaSystemOtherPreferenceController extends AbstractZenModePreferenceController
+public class ZenModeMediaPreferenceController extends AbstractZenModePreferenceController
         implements Preference.OnPreferenceChangeListener {
 
     protected static final String KEY = "zen_mode_media";
     private final ZenModeBackend mBackend;
 
-    public ZenModeMediaSystemOtherPreferenceController(Context context, Lifecycle lifecycle) {
+    public ZenModeMediaPreferenceController(Context context, Lifecycle lifecycle) {
         super(context, KEY, lifecycle);
         mBackend = ZenModeBackend.getInstance(context);
     }
@@ -63,7 +63,7 @@
             default:
                 pref.setEnabled(true);
                 pref.setChecked(mBackend.isPriorityCategoryEnabled(
-                        Policy.PRIORITY_CATEGORY_MEDIA_SYSTEM_OTHER));
+                        Policy.PRIORITY_CATEGORY_MEDIA));
         }
     }
 
@@ -71,9 +71,9 @@
     public boolean onPreferenceChange(Preference preference, Object newValue) {
         final boolean allowMedia = (Boolean) newValue;
         if (ZenModeSettingsBase.DEBUG) {
-            Log.d(TAG, "onPrefChange allowMediaSystemOther=" + allowMedia);
+            Log.d(TAG, "onPrefChange allowMedia=" + allowMedia);
         }
-        mBackend.saveSoundPolicy(Policy.PRIORITY_CATEGORY_MEDIA_SYSTEM_OTHER, allowMedia);
+        mBackend.saveSoundPolicy(Policy.PRIORITY_CATEGORY_MEDIA, allowMedia);
         return true;
     }
 }
diff --git a/src/com/android/settings/notification/ZenModeSettings.java b/src/com/android/settings/notification/ZenModeSettings.java
index 272bb41..4e8793b 100644
--- a/src/com/android/settings/notification/ZenModeSettings.java
+++ b/src/com/android/settings/notification/ZenModeSettings.java
@@ -77,9 +77,11 @@
             mContext = context;
         }
 
+        // these should match NotificationManager.Policy#ALL_PRIORITY_CATEGORIES
         private static final int[] ALL_PRIORITY_CATEGORIES = {
                 Policy.PRIORITY_CATEGORY_ALARMS,
-                Policy.PRIORITY_CATEGORY_MEDIA_SYSTEM_OTHER,
+                Policy.PRIORITY_CATEGORY_MEDIA,
+                Policy.PRIORITY_CATEGORY_SYSTEM,
                 Policy.PRIORITY_CATEGORY_REMINDERS,
                 Policy.PRIORITY_CATEGORY_EVENTS,
                 Policy.PRIORITY_CATEGORY_MESSAGES,
@@ -104,10 +106,10 @@
                 return mContext.getString(R.string.zen_mode_behavior_total_silence);
             }
 
-            // only alarms and media/system can bypass dnd
+            // only alarms and media can bypass dnd
             if (numCategories == 2 &&
                     isCategoryEnabled(policy, Policy.PRIORITY_CATEGORY_ALARMS) &&
-                    isCategoryEnabled(policy, Policy.PRIORITY_CATEGORY_MEDIA_SYSTEM_OTHER)) {
+                    isCategoryEnabled(policy, Policy.PRIORITY_CATEGORY_MEDIA)) {
                 return mContext.getString(R.string.zen_mode_behavior_alarms_only);
             }
 
@@ -164,9 +166,12 @@
                 if (isCategoryEnabled(policy, category)) {
                     if (category == Policy.PRIORITY_CATEGORY_ALARMS) {
                         enabledCategories.add(mContext.getString(R.string.zen_mode_alarms));
-                    } else if (category == Policy.PRIORITY_CATEGORY_MEDIA_SYSTEM_OTHER) {
+                    } else if (category == Policy.PRIORITY_CATEGORY_MEDIA) {
                         enabledCategories.add(mContext.getString(
-                                R.string.zen_mode_media_system_other));
+                                R.string.zen_mode_media));
+                    } else if (category == Policy.PRIORITY_CATEGORY_SYSTEM) {
+                        enabledCategories.add(mContext.getString(
+                                R.string.zen_mode_system));
                     } else if (category == Policy.PRIORITY_CATEGORY_REMINDERS) {
                         enabledCategories.add(mContext.getString(R.string.zen_mode_reminders));
                     } else if (category == Policy.PRIORITY_CATEGORY_EVENTS) {
diff --git a/src/com/android/settings/notification/ZenModeMediaSystemOtherPreferenceController.java b/src/com/android/settings/notification/ZenModeSystemPreferenceController.java
similarity index 69%
copy from src/com/android/settings/notification/ZenModeMediaSystemOtherPreferenceController.java
copy to src/com/android/settings/notification/ZenModeSystemPreferenceController.java
index 8afe881..364c829 100644
--- a/src/com/android/settings/notification/ZenModeMediaSystemOtherPreferenceController.java
+++ b/src/com/android/settings/notification/ZenModeSystemPreferenceController.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2017 The Android Open Source Project
+ * 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.
@@ -23,17 +23,16 @@
 import android.support.v7.preference.Preference;
 import android.util.Log;
 
+import com.android.internal.logging.nano.MetricsProto;
 import com.android.settingslib.core.lifecycle.Lifecycle;
 
-public class ZenModeMediaSystemOtherPreferenceController extends AbstractZenModePreferenceController
-        implements Preference.OnPreferenceChangeListener {
+public class ZenModeSystemPreferenceController extends
+        AbstractZenModePreferenceController implements Preference.OnPreferenceChangeListener {
 
-    protected static final String KEY = "zen_mode_media";
-    private final ZenModeBackend mBackend;
+    protected static final String KEY = "zen_mode_system";
 
-    public ZenModeMediaSystemOtherPreferenceController(Context context, Lifecycle lifecycle) {
+    public ZenModeSystemPreferenceController(Context context, Lifecycle lifecycle) {
         super(context, KEY, lifecycle);
-        mBackend = ZenModeBackend.getInstance(context);
     }
 
     @Override
@@ -58,22 +57,25 @@
                 break;
             case Settings.Global.ZEN_MODE_ALARMS:
                 pref.setEnabled(false);
-                pref.setChecked(true);
+                pref.setChecked(false);
                 break;
             default:
                 pref.setEnabled(true);
                 pref.setChecked(mBackend.isPriorityCategoryEnabled(
-                        Policy.PRIORITY_CATEGORY_MEDIA_SYSTEM_OTHER));
+                        Policy.PRIORITY_CATEGORY_SYSTEM));
         }
     }
 
     @Override
     public boolean onPreferenceChange(Preference preference, Object newValue) {
-        final boolean allowMedia = (Boolean) newValue;
+        final boolean allowSystem = (Boolean) newValue;
         if (ZenModeSettingsBase.DEBUG) {
-            Log.d(TAG, "onPrefChange allowMediaSystemOther=" + allowMedia);
+            Log.d(TAG, "onPrefChange allowSystem=" + allowSystem);
         }
-        mBackend.saveSoundPolicy(Policy.PRIORITY_CATEGORY_MEDIA_SYSTEM_OTHER, allowMedia);
+
+        mMetricsFeatureProvider.action(mContext, MetricsProto.MetricsEvent.ACTION_ZEN_ALLOW_SYSTEM,
+                allowSystem);
+        mBackend.saveSoundPolicy(Policy.PRIORITY_CATEGORY_SYSTEM, allowSystem);
         return true;
     }
 }
diff --git a/src/com/android/settings/search/SearchIndexableResourcesImpl.java b/src/com/android/settings/search/SearchIndexableResourcesImpl.java
index 87c2a91..1798d34 100644
--- a/src/com/android/settings/search/SearchIndexableResourcesImpl.java
+++ b/src/com/android/settings/search/SearchIndexableResourcesImpl.java
@@ -49,8 +49,9 @@
 import com.android.settings.display.ScreenZoomSettings;
 import com.android.settings.dream.DreamSettings;
 import com.android.settings.enterprise.EnterprisePrivacySettings;
-import com.android.settings.fuelgauge.batterysaver.BatterySaverSettings;
 import com.android.settings.fuelgauge.PowerUsageAdvanced;
+import com.android.settings.fuelgauge.PowerUsageAdvancedLegacy;
+import com.android.settings.fuelgauge.batterysaver.BatterySaverSettings;
 import com.android.settings.fuelgauge.PowerUsageSummary;
 import com.android.settings.fuelgauge.SmartBatterySettings;
 import com.android.settings.gestures.AssistGestureSettings;
@@ -122,6 +123,7 @@
         addIndex(ZenModeSettings.class);
         addIndex(StorageSettings.class);
         addIndex(PowerUsageAdvanced.class);
+        addIndex(PowerUsageAdvancedLegacy.class);
         addIndex(DefaultAppSettings.class);
         addIndex(ManageAssist.class);
         addIndex(SpecialAccessSettings.class);
diff --git a/tests/robotests/assets/grandfather_not_implementing_index_provider b/tests/robotests/assets/grandfather_not_implementing_index_provider
index 43697bd..223d8f8 100644
--- a/tests/robotests/assets/grandfather_not_implementing_index_provider
+++ b/tests/robotests/assets/grandfather_not_implementing_index_provider
@@ -24,3 +24,4 @@
 com.android.settings.notification.ZenModeEventRuleSettings
 com.android.settings.notification.ZenModeScheduleRuleSettings
 com.android.settings.fuelgauge.RestrictedAppDetails
+com.android.settings.datetime.timezone.TimeZoneSettings
diff --git a/tests/robotests/src/com/android/settings/applications/appinfo/InstantAppButtonsPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/applications/appinfo/InstantAppButtonsPreferenceControllerTest.java
index 8a85d70..ad0a9fe 100644
--- a/tests/robotests/src/com/android/settings/applications/appinfo/InstantAppButtonsPreferenceControllerTest.java
+++ b/tests/robotests/src/com/android/settings/applications/appinfo/InstantAppButtonsPreferenceControllerTest.java
@@ -262,6 +262,9 @@
 
         verify(mFragment).startActivity(argThat(intent-> intent != null
             && intent.getAction().equals(Intent.ACTION_VIEW)
+            && intent.hasCategory(Intent.CATEGORY_BROWSABLE)
+            && (intent.getFlags() & Intent.FLAG_ACTIVITY_NEW_TASK) != 0
+            && TextUtils.equals(intent.getPackage(), TEST_AIA_PACKAGE_NAME)
             && TextUtils.equals(intent.getDataString(), launchUri)));
     }
 
diff --git a/tests/robotests/src/com/android/settings/dashboard/DashboardAdapterTest.java b/tests/robotests/src/com/android/settings/dashboard/DashboardAdapterTest.java
index e45b02c..5256ac4 100644
--- a/tests/robotests/src/com/android/settings/dashboard/DashboardAdapterTest.java
+++ b/tests/robotests/src/com/android/settings/dashboard/DashboardAdapterTest.java
@@ -16,8 +16,8 @@
 package com.android.settings.dashboard;
 
 import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.reset;
@@ -93,15 +93,16 @@
         mConditionList.add(mCondition);
         when(mCondition.shouldShow()).thenReturn(true);
         mDashboardAdapter = new DashboardAdapter(mContext, null /* savedInstanceState */,
-            mConditionList, null /* suggestionControllerMixin */, null /* lifecycle */);
+                mConditionList, null /* suggestionControllerMixin */, null /* lifecycle */);
         when(mView.getTag()).thenReturn(mCondition);
     }
 
     @Test
     public void testSuggestionDismissed_notOnlySuggestion_updateSuggestionOnly() {
         final DashboardAdapter adapter =
-            spy(new DashboardAdapter(mContext, null /* savedInstanceState */,
-                null /* conditions */, null /* suggestionControllerMixin */, null /* lifecycle */));
+                spy(new DashboardAdapter(mContext, null /* savedInstanceState */,
+                        null /* conditions */, null /* suggestionControllerMixin */,
+                        null /* lifecycle */));
         final List<Suggestion> suggestions = makeSuggestionsV2("pkg1", "pkg2", "pkg3");
         adapter.setSuggestions(suggestions);
 
@@ -114,7 +115,7 @@
         when(itemView.findViewById(android.R.id.summary)).thenReturn(mock(TextView.class));
         when(itemView.findViewById(android.R.id.title)).thenReturn(mock(TextView.class));
         final DashboardAdapter.SuggestionContainerHolder holder =
-            new DashboardAdapter.SuggestionContainerHolder(itemView);
+                new DashboardAdapter.SuggestionContainerHolder(itemView);
 
         adapter.onBindSuggestion(holder, 0);
 
@@ -132,8 +133,9 @@
     @Test
     public void testSuggestionDismissed_onlySuggestion_updateDashboardData() {
         DashboardAdapter adapter =
-            spy(new DashboardAdapter(mContext, null /* savedInstanceState */,
-                null /* conditions */, null /* suggestionControllerMixin */, null /* lifecycle */));
+                spy(new DashboardAdapter(mContext, null /* savedInstanceState */,
+                        null /* conditions */, null /* suggestionControllerMixin */,
+                        null /* lifecycle */));
         final List<Suggestion> suggestions = makeSuggestionsV2("pkg1");
         adapter.setSuggestions(suggestions);
         final DashboardData dashboardData = adapter.mDashboardData;
@@ -148,7 +150,7 @@
     @Test
     public void testBindSuggestion_shouldSetSuggestionAdapterAndNoCrash() {
         mDashboardAdapter = new DashboardAdapter(mContext, null /* savedInstanceState */,
-            null /* conditions */, null /* suggestionControllerMixin */, null /* lifecycle */);
+                null /* conditions */, null /* suggestionControllerMixin */, null /* lifecycle */);
         final List<Suggestion> suggestions = makeSuggestionsV2("pkg1");
 
         mDashboardAdapter.setSuggestions(suggestions);
@@ -162,7 +164,7 @@
         when(itemView.findViewById(android.R.id.summary)).thenReturn(mock(TextView.class));
         when(itemView.findViewById(android.R.id.title)).thenReturn(mock(TextView.class));
         final DashboardAdapter.SuggestionContainerHolder holder =
-            new DashboardAdapter.SuggestionContainerHolder(itemView);
+                new DashboardAdapter.SuggestionContainerHolder(itemView);
 
         mDashboardAdapter.onBindSuggestion(holder, 0);
 
@@ -175,14 +177,14 @@
         final Context context = RuntimeEnvironment.application;
         final View view = LayoutInflater.from(context).inflate(R.layout.dashboard_tile, null);
         final DashboardAdapter.DashboardItemHolder holder =
-            new DashboardAdapter.DashboardItemHolder(view);
+                new DashboardAdapter.DashboardItemHolder(view);
         final Tile tile = new Tile();
         tile.icon = Icon.createWithResource(context, R.drawable.ic_settings);
         final IconCache iconCache = mock(IconCache.class);
         when(iconCache.getIcon(tile.icon)).thenReturn(context.getDrawable(R.drawable.ic_settings));
 
         mDashboardAdapter = new DashboardAdapter(context, null /* savedInstanceState */,
-            null /* conditions */, null /* suggestionControllerMixin */, null /* lifecycle */);
+                null /* conditions */, null /* suggestionControllerMixin */, null /* lifecycle */);
         ReflectionHelpers.setField(mDashboardAdapter, "mCache", iconCache);
         mDashboardAdapter.onBindTile(holder, tile);
 
@@ -190,11 +192,11 @@
     }
 
     @Test
-    public void onBindTile_externalTile_shouldNotUseGenericBackgroundIcon() {
+    public void onBindTile_externalTile_shouldUpdateIcon() {
         final Context context = RuntimeEnvironment.application;
         final View view = LayoutInflater.from(context).inflate(R.layout.dashboard_tile, null);
         final DashboardAdapter.DashboardItemHolder holder =
-            new DashboardAdapter.DashboardItemHolder(view);
+                new DashboardAdapter.DashboardItemHolder(view);
         final Tile tile = new Tile();
         tile.icon = mock(Icon.class);
         when(tile.icon.getResPackage()).thenReturn("another.package");
@@ -203,13 +205,36 @@
         when(iconCache.getIcon(tile.icon)).thenReturn(context.getDrawable(R.drawable.ic_settings));
 
         mDashboardAdapter = new DashboardAdapter(context, null /* savedInstanceState */,
-            null /* conditions */, null /* suggestionControllerMixin */, null /* lifecycle */);
+                null /* conditions */, null /* suggestionControllerMixin */, null /* lifecycle */);
         ReflectionHelpers.setField(mDashboardAdapter, "mCache", iconCache);
+
         mDashboardAdapter.onBindTile(holder, tile);
 
         verify(iconCache).updateIcon(eq(tile.icon), any(RoundedHomepageIcon.class));
     }
 
+    @Test
+    public void onBindTile_externalTile_usingRoundedHomepageIcon_shouldNotUpdateIcon() {
+        final Context context = RuntimeEnvironment.application;
+        final View view = LayoutInflater.from(context).inflate(R.layout.dashboard_tile, null);
+        final DashboardAdapter.DashboardItemHolder holder =
+                new DashboardAdapter.DashboardItemHolder(view);
+        final Tile tile = new Tile();
+        tile.icon = mock(Icon.class);
+        when(tile.icon.getResPackage()).thenReturn("another.package");
+
+        final IconCache iconCache = mock(IconCache.class);
+        when(iconCache.getIcon(tile.icon)).thenReturn(mock(RoundedHomepageIcon.class));
+
+        mDashboardAdapter = new DashboardAdapter(context, null /* savedInstanceState */,
+                null /* conditions */, null /* suggestionControllerMixin */, null /* lifecycle */);
+        ReflectionHelpers.setField(mDashboardAdapter, "mCache", iconCache);
+
+        mDashboardAdapter.onBindTile(holder, tile);
+
+        verify(iconCache, never()).updateIcon(eq(tile.icon), any(RoundedHomepageIcon.class));
+    }
+
     private List<Suggestion> makeSuggestionsV2(String... pkgNames) {
         final List<Suggestion> suggestions = new ArrayList<>();
         for (String pkgName : pkgNames) {
diff --git a/tests/robotests/src/com/android/settings/datetime/timezone/BaseTimeZonePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/datetime/timezone/BaseTimeZonePreferenceControllerTest.java
new file mode 100644
index 0000000..49c468e
--- /dev/null
+++ b/tests/robotests/src/com/android/settings/datetime/timezone/BaseTimeZonePreferenceControllerTest.java
@@ -0,0 +1,99 @@
+/*
+ * 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.datetime.timezone;
+
+import android.app.Activity;
+import android.content.Context;
+import android.support.v7.preference.Preference;
+
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.Robolectric;
+import org.robolectric.RuntimeEnvironment;
+
+import static com.google.common.truth.Truth.assertThat;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+public class BaseTimeZonePreferenceControllerTest {
+
+    private Activity mActivity;
+
+    @Before
+    public void setUp() {
+        mActivity = Robolectric.setupActivity(Activity.class);
+    }
+
+    @Test
+    public void handlePreferenceTreeClick_correctKey_triggerOnClickListener() {
+        String prefKey = "key1";
+        TestClickListener clickListener = new TestClickListener();
+        TestPreference preference = new TestPreference(mActivity, prefKey);
+        TestPreferenceController controller = new TestPreferenceController(mActivity, prefKey);
+        controller.setOnClickListener(clickListener);
+
+        controller.handlePreferenceTreeClick(preference);
+        assertThat(clickListener.isClicked()).isTrue();
+    }
+
+    @Test
+    public void handlePreferenceTreeClick_wrongKey_triggerOnClickListener() {
+        String prefKey = "key1";
+        TestClickListener clickListener = new TestClickListener();
+        TestPreference preference = new TestPreference(mActivity, "wrong_key");
+        TestPreferenceController controller = new TestPreferenceController(mActivity, prefKey);
+        controller.setOnClickListener(clickListener);
+
+        controller.handlePreferenceTreeClick(preference);
+        assertThat(clickListener.isClicked()).isFalse();
+    }
+
+    private static class TestPreferenceController extends BaseTimeZonePreferenceController {
+
+        private final Preference mTestPreference;
+
+        public TestPreferenceController(Context context, String preferenceKey) {
+            super(context, preferenceKey);
+            mTestPreference = new Preference(context);
+            mTestPreference.setKey(preferenceKey);
+        }
+    }
+
+    private static class TestPreference extends Preference {
+        public TestPreference(Context context, String preferenceKey) {
+            super(context);
+            setKey(preferenceKey);
+        }
+    }
+
+    private static class TestClickListener implements OnPreferenceClickListener {
+
+        private boolean isClicked = false;
+
+        @Override
+        public void onClick() {
+            isClicked = true;
+        }
+
+        public boolean isClicked() {
+            return isClicked;
+        }
+
+    }
+}
diff --git a/tests/robotests/src/com/android/settings/datetime/timezone/FixedOffsetPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/datetime/timezone/FixedOffsetPreferenceControllerTest.java
new file mode 100644
index 0000000..0ffb7d2
--- /dev/null
+++ b/tests/robotests/src/com/android/settings/datetime/timezone/FixedOffsetPreferenceControllerTest.java
@@ -0,0 +1,57 @@
+/*
+ * 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.datetime.timezone;
+
+import android.app.Activity;
+import android.icu.util.TimeZone;
+import android.support.v7.preference.Preference;
+
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.Robolectric;
+
+import static com.google.common.truth.Truth.assertThat;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+public class FixedOffsetPreferenceControllerTest {
+
+    private Activity mActivity;
+
+    @Before
+    public void setUp() {
+        mActivity = Robolectric.setupActivity(Activity.class);
+    }
+
+    @Test
+    public void updateState_matchTimeZoneSummary() {
+        TimeZoneInfo fixedOffsetZone = new TimeZoneInfo.Builder(
+                    TimeZone.getFrozenTimeZone("Etc/GMT-8"))
+                    .setExemplarLocation("Los Angeles")
+                    .setGmtOffset("GMT-08:00")
+                    .setItemId(0)
+                    .build();
+        Preference preference = new Preference(mActivity);
+        FixedOffsetPreferenceController controller = new FixedOffsetPreferenceController(mActivity);
+        controller.setTimeZoneInfo(fixedOffsetZone);
+        controller.updateState(preference);
+        assertThat(preference.getSummary()).isEqualTo("GMT-08:00");
+
+    }
+}
diff --git a/tests/robotests/src/com/android/settings/datetime/timezone/RegionPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/datetime/timezone/RegionPreferenceControllerTest.java
new file mode 100644
index 0000000..7a8f267
--- /dev/null
+++ b/tests/robotests/src/com/android/settings/datetime/timezone/RegionPreferenceControllerTest.java
@@ -0,0 +1,51 @@
+/*
+ * 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.datetime.timezone;
+
+import android.app.Activity;
+import android.support.v7.preference.Preference;
+
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.Robolectric;
+
+import static com.google.common.truth.Truth.assertThat;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+public class RegionPreferenceControllerTest {
+
+    private Activity mActivity;
+
+    @Before
+    public void setUp() {
+        mActivity = Robolectric.setupActivity(Activity.class);
+    }
+
+    @Test
+    public void updateState_matchCountryName() {
+        Preference preference = new Preference(mActivity);
+        RegionPreferenceController controller = new RegionPreferenceController(mActivity);
+        controller.setRegionId("US");
+        controller.updateState(preference);
+        assertThat(controller.getSummary()).isEqualTo("United States");
+        assertThat(preference.getSummary()).isEqualTo("United States");
+
+    }
+}
diff --git a/tests/robotests/src/com/android/settings/datetime/timezone/RegionZonePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/datetime/timezone/RegionZonePreferenceControllerTest.java
new file mode 100644
index 0000000..b39641f
--- /dev/null
+++ b/tests/robotests/src/com/android/settings/datetime/timezone/RegionZonePreferenceControllerTest.java
@@ -0,0 +1,64 @@
+/*
+ * 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.datetime.timezone;
+
+import android.app.Activity;
+import android.icu.util.TimeZone;
+import android.support.v7.preference.Preference;
+
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.Robolectric;
+
+import static com.google.common.truth.Truth.assertThat;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+public class RegionZonePreferenceControllerTest {
+
+    private Activity mActivity;
+
+    @Before
+    public void setUp() {
+        mActivity = Robolectric.setupActivity(Activity.class);
+    }
+
+    @Test
+    public void updateState_matchTimeZoneName() {
+        TimeZoneInfo tzInfo = new TimeZoneInfo.Builder(
+                TimeZone.getFrozenTimeZone("America/Los_Angeles"))
+                .setGenericName("Pacific Time")
+                .setStandardName("Pacific Standard Time")
+                .setDaylightName("Pacific Daylight Time")
+                .setExemplarLocation("Los Angeles")
+                .setGmtOffset("GMT-08:00")
+                .setItemId(0)
+                .build();
+        Preference preference = new Preference(mActivity);
+        RegionZonePreferenceController controller = new RegionZonePreferenceController(mActivity);
+        controller.setTimeZoneInfo(tzInfo);
+        controller.setClickable(false);
+        controller.updateState(preference);
+        String expectedSummary = "Los Angeles (GMT-08:00)";
+        assertThat(controller.getSummary().toString()).isEqualTo(expectedSummary);
+        assertThat(preference.getSummary().toString()).isEqualTo(expectedSummary);
+        assertThat(preference.isEnabled()).isFalse();
+
+    }
+}
diff --git a/tests/robotests/src/com/android/settings/datetime/timezone/TimeZoneInfoPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/datetime/timezone/TimeZoneInfoPreferenceControllerTest.java
new file mode 100644
index 0000000..2a58770
--- /dev/null
+++ b/tests/robotests/src/com/android/settings/datetime/timezone/TimeZoneInfoPreferenceControllerTest.java
@@ -0,0 +1,52 @@
+/*
+ * 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.datetime.timezone;
+
+import android.support.v7.preference.Preference;
+
+import com.android.settings.datetime.timezone.TimeZoneInfo.Formatter;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RuntimeEnvironment;
+
+import java.util.Date;
+import java.util.Locale;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.spy;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+public class TimeZoneInfoPreferenceControllerTest {
+
+    @Test
+    public void updateState_matchExpectedFormattedText() {
+        Date now = new Date(0L); // 00:00 1/1/1970
+        Formatter formatter = new Formatter(Locale.US, now);
+
+        TimeZoneInfo timeZoneInfo = formatter.format("America/Los_Angeles");
+        TimeZoneInfoPreferenceController controller =
+                new TimeZoneInfoPreferenceController(RuntimeEnvironment.application, now);
+        controller.setTimeZoneInfo(timeZoneInfo);
+        Preference preference = spy(new Preference(RuntimeEnvironment.application));
+        controller.updateState(preference);
+        assertEquals("Uses Pacific Time (GMT-08:00). "
+                + "Pacific Daylight Time starts on April 26, 1970.",
+                preference.getTitle().toString());
+    }
+}
diff --git a/tests/robotests/src/com/android/settings/datetime/timezone/TimeZoneSettingsTest.java b/tests/robotests/src/com/android/settings/datetime/timezone/TimeZoneSettingsTest.java
new file mode 100644
index 0000000..21ca30d
--- /dev/null
+++ b/tests/robotests/src/com/android/settings/datetime/timezone/TimeZoneSettingsTest.java
@@ -0,0 +1,69 @@
+/*
+ * 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.datetime.timezone;
+
+import com.android.settings.datetime.timezone.model.TimeZoneData;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+import com.android.settings.testutils.shadow.SettingsShadowResources;
+import com.android.settingslib.core.AbstractPreferenceController;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+@Config(shadows = {
+                SettingsShadowResources.class,
+                SettingsShadowResources.SettingsShadowTheme.class,
+        })
+public class TimeZoneSettingsTest {
+
+    @Test
+    public void findRegionIdForTzId_matchExpectedCountry() {
+        String tzId = "Unknown/Secret_City";
+        TimeZoneData timeZoneData = mock(TimeZoneData.class);
+        when(timeZoneData.lookupCountryCodesForZoneId(tzId))
+                .thenReturn(new HashSet<>(Arrays.asList("US", "GB")));
+
+        TimeZoneSettings settings = new TimeZoneSettings();
+        settings.setTimeZoneData(timeZoneData);
+        assertThat(settings.findRegionIdForTzId(tzId, null, "")).matches("US|GB");
+        assertThat(settings.findRegionIdForTzId(tzId, "GB", "")).isEqualTo("GB");
+        assertThat(settings.findRegionIdForTzId(tzId, null, "GB")).isEqualTo("GB");
+    }
+
+    @Test
+    public void createPreferenceControllers_matchExpectedControllers() {
+        TimeZoneSettings settings = new TimeZoneSettings();
+        List<AbstractPreferenceController> controllers =
+                settings.createPreferenceControllers(RuntimeEnvironment.application);
+        assertThat(controllers).hasSize(4);
+        assertThat(controllers.get(0)).isInstanceOf(RegionPreferenceController.class);
+        assertThat(controllers.get(1)).isInstanceOf(RegionZonePreferenceController.class);
+        assertThat(controllers.get(2)).isInstanceOf(TimeZoneInfoPreferenceController.class);
+        assertThat(controllers.get(3)).isInstanceOf(FixedOffsetPreferenceController.class);
+    }
+}
diff --git a/tests/robotests/src/com/android/settings/fuelgauge/AppButtonsPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/fuelgauge/AppButtonsPreferenceControllerTest.java
index d2252a7..eebccd8 100644
--- a/tests/robotests/src/com/android/settings/fuelgauge/AppButtonsPreferenceControllerTest.java
+++ b/tests/robotests/src/com/android/settings/fuelgauge/AppButtonsPreferenceControllerTest.java
@@ -26,6 +26,7 @@
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -137,7 +138,7 @@
     }
 
     @Test
-    public void testRetrieveAppEntry_hasAppEntry_notNull()
+    public void retrieveAppEntry_hasAppEntry_notNull()
             throws PackageManager.NameNotFoundException {
         doReturn(mPackageInfo).when(mPackageManger).getPackageInfo(anyString(), anyInt());
 
@@ -148,7 +149,7 @@
     }
 
     @Test
-    public void testRetrieveAppEntry_noAppEntry_null() throws PackageManager.NameNotFoundException {
+    public void retrieveAppEntry_noAppEntry_null() throws PackageManager.NameNotFoundException {
         doReturn(null).when(mState).getEntry(eq(PACKAGE_NAME), anyInt());
         doReturn(mPackageInfo).when(mPackageManger).getPackageInfo(anyString(), anyInt());
 
@@ -159,7 +160,7 @@
     }
 
     @Test
-    public void testRetrieveAppEntry_throwException_null() throws
+    public void retrieveAppEntry_throwException_null() throws
             PackageManager.NameNotFoundException {
         doReturn(mAppEntry).when(mState).getEntry(anyString(), anyInt());
         doThrow(new PackageManager.NameNotFoundException()).when(mPackageManger).getPackageInfo(
@@ -172,7 +173,7 @@
     }
 
     @Test
-    public void testUpdateUninstallButton_isSystemApp_handleAsDisableableButton() {
+    public void updateUninstallButton_isSystemApp_handleAsDisableableButton() {
         doReturn(false).when(mController).handleDisableable();
         mAppInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
 
@@ -183,7 +184,7 @@
     }
 
     @Test
-    public void testIsAvailable_nonInstantApp() throws Exception {
+    public void isAvailable_nonInstantApp() throws Exception {
         mController.mAppEntry = mAppEntry;
         ReflectionHelpers.setStaticField(AppUtils.class, "sInstantAppDataProvider",
                 new InstantAppDataProvider() {
@@ -196,7 +197,7 @@
     }
 
     @Test
-    public void testIsAvailable_instantApp() throws Exception {
+    public void isAvailable_instantApp() throws Exception {
         mController.mAppEntry = mAppEntry;
         ReflectionHelpers.setStaticField(AppUtils.class, "sInstantAppDataProvider",
                 new InstantAppDataProvider() {
@@ -209,7 +210,7 @@
     }
 
     @Test
-    public void testUpdateUninstallButton_isDeviceAdminApp_setButtonDisable() {
+    public void updateUninstallButton_isDeviceAdminApp_setButtonDisable() {
         doReturn(true).when(mController).handleDisableable();
         mAppInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
         doReturn(true).when(mDpm).packageHasActiveAdmins(anyString());
@@ -221,7 +222,7 @@
     }
 
     @Test
-    public void testUpdateUninstallButton_isProfileOrDeviceOwner_setButtonDisable() {
+    public void updateUninstallButton_isProfileOrDeviceOwner_setButtonDisable() {
         doReturn(true).when(mDpm).isDeviceOwnerAppOnAnyUser(anyString());
 
         mController.updateUninstallButton();
@@ -230,7 +231,7 @@
     }
 
     @Test
-    public void testUpdateUninstallButton_isDeviceProvisioningApp_setButtonDisable() {
+    public void updateUninstallButton_isDeviceProvisioningApp_setButtonDisable() {
         doReturn(true).when(mDpm).isDeviceOwnerAppOnAnyUser(anyString());
         when(mSettingsActivity.getResources().getString(anyInt())).thenReturn(PACKAGE_NAME);
 
@@ -240,7 +241,7 @@
     }
 
     @Test
-    public void testUpdateUninstallButton_isUninstallInQueue_setButtonDisable() {
+    public void updateUninstallButton_isUninstallInQueue_setButtonDisable() {
         doReturn(true).when(mDpm).isUninstallInQueue(any());
 
         mController.updateUninstallButton();
@@ -249,7 +250,7 @@
     }
 
     @Test
-    public void testUpdateUninstallButton_isHomeAppAndBundled_setButtonDisable() {
+    public void updateUninstallButton_isHomeAppAndBundled_setButtonDisable() {
         mAppInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
         mController.mHomePackages.add(PACKAGE_NAME);
 
@@ -259,7 +260,7 @@
     }
 
     @Test
-    public void testUpdateForceStopButton_HasActiveAdmins_setButtonDisable() {
+    public void updateForceStopButton_HasActiveAdmins_setButtonDisable() {
         doReturn(true).when(mDpm).packageHasActiveAdmins(anyString());
 
         mController.updateForceStopButton();
@@ -268,14 +269,14 @@
     }
 
     @Test
-    public void testUpdateForceStopButton_AppNotStopped_setButtonEnable() {
+    public void updateForceStopButton_AppNotStopped_setButtonEnable() {
         mController.updateForceStopButton();
 
         verify(mController).updateForceStopButtonInner(true);
     }
 
     @Test
-    public void testUninstallPkg_intentSent() {
+    public void uninstallPkg_intentSent() {
         mController.uninstallPkg(PACKAGE_NAME, ALL_USERS, DISABLE_AFTER_INSTALL);
 
         verify(mFragment).startActivityForResult(any(), eq(REQUEST_UNINSTALL));
@@ -287,7 +288,7 @@
     }
 
     @Test
-    public void testForceStopPackage_methodInvokedAndUpdated() {
+    public void forceStopPackage_methodInvokedAndUpdated() {
         final ApplicationsState.AppEntry appEntry = mock(ApplicationsState.AppEntry.class);
         doReturn(appEntry).when(mState).getEntry(anyString(), anyInt());
         doNothing().when(mController).updateForceStopButton();
@@ -300,7 +301,7 @@
     }
 
     @Test
-    public void testHandleDisableable_isHomeApp_notControllable() {
+    public void handleDisableable_isHomeApp_notControllable() {
         mController.mHomePackages.add(PACKAGE_NAME);
 
         final boolean controllable = mController.handleDisableable();
@@ -310,7 +311,7 @@
     }
 
     @Test
-    public void testHandleDisableable_isAppEnabled_controllable() {
+    public void handleDisableable_isAppEnabled_controllable() {
         mAppEntry.info.enabled = true;
         mAppEntry.info.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT;
         doReturn(false).when(mController).isSystemPackage(any(), any(), any());
@@ -322,7 +323,7 @@
     }
 
     @Test
-    public void testHandleDisableable_isAppDisabled_controllable() {
+    public void handleDisableable_isAppDisabled_controllable() {
         mAppEntry.info.enabled = false;
         mAppEntry.info.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT;
         doReturn(false).when(mController).isSystemPackage(any(), any(), any());
@@ -334,13 +335,33 @@
     }
 
     @Test
-    public void testRefreshUi_packageNull_shouldNotCrash() {
+    public void refreshUi_packageNull_shouldNotCrash() {
         mController.mPackageName = null;
 
         // Should not crash in this method
         assertThat(mController.refreshUi()).isFalse();
     }
 
+    @Test
+    public void onPackageListChanged_available_shouldRefreshUi() {
+        doReturn(true).when(mController).isAvailable();
+        doReturn(true).when(mController).refreshUi();
+
+        mController.onPackageListChanged();
+
+        verify(mController).refreshUi();
+    }
+
+    @Test
+    public void onPackageListChanged_notAvailable_shouldNotRefreshUiAndNoCrash() {
+        doReturn(false).when(mController).isAvailable();
+
+        mController.onPackageListChanged();
+
+        verify(mController, never()).refreshUi();
+        // Should not crash in this method
+    }
+
     /**
      * The test fragment which implements
      * {@link ButtonActionDialogFragment.AppButtonsDialogListener}
diff --git a/tests/robotests/src/com/android/settings/fuelgauge/AutoRestrictionPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/fuelgauge/AutoRestrictionPreferenceControllerTest.java
new file mode 100644
index 0000000..241f550
--- /dev/null
+++ b/tests/robotests/src/com/android/settings/fuelgauge/AutoRestrictionPreferenceControllerTest.java
@@ -0,0 +1,115 @@
+/*
+ * 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.fuelgauge;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.doReturn;
+
+import android.content.Context;
+import android.provider.Settings;
+import android.support.v14.preference.SwitchPreference;
+
+import com.android.settings.core.BasePreferenceController;
+import com.android.settings.testutils.FakeFeatureFactory;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+
+@RunWith(RobolectricTestRunner.class)
+public class AutoRestrictionPreferenceControllerTest {
+    private static final int ON = 1;
+    private static final int OFF = 0;
+
+    private AutoRestrictionPreferenceController mController;
+    private SwitchPreference mPreference;
+    private Context mContext;
+    private FakeFeatureFactory mFeatureFactory;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+
+        mFeatureFactory = FakeFeatureFactory.setupForTest();
+        mContext = RuntimeEnvironment.application;
+        mController = new AutoRestrictionPreferenceController(mContext);
+        mPreference = new SwitchPreference(mContext);
+    }
+
+    @Test
+    public void testUpdateState_AutoRestrictionOn_preferenceChecked() {
+        putAutoRestrictionValue(ON);
+
+        mController.updateState(mPreference);
+
+        assertThat(mPreference.isChecked()).isTrue();
+    }
+
+    @Test
+    public void testUpdateState_AutoRestrictionOff_preferenceUnchecked() {
+        putAutoRestrictionValue(OFF);
+
+        mController.updateState(mPreference);
+
+        assertThat(mPreference.isChecked()).isFalse();
+    }
+
+    @Test
+    public void testUpdateState_checkPreference_autoRestrictionOn() {
+        mController.onPreferenceChange(mPreference, true);
+
+        assertThat(getAutoRestrictionValue()).isEqualTo(ON);
+    }
+
+    @Test
+    public void testUpdateState_unCheckPreference_autoRestrictionOff() {
+        mController.onPreferenceChange(mPreference, false);
+
+        assertThat(getAutoRestrictionValue()).isEqualTo(OFF);
+    }
+
+    @Test
+    public void testGetAvailabilityStatus_smartBatterySupported_returnDisabled() {
+        doReturn(true).when(mFeatureFactory.powerUsageFeatureProvider).isSmartBatterySupported();
+
+        assertThat(mController.getAvailabilityStatus()).isEqualTo(
+                BasePreferenceController.DISABLED_UNSUPPORTED);
+    }
+
+    @Test
+    public void testGetAvailabilityStatus_smartBatteryUnSupported_returnAvailable() {
+        doReturn(false).when(mFeatureFactory.powerUsageFeatureProvider).isSmartBatterySupported();
+
+        assertThat(mController.getAvailabilityStatus()).isEqualTo(
+                BasePreferenceController.AVAILABLE);
+    }
+
+    private void putAutoRestrictionValue(int value) {
+        Settings.Global.putInt(mContext.getContentResolver(),
+                Settings.Global.APP_AUTO_RESTRICTION_ENABLED,
+                value);
+    }
+
+    private int getAutoRestrictionValue() {
+        return Settings.Global.getInt(mContext.getContentResolver(),
+                Settings.Global.APP_AUTO_RESTRICTION_ENABLED, ON);
+    }
+}
diff --git a/tests/robotests/src/com/android/settings/fuelgauge/BatteryAppListPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/fuelgauge/BatteryAppListPreferenceControllerTest.java
index b223a10..8156428 100644
--- a/tests/robotests/src/com/android/settings/fuelgauge/BatteryAppListPreferenceControllerTest.java
+++ b/tests/robotests/src/com/android/settings/fuelgauge/BatteryAppListPreferenceControllerTest.java
@@ -203,20 +203,6 @@
     }
 
     @Test
-    public void testIsAvailable_featureOn_returnTrue() {
-        FeatureFlagUtils.setEnabled(mContext, FeatureFlags.BATTERY_DISPLAY_APP_LIST, true);
-
-        assertThat(mPreferenceController.isAvailable()).isTrue();
-    }
-
-    @Test
-    public void testIsAvailable_featureOff_returnFalse() {
-        FeatureFlagUtils.setEnabled(mContext, FeatureFlags.BATTERY_DISPLAY_APP_LIST, false);
-
-        assertThat(mPreferenceController.isAvailable()).isFalse();
-    }
-
-    @Test
     public void testNeverUseFakeData() {
         assertThat(BatteryAppListPreferenceController.USE_FAKE_DATA).isFalse();
     }
diff --git a/tests/robotests/src/com/android/settings/fuelgauge/BatteryDatabaseManagerTest.java b/tests/robotests/src/com/android/settings/fuelgauge/BatteryDatabaseManagerTest.java
index 8b4ff53..6360232 100644
--- a/tests/robotests/src/com/android/settings/fuelgauge/BatteryDatabaseManagerTest.java
+++ b/tests/robotests/src/com/android/settings/fuelgauge/BatteryDatabaseManagerTest.java
@@ -42,8 +42,10 @@
 public class BatteryDatabaseManagerTest {
 
     private static String PACKAGE_NAME_NEW = "com.android.app1";
+    private static int UID_NEW = 345;
     private static int TYPE_NEW = 1;
     private static String PACKAGE_NAME_OLD = "com.android.app2";
+    private static int UID_OLD = 543;
     private static int TYPE_OLD = 2;
     private static long NOW = System.currentTimeMillis();
     private static long ONE_DAY_BEFORE = NOW - DateUtils.DAY_IN_MILLIS;
@@ -67,23 +69,23 @@
 
     @Test
     public void testAllFunctions() {
-        mBatteryDatabaseManager.insertAnomaly(PACKAGE_NAME_NEW, TYPE_NEW,
+        mBatteryDatabaseManager.insertAnomaly(UID_NEW, PACKAGE_NAME_NEW, TYPE_NEW,
                 AnomalyDatabaseHelper.State.NEW, NOW);
-        mBatteryDatabaseManager.insertAnomaly(PACKAGE_NAME_OLD, TYPE_OLD,
+        mBatteryDatabaseManager.insertAnomaly(UID_OLD, PACKAGE_NAME_OLD, TYPE_OLD,
                 AnomalyDatabaseHelper.State.NEW, TWO_DAYS_BEFORE);
 
         // In database, it contains two record
         List<AppInfo> totalAppInfos = mBatteryDatabaseManager.queryAllAnomalies(0 /* timeMsAfter */,
                 AnomalyDatabaseHelper.State.NEW);
         assertThat(totalAppInfos).hasSize(2);
-        assertAppInfo(totalAppInfos.get(0), PACKAGE_NAME_NEW, TYPE_NEW);
-        assertAppInfo(totalAppInfos.get(1), PACKAGE_NAME_OLD, TYPE_OLD);
+        assertAppInfo(totalAppInfos.get(0), UID_NEW, PACKAGE_NAME_NEW, TYPE_NEW);
+        assertAppInfo(totalAppInfos.get(1), UID_OLD, PACKAGE_NAME_OLD, TYPE_OLD);
 
         // Only one record shows up if we query by timestamp
         List<AppInfo> appInfos = mBatteryDatabaseManager.queryAllAnomalies(ONE_DAY_BEFORE,
                 AnomalyDatabaseHelper.State.NEW);
         assertThat(appInfos).hasSize(1);
-        assertAppInfo(appInfos.get(0), PACKAGE_NAME_NEW, TYPE_NEW);
+        assertAppInfo(appInfos.get(0), UID_NEW, PACKAGE_NAME_NEW, TYPE_NEW);
 
         mBatteryDatabaseManager.deleteAllAnomaliesBeforeTimeStamp(ONE_DAY_BEFORE);
 
@@ -91,14 +93,14 @@
         List<AppInfo> appInfos1 = mBatteryDatabaseManager.queryAllAnomalies(0 /* timeMsAfter */,
                 AnomalyDatabaseHelper.State.NEW);
         assertThat(appInfos1).hasSize(1);
-        assertAppInfo(appInfos1.get(0), PACKAGE_NAME_NEW, TYPE_NEW);
+        assertAppInfo(appInfos1.get(0), UID_NEW, PACKAGE_NAME_NEW, TYPE_NEW);
     }
 
     @Test
     public void testUpdateAnomalies_updateSuccessfully() {
-        mBatteryDatabaseManager.insertAnomaly(PACKAGE_NAME_NEW, TYPE_NEW,
+        mBatteryDatabaseManager.insertAnomaly(UID_NEW, PACKAGE_NAME_NEW, TYPE_NEW,
                 AnomalyDatabaseHelper.State.NEW, NOW);
-        mBatteryDatabaseManager.insertAnomaly(PACKAGE_NAME_OLD, TYPE_OLD,
+        mBatteryDatabaseManager.insertAnomaly(UID_OLD, PACKAGE_NAME_OLD, TYPE_OLD,
                 AnomalyDatabaseHelper.State.NEW, NOW);
         final AppInfo appInfo = new AppInfo.Builder().setPackageName(PACKAGE_NAME_OLD).build();
         final List<AppInfo> updateAppInfos = new ArrayList<>();
@@ -112,17 +114,18 @@
         List<AppInfo> newAppInfos = mBatteryDatabaseManager.queryAllAnomalies(ONE_DAY_BEFORE,
                 AnomalyDatabaseHelper.State.NEW);
         assertThat(newAppInfos).hasSize(1);
-        assertAppInfo(newAppInfos.get(0), PACKAGE_NAME_NEW, TYPE_NEW);
+        assertAppInfo(newAppInfos.get(0), UID_NEW, PACKAGE_NAME_NEW, TYPE_NEW);
 
         // The state of PACKAGE_NAME_OLD is changed to handled
         List<AppInfo> handledAppInfos = mBatteryDatabaseManager.queryAllAnomalies(ONE_DAY_BEFORE,
                 AnomalyDatabaseHelper.State.HANDLED);
         assertThat(handledAppInfos).hasSize(1);
-        assertAppInfo(handledAppInfos.get(0), PACKAGE_NAME_OLD, TYPE_OLD);
+        assertAppInfo(handledAppInfos.get(0), UID_OLD, PACKAGE_NAME_OLD, TYPE_OLD);
     }
 
-    private void assertAppInfo(final AppInfo appInfo, String packageName, int type) {
+    private void assertAppInfo(final AppInfo appInfo, int uid, String packageName, int type) {
         assertThat(appInfo.packageName).isEqualTo(packageName);
         assertThat(appInfo.anomalyType).isEqualTo(type);
+        assertThat(appInfo.uid).isEqualTo(uid);
     }
 }
diff --git a/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageAdvancedLegacyTest.java b/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageAdvancedLegacyTest.java
new file mode 100644
index 0000000..756d913
--- /dev/null
+++ b/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageAdvancedLegacyTest.java
@@ -0,0 +1,437 @@
+/*
+ * Copyright (C) 2017 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.fuelgauge;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.pm.UserInfo;
+import android.net.ConnectivityManager;
+import android.os.UserManager;
+import android.support.v7.preference.PreferenceCategory;
+import android.support.v7.preference.PreferenceGroup;
+import android.support.v7.preference.PreferenceManager;
+
+import com.android.internal.os.BatterySipper;
+import com.android.internal.os.BatterySipper.DrainType;
+import com.android.internal.os.BatteryStatsHelper;
+import com.android.settings.R;
+import com.android.settings.Utils;
+import com.android.settings.testutils.BatteryTestUtils;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+import com.android.settings.fuelgauge.PowerUsageAdvancedLegacy.PowerUsageData;
+import com.android.settings.fuelgauge.PowerUsageAdvancedLegacy.PowerUsageData.UsageType;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Answers;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+public class PowerUsageAdvancedLegacyTest {
+    private static final int FAKE_UID_1 = 50;
+    private static final int FAKE_UID_2 = 100;
+    private static final int DISCHARGE_AMOUNT = 60;
+    private static final double TYPE_APP_USAGE = 80;
+    private static final double TYPE_BLUETOOTH_USAGE = 50;
+    private static final double TYPE_WIFI_USAGE = 0;
+    private static final double TOTAL_USAGE = TYPE_APP_USAGE * 2 + TYPE_BLUETOOTH_USAGE
+            + TYPE_WIFI_USAGE;
+    private static final double TOTAL_POWER = 500;
+    private static final double PRECISION = 0.001;
+    private static final String STUB_STRING = "stub_string";
+    @Mock
+    private BatterySipper mNormalBatterySipper;
+    @Mock
+    private BatterySipper mMaxBatterySipper;
+    @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+    private BatteryStatsHelper mBatteryStatsHelper;
+    @Mock
+    private PowerUsageFeatureProvider mPowerUsageFeatureProvider;
+    @Mock
+    private PackageManager mPackageManager;
+    @Mock
+    private UserManager mUserManager;
+    @Mock
+    private BatteryHistoryPreference mHistPref;
+    @Mock
+    private PreferenceGroup mUsageListGroup;
+    @Mock
+    private ConnectivityManager mConnectivityManager;
+    @Mock
+    private UserInfo mNormalUserInfo;
+    @Mock
+    private UserInfo mManagedUserInfo;
+    private PowerUsageAdvancedLegacy mPowerUsageAdvanced;
+    private PowerUsageData mPowerUsageData;
+    private Context mShadowContext;
+    private Intent mDischargingBatteryIntent;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        mShadowContext = spy(RuntimeEnvironment.application);
+        mPowerUsageAdvanced = spy(new PowerUsageAdvancedLegacy());
+
+        List<BatterySipper> batterySippers = new ArrayList<>();
+        batterySippers.add(new BatterySipper(DrainType.APP,
+                new FakeUid(FAKE_UID_1), TYPE_APP_USAGE));
+        batterySippers.add(new BatterySipper(DrainType.APP,
+                new FakeUid(FAKE_UID_2), TYPE_APP_USAGE));
+        batterySippers.add(new BatterySipper(DrainType.BLUETOOTH, new FakeUid(FAKE_UID_1),
+                TYPE_BLUETOOTH_USAGE));
+        batterySippers.add(new BatterySipper(DrainType.WIFI, new FakeUid(FAKE_UID_1),
+                TYPE_WIFI_USAGE));
+
+        mDischargingBatteryIntent = BatteryTestUtils.getDischargingIntent();
+        doReturn(mDischargingBatteryIntent).when(mShadowContext).registerReceiver(any(), any());
+        when(mBatteryStatsHelper.getStats().getDischargeAmount(anyInt())).thenReturn(
+                DISCHARGE_AMOUNT);
+        when(mBatteryStatsHelper.getUsageList()).thenReturn(batterySippers);
+        when(mBatteryStatsHelper.getTotalPower()).thenReturn(TOTAL_USAGE);
+        when(mPowerUsageAdvanced.getContext()).thenReturn(mShadowContext);
+        doReturn(STUB_STRING).when(mPowerUsageAdvanced).getString(anyInt(), any(), any());
+        doReturn(STUB_STRING).when(mPowerUsageAdvanced).getString(anyInt(), any());
+        doReturn(mShadowContext.getText(R.string.battery_used_for)).when(
+                mPowerUsageAdvanced).getText(R.string.battery_used_for);
+        mPowerUsageAdvanced.setPackageManager(mPackageManager);
+        mPowerUsageAdvanced.setPowerUsageFeatureProvider(mPowerUsageFeatureProvider);
+        mPowerUsageAdvanced.setUserManager(mUserManager);
+        mPowerUsageAdvanced.setBatteryUtils(BatteryUtils.getInstance(mShadowContext));
+        when(mShadowContext.getSystemService(Context.CONNECTIVITY_SERVICE)).thenReturn(
+                mConnectivityManager);
+
+        mPowerUsageData = new PowerUsageData(UsageType.USER);
+        mMaxBatterySipper.totalPowerMah = TYPE_BLUETOOTH_USAGE;
+        mMaxBatterySipper.drainType = DrainType.BLUETOOTH;
+        mNormalBatterySipper.drainType = DrainType.SCREEN;
+
+        doReturn(true).when(mNormalUserInfo).isEnabled();
+        doReturn(false).when(mNormalUserInfo).isManagedProfile();
+        doReturn(true).when(mManagedUserInfo).isEnabled();
+        doReturn(true).when(mManagedUserInfo).isManagedProfile();
+    }
+
+    @Test
+    public void testPrefs_shouldNotBeSelectable() {
+        PreferenceManager pm = new PreferenceManager(mShadowContext);
+        when(mPowerUsageAdvanced.getPreferenceManager()).thenReturn(pm);
+        PreferenceGroup prefGroup = spy(new PreferenceCategory(mShadowContext));
+        when(prefGroup.getPreferenceManager()).thenReturn(pm);
+
+        mPowerUsageAdvanced.refreshPowerUsageDataList(mBatteryStatsHelper, prefGroup);
+        assertThat(prefGroup.getPreferenceCount()).isAtLeast(1);
+        for (int i = 0, count = prefGroup.getPreferenceCount(); i < count; i++) {
+            PowerGaugePreference pref = (PowerGaugePreference) prefGroup.getPreference(i);
+            assertThat(pref.isSelectable()).isFalse();
+        }
+    }
+
+    @Test
+    public void testExtractUsageType_TypeSystem_ReturnSystem() {
+        mNormalBatterySipper.drainType = DrainType.APP;
+        when(mPowerUsageFeatureProvider.isTypeSystem(any())).thenReturn(true);
+
+        assertThat(mPowerUsageAdvanced.extractUsageType(mNormalBatterySipper))
+                .isEqualTo(UsageType.SYSTEM);
+    }
+
+    @Test
+    public void testExtractUsageType_TypeEqualsToDrainType_ReturnRelevantType() {
+        final DrainType drainTypes[] = {DrainType.WIFI, DrainType.BLUETOOTH, DrainType.IDLE,
+                DrainType.USER, DrainType.CELL, DrainType.UNACCOUNTED};
+        final int usageTypes[] = {UsageType.WIFI, UsageType.BLUETOOTH, UsageType.IDLE,
+                UsageType.USER, UsageType.CELL, UsageType.UNACCOUNTED};
+
+        assertThat(drainTypes.length).isEqualTo(usageTypes.length);
+        for (int i = 0, size = drainTypes.length; i < size; i++) {
+            mNormalBatterySipper.drainType = drainTypes[i];
+            assertThat(mPowerUsageAdvanced.extractUsageType(mNormalBatterySipper))
+                    .isEqualTo(usageTypes[i]);
+        }
+    }
+
+    @Test
+    public void testExtractUsageType_TypeService_ReturnSystem() {
+        mNormalBatterySipper.drainType = DrainType.APP;
+        when(mNormalBatterySipper.getUid()).thenReturn(FAKE_UID_1);
+        when(mPowerUsageFeatureProvider.isTypeService(any())).thenReturn(true);
+
+        assertThat(mPowerUsageAdvanced.extractUsageType(mNormalBatterySipper))
+                .isEqualTo(UsageType.SYSTEM);
+    }
+
+    @Test
+    public void testParsePowerUsageData_PercentageCalculatedCorrectly() {
+        final double percentApp = TYPE_APP_USAGE * 2 / TOTAL_USAGE * DISCHARGE_AMOUNT;
+        final double percentWifi = TYPE_WIFI_USAGE / TOTAL_USAGE * DISCHARGE_AMOUNT;
+        final double percentBluetooth = TYPE_BLUETOOTH_USAGE / TOTAL_USAGE * DISCHARGE_AMOUNT;
+
+        List<PowerUsageData> batteryData =
+                mPowerUsageAdvanced.parsePowerUsageData(mBatteryStatsHelper);
+        for (PowerUsageData data : batteryData) {
+            switch (data.usageType) {
+                case UsageType.WIFI:
+                    assertThat(data.percentage).isWithin(PRECISION).of(percentWifi);
+                    break;
+                case UsageType.APP:
+                    assertThat(data.percentage).isWithin(PRECISION).of(percentApp);
+                    break;
+                case UsageType.BLUETOOTH:
+                    assertThat(data.percentage).isWithin(PRECISION).of(percentBluetooth);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+
+    @Test
+    public void testUpdateUsageDataSummary_onlyOneApp_showUsageTime() {
+        final String expectedSummary = "Used for 0m";
+        mPowerUsageData.usageList.add(mNormalBatterySipper);
+
+        mPowerUsageAdvanced.updateUsageDataSummary(mPowerUsageData, TOTAL_POWER, DISCHARGE_AMOUNT);
+
+        assertThat(mPowerUsageData.summary.toString()).isEqualTo(expectedSummary);
+    }
+
+    @Test
+    public void testUpdateUsageDataSummary_typeIdle_showUsageTime() {
+        mPowerUsageData.usageType = UsageType.IDLE;
+        mPowerUsageData.usageList.add(mNormalBatterySipper);
+
+        mPowerUsageAdvanced.updateUsageDataSummary(mPowerUsageData, TOTAL_POWER, DISCHARGE_AMOUNT);
+
+        assertThat(mPowerUsageData.summary.toString()).isEqualTo("0m");
+    }
+
+    @Test
+    public void testUpdateUsageDataSummary_moreThanOneApp_showMaxUsageApp() {
+        mPowerUsageData.usageList.add(mNormalBatterySipper);
+        mPowerUsageData.usageList.add(mMaxBatterySipper);
+        doReturn(mMaxBatterySipper).when(mPowerUsageAdvanced)
+            .findBatterySipperWithMaxBatteryUsage(mPowerUsageData.usageList);
+        final double percentage = (TYPE_BLUETOOTH_USAGE / TOTAL_POWER) * DISCHARGE_AMOUNT;
+        mPowerUsageAdvanced.updateUsageDataSummary(mPowerUsageData, TOTAL_POWER, DISCHARGE_AMOUNT);
+
+        verify(mPowerUsageAdvanced).getString(eq(R.string.battery_used_by),
+                eq(Utils.formatPercentage(percentage, true)), any());
+    }
+
+    @Test
+    public void testFindBatterySipperWithMaxBatteryUsage_findCorrectOne() {
+        mPowerUsageData.usageList.add(mNormalBatterySipper);
+        mPowerUsageData.usageList.add(mMaxBatterySipper);
+        BatterySipper sipper =
+            mPowerUsageAdvanced.findBatterySipperWithMaxBatteryUsage(mPowerUsageData.usageList);
+
+        assertThat(sipper).isEqualTo(mMaxBatterySipper);
+    }
+
+    @Test
+    public void testInit_ContainsAllUsageType() {
+        final int[] usageTypeSet = mPowerUsageAdvanced.mUsageTypes;
+
+        assertThat(usageTypeSet).asList().containsExactly(UsageType.APP, UsageType.WIFI,
+                UsageType.CELL, UsageType.BLUETOOTH, UsageType.IDLE, UsageType.USER,
+                UsageType.SYSTEM, UsageType.UNACCOUNTED, UsageType.OVERCOUNTED);
+    }
+
+    @Test
+    public void testPowerUsageData_SortedByUsage() {
+        List<PowerUsageData> dataList = new ArrayList<>();
+
+        dataList.add(new PowerUsageData(UsageType.WIFI, TYPE_WIFI_USAGE));
+        dataList.add(new PowerUsageData(UsageType.BLUETOOTH, TYPE_BLUETOOTH_USAGE));
+        dataList.add(new PowerUsageData(UsageType.APP, TYPE_APP_USAGE));
+        Collections.sort(dataList);
+
+        for (int i = 1, size = dataList.size(); i < size; i++) {
+            assertThat(dataList.get(i - 1).totalPowerMah).isAtLeast(dataList.get(i).totalPowerMah);
+        }
+    }
+
+    @Test
+    public void testShouldHideCategory_typeUnAccounted_returnTrue() {
+        mPowerUsageData.usageType = UsageType.UNACCOUNTED;
+
+        assertThat(mPowerUsageAdvanced.shouldHideCategory(mPowerUsageData)).isTrue();
+    }
+
+    @Test
+    public void testShouldHideCategory_typeOverCounted_returnTrue() {
+        mPowerUsageData.usageType = UsageType.OVERCOUNTED;
+
+        assertThat(mPowerUsageAdvanced.shouldHideCategory(mPowerUsageData)).isTrue();
+    }
+
+    @Test
+    public void testShouldHideCategory_typeUserAndOnlyOneNormalUser_returnTrue() {
+        mPowerUsageData.usageType = UsageType.USER;
+        List<UserInfo> userInfos = new ArrayList<>();
+        userInfos.add(mNormalUserInfo);
+        userInfos.add(mManagedUserInfo);
+        doReturn(userInfos).when(mUserManager).getUsers();
+
+        assertThat(mPowerUsageAdvanced.shouldHideCategory(mPowerUsageData)).isTrue();
+    }
+
+    @Test
+    public void testShouldHideCategory_typeCellWhileNotSupported_returnTrue() {
+        mPowerUsageData.usageType = UsageType.CELL;
+        doReturn(false).when(mConnectivityManager)
+            .isNetworkSupported(ConnectivityManager.TYPE_MOBILE);
+
+        assertThat(mPowerUsageAdvanced.shouldHideCategory(mPowerUsageData)).isTrue();
+    }
+
+    @Test
+    public void testShouldHideCategory_typeCellWhileSupported_returnFalse() {
+        mPowerUsageData.usageType = UsageType.CELL;
+        doReturn(true).when(mConnectivityManager).isNetworkSupported(
+                ConnectivityManager.TYPE_MOBILE);
+
+        assertThat(mPowerUsageAdvanced.shouldHideCategory(mPowerUsageData)).isFalse();
+    }
+
+    @Test
+    public void testShouldHideCategory_typeUserAndMoreThanOne_returnFalse() {
+        mPowerUsageData.usageType = UsageType.USER;
+        List<UserInfo> userInfos = new ArrayList<>();
+        userInfos.add(mNormalUserInfo);
+        userInfos.add(mNormalUserInfo);
+        doReturn(userInfos).when(mUserManager).getUsers();
+
+        assertThat(mPowerUsageAdvanced.shouldHideCategory(mPowerUsageData)).isFalse();
+    }
+
+    @Test
+    public void testShouldHideCategory_typeNormal_returnFalse() {
+        mPowerUsageData.usageType = UsageType.APP;
+
+        assertThat(mPowerUsageAdvanced.shouldHideCategory(mPowerUsageData)).isFalse();
+    }
+
+    @Test
+    public void testShouldHideSummary_typeCell_returnTrue() {
+        mPowerUsageData.usageType = UsageType.CELL;
+
+        assertThat(mPowerUsageAdvanced.shouldHideSummary(mPowerUsageData)).isTrue();
+    }
+
+    @Test
+    public void testShouldHideSummary_typeSystem_returnTrue() {
+        mPowerUsageData.usageType = UsageType.SYSTEM;
+
+        assertThat(mPowerUsageAdvanced.shouldHideSummary(mPowerUsageData)).isTrue();
+    }
+
+    @Test
+    public void testShouldHideSummary_typeWifi_returnTrue() {
+        mPowerUsageData.usageType = UsageType.WIFI;
+
+        assertThat(mPowerUsageAdvanced.shouldHideSummary(mPowerUsageData)).isTrue();
+    }
+
+    @Test
+    public void testShouldHideSummary_typeBluetooth_returnTrue() {
+        mPowerUsageData.usageType = UsageType.BLUETOOTH;
+
+        assertThat(mPowerUsageAdvanced.shouldHideSummary(mPowerUsageData)).isTrue();
+    }
+
+    @Test
+    public void testShouldHideSummary_typeApp_returnTrue() {
+        mPowerUsageData.usageType = UsageType.APP;
+
+        assertThat(mPowerUsageAdvanced.shouldHideSummary(mPowerUsageData)).isTrue();
+    }
+
+    @Test
+    public void testShouldHideSummary_typeNormal_returnFalse() {
+        mPowerUsageData.usageType = UsageType.IDLE;
+
+        assertThat(mPowerUsageAdvanced.shouldHideSummary(mPowerUsageData)).isFalse();
+    }
+
+    @Test
+    public void testShouldShowBatterySipper_typeScreen_returnFalse() {
+        mNormalBatterySipper.drainType = DrainType.SCREEN;
+
+        assertThat(mPowerUsageAdvanced.shouldShowBatterySipper(mNormalBatterySipper)).isFalse();
+    }
+
+    @Test
+    public void testShouldShowBatterySipper_typeNormal_returnTrue() {
+        mNormalBatterySipper.drainType = DrainType.APP;
+
+        assertThat(mPowerUsageAdvanced.shouldShowBatterySipper(mNormalBatterySipper)).isTrue();
+    }
+
+    @Test
+    public void testCalculateHiddenPower_returnCorrectPower() {
+        List<PowerUsageData> powerUsageDataList = new ArrayList<>();
+        final double unaccountedPower = 100;
+        final double normalPower = 150;
+        powerUsageDataList.add(new PowerUsageData(UsageType.UNACCOUNTED, unaccountedPower));
+        powerUsageDataList.add(new PowerUsageData(UsageType.APP, normalPower));
+        powerUsageDataList.add(new PowerUsageData(UsageType.CELL, normalPower));
+
+        assertThat(mPowerUsageAdvanced.calculateHiddenPower(powerUsageDataList))
+            .isWithin(PRECISION).of(unaccountedPower);
+    }
+
+    @Test
+    public void testRefreshUi_addsSubtextWhenAppropriate() {
+        // Mock out all the battery stuff
+        mPowerUsageAdvanced.mHistPref = mHistPref;
+        mPowerUsageAdvanced.mStatsHelper = mBatteryStatsHelper;
+        doReturn(new ArrayList<PowerUsageData>())
+                .when(mPowerUsageAdvanced).parsePowerUsageData(any());
+        doReturn("").when(mPowerUsageAdvanced).getString(anyInt());
+        mPowerUsageAdvanced.mUsageListGroup = mUsageListGroup;
+
+        // refresh the ui and check that text was not updated when enhanced prediction disabled
+        when(mPowerUsageFeatureProvider.isEnhancedBatteryPredictionEnabled(any()))
+                .thenReturn(false);
+        mPowerUsageAdvanced.refreshUi();
+        verify(mHistPref, never()).setBottomSummary(any());
+
+        // refresh the ui and check that text was updated when enhanced prediction enabled
+        when(mPowerUsageFeatureProvider.isEnhancedBatteryPredictionEnabled(any())).thenReturn(true);
+        mPowerUsageAdvanced.refreshUi();
+        verify(mHistPref, atLeastOnce()).setBottomSummary(any());
+    }
+}
diff --git a/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageAdvancedTest.java b/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageAdvancedTest.java
index 81d40a3..4a905b4 100644
--- a/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageAdvancedTest.java
+++ b/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageAdvancedTest.java
@@ -16,34 +16,25 @@
 package com.android.settings.fuelgauge;
 
 import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyInt;
+
+import static org.mockito.ArgumentMatchers.nullable;
 import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import android.content.Context;
-import android.content.Intent;
-import android.content.pm.PackageManager;
-import android.content.pm.UserInfo;
-import android.net.ConnectivityManager;
-import android.os.UserManager;
-import android.support.v7.preference.PreferenceCategory;
-import android.support.v7.preference.PreferenceGroup;
-import android.support.v7.preference.PreferenceManager;
+import android.os.Bundle;
+import android.support.v7.preference.PreferenceScreen;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
 
-import com.android.internal.os.BatterySipper;
-import com.android.internal.os.BatterySipper.DrainType;
-import com.android.internal.os.BatteryStatsHelper;
+import com.android.internal.logging.nano.MetricsProto;
 import com.android.settings.R;
-import com.android.settings.Utils;
-import com.android.settings.fuelgauge.PowerUsageAdvanced.PowerUsageData;
-import com.android.settings.fuelgauge.PowerUsageAdvanced.PowerUsageData.UsageType;
-import com.android.settings.testutils.BatteryTestUtils;
+import com.android.settings.testutils.FakeFeatureFactory;
 import com.android.settings.testutils.SettingsRobolectricTestRunner;
 
 import org.junit.Before;
@@ -54,385 +45,64 @@
 import org.mockito.MockitoAnnotations;
 import org.robolectric.RuntimeEnvironment;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
 @RunWith(SettingsRobolectricTestRunner.class)
 public class PowerUsageAdvancedTest {
-
-    private static final int FAKE_UID_1 = 50;
-    private static final int FAKE_UID_2 = 100;
-    private static final int DISCHARGE_AMOUNT = 60;
-    private static final double TYPE_APP_USAGE = 80;
-    private static final double TYPE_BLUETOOTH_USAGE = 50;
-    private static final double TYPE_WIFI_USAGE = 0;
-    private static final double TOTAL_USAGE = TYPE_APP_USAGE * 2 + TYPE_BLUETOOTH_USAGE
-            + TYPE_WIFI_USAGE;
-    private static final double TOTAL_POWER = 500;
-    private static final double PRECISION = 0.001;
-    private static final String STUB_STRING = "stub_string";
     @Mock
-    private BatterySipper mNormalBatterySipper;
-    @Mock
-    private BatterySipper mMaxBatterySipper;
+    private PreferenceScreen mPreferenceScreen;
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
-    private BatteryStatsHelper mBatteryStatsHelper;
+    private Menu mMenu;
     @Mock
-    private PowerUsageFeatureProvider mPowerUsageFeatureProvider;
+    private MenuInflater mMenuInflater;
     @Mock
-    private PackageManager mPackageManager;
-    @Mock
-    private UserManager mUserManager;
-    @Mock
-    private BatteryHistoryPreference mHistPref;
-    @Mock
-    private PreferenceGroup mUsageListGroup;
-    @Mock
-    private ConnectivityManager mConnectivityManager;
-    @Mock
-    private UserInfo mNormalUserInfo;
-    @Mock
-    private UserInfo mManagedUserInfo;
-    private PowerUsageAdvanced mPowerUsageAdvanced;
-    private PowerUsageData mPowerUsageData;
-    private Context mShadowContext;
-    private Intent mDischargingBatteryIntent;
+    private MenuItem mToggleAppsMenu;
+    private Context mContext;
+    private PowerUsageAdvanced mFragment;
+    private FakeFeatureFactory mFeatureFactory;
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
-        mShadowContext = spy(RuntimeEnvironment.application);
-        mPowerUsageAdvanced = spy(new PowerUsageAdvanced());
 
-        List<BatterySipper> batterySippers = new ArrayList<>();
-        batterySippers.add(new BatterySipper(DrainType.APP,
-                new FakeUid(FAKE_UID_1), TYPE_APP_USAGE));
-        batterySippers.add(new BatterySipper(DrainType.APP,
-                new FakeUid(FAKE_UID_2), TYPE_APP_USAGE));
-        batterySippers.add(new BatterySipper(DrainType.BLUETOOTH, new FakeUid(FAKE_UID_1),
-                TYPE_BLUETOOTH_USAGE));
-        batterySippers.add(new BatterySipper(DrainType.WIFI, new FakeUid(FAKE_UID_1),
-                TYPE_WIFI_USAGE));
+        mContext = RuntimeEnvironment.application;
+        mFeatureFactory = FakeFeatureFactory.setupForTest();
+        when(mToggleAppsMenu.getItemId()).thenReturn(PowerUsageAdvanced.MENU_TOGGLE_APPS);
 
-        mDischargingBatteryIntent = BatteryTestUtils.getDischargingIntent();
-        doReturn(mDischargingBatteryIntent).when(mShadowContext).registerReceiver(any(), any());
-        when(mBatteryStatsHelper.getStats().getDischargeAmount(anyInt())).thenReturn(
-                DISCHARGE_AMOUNT);
-        when(mBatteryStatsHelper.getUsageList()).thenReturn(batterySippers);
-        when(mBatteryStatsHelper.getTotalPower()).thenReturn(TOTAL_USAGE);
-        when(mPowerUsageAdvanced.getContext()).thenReturn(mShadowContext);
-        doReturn(STUB_STRING).when(mPowerUsageAdvanced).getString(anyInt(), any(), any());
-        doReturn(STUB_STRING).when(mPowerUsageAdvanced).getString(anyInt(), any());
-        doReturn(mShadowContext.getText(R.string.battery_used_for)).when(
-                mPowerUsageAdvanced).getText(R.string.battery_used_for);
-        mPowerUsageAdvanced.setPackageManager(mPackageManager);
-        mPowerUsageAdvanced.setPowerUsageFeatureProvider(mPowerUsageFeatureProvider);
-        mPowerUsageAdvanced.setUserManager(mUserManager);
-        mPowerUsageAdvanced.setBatteryUtils(BatteryUtils.getInstance(mShadowContext));
-        when(mShadowContext.getSystemService(Context.CONNECTIVITY_SERVICE)).thenReturn(
-                mConnectivityManager);
-
-        mPowerUsageData = new PowerUsageData(UsageType.USER);
-        mMaxBatterySipper.totalPowerMah = TYPE_BLUETOOTH_USAGE;
-        mMaxBatterySipper.drainType = DrainType.BLUETOOTH;
-        mNormalBatterySipper.drainType = DrainType.SCREEN;
-
-        doReturn(true).when(mNormalUserInfo).isEnabled();
-        doReturn(false).when(mNormalUserInfo).isManagedProfile();
-        doReturn(true).when(mManagedUserInfo).isEnabled();
-        doReturn(true).when(mManagedUserInfo).isManagedProfile();
+        mFragment = spy(new PowerUsageAdvanced());
+        mFragment.onAttach(mContext);
     }
 
     @Test
-    public void testPrefs_shouldNotBeSelectable() {
-        PreferenceManager pm = new PreferenceManager(mShadowContext);
-        when(mPowerUsageAdvanced.getPreferenceManager()).thenReturn(pm);
-        PreferenceGroup prefGroup = spy(new PreferenceCategory(mShadowContext));
-        when(prefGroup.getPreferenceManager()).thenReturn(pm);
+    public void testSaveInstanceState_showAllAppsRestored() {
+        Bundle bundle = new Bundle();
+        mFragment.mShowAllApps = true;
+        doReturn(mPreferenceScreen).when(mFragment).getPreferenceScreen();
 
-        mPowerUsageAdvanced.refreshPowerUsageDataList(mBatteryStatsHelper, prefGroup);
-        assertThat(prefGroup.getPreferenceCount()).isAtLeast(1);
-        for (int i = 0, count = prefGroup.getPreferenceCount(); i < count; i++) {
-            PowerGaugePreference pref = (PowerGaugePreference) prefGroup.getPreference(i);
-            assertThat(pref.isSelectable()).isFalse();
-        }
+        mFragment.onSaveInstanceState(bundle);
+        mFragment.restoreSavedInstance(bundle);
+
+        assertThat(mFragment.mShowAllApps).isTrue();
     }
 
     @Test
-    public void testExtractUsageType_TypeSystem_ReturnSystem() {
-        mNormalBatterySipper.drainType = DrainType.APP;
-        when(mPowerUsageFeatureProvider.isTypeSystem(any())).thenReturn(true);
+    public void testOptionsMenu_menuAppToggle_metricEventInvoked() {
+        mFragment.mShowAllApps = false;
+        doNothing().when(mFragment).restartBatteryStatsLoader();
 
-        assertThat(mPowerUsageAdvanced.extractUsageType(mNormalBatterySipper))
-                .isEqualTo(UsageType.SYSTEM);
+        mFragment.onOptionsItemSelected(mToggleAppsMenu);
+
+        verify(mFeatureFactory.metricsFeatureProvider).action(nullable(Context.class),
+                eq(MetricsProto.MetricsEvent.ACTION_SETTINGS_MENU_BATTERY_APPS_TOGGLE), eq(true));
     }
 
     @Test
-    public void testExtractUsageType_TypeEqualsToDrainType_ReturnRelevantType() {
-        final DrainType drainTypes[] = {DrainType.WIFI, DrainType.BLUETOOTH, DrainType.IDLE,
-                DrainType.USER, DrainType.CELL, DrainType.UNACCOUNTED};
-        final int usageTypes[] = {UsageType.WIFI, UsageType.BLUETOOTH, UsageType.IDLE,
-                UsageType.USER, UsageType.CELL, UsageType.UNACCOUNTED};
+    public void testOptionsMenu_toggleAppsEnabled() {
+        when(mFeatureFactory.powerUsageFeatureProvider.isPowerAccountingToggleEnabled())
+                .thenReturn(true);
+        mFragment.mShowAllApps = false;
 
-        assertThat(drainTypes.length).isEqualTo(usageTypes.length);
-        for (int i = 0, size = drainTypes.length; i < size; i++) {
-            mNormalBatterySipper.drainType = drainTypes[i];
-            assertThat(mPowerUsageAdvanced.extractUsageType(mNormalBatterySipper))
-                    .isEqualTo(usageTypes[i]);
-        }
-    }
+        mFragment.onCreateOptionsMenu(mMenu, mMenuInflater);
 
-    @Test
-    public void testExtractUsageType_TypeService_ReturnSystem() {
-        mNormalBatterySipper.drainType = DrainType.APP;
-        when(mNormalBatterySipper.getUid()).thenReturn(FAKE_UID_1);
-        when(mPowerUsageFeatureProvider.isTypeService(any())).thenReturn(true);
-
-        assertThat(mPowerUsageAdvanced.extractUsageType(mNormalBatterySipper))
-                .isEqualTo(UsageType.SYSTEM);
-    }
-
-    @Test
-    public void testParsePowerUsageData_PercentageCalculatedCorrectly() {
-        final double percentApp = TYPE_APP_USAGE * 2 / TOTAL_USAGE * DISCHARGE_AMOUNT;
-        final double percentWifi = TYPE_WIFI_USAGE / TOTAL_USAGE * DISCHARGE_AMOUNT;
-        final double percentBluetooth = TYPE_BLUETOOTH_USAGE / TOTAL_USAGE * DISCHARGE_AMOUNT;
-
-        List<PowerUsageData> batteryData =
-                mPowerUsageAdvanced.parsePowerUsageData(mBatteryStatsHelper);
-        for (PowerUsageData data : batteryData) {
-            switch (data.usageType) {
-                case UsageType.WIFI:
-                    assertThat(data.percentage).isWithin(PRECISION).of(percentWifi);
-                    break;
-                case UsageType.APP:
-                    assertThat(data.percentage).isWithin(PRECISION).of(percentApp);
-                    break;
-                case UsageType.BLUETOOTH:
-                    assertThat(data.percentage).isWithin(PRECISION).of(percentBluetooth);
-                    break;
-                default:
-                    break;
-            }
-        }
-    }
-
-    @Test
-    public void testUpdateUsageDataSummary_onlyOneApp_showUsageTime() {
-        final String expectedSummary = "Used for 0m";
-        mPowerUsageData.usageList.add(mNormalBatterySipper);
-
-        mPowerUsageAdvanced.updateUsageDataSummary(mPowerUsageData, TOTAL_POWER, DISCHARGE_AMOUNT);
-
-        assertThat(mPowerUsageData.summary.toString()).isEqualTo(expectedSummary);
-    }
-
-    @Test
-    public void testUpdateUsageDataSummary_typeIdle_showUsageTime() {
-        mPowerUsageData.usageType = UsageType.IDLE;
-        mPowerUsageData.usageList.add(mNormalBatterySipper);
-
-        mPowerUsageAdvanced.updateUsageDataSummary(mPowerUsageData, TOTAL_POWER, DISCHARGE_AMOUNT);
-
-        assertThat(mPowerUsageData.summary.toString()).isEqualTo("0m");
-    }
-
-    @Test
-    public void testUpdateUsageDataSummary_moreThanOneApp_showMaxUsageApp() {
-        mPowerUsageData.usageList.add(mNormalBatterySipper);
-        mPowerUsageData.usageList.add(mMaxBatterySipper);
-        doReturn(mMaxBatterySipper).when(mPowerUsageAdvanced)
-            .findBatterySipperWithMaxBatteryUsage(mPowerUsageData.usageList);
-        final double percentage = (TYPE_BLUETOOTH_USAGE / TOTAL_POWER) * DISCHARGE_AMOUNT;
-        mPowerUsageAdvanced.updateUsageDataSummary(mPowerUsageData, TOTAL_POWER, DISCHARGE_AMOUNT);
-
-        verify(mPowerUsageAdvanced).getString(eq(R.string.battery_used_by),
-                eq(Utils.formatPercentage(percentage, true)), any());
-    }
-
-    @Test
-    public void testFindBatterySipperWithMaxBatteryUsage_findCorrectOne() {
-        mPowerUsageData.usageList.add(mNormalBatterySipper);
-        mPowerUsageData.usageList.add(mMaxBatterySipper);
-        BatterySipper sipper =
-            mPowerUsageAdvanced.findBatterySipperWithMaxBatteryUsage(mPowerUsageData.usageList);
-
-        assertThat(sipper).isEqualTo(mMaxBatterySipper);
-    }
-
-    @Test
-    public void testInit_ContainsAllUsageType() {
-        final int[] usageTypeSet = mPowerUsageAdvanced.mUsageTypes;
-
-        assertThat(usageTypeSet).asList().containsExactly(UsageType.APP, UsageType.WIFI,
-                UsageType.CELL, UsageType.BLUETOOTH, UsageType.IDLE, UsageType.USER,
-                UsageType.SYSTEM, UsageType.UNACCOUNTED, UsageType.OVERCOUNTED);
-    }
-
-    @Test
-    public void testPowerUsageData_SortedByUsage() {
-        List<PowerUsageData> dataList = new ArrayList<>();
-
-        dataList.add(new PowerUsageData(UsageType.WIFI, TYPE_WIFI_USAGE));
-        dataList.add(new PowerUsageData(UsageType.BLUETOOTH, TYPE_BLUETOOTH_USAGE));
-        dataList.add(new PowerUsageData(UsageType.APP, TYPE_APP_USAGE));
-        Collections.sort(dataList);
-
-        for (int i = 1, size = dataList.size(); i < size; i++) {
-            assertThat(dataList.get(i - 1).totalPowerMah).isAtLeast(dataList.get(i).totalPowerMah);
-        }
-    }
-
-    @Test
-    public void testShouldHideCategory_typeUnAccounted_returnTrue() {
-        mPowerUsageData.usageType = UsageType.UNACCOUNTED;
-
-        assertThat(mPowerUsageAdvanced.shouldHideCategory(mPowerUsageData)).isTrue();
-    }
-
-    @Test
-    public void testShouldHideCategory_typeOverCounted_returnTrue() {
-        mPowerUsageData.usageType = UsageType.OVERCOUNTED;
-
-        assertThat(mPowerUsageAdvanced.shouldHideCategory(mPowerUsageData)).isTrue();
-    }
-
-    @Test
-    public void testShouldHideCategory_typeUserAndOnlyOneNormalUser_returnTrue() {
-        mPowerUsageData.usageType = UsageType.USER;
-        List<UserInfo> userInfos = new ArrayList<>();
-        userInfos.add(mNormalUserInfo);
-        userInfos.add(mManagedUserInfo);
-        doReturn(userInfos).when(mUserManager).getUsers();
-
-        assertThat(mPowerUsageAdvanced.shouldHideCategory(mPowerUsageData)).isTrue();
-    }
-
-    @Test
-    public void testShouldHideCategory_typeCellWhileNotSupported_returnTrue() {
-        mPowerUsageData.usageType = UsageType.CELL;
-        doReturn(false).when(mConnectivityManager)
-            .isNetworkSupported(ConnectivityManager.TYPE_MOBILE);
-
-        assertThat(mPowerUsageAdvanced.shouldHideCategory(mPowerUsageData)).isTrue();
-    }
-
-    @Test
-    public void testShouldHideCategory_typeCellWhileSupported_returnFalse() {
-        mPowerUsageData.usageType = UsageType.CELL;
-        doReturn(true).when(mConnectivityManager).isNetworkSupported(
-                ConnectivityManager.TYPE_MOBILE);
-
-        assertThat(mPowerUsageAdvanced.shouldHideCategory(mPowerUsageData)).isFalse();
-    }
-
-    @Test
-    public void testShouldHideCategory_typeUserAndMoreThanOne_returnFalse() {
-        mPowerUsageData.usageType = UsageType.USER;
-        List<UserInfo> userInfos = new ArrayList<>();
-        userInfos.add(mNormalUserInfo);
-        userInfos.add(mNormalUserInfo);
-        doReturn(userInfos).when(mUserManager).getUsers();
-
-        assertThat(mPowerUsageAdvanced.shouldHideCategory(mPowerUsageData)).isFalse();
-    }
-
-    @Test
-    public void testShouldHideCategory_typeNormal_returnFalse() {
-        mPowerUsageData.usageType = UsageType.APP;
-
-        assertThat(mPowerUsageAdvanced.shouldHideCategory(mPowerUsageData)).isFalse();
-    }
-
-    @Test
-    public void testShouldHideSummary_typeCell_returnTrue() {
-        mPowerUsageData.usageType = UsageType.CELL;
-
-        assertThat(mPowerUsageAdvanced.shouldHideSummary(mPowerUsageData)).isTrue();
-    }
-
-    @Test
-    public void testShouldHideSummary_typeSystem_returnTrue() {
-        mPowerUsageData.usageType = UsageType.SYSTEM;
-
-        assertThat(mPowerUsageAdvanced.shouldHideSummary(mPowerUsageData)).isTrue();
-    }
-
-    @Test
-    public void testShouldHideSummary_typeWifi_returnTrue() {
-        mPowerUsageData.usageType = UsageType.WIFI;
-
-        assertThat(mPowerUsageAdvanced.shouldHideSummary(mPowerUsageData)).isTrue();
-    }
-
-    @Test
-    public void testShouldHideSummary_typeBluetooth_returnTrue() {
-        mPowerUsageData.usageType = UsageType.BLUETOOTH;
-
-        assertThat(mPowerUsageAdvanced.shouldHideSummary(mPowerUsageData)).isTrue();
-    }
-
-    @Test
-    public void testShouldHideSummary_typeApp_returnTrue() {
-        mPowerUsageData.usageType = UsageType.APP;
-
-        assertThat(mPowerUsageAdvanced.shouldHideSummary(mPowerUsageData)).isTrue();
-    }
-
-    @Test
-    public void testShouldHideSummary_typeNormal_returnFalse() {
-        mPowerUsageData.usageType = UsageType.IDLE;
-
-        assertThat(mPowerUsageAdvanced.shouldHideSummary(mPowerUsageData)).isFalse();
-    }
-
-    @Test
-    public void testShouldShowBatterySipper_typeScreen_returnFalse() {
-        mNormalBatterySipper.drainType = DrainType.SCREEN;
-
-        assertThat(mPowerUsageAdvanced.shouldShowBatterySipper(mNormalBatterySipper)).isFalse();
-    }
-
-    @Test
-    public void testShouldShowBatterySipper_typeNormal_returnTrue() {
-        mNormalBatterySipper.drainType = DrainType.APP;
-
-        assertThat(mPowerUsageAdvanced.shouldShowBatterySipper(mNormalBatterySipper)).isTrue();
-    }
-
-    @Test
-    public void testCalculateHiddenPower_returnCorrectPower() {
-        List<PowerUsageData> powerUsageDataList = new ArrayList<>();
-        final double unaccountedPower = 100;
-        final double normalPower = 150;
-        powerUsageDataList.add(new PowerUsageData(UsageType.UNACCOUNTED, unaccountedPower));
-        powerUsageDataList.add(new PowerUsageData(UsageType.APP, normalPower));
-        powerUsageDataList.add(new PowerUsageData(UsageType.CELL, normalPower));
-
-        assertThat(mPowerUsageAdvanced.calculateHiddenPower(powerUsageDataList))
-            .isWithin(PRECISION).of(unaccountedPower);
-    }
-
-    @Test
-    public void testRefreshUi_addsSubtextWhenAppropriate() {
-        // Mock out all the battery stuff
-        mPowerUsageAdvanced.mHistPref = mHistPref;
-        mPowerUsageAdvanced.mStatsHelper = mBatteryStatsHelper;
-        doReturn(new ArrayList<PowerUsageData>())
-                .when(mPowerUsageAdvanced).parsePowerUsageData(any());
-        doReturn("").when(mPowerUsageAdvanced).getString(anyInt());
-        mPowerUsageAdvanced.mUsageListGroup = mUsageListGroup;
-
-        // refresh the ui and check that text was not updated when enhanced prediction disabled
-        when(mPowerUsageFeatureProvider.isEnhancedBatteryPredictionEnabled(any()))
-                .thenReturn(false);
-        mPowerUsageAdvanced.refreshUi();
-        verify(mHistPref, never()).setBottomSummary(any());
-
-        // refresh the ui and check that text was updated when enhanced prediction enabled
-        when(mPowerUsageFeatureProvider.isEnhancedBatteryPredictionEnabled(any())).thenReturn(true);
-        mPowerUsageAdvanced.refreshUi();
-        verify(mHistPref, atLeastOnce()).setBottomSummary(any());
+        verify(mMenu).add(Menu.NONE, PowerUsageAdvanced.MENU_TOGGLE_APPS, Menu.NONE,
+                R.string.show_all_apps);
     }
 }
diff --git a/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImplTest.java b/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImplTest.java
index f37d607..70acb73 100644
--- a/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImplTest.java
+++ b/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImplTest.java
@@ -136,4 +136,9 @@
     public void testIsPowerAccountingToggleEnabled_returnTrue() {
         assertThat(mPowerFeatureProvider.isPowerAccountingToggleEnabled()).isTrue();
     }
+
+    @Test
+    public void testIsSmartBatterySupported_returnFalse() {
+        assertThat(mPowerFeatureProvider.isSmartBatterySupported()).isFalse();
+    }
 }
diff --git a/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageSummaryTest.java b/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageSummaryTest.java
index 7f6e39d..6176bef 100644
--- a/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageSummaryTest.java
+++ b/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageSummaryTest.java
@@ -15,6 +15,8 @@
  */
 package com.android.settings.fuelgauge;
 
+import static com.android.settings.fuelgauge.PowerUsageSummary.MENU_ADVANCED_BATTERY;
+
 import static com.google.common.truth.Truth.assertThat;
 import static org.mockito.Matchers.any;
 import static org.mockito.Matchers.anyInt;
@@ -35,6 +37,8 @@
 import android.content.Intent;
 import android.os.Bundle;
 import android.util.SparseArray;
+import android.view.Menu;
+import android.view.MenuInflater;
 import android.view.MenuItem;
 import android.view.View;
 import android.widget.TextView;
@@ -53,7 +57,6 @@
 
 import org.junit.Before;
 import org.junit.BeforeClass;
-import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Answers;
@@ -114,6 +117,12 @@
     private LoaderManager mLoaderManager;
     @Mock
     private BatteryHeaderPreferenceController mBatteryHeaderPreferenceController;
+    @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+    private Menu mMenu;
+    @Mock
+    private MenuInflater mMenuInflater;
+    @Mock
+    private MenuItem mAdvancedPageMenu;
 
     private List<BatterySipper> mUsageList;
     private Context mRealContext;
@@ -122,12 +131,13 @@
     private BatteryMeterView mBatteryMeterView;
     private PowerGaugePreference mScreenUsagePref;
     private PowerGaugePreference mLastFullChargePref;
+    private Intent mIntent;
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
 
-        mRealContext = RuntimeEnvironment.application;
+        mRealContext = spy(RuntimeEnvironment.application);
         mFeatureFactory = FakeFeatureFactory.setupForTest();
         mScreenUsagePref = new PowerGaugePreference(mRealContext);
         mLastFullChargePref = new PowerGaugePreference(mRealContext);
@@ -137,6 +147,7 @@
         mBatteryMeterView.mDrawable = new BatteryMeterView.BatteryMeterDrawable(mRealContext, 0);
         doNothing().when(mFragment).restartBatteryStatsLoader();
         doReturn(mock(LoaderManager.class)).when(mFragment).getLoaderManager();
+        doReturn(MENU_ADVANCED_BATTERY).when(mAdvancedPageMenu).getItemId();
 
         when(mFragment.getActivity()).thenReturn(mSettingsActivity);
         when(mFeatureFactory.powerUsageFeatureProvider.getAdditionalBatteryInfoIntent())
@@ -294,6 +305,35 @@
         verify(mBatteryHeaderPreferenceController, never()).quickUpdateHeaderPreference();
     }
 
+    @Test
+    public void testOptionsMenu_advancedPageEnabled() {
+        when(mFeatureFactory.powerUsageFeatureProvider.isPowerAccountingToggleEnabled())
+                .thenReturn(true);
+
+        mFragment.onCreateOptionsMenu(mMenu, mMenuInflater);
+
+        verify(mMenu).add(Menu.NONE, MENU_ADVANCED_BATTERY, Menu.NONE,
+                R.string.advanced_battery_title);
+    }
+
+    @Test
+    public void testOptionsMenu_clickAdvancedPage_fireIntent() {
+        final ArgumentCaptor<Intent> captor = ArgumentCaptor.forClass(Intent.class);
+        doAnswer(invocation -> {
+            // Get the intent in which it has the app info bundle
+            mIntent = captor.getValue();
+            return true;
+        }).when(mRealContext).startActivity(captor.capture());
+
+        mFragment.onOptionsItemSelected(mAdvancedPageMenu);
+
+        assertThat(mIntent.getStringExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT)).isEqualTo(
+                PowerUsageAdvanced.class.getName());
+        assertThat(
+                mIntent.getIntExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_TITLE_RESID, 0)).isEqualTo(
+                R.string.advanced_battery_title);
+    }
+
     public static class TestFragment extends PowerUsageSummary {
         private Context mContext;
 
diff --git a/tests/robotests/src/com/android/settings/fuelgauge/SmartBatteryPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/fuelgauge/SmartBatteryPreferenceControllerTest.java
index 494d563..fbbc6f9 100644
--- a/tests/robotests/src/com/android/settings/fuelgauge/SmartBatteryPreferenceControllerTest.java
+++ b/tests/robotests/src/com/android/settings/fuelgauge/SmartBatteryPreferenceControllerTest.java
@@ -18,10 +18,16 @@
 
 import static com.google.common.truth.Truth.assertThat;
 
+import static org.mockito.Mockito.doReturn;
+
 import android.content.ContentResolver;
+import android.content.Context;
 import android.provider.Settings;
 import android.support.v14.preference.SwitchPreference;
 
+import com.android.settings.core.BasePreferenceController;
+import com.android.settings.testutils.FakeFeatureFactory;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -38,11 +44,15 @@
     private SmartBatteryPreferenceController mController;
     private SwitchPreference mPreference;
     private ContentResolver mContentResolver;
+    private Context mContext;
+    private FakeFeatureFactory mFeatureFactory;
+
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
 
+        mFeatureFactory = FakeFeatureFactory.setupForTest();
         mContentResolver = RuntimeEnvironment.application.getContentResolver();
         mController = new SmartBatteryPreferenceController(RuntimeEnvironment.application);
         mPreference = new SwitchPreference(RuntimeEnvironment.application);
@@ -80,6 +90,22 @@
         assertThat(getSmartBatteryValue()).isEqualTo(OFF);
     }
 
+    @Test
+    public void testGetAvailabilityStatus_smartBatterySupported_returnAvailable() {
+        doReturn(true).when(mFeatureFactory.powerUsageFeatureProvider).isSmartBatterySupported();
+
+        assertThat(mController.getAvailabilityStatus()).isEqualTo(
+                BasePreferenceController.AVAILABLE);
+    }
+
+    @Test
+    public void testGetAvailabilityStatus_smartBatteryUnSupported_returnDisabled() {
+        doReturn(false).when(mFeatureFactory.powerUsageFeatureProvider).isSmartBatterySupported();
+
+        assertThat(mController.getAvailabilityStatus()).isEqualTo(
+                BasePreferenceController.DISABLED_UNSUPPORTED);
+    }
+
     private void putSmartBatteryValue(int value) {
         Settings.Global.putInt(mContentResolver, Settings.Global.APP_STANDBY_ENABLED, value);
     }
diff --git a/tests/robotests/src/com/android/settings/fuelgauge/batterytip/AppInfoTest.java b/tests/robotests/src/com/android/settings/fuelgauge/batterytip/AppInfoTest.java
index 155351a..b140c4c 100644
--- a/tests/robotests/src/com/android/settings/fuelgauge/batterytip/AppInfoTest.java
+++ b/tests/robotests/src/com/android/settings/fuelgauge/batterytip/AppInfoTest.java
@@ -38,6 +38,7 @@
     private static final String PACKAGE_NAME = "com.android.app";
     private static final int ANOMALY_TYPE = Anomaly.AnomalyType.WAKE_LOCK;
     private static final long SCREEN_TIME_MS = DateUtils.HOUR_IN_MILLIS;
+    private static final int UID = 3452;
 
     private AppInfo mAppInfo;
 
@@ -47,6 +48,7 @@
                 .setPackageName(PACKAGE_NAME)
                 .setAnomalyType(ANOMALY_TYPE)
                 .setScreenOnTimeMs(SCREEN_TIME_MS)
+                .setUid(UID)
                 .build();
     }
 
@@ -61,6 +63,7 @@
         assertThat(appInfo.packageName).isEqualTo(PACKAGE_NAME);
         assertThat(appInfo.anomalyType).isEqualTo(ANOMALY_TYPE);
         assertThat(appInfo.screenOnTimeMs).isEqualTo(SCREEN_TIME_MS);
+        assertThat(appInfo.uid).isEqualTo(UID);
     }
 
     @Test
@@ -84,5 +87,6 @@
         assertThat(mAppInfo.packageName).isEqualTo(PACKAGE_NAME);
         assertThat(mAppInfo.anomalyType).isEqualTo(ANOMALY_TYPE);
         assertThat(mAppInfo.screenOnTimeMs).isEqualTo(SCREEN_TIME_MS);
+        assertThat(mAppInfo.uid).isEqualTo(UID);
     }
 }
diff --git a/tests/robotests/src/com/android/settings/notification/ZenModeMediaPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/notification/ZenModeMediaPreferenceControllerTest.java
index db0a2e9..db828a2 100644
--- a/tests/robotests/src/com/android/settings/notification/ZenModeMediaPreferenceControllerTest.java
+++ b/tests/robotests/src/com/android/settings/notification/ZenModeMediaPreferenceControllerTest.java
@@ -46,10 +46,7 @@
 
 @RunWith(SettingsRobolectricTestRunner.class)
 public class ZenModeMediaPreferenceControllerTest {
-
-    private static final boolean MEDIA_SETTINGS = true;
-
-    private ZenModeMediaSystemOtherPreferenceController mController;
+    private ZenModeMediaPreferenceController mController;
 
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private Context mContext;
@@ -75,7 +72,7 @@
         mContentResolver = RuntimeEnvironment.application.getContentResolver();
         when(mNotificationManager.getNotificationPolicy()).thenReturn(mPolicy);
 
-        mController = new ZenModeMediaSystemOtherPreferenceController(mContext,
+        mController = new ZenModeMediaPreferenceController(mContext,
                 mock(Lifecycle.class));
         ReflectionHelpers.setField(mController, "mBackend", mBackend);
 
@@ -111,13 +108,13 @@
         Settings.Global.putInt(mContentResolver, ZEN_MODE, ZEN_MODE_IMPORTANT_INTERRUPTIONS);
 
         when(mBackend.isPriorityCategoryEnabled(
-                NotificationManager.Policy.PRIORITY_CATEGORY_MEDIA_SYSTEM_OTHER)).
-                thenReturn(MEDIA_SETTINGS);
+                NotificationManager.Policy.PRIORITY_CATEGORY_MEDIA)).
+                thenReturn(true);
 
         mController.updateState(mockPref);
 
         verify(mockPref).setEnabled(true);
-        verify(mockPref).setChecked(MEDIA_SETTINGS);
+        verify(mockPref).setChecked(true);
     }
 
     @Test
@@ -126,7 +123,7 @@
         mController.onPreferenceChange(mockPref, allow);
 
         verify(mBackend).saveSoundPolicy(
-                NotificationManager.Policy.PRIORITY_CATEGORY_MEDIA_SYSTEM_OTHER, allow);
+                NotificationManager.Policy.PRIORITY_CATEGORY_MEDIA, allow);
     }
 
     @Test
@@ -135,6 +132,6 @@
         mController.onPreferenceChange(mockPref, allow);
 
         verify(mBackend).saveSoundPolicy(
-                NotificationManager.Policy.PRIORITY_CATEGORY_MEDIA_SYSTEM_OTHER, allow);
+                NotificationManager.Policy.PRIORITY_CATEGORY_MEDIA, allow);
     }
 }
\ No newline at end of file
diff --git a/tests/robotests/src/com/android/settings/notification/ZenModeSettingsTest.java b/tests/robotests/src/com/android/settings/notification/ZenModeSettingsTest.java
index 66b11a6..5c81efc 100644
--- a/tests/robotests/src/com/android/settings/notification/ZenModeSettingsTest.java
+++ b/tests/robotests/src/com/android/settings/notification/ZenModeSettingsTest.java
@@ -52,7 +52,7 @@
                 NotificationManager.Policy.PRIORITY_CATEGORY_EVENTS
                         | NotificationManager.Policy.PRIORITY_CATEGORY_REMINDERS
                         | NotificationManager.Policy.PRIORITY_CATEGORY_ALARMS
-                        | NotificationManager.Policy.PRIORITY_CATEGORY_MEDIA_SYSTEM_OTHER,
+                        | NotificationManager.Policy.PRIORITY_CATEGORY_MEDIA,
                 0, 0);
         final String result = mBuilder.getBehaviorSettingSummary(policy,
                 Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS);
@@ -75,7 +75,7 @@
     public void testGetBehaviorSettingSummary_alarmsAndMedia() {
         NotificationManager.Policy policy = new NotificationManager.Policy(
                         NotificationManager.Policy.PRIORITY_CATEGORY_ALARMS
-                        | NotificationManager.Policy.PRIORITY_CATEGORY_MEDIA_SYSTEM_OTHER,
+                        | NotificationManager.Policy.PRIORITY_CATEGORY_MEDIA,
                 0, 0);
         final String result = mBuilder.getBehaviorSettingSummary(policy,
                 Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS);
diff --git a/tests/robotests/src/com/android/settings/notification/ZenModeSystemPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/notification/ZenModeSystemPreferenceControllerTest.java
new file mode 100644
index 0000000..46dfc69
--- /dev/null
+++ b/tests/robotests/src/com/android/settings/notification/ZenModeSystemPreferenceControllerTest.java
@@ -0,0 +1,135 @@
+/*
+ * 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.notification;
+
+import static android.provider.Settings.Global.ZEN_MODE;
+import static android.provider.Settings.Global.ZEN_MODE_ALARMS;
+import static android.provider.Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS;
+import static android.provider.Settings.Global.ZEN_MODE_NO_INTERRUPTIONS;
+
+import static junit.framework.Assert.assertEquals;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.app.NotificationManager;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.provider.Settings;
+import android.support.v14.preference.SwitchPreference;
+import android.support.v7.preference.PreferenceScreen;
+
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+import com.android.settingslib.core.lifecycle.Lifecycle;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.annotation.Config;
+import org.robolectric.shadows.ShadowApplication;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.util.ReflectionHelpers;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+public class ZenModeSystemPreferenceControllerTest {
+    private ZenModeSystemPreferenceController mController;
+
+    @Mock
+    private ZenModeBackend mBackend;
+    @Mock
+    private NotificationManager mNotificationManager;
+    @Mock
+    private SwitchPreference mockPref;
+    @Mock
+    private NotificationManager.Policy mPolicy;
+    @Mock
+    private PreferenceScreen mPreferenceScreen;
+
+    private Context mContext;
+    private ContentResolver mContentResolver;
+
+    @Before
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+        ShadowApplication shadowApplication = ShadowApplication.getInstance();
+        shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNotificationManager);
+
+        mContext = shadowApplication.getApplicationContext();
+        mContentResolver = RuntimeEnvironment.application.getContentResolver();
+        when(mNotificationManager.getNotificationPolicy()).thenReturn(mPolicy);
+        mController = new ZenModeSystemPreferenceController(mContext, mock(Lifecycle.class));
+        ReflectionHelpers.setField(mController, "mBackend", mBackend);
+
+        when(mPreferenceScreen.findPreference(mController.getPreferenceKey())).thenReturn(
+                mockPref);
+        mController.displayPreference(mPreferenceScreen);
+    }
+
+    @Test
+    public void updateState_TotalSilence() {
+        Settings.Global.putInt(mContentResolver, ZEN_MODE, ZEN_MODE_NO_INTERRUPTIONS);
+
+        final SwitchPreference mockPref = mock(SwitchPreference.class);
+        mController.updateState(mockPref);
+
+        verify(mockPref).setEnabled(false);
+        verify(mockPref).setChecked(false);
+    }
+
+    @Test
+    public void updateState_AlarmsOnly() {
+        Settings.Global.putInt(mContentResolver, ZEN_MODE, ZEN_MODE_ALARMS);
+
+        final SwitchPreference mockPref = mock(SwitchPreference.class);
+        mController.updateState(mockPref);
+
+        verify(mockPref).setEnabled(false);
+        verify(mockPref).setChecked(false);
+    }
+
+    @Test
+    public void updateState_Priority() {
+        Settings.Global.putInt(mContentResolver, ZEN_MODE, ZEN_MODE_IMPORTANT_INTERRUPTIONS);
+
+        when(mBackend.isPriorityCategoryEnabled(
+                NotificationManager.Policy.PRIORITY_CATEGORY_SYSTEM)).thenReturn(true);
+
+        mController.updateState(mockPref);
+
+        verify(mockPref).setEnabled(true);
+        verify(mockPref).setChecked(true);
+    }
+
+    @Test
+    public void onPreferenceChanged_EnableSystem() {
+        mController.onPreferenceChange(mockPref, true);
+
+        verify(mBackend).saveSoundPolicy(NotificationManager.Policy.PRIORITY_CATEGORY_SYSTEM,
+                true);
+    }
+
+    @Test
+    public void onPreferenceChanged_DisableSystem() {
+        mController.onPreferenceChange(mockPref, false);
+
+        verify(mBackend).saveSoundPolicy(NotificationManager.Policy.PRIORITY_CATEGORY_SYSTEM,
+                false);
+    }
+}
\ No newline at end of file
diff --git a/tests/uitests/src/com/android/settings/ui/ZonePickerSettingsTest.java b/tests/uitests/src/com/android/settings/ui/ZonePickerSettingsTest.java
index 109c3bc..30206bc 100644
--- a/tests/uitests/src/com/android/settings/ui/ZonePickerSettingsTest.java
+++ b/tests/uitests/src/com/android/settings/ui/ZonePickerSettingsTest.java
@@ -32,8 +32,6 @@
 import android.support.test.uiautomator.Until;
 import android.system.helpers.SettingsHelper;
 import android.system.helpers.SettingsHelper.SettingsType;
-import android.widget.ListView;
-import android.widget.Spinner;
 
 import org.junit.After;
 import org.junit.Before;
@@ -102,16 +100,16 @@
     // Test 2 time zones with no DST
     @Test
     public void testSelectReykjavik() throws Exception {
-        testSelectTimeZone("Iceland", "Reykjavik", "GMT+00:00", "Atlantic/Reykjavik");
+        testSelectTimeZone("Iceland", "Reykjavik", "GMT+00:00", "Atlantic/Reykjavik", true);
     }
 
     @Test
     public void testSelectPhoenix() throws Exception {
-        testSelectTimeZone("United States", "Phoenix", "GMT-07:00", "America/Phoenix");
+        testSelectTimeZone("United States", "Phoenix", "GMT-07:00", "America/Phoenix", false);
     }
 
     private void testSelectTimeZone(String region, String timezone, String expectedTimeZoneOffset,
-            String expectedTimeZoneId) throws Exception {
+            String expectedTimeZoneId, boolean assumeOneTimeZoneInRegion) throws Exception {
         mHelper.setIntSetting(SettingsType.GLOBAL, Settings.Global.AUTO_TIME_ZONE, 0);
 
         SettingsHelper.launchSettingsPage(
@@ -121,16 +119,21 @@
         assertTrue(selectTimeZone.isEnabled());
         selectTimeZone.click();
 
-        // Select region in the dropdown list
-        selectScrollableItem(selectDropDownInSpinner(By.clazz(Spinner.class)),
-                new UiSelector().textContains(region))
+        wait(By.text("Region")).click();
+        // Speed-up the test by searching with the first 2 characters of the region name
+        wait(By.res("android", "search_src_text")).setText(region.substring(0, 2));
+        // Select region in the list
+        selectItemInList(new UiSelector().textContains(region))
                 .click();
 
-        // Select time zone
-        selectScrollableItem(selectTimeZoneList(),
-                new UiSelector().textContains(timezone))
-                .click();
+        // Only select time zone explicitly if there are more than one time zones in a region
+        if (!assumeOneTimeZoneInRegion) {
+            wait(By.text("Time Zone"));
+            selectItemInList(new UiSelector().textContains(timezone))
+                    .click();
+        }
 
+        mDevice.pressBack();
         // The select button should include the GMT offset in the summary
         BySelector summarySelector = By.res("android:id/summary");
         UiObject2 selectedTimeZone = selectTimeZone.findObject(summarySelector);
@@ -162,21 +165,10 @@
         assertEquals(expectedTimeZoneId, TimeZone.getDefault().getID());
     }
 
-    /**
-     * Perform click on {@link Spinner} and return the pop-up dropdown list.
-     * @return UiScrollable representing the pop-up dropdown after clicking on the spinner
-     */
-    private UiScrollable selectDropDownInSpinner(BySelector spinnerSelector)
-            throws UiObjectNotFoundException {
-        UiObject2 spinner = wait(spinnerSelector);
-        spinner.click();
-
-        UiSelector dropDownSelector = new UiSelector().className(ListView.class);
-        return new UiScrollable(dropDownSelector);
-    }
-
-    private UiScrollable selectTimeZoneList() {
-        return new UiScrollable(new UiSelector().resourceId(SETTINGS_PACKAGE + ":id/tz_list"));
+    private UiObject selectItemInList(UiSelector childSelector) throws UiObjectNotFoundException {
+        UiScrollable recyclerView = new UiScrollable(
+                new UiSelector().resourceId(SETTINGS_PACKAGE + ":id/recycler_view"));
+        return selectScrollableItem(recyclerView, childSelector);
     }
 
     /**