diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index 01aa181..0f4072c 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -64,15 +64,8 @@
         <activity
             android:name=".common.CarSettingActivity"
             android:label="@string/settings_label"
-            android:launchMode="singleTop"
-            android:windowSoftInputMode="adjustPan">
-        </activity>
-
-        <activity
-            android:name=".quicksettings.QuickSettingActivity"
-            android:theme="@style/CarQuickSettingTheme"
-            android:label="@string/settings_label"
             android:launchMode="singleTask"
+            android:windowSoftInputMode="adjustPan"
             android:exported="true">
             <!-- Set priority high enough to trump the phone setting app -->
             <!-- TODO: once phone setting is removed from car system image, set priority to 1 -->
diff --git a/res/color/toggle_bg.xml b/res/color/toggle_bg.xml
new file mode 100644
index 0000000..f48f216
--- /dev/null
+++ b/res/color/toggle_bg.xml
@@ -0,0 +1,24 @@
+<?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.
+-->
+
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+  <item android:state_enabled="false"
+      android:color="@color/toggle_bg_disabled"/>
+  <item android:state_enabled="true"
+      android:color="@color/car_accent"/>
+  <item android:color="@color/car_accent"/>
+</selector>
\ No newline at end of file
diff --git a/res/color/toggle_icon_tint.xml b/res/color/toggle_icon_tint.xml
new file mode 100644
index 0000000..41388ba
--- /dev/null
+++ b/res/color/toggle_icon_tint.xml
@@ -0,0 +1,24 @@
+<?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.
+-->
+
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+  <item android:state_enabled="false"
+      android:color="@color/toggle_icon_disabled"/>
+  <item android:state_enabled="true"
+      android:color="@color/car_card"/>
+  <item android:color="@color/car_card"/>
+</selector>
\ No newline at end of file
diff --git a/res/drawable/button_ripple_bg.xml b/res/drawable/button_ripple_bg.xml
index 7565c69..c9c4cf8 100644
--- a/res/drawable/button_ripple_bg.xml
+++ b/res/drawable/button_ripple_bg.xml
@@ -16,5 +16,6 @@
 -->
 
 <ripple xmlns:android="http://schemas.android.com/apk/res/android"
-        android:color="@color/car_card_ripple_background">
+        android:color="@color/car_card_ripple_background"
+        android:radius="@dimen/toggle_ripple">
 </ripple>
diff --git a/res/drawable/circle_bg.xml b/res/drawable/circle_bg.xml
index b002eba..5fc37ad 100644
--- a/res/drawable/circle_bg.xml
+++ b/res/drawable/circle_bg.xml
@@ -20,7 +20,7 @@
     android:shape="oval">
 
   <solid
-      android:color="@color/car_accent"/>
+      android:color="@color/toggle_bg"/>
 
   <size
       android:width="@dimen/car_touch_target_size"
diff --git a/res/drawable/ic_brightness_knob.xml b/res/drawable/ic_brightness_knob.xml
new file mode 100644
index 0000000..a6f2026
--- /dev/null
+++ b/res/drawable/ic_brightness_knob.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+        android:width="30dp"
+        android:height="30dp"
+        android:viewportWidth="24.0"
+        android:viewportHeight="24.0">
+    <path
+        android:pathData="M20,8.69L20,4h-4.69L12,0.69 8.69,4L4,4v4.69L0.69,12 4,15.31L4,20h4.69L12,23.31 15.31,20L20,20v-4.69L23.31,12 20,8.69zM12,18c-3.31,0 -6,-2.69 -6,-6s2.69,-6 6,-6 6,2.69 6,6 -2.69,6 -6,6zM12,8c-2.21,0 -4,1.79 -4,4s1.79,4 4,4 4,-1.79 4,-4 -1.79,-4 -4,-4z"
+        android:fillColor="@color/car_accent"/>
+</vector>
diff --git a/res/layout/action_bar_quick_settings.xml b/res/layout/action_bar_quick_settings.xml
index 88856dd..7b3ba20 100644
--- a/res/layout/action_bar_quick_settings.xml
+++ b/res/layout/action_bar_quick_settings.xml
@@ -18,7 +18,8 @@
 <RelativeLayout
     xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_width="match_parent"
-    android:layout_height="@dimen/car_app_bar_height">
+    android:layout_height="@dimen/car_app_bar_height"
+    android:layout_gravity="top">
 
     <FrameLayout
         android:id="@+id/action_bar_icon_container"
@@ -39,7 +40,6 @@
         android:layout_height="match_parent"
         android:layout_marginEnd="@dimen/car_keyline_1"
         android:layout_toEndOf="@id/action_bar_icon_container"
-        android:text="@string/settings_label"
         android:gravity="center_vertical"
         android:textAppearance="@style/TextAppearance.Car.Title2"
         android:textColor="@color/car_accent"/>
@@ -58,17 +58,21 @@
             android:layout_height="wrap_content"
             android:layout_gravity="center_vertical"
             android:layout_marginEnd="@dimen/car_padding_4"
+            android:background="@drawable/button_ripple_bg"
             style="@style/Widget.Car.Settings.ActionBar.Button.Borderless.Colored"
             android:orientation="horizontal">
             <ImageView
                 android:id="@+id/user_icon"
                 android:src="@drawable/ic_user"
-                style="@style/ListIcon"/>
+                android:background="@null"
+                style="@style/ListIcon.ActionBar"/>
             <TextView
                 android:id="@+id/user_switcher_text"
                 android:layout_width="wrap_content"
                 android:layout_height="wrap_content"
                 android:layout_gravity="center_vertical"
+                android:background="@null"
+                android:textColor="@color/car_accent"
                 android:textAppearance="@style/TextAppearance.Car.Label1"
                 android:layout_marginStart="@dimen/car_padding_2"
                 android:layout_marginEnd="@dimen/car_padding_2"/>
@@ -79,24 +83,23 @@
             android:layout_height="wrap_content"
             android:layout_gravity="center_vertical"
             android:layout_marginEnd="@dimen/car_padding_4"
+            android:background="@drawable/button_ripple_bg"
             style="@style/Widget.Car.Settings.ActionBar.Button.Borderless.Colored"
             android:orientation="horizontal">
             <ImageView
                 android:src="@drawable/ic_settings_gear"
-                style="@style/ListIcon"/>
+                android:background="@null"
+                style="@style/ListIcon.ActionBar"/>
             <TextView
                 android:layout_width="wrap_content"
                 android:layout_height="wrap_content"
                 android:layout_gravity="center_vertical"
                 android:text="@string/more_settings_label"
+                android:textColor="@color/car_accent"
                 android:textAppearance="@style/TextAppearance.Car.Label1"
+                android:background="@null"
                 android:layout_marginStart="@dimen/car_padding_2"
                 android:layout_marginEnd="@dimen/car_padding_2"/>
         </LinearLayout>
     </LinearLayout>
-    <View
-        android:layout_alignParentBottom="true"
-        android:background="@color/car_list_divider"
-        android:layout_width="match_parent"
-        android:layout_height="@dimen/car_list_divider_height" />
 </RelativeLayout>
diff --git a/res/layout/brightness_tile.xml b/res/layout/brightness_tile.xml
index 6ca3349..57f7a71 100644
--- a/res/layout/brightness_tile.xml
+++ b/res/layout/brightness_tile.xml
@@ -20,6 +20,7 @@
     android:id="@+id/seekbar"
     android:progressDrawable="@drawable/ic_seekbar_track"
     android:layout_marginBottom="@dimen/car_padding_4"
-    android:thumb="@drawable/ic_seekbar_thumb"
+    android:thumb="@drawable/ic_brightness_knob"
+    android:splitTrack="false"
     android:layout_width="match_parent"
     android:layout_height="@dimen/car_single_line_list_item_height"/>
diff --git a/res/layout/quick_settings.xml b/res/layout/quick_settings.xml
index d9b26a5..08eee4f 100644
--- a/res/layout/quick_settings.xml
+++ b/res/layout/quick_settings.xml
@@ -15,23 +15,11 @@
   ~ limitations under the License
   -->
 
-<LinearLayout
+<androidx.car.widget.PagedListView
     xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:id="@+id/list"
     android:layout_width="match_parent"
-    android:layout_height="match_parent"
-    android:orientation="vertical"
-    android:id="@+id/container">
-    <android.support.v7.widget.Toolbar
-        android:id="@+id/toolbar"
-        android:layout_width="match_parent"
-        android:layout_height="@dimen/car_app_bar_height"
-        app:contentInsetStart="0dp"
-        style="@style/ActionBarStyle.Car" />
-    <androidx.car.widget.PagedListView
-        android:id="@+id/list"
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        app:showPagedListViewDivider="false"
-        style="@style/PagedList" />
-</LinearLayout>
\ No newline at end of file
+    android:layout_height="wrap_content"
+    app:showPagedListViewDivider="false"
+    style="@style/PagedList" />
\ No newline at end of file
diff --git a/res/layout/tile.xml b/res/layout/tile.xml
index 58e3b88..f05a739 100644
--- a/res/layout/tile.xml
+++ b/res/layout/tile.xml
@@ -15,38 +15,54 @@
   ~ limitations under the License
   -->
 
-<com.android.car.list.InterceptTouchRelativeLayout
+<LinearLayout
     xmlns:android="http://schemas.android.com/apk/res/android"
-    android:id="@+id/tile_container"
     android:padding="@dimen/toggle_padding"
     android:layout_marginStart="@dimen/car_padding_2"
     android:layout_marginEnd="@dimen/car_padding_2"
     android:layout_marginBottom="@dimen/car_padding_5"
     android:layout_width="match_parent"
-    android:layout_height="wrap_content">
+    android:layout_height="wrap_content"
+    android:gravity="center_horizontal"
+    android:orientation="vertical">
     <FrameLayout
         android:id="@+id/icon_container"
         android:layout_width="@dimen/car_touch_target_size"
         android:layout_height="@dimen/car_touch_target_size"
-        android:background="@drawable/circle_bg"
-        android:layout_centerHorizontal="true"
-        android:layout_marginBottom="@dimen/car_padding_4">
-        <ImageButton
+        android:background="@drawable/button_ripple_bg"
+        android:layout_marginBottom="@dimen/car_padding_4"
+        android:gravity="center">
+        <View
+            android:id="@+id/icon_background"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:background="@drawable/circle_bg"/>
+        <ImageView
             android:id="@+id/tile_icon"
             android:layout_width="@dimen/car_primary_icon_size"
             android:layout_height="@dimen/car_primary_icon_size"
             android:layout_gravity="center"
             android:src="@drawable/ic_settings_wifi"
-            android:tint="@color/car_card"
-            android:background="@null"
+            android:tint="@color/toggle_icon_tint"
             style="@style/ListIcon" />
     </FrameLayout>
-    <TextView
-        android:id="@+id/tile_text"
+    <LinearLayout
+        android:id="@+id/text_container"
         android:layout_height="wrap_content"
         android:layout_width="wrap_content"
-        android:paddingTop="@dimen/car_padding_1"
-        android:layout_centerHorizontal="true"
-        android:layout_below="@id/icon_container"
-        android:textAppearance="@style/TextAppearance.Car.Label1"/>
-</com.android.car.list.InterceptTouchRelativeLayout>
\ No newline at end of file
+        android:orientation="horizontal">
+        <TextView
+            android:id="@+id/tile_text"
+            android:layout_height="wrap_content"
+            android:layout_width="wrap_content"
+            android:textAppearance="@style/TextAppearance.Car.Label1"/>
+        <ImageView
+            android:id="@+id/deep_dive_icon"
+            android:layout_width="@dimen/car_primary_icon_size"
+            android:layout_height="@dimen/car_primary_icon_size"
+            android:src="@drawable/ic_arrow_drop_down"
+            android:tint="@color/car_label1"
+            android:layout_marginStart="@dimen/car_padding_1"
+            android:visibility="gone"/>
+    </LinearLayout>
+</LinearLayout>
\ No newline at end of file
diff --git a/res/values-night/colors.xml b/res/values-night/colors.xml
new file mode 100644
index 0000000..fa0d625
--- /dev/null
+++ b/res/values-night/colors.xml
@@ -0,0 +1,20 @@
+<?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.
+-->
+<resources>
+    <color name="toggle_bg_disabled">@color/car_grey_800</color>
+    <color name="toggle_icon_disabled">@color/car_grey_400</color>
+</resources>
\ No newline at end of file
diff --git a/res/values/colors.xml b/res/values/colors.xml
index d3ae5f0..047b1e0 100644
--- a/res/values/colors.xml
+++ b/res/values/colors.xml
@@ -16,4 +16,7 @@
 -->
 <resources>
     <color name="lock_pattern_background">#353839</color>
+
+    <color name="toggle_bg_disabled">@color/car_grey_400</color>
+    <color name="toggle_icon_disabled">@color/car_grey_800</color>
 </resources>
\ No newline at end of file
diff --git a/res/values/dimens.xml b/res/values/dimens.xml
index 23caf72..96e8cc6 100644
--- a/res/values/dimens.xml
+++ b/res/values/dimens.xml
@@ -38,5 +38,7 @@
     <dimen name="pin_pad_key_text_size">48sp</dimen>
 
     <dimen name="lockscreen_title_drawable_padding">5dp</dimen>
+
     <dimen name="toggle_padding">10dp</dimen>
+    <dimen name="toggle_ripple">90dp</dimen>
 </resources>
\ No newline at end of file
diff --git a/res/values/strings.xml b/res/values/strings.xml
index 9d90626..b45a89c 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -33,6 +33,8 @@
     <string name="keywords_display_brightness_level">dim screen, touchscreen, battery</string>
     <string name="keywords_display_auto_brightness">dim screen, touchscreen, battery</string>
     <string name="keywords_display_night_display">dim screen, night, tint</string>
+    <!-- Label for night mode toggle tile in quick setting [CHAR LIMIT=20] -->
+    <string name="night_mode_tile_label">Night mode</string>
 
     <!-- wifi settings--><skip />
     <!-- Used in the 1st-level settings screen to go to the 2nd-level settings screen  [CHAR LIMIT=20]-->
diff --git a/res/values/styles.xml b/res/values/styles.xml
index 53b26e5..465f4b2 100644
--- a/res/values/styles.xml
+++ b/res/values/styles.xml
@@ -48,6 +48,7 @@
     <style name="ListIcon.ActionBar" parent="ListIcon">
         <item name="android:tint">@color/car_accent</item>
         <item name="android:layout_gravity">center</item>
+        <item name="android:background">@drawable/button_ripple_bg</item>
         <item name="android:src">@drawable/ic_arrow_back</item>
     </style>
 
diff --git a/src/com/android/car/settings/common/BaseFragment.java b/src/com/android/car/settings/common/BaseFragment.java
index dd1931c..2639e68 100644
--- a/src/com/android/car/settings/common/BaseFragment.java
+++ b/src/com/android/car/settings/common/BaseFragment.java
@@ -16,6 +16,8 @@
 
 package com.android.car.settings.common;
 
+import android.annotation.NonNull;
+import android.car.drivingstate.CarUxRestrictions;
 import android.os.Bundle;
 import android.support.annotation.LayoutRes;
 import android.support.annotation.StringRes;
@@ -29,6 +31,7 @@
 import android.widget.TextView;
 
 import com.android.car.settings.R;
+import com.android.car.settings.quicksettings.QuickSettingFragment;
 
 import java.util.Set;
 
@@ -67,16 +70,54 @@
 
     protected FragmentController mFragmentController;
 
-    public void setFragmentController(FragmentController fragmentController) {
+    @NonNull
+    private CarUxRestrictions mCurrentRestrictions;
+
+    public final void setFragmentController(FragmentController fragmentController) {
         mFragmentController = fragmentController;
     }
 
+    /**
+     * Sets the CarUxRestrictions and update this fragment by calling onUxRestrictionChanged().
+     */
+    void setCarUxRestrictions(@NonNull CarUxRestrictions restrictions) {
+        mCurrentRestrictions = restrictions;
+        onUxRestrictionChanged(restrictions);
+    }
+
     protected static Bundle getBundle() {
         Bundle bundle = new Bundle();
         bundle.putInt(EXTRA_ACTION_BAR_LAYOUT, R.layout.action_bar);
         return bundle;
     }
 
+    /**
+     * Checks if this fragment can be shown or not given the CarUxRestrictions. Default to
+     * {@code false} if UX_RESTRICTIONS_NO_SETUP is set.
+     */
+    protected boolean canBeShown(@NonNull CarUxRestrictions carUxRestrictions) {
+        return !CarUxRestrictionsHelper.isNoSetup(carUxRestrictions);
+    }
+
+    /**
+     * Notifies the fragment with the latest CarUxRestrictions change. Default to quick setting
+     * page when canBeShown() return false, no-op otherwise.
+     */
+    protected void onUxRestrictionChanged(@NonNull CarUxRestrictions carUxRestrictions) {
+        mCurrentRestrictions = carUxRestrictions;
+        if (!canBeShown(carUxRestrictions)) {
+            mFragmentController.launchFragment(QuickSettingFragment.newInstance());
+        }
+    }
+
+    @Override
+    public void onStart() {
+        super.onStart();
+        if (mCurrentRestrictions != null) {
+            onUxRestrictionChanged(mCurrentRestrictions);
+        }
+    }
+
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
diff --git a/src/com/android/car/settings/common/CarSettingActivity.java b/src/com/android/car/settings/common/CarSettingActivity.java
index d7767c5..222cd17 100644
--- a/src/com/android/car/settings/common/CarSettingActivity.java
+++ b/src/com/android/car/settings/common/CarSettingActivity.java
@@ -15,6 +15,7 @@
  */
 package com.android.car.settings.common;
 
+import android.car.drivingstate.CarUxRestrictions;
 import android.content.Context;
 import android.content.Intent;
 import android.os.Bundle;
@@ -23,9 +24,7 @@
 import android.view.inputmethod.InputMethodManager;
 
 import com.android.car.settings.R;
-import com.android.car.settings.home.HomepageFragment;
-import com.android.car.settings.users.UsersListFragment;
-import com.android.car.settings.wifi.WifiSettingsFragment;
+import com.android.car.settings.quicksettings.QuickSettingFragment;
 
 /**
  * Base activity class for car settings, provides a action bar with a back button that goes to
@@ -35,12 +34,8 @@
         BaseFragment.FragmentController {
     private static final String TAG = "CarSetting";
 
-    /** Actions to launch setting page to configure a new wifi network. */
-    public static final String ACTION_ADD_WIFI = "android.car.settings.action_add_wifi";
-
-    /** Actions to launch setting page to show the list of all users. */
-    public static final String ACTION_LIST_USER = "android.car.settings.action_list_user";
-
+    private CarUxRestrictionsHelper mUxRestrictionsHelper;
+    private CarUxRestrictions mCarUxRestrictions;
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
@@ -53,21 +48,23 @@
     @Override
     public void onStart() {
         super.onStart();
-        Intent intent = getIntent();
-        if (intent != null && intent.getAction() != null) {
-            switch (intent.getAction()) {
-                case ACTION_LIST_USER:
-                    launchFragment(UsersListFragment.newInstance());
-                    return;
-                case ACTION_ADD_WIFI:
-                    launchFragment(WifiSettingsFragment.getInstance());
-                    return;
-                default:
-            }
-        }
-        HomepageFragment homepageFragment = HomepageFragment.getInstance();
-        homepageFragment.setFragmentController(this);
-        launchFragment(homepageFragment);
+        mUxRestrictionsHelper =
+                new CarUxRestrictionsHelper(this, carUxRestrictions -> {
+                    mCarUxRestrictions = carUxRestrictions;
+                    BaseFragment currentFragment = getCurrentFragment();
+                    if (currentFragment != null) {
+                        currentFragment.setCarUxRestrictions(carUxRestrictions);
+                    }
+                });
+        mUxRestrictionsHelper.start();
+        QuickSettingFragment qs = QuickSettingFragment.newInstance();
+        launchFragment(qs);
+    }
+
+    @Override
+    public void onStop() {
+        super.onStop();
+        mUxRestrictionsHelper.stop();
     }
 
     @Override
@@ -77,6 +74,14 @@
 
     @Override
     public void launchFragment(BaseFragment fragment) {
+        if (mCarUxRestrictions != null && !fragment.canBeShown(mCarUxRestrictions)) {
+            DoBlockingDialogFragment alertDialog = new DoBlockingDialogFragment();
+            alertDialog.show(getSupportFragmentManager(), DoBlockingDialogFragment.DIALOG_TAG);
+            return;
+        }
+        if (mCarUxRestrictions != null) {
+            fragment.setCarUxRestrictions(mCarUxRestrictions);
+        }
         fragment.setFragmentController(this);
         getSupportFragmentManager()
                 .beginTransaction()
@@ -105,6 +110,10 @@
         }
     }
 
+    private BaseFragment getCurrentFragment() {
+        return (BaseFragment) getSupportFragmentManager().findFragmentById(R.id.fragment_container);
+    }
+
     private void hideKeyboard() {
         InputMethodManager imm = (InputMethodManager)this.getSystemService(
                 Context.INPUT_METHOD_SERVICE);
diff --git a/src/com/android/car/settings/common/CarUxRestrictionsHelper.java b/src/com/android/car/settings/common/CarUxRestrictionsHelper.java
index 492367a..fbe810e 100644
--- a/src/com/android/car/settings/common/CarUxRestrictionsHelper.java
+++ b/src/com/android/car/settings/common/CarUxRestrictionsHelper.java
@@ -87,6 +87,15 @@
         }
     }
 
+    /**
+     * Checks if UX_RESTRICTIONS_NO_SETUP is set or not.
+     */
+    public static boolean isNoSetup(CarUxRestrictions carUxRestrictions) {
+        return (carUxRestrictions.getActiveRestrictions()
+                & CarUxRestrictions.UX_RESTRICTIONS_NO_SETUP)
+                == CarUxRestrictions.UX_RESTRICTIONS_NO_SETUP;
+    }
+
     private final ServiceConnection mServiceConnection = new ServiceConnection() {
         @Override
         public void onServiceConnected(ComponentName name, IBinder service) {
diff --git a/src/com/android/car/settings/common/DoBlockingDialogFragment.java b/src/com/android/car/settings/common/DoBlockingDialogFragment.java
new file mode 100644
index 0000000..9fd43ac
--- /dev/null
+++ b/src/com/android/car/settings/common/DoBlockingDialogFragment.java
@@ -0,0 +1,42 @@
+/*
+ * 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.car.settings.common;
+
+import android.app.Dialog;
+import android.content.Context;
+import android.os.Bundle;
+import android.support.v4.app.DialogFragment;
+
+import androidx.car.app.CarAlertDialog;
+
+import com.android.car.settings.R;
+
+/**
+ * A dialog to block non-distrction optimized view when restriction is applied.
+ */
+public class DoBlockingDialogFragment extends DialogFragment {
+    public static final String DIALOG_TAG = "block_dialog_tag";
+
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        Context context = getContext();
+        return new CarAlertDialog.Builder(context)
+                .setBody(context.getString(R.string.restricted_while_driving))
+                .setPositiveButton(context.getString(R.string.okay),
+                        /* listener= */ null)
+                .create();
+    }
+}
diff --git a/src/com/android/car/settings/quicksettings/BluetoothTile.java b/src/com/android/car/settings/quicksettings/BluetoothTile.java
index a3b4ffc..c3687da 100644
--- a/src/com/android/car/settings/quicksettings/BluetoothTile.java
+++ b/src/com/android/car/settings/quicksettings/BluetoothTile.java
@@ -39,6 +39,7 @@
     private final Context mContext;
     private final StateChangedListener mStateChangedListener;
     private LocalBluetoothAdapter mLocalAdapter;
+    private LocalBluetoothManager mLocalManager;
 
     @DrawableRes
     private int mIconRes = R.drawable.ic_settings_bluetooth;
@@ -60,7 +61,6 @@
                         // TODO show a different status icon?
                     case BluetoothAdapter.STATE_OFF:
                         mIconRes = R.drawable.ic_settings_bluetooth_disabled;
-                        mText = mContext.getString(R.string.bluetooth_disabled);
                         mState = State.OFF;
                         break;
                     default:
@@ -91,27 +91,33 @@
         mBtStateChangeFilter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
         mBtStateChangeFilter.addAction(BluetoothAdapter.ACTION_CONNECTION_STATE_CHANGED);
         mContext.registerReceiver(mBtStateReceiver, mBtStateChangeFilter);
-        LocalBluetoothManager mLocalManager = LocalBluetoothManager.getInstance(
+        mLocalManager = LocalBluetoothManager.getInstance(
                 mContext, null /* listener */);
         if (mLocalManager == null) {
             Log.e(TAG, "Bluetooth is not supported on this device");
-            mIconRes = R.drawable.ic_settings_bluetooth_disabled;
-            mText = mContext.getString(R.string.bluetooth_disabled);
-            mState = State.OFF;
             return;
         }
+        mText = mContext.getString(R.string.bluetooth_settings);
         mLocalAdapter = mLocalManager.getBluetoothAdapter();
         if (mLocalAdapter.isEnabled()) {
             mIconRes = R.drawable.ic_settings_bluetooth;
-            mText = mContext.getString(R.string.bluetooth_settings);
             mState = State.ON;
         } else {
             mIconRes = R.drawable.ic_settings_bluetooth_disabled;
-            mText = mContext.getString(R.string.bluetooth_disabled);
             mState = State.OFF;
         }
     }
 
+    @Nullable
+    public View.OnClickListener getDeepDiveListener() {
+        return null;
+    }
+
+    @Override
+    public boolean isAvailable() {
+        return mLocalManager != null;
+    }
+
     @Override
     public Drawable getIcon() {
         return mContext.getDrawable(mIconRes);
@@ -120,6 +126,7 @@
     @Override
     @Nullable
     public String getText() {
+        // TODO: return connected ssid
         return mText;
     }
 
diff --git a/src/com/android/car/settings/quicksettings/DayNightTile.java b/src/com/android/car/settings/quicksettings/DayNightTile.java
index 1a6b5da..ef4107c 100644
--- a/src/com/android/car/settings/quicksettings/DayNightTile.java
+++ b/src/com/android/car/settings/quicksettings/DayNightTile.java
@@ -19,18 +19,12 @@
 import android.annotation.DrawableRes;
 import android.annotation.Nullable;
 import android.app.UiModeManager;
-import android.bluetooth.BluetoothAdapter;
-import android.content.BroadcastReceiver;
 import android.content.Context;
-import android.content.Intent;
-import android.content.IntentFilter;
 import android.graphics.drawable.Drawable;
-import android.util.Log;
 import android.view.View;
+import android.view.View.OnClickListener;
 
 import com.android.car.settings.R;
-import com.android.settingslib.bluetooth.LocalBluetoothAdapter;
-import com.android.settingslib.bluetooth.LocalBluetoothManager;
 
 /**
  * Controls Day night mode tile on quick setting page.
@@ -43,7 +37,7 @@
     @DrawableRes
     private int mIconRes = R.drawable.ic_settings_night_display;
 
-    private String mText = "night mode";
+    private final String mText;
 
     private State mState = State.ON;
 
@@ -52,10 +46,21 @@
         mContext = context;
         mUiModeManager = (UiModeManager) mContext.getSystemService(Context.UI_MODE_SERVICE);
         if (mUiModeManager.getNightMode() == UiModeManager.MODE_NIGHT_YES) {
-            mState = State.OFF;
-        } else {
             mState = State.ON;
+        } else {
+            mState = State.OFF;
         }
+        mText = mContext.getString(R.string.night_mode_tile_label);
+    }
+
+    @Nullable
+    public OnClickListener getDeepDiveListener() {
+        return null;
+    }
+
+    @Override
+    public boolean isAvailable() {
+        return true;
     }
 
     @Override
diff --git a/src/com/android/car/settings/quicksettings/QuickSettingActivity.java b/src/com/android/car/settings/quicksettings/QuickSettingActivity.java
deleted file mode 100644
index be2ac37..0000000
--- a/src/com/android/car/settings/quicksettings/QuickSettingActivity.java
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
- * 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.car.settings.quicksettings;
-
-import android.app.Dialog;
-import android.car.drivingstate.CarUxRestrictions;
-import android.content.Context;
-import android.content.Intent;
-import android.content.pm.UserInfo;
-import android.os.Bundle;
-import android.support.v4.app.DialogFragment;
-import android.support.v7.app.ActionBar;
-import android.support.v7.app.AppCompatActivity;
-import android.support.v7.widget.Toolbar;
-import android.view.View;
-import android.view.View.OnClickListener;
-import android.widget.ImageView;
-import android.widget.TextView;
-
-import androidx.car.app.CarAlertDialog;
-import androidx.car.widget.PagedListView;
-
-import com.android.car.settings.R;
-import com.android.car.settings.common.CarSettingActivity;
-import com.android.car.settings.common.CarUxRestrictionsHelper;
-import com.android.car.settings.users.UserIconProvider;
-import com.android.settingslib.users.UserManagerHelper;
-
-/**
- * Shows a page to access frequently used settings.
- */
-public class QuickSettingActivity extends AppCompatActivity {
-    private static final String TAG = "QS";
-    private static final String DIALOG_TAG = "block_dialog_tag";
-
-    private static final float RESTRICTED_ALPHA = 0.5f;
-    private static final float UNRESTRICTED_ALPHA = 1f;
-
-    private CarUxRestrictionsHelper mUxRestrictionsHelper;
-    private UserManagerHelper  mUserManagerHelper;
-    private QuickSettingGridAdapter mGridAdapter;
-    private PagedListView mListView;
-    private View mFullSettingBtn;
-    private View mUserSwitcherBtn;
-
-    private final OnClickListener mLaunchSettingListener = v -> {
-        Intent intent = new Intent(this, CarSettingActivity.class);
-        startActivity(intent);
-    };
-
-    private final OnClickListener mBlockingListener = v -> {
-        AlertDialogFragment alertDialog = new AlertDialogFragment();
-        alertDialog.show(getSupportFragmentManager(), DIALOG_TAG);
-    };
-
-    /**
-     * Shows a dialog to notify user that the actions is not available while driving.
-     */
-    public static class AlertDialogFragment extends DialogFragment {
-        @Override
-        public Dialog onCreateDialog(Bundle savedInstanceState) {
-            Context context = getContext();
-            return new CarAlertDialog.Builder(context)
-                    .setBody(context.getString(R.string.restricted_while_driving))
-                    .setPositiveButton(context.getString(R.string.okay),
-                            /* listener= */ null)
-                    .create();
-        }
-    }
-
-    @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        mUserManagerHelper = new UserManagerHelper(this);
-        setContentView(R.layout.quick_settings);
-        mListView = (PagedListView) findViewById(R.id.list);
-        mGridAdapter = new QuickSettingGridAdapter(this);
-        mListView.getRecyclerView().setLayoutManager(mGridAdapter.getGridLayoutManager());
-        Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
-        // make the toolbar take the whole width.
-        toolbar.setPadding(0, 0, 0, 0);
-        setSupportActionBar(toolbar);
-        ActionBar actionBar = getSupportActionBar();
-        actionBar.setDisplayHomeAsUpEnabled(false);
-        actionBar.setCustomView(R.layout.action_bar_quick_settings);
-        actionBar.setDisplayShowCustomEnabled(true);
-
-        mFullSettingBtn = findViewById(R.id.full_setting_btn);
-        mUserSwitcherBtn = findViewById(R.id.user_switcher_btn);
-        mUserSwitcherBtn.setOnClickListener(v -> {
-            Intent intent = new Intent(this, CarSettingActivity.class);
-            intent.setAction(CarSettingActivity.ACTION_LIST_USER);
-            startActivity(intent);
-        });
-
-        setupAccountButton();
-        View exitBtn = findViewById(R.id.exit_button);
-        exitBtn.setOnClickListener(v -> finish());
-        mUxRestrictionsHelper =
-                new CarUxRestrictionsHelper(
-                        this, QuickSettingActivity.this::onUxRestrictionChagned);
-    }
-
-    private void setupAccountButton() {
-        ImageView userIcon = (ImageView) findViewById(R.id.user_icon);
-        UserInfo currentUserInfo = mUserManagerHelper.getForegroundUserInfo();
-        userIcon.setImageDrawable(
-                UserIconProvider.getUserIcon(currentUserInfo, mUserManagerHelper, this));
-
-        TextView userSwitcherText = (TextView) findViewById(R.id.user_switcher_text);
-        userSwitcherText.setText(currentUserInfo.name);
-    }
-
-    @Override
-    public void onStart() {
-        super.onStart();
-
-        mGridAdapter
-                .addTile(new WifiTile(this, mGridAdapter))
-                .addTile(new BluetoothTile(this, mGridAdapter))
-                .addTile(new DayNightTile(this, mGridAdapter))
-                .addSeekbarTile(new BrightnessTile(this));
-        mListView.setAdapter(mGridAdapter);
-        mUxRestrictionsHelper.start();
-    }
-
-    @Override
-    public void onStop() {
-        super.onStop();
-        mGridAdapter.stop();
-        mUxRestrictionsHelper.stop();
-    }
-
-    private void onUxRestrictionChagned(CarUxRestrictions carUxRestrictions) {
-        // TODO: update tiles
-        applyRestriction(
-                (carUxRestrictions.getActiveRestrictions()
-                        & CarUxRestrictions.UX_RESTRICTIONS_NO_SETUP)
-                        == CarUxRestrictions.UX_RESTRICTIONS_NO_SETUP);
-    }
-
-    private void applyRestriction(boolean restricted) {
-        if (restricted) {
-            mFullSettingBtn.setAlpha(RESTRICTED_ALPHA);
-            mFullSettingBtn.setOnClickListener(mBlockingListener);
-        } else {
-            mFullSettingBtn.setAlpha(UNRESTRICTED_ALPHA);
-            mFullSettingBtn.setOnClickListener(mLaunchSettingListener);
-        }
-    }
-}
diff --git a/src/com/android/car/settings/quicksettings/QuickSettingFragment.java b/src/com/android/car/settings/quicksettings/QuickSettingFragment.java
new file mode 100644
index 0000000..bae76a6
--- /dev/null
+++ b/src/com/android/car/settings/quicksettings/QuickSettingFragment.java
@@ -0,0 +1,129 @@
+/*
+ * 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.car.settings.quicksettings;
+
+import android.car.drivingstate.CarUxRestrictions;
+import android.content.pm.UserInfo;
+import android.os.Bundle;
+import android.view.View;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import androidx.car.widget.PagedListView;
+
+import com.android.car.settings.R;
+import com.android.car.settings.common.BaseFragment;
+import com.android.car.settings.common.CarUxRestrictionsHelper;
+import com.android.car.settings.home.HomepageFragment;
+import com.android.car.settings.users.UserIconProvider;
+import com.android.car.settings.users.UsersListFragment;
+import com.android.settingslib.users.UserManagerHelper;
+
+/**
+ * Shows a page to access frequently used settings.
+ */
+public class QuickSettingFragment extends BaseFragment {
+    private static final String TAG = "QS";
+
+    private static final float RESTRICTED_ALPHA = 0.5f;
+    private static final float UNRESTRICTED_ALPHA = 1f;
+
+    private UserManagerHelper  mUserManagerHelper;
+    private QuickSettingGridAdapter mGridAdapter;
+    private PagedListView mListView;
+    private View mFullSettingBtn;
+    private View mUserSwitcherBtn;
+
+    /**
+     * Returns an instance of this class.
+     */
+    public static QuickSettingFragment newInstance() {
+        QuickSettingFragment quickSettingFragment = new QuickSettingFragment();
+        Bundle bundle = quickSettingFragment.getBundle();
+        bundle.putInt(EXTRA_ACTION_BAR_LAYOUT, R.layout.action_bar_quick_settings);
+        bundle.putInt(EXTRA_LAYOUT, R.layout.quick_settings);
+        bundle.putInt(EXTRA_TITLE_ID, R.string.settings_label);
+        quickSettingFragment.setArguments(bundle);
+        return quickSettingFragment;
+    }
+
+    @Override
+    public void onActivityCreated(Bundle savedInstanceState) {
+        super.onActivityCreated(savedInstanceState);
+        getActivity().findViewById(R.id.action_bar_icon_container).setOnClickListener(
+                v -> getActivity().finish());
+
+        mUserManagerHelper = new UserManagerHelper(getContext());
+        mListView = (PagedListView) getActivity().findViewById(R.id.list);
+        mGridAdapter = new QuickSettingGridAdapter(getContext());
+        mListView.getRecyclerView().setLayoutManager(mGridAdapter.getGridLayoutManager());
+
+        mFullSettingBtn = getActivity().findViewById(R.id.full_setting_btn);
+        mFullSettingBtn.setOnClickListener(v -> {
+            mFragmentController.launchFragment(HomepageFragment.getInstance());
+        });
+        mUserSwitcherBtn = getActivity().findViewById(R.id.user_switcher_btn);
+        mUserSwitcherBtn.setOnClickListener(v -> {
+            mFragmentController.launchFragment(UsersListFragment.newInstance());
+        });
+
+        setupAccountButton();
+        View exitBtn = getActivity().findViewById(R.id.exit_button);
+        exitBtn.setOnClickListener(v -> mFragmentController.goBack());
+
+        mGridAdapter
+                .addTile(new WifiTile(getContext(), mGridAdapter, mFragmentController))
+                .addTile(new BluetoothTile(getContext(), mGridAdapter))
+                .addTile(new DayNightTile(getContext(), mGridAdapter))
+                .addSeekbarTile(new BrightnessTile(getContext()));
+        mListView.setAdapter(mGridAdapter);
+    }
+
+    @Override
+    public void onStop() {
+        super.onStop();
+        mGridAdapter.stop();
+    }
+
+    private void setupAccountButton() {
+        ImageView userIcon = (ImageView) getActivity().findViewById(R.id.user_icon);
+        UserInfo currentUserInfo = mUserManagerHelper.getForegroundUserInfo();
+        userIcon.setImageDrawable(
+                UserIconProvider.getUserIcon(
+                        currentUserInfo, mUserManagerHelper, getContext()));
+
+        TextView userSwitcherText = (TextView) getActivity().findViewById(R.id.user_switcher_text);
+        userSwitcherText.setText(currentUserInfo.name);
+    }
+
+    /**
+     * Quick setting fragment is distraction optimized, so is allowed at all times.
+     */
+    @Override
+    public boolean canBeShown(CarUxRestrictions carUxRestrictions) {
+        return true;
+    }
+
+    @Override
+    public void onUxRestrictionChanged(CarUxRestrictions carUxRestrictions) {
+        // TODO: update tiles
+        applyRestriction(CarUxRestrictionsHelper.isNoSetup(carUxRestrictions));
+    }
+
+    private void applyRestriction(boolean restricted) {
+        mFullSettingBtn.setAlpha(restricted ? RESTRICTED_ALPHA : UNRESTRICTED_ALPHA);
+    }
+}
diff --git a/src/com/android/car/settings/quicksettings/QuickSettingGridAdapter.java b/src/com/android/car/settings/quicksettings/QuickSettingGridAdapter.java
index 45012f4..6c392ca 100644
--- a/src/com/android/car/settings/quicksettings/QuickSettingGridAdapter.java
+++ b/src/com/android/car/settings/quicksettings/QuickSettingGridAdapter.java
@@ -23,6 +23,7 @@
 import android.text.TextUtils;
 import android.view.LayoutInflater;
 import android.view.View;
+import android.view.View.OnClickListener;
 import android.view.ViewGroup;
 import android.widget.ImageView;
 import android.widget.SeekBar;
@@ -39,9 +40,6 @@
 public class QuickSettingGridAdapter
         extends RecyclerView.Adapter<RecyclerView.ViewHolder> implements StateChangedListener {
     private static final int COLUMN_COUNT = 4;
-    // alpha value for icon or text.
-    private static final int ALPHA_DISABLED = 128;
-    private static final int ALPHA_ENABLED = 255;
     private static final int SEEKBAR_VIEWTYPE = 0;
     private static final int TILE_VIEWTYPE = 1;
     private final Context mContext;
@@ -84,6 +82,18 @@
         String getText();
 
         State getState();
+
+        /**
+         * Returns {@code true} if this tile should be displayed.
+         */
+        boolean isAvailable();
+
+        /**
+         * Returns a listener for launching a setting fragment for advanced configuration for this
+         * tile, A.K.A deep dive, if available. {@code null} if deep dive is not available.
+         */
+        @Nullable
+        OnClickListener getDeepDiveListener();
     }
 
     interface SeekbarTile extends SeekBar.OnSeekBarChangeListener {
@@ -103,7 +113,9 @@
     }
 
     QuickSettingGridAdapter addTile(Tile tile) {
-        mTiles.add(tile);
+        if (tile.isAvailable()) {
+            mTiles.add(tile);
+        }
         return this;
     }
 
@@ -145,15 +157,31 @@
             case TILE_VIEWTYPE:
                 Tile tile = mTiles.get(position - mSeekbarTiles.size());
                 TileViewHolder vh = (TileViewHolder) holder;
+                OnClickListener deepDiveListener = tile.getDeepDiveListener();
+                if (deepDiveListener != null) {
+                    vh.mDeepDiveIcon.setVisibility(View.VISIBLE);
+                    vh.mTextContainer.setOnClickListener(deepDiveListener);
+                    vh.mIconContainer.setOnClickListener(tile);
+                    vh.itemView.setOnClickListener(null);
+                    vh.itemView.setClickable(false);
+                } else {
+                    vh.itemView.setOnClickListener(tile);
+                    vh.itemView.setClickable(true);
+                    vh.mIconContainer.setOnClickListener(null);
+                    vh.mIconContainer.setClickable(false);
+                    vh.mDeepDiveIcon.setVisibility(View.GONE);
+                    vh.mTextContainer.setClickable(false);
+                    vh.mTextContainer.setOnClickListener(null);
+                }
                 vh.mIcon.setImageDrawable(tile.getIcon());
                 switch (tile.getState()) {
                     case ON:
-                        vh.mIcon.setAlpha(ALPHA_ENABLED);
-                        vh.mText.setAlpha(ALPHA_ENABLED);
+                        vh.mIcon.setEnabled(true);
+                        vh.mIconBackground.setEnabled(true);
                         break;
                     case OFF:
-                        vh.mIcon.setAlpha(ALPHA_DISABLED);
-                        vh.mText.setAlpha(ALPHA_DISABLED);
+                        vh.mIcon.setEnabled(false);
+                        vh.mIconBackground.setEnabled(false);
                         break;
                     default:
                 }
@@ -161,7 +189,6 @@
                 if (!TextUtils.isEmpty(textString)) {
                     vh.mText.setText(textString);
                 }
-                vh.itemView.setOnClickListener(tile);
                 break;
             default:
         }
@@ -177,12 +204,20 @@
     }
 
     private class TileViewHolder extends RecyclerView.ViewHolder {
+        private final View mIconContainer;
+        private final View mTextContainer;
+        private final View mIconBackground;
         private final ImageView mIcon;
+        private final ImageView mDeepDiveIcon;
         private final TextView mText;
 
         TileViewHolder(View view) {
             super(view);
+            mIconContainer = view.findViewById(R.id.icon_container);
+            mTextContainer = view.findViewById(R.id.text_container);
+            mIconBackground = view.findViewById(R.id.icon_background);
             mIcon = (ImageView) view.findViewById(R.id.tile_icon);
+            mDeepDiveIcon = (ImageView) view.findViewById(R.id.deep_dive_icon);
             mText = (TextView) view.findViewById(R.id.tile_text);
         }
     }
diff --git a/src/com/android/car/settings/quicksettings/WifiTile.java b/src/com/android/car/settings/quicksettings/WifiTile.java
index 664a817..30191bf 100644
--- a/src/com/android/car/settings/quicksettings/WifiTile.java
+++ b/src/com/android/car/settings/quicksettings/WifiTile.java
@@ -19,13 +19,15 @@
 import android.annotation.DrawableRes;
 import android.annotation.Nullable;
 import android.content.Context;
-import android.content.Intent;
+import android.content.pm.PackageManager;
 import android.graphics.drawable.Drawable;
 import android.view.View;
+import android.view.View.OnClickListener;
 
 import com.android.car.settings.R;
-import com.android.car.settings.common.CarSettingActivity;
+import com.android.car.settings.common.BaseFragment.FragmentController;
 import com.android.car.settings.wifi.CarWifiManager;
+import com.android.car.settings.wifi.WifiSettingsFragment;
 import com.android.car.settings.wifi.WifiUtil;
 import com.android.settingslib.wifi.AccessPoint;
 
@@ -33,9 +35,13 @@
  * Controls Wifi tile on quick setting page.
  */
 public class WifiTile implements QuickSettingGridAdapter.Tile, CarWifiManager.Listener {
+    private static final String TAG = "WifiTile";
     private final StateChangedListener mStateChangedListener;
     private final CarWifiManager mCarWifiManager;
     private final Context mContext;
+    private final FragmentController mFragmentController;
+
+    private final OnClickListener mSwitchSavedWifiListener;
 
     @DrawableRes
     private int mIconRes = R.drawable.ic_settings_wifi;
@@ -44,15 +50,33 @@
 
     private State mState = State.OFF;
 
-    WifiTile(Context context, StateChangedListener stateChangedListener) {
+    WifiTile(Context context, StateChangedListener stateChangedListener,
+            FragmentController fragmentController) {
         mContext = context;
+        mFragmentController = fragmentController;
+        mSwitchSavedWifiListener = v -> {
+            mFragmentController.launchFragment(
+                    WifiSettingsFragment.getInstance().showSavedApOnly(true));
+        };
         mCarWifiManager = new CarWifiManager(context, this /* listener */);
         mCarWifiManager.start();
         mStateChangedListener = stateChangedListener;
         // init icon and text etc.
+        updateAccessPointSsid();
         onWifiStateChanged(mCarWifiManager.getWifiState());
     }
 
+    @Nullable
+    public OnClickListener getDeepDiveListener() {
+        return !mCarWifiManager.getSavedAccessPoints().isEmpty()
+                ? mSwitchSavedWifiListener : null;
+    }
+
+    @Override
+    public boolean isAvailable() {
+        return mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WIFI);
+    }
+
     @Override
     public Drawable getIcon() {
         return mContext.getDrawable(mIconRes);
@@ -100,9 +124,7 @@
     @Override
     public void onClick(View v) {
         if (wifiEnabledNotConnected()) {
-            Intent intent = new Intent(mContext, CarSettingActivity.class);
-            intent.setAction(CarSettingActivity.ACTION_ADD_WIFI);
-            mContext.startActivity(intent);
+            mFragmentController.launchFragment(WifiSettingsFragment.getInstance());
         } else {
             mCarWifiManager.setWifiEnabled(!mCarWifiManager.isWifiEnabled());
         }
diff --git a/src/com/android/car/settings/wifi/AccessPointListAdapter.java b/src/com/android/car/settings/wifi/AccessPointListAdapter.java
index 8baa8eb..4e9f0ce 100644
--- a/src/com/android/car/settings/wifi/AccessPointListAdapter.java
+++ b/src/com/android/car/settings/wifi/AccessPointListAdapter.java
@@ -29,14 +29,14 @@
 import android.widget.TextView;
 import android.widget.Toast;
 
+import androidx.car.widget.PagedListView;
+
 import com.android.car.settings.R;
 import com.android.car.settings.common.BaseFragment;
 import com.android.settingslib.wifi.AccessPoint;
 
 import java.util.List;
 
-import androidx.car.widget.PagedListView;
-
 /**
  * Renders {@link AccessPoint} to a view to be displayed as a row in a list.
  */
@@ -58,6 +58,7 @@
     private final BaseFragment.FragmentController mFragmentController;
     private final CarWifiManager mCarWifiManager;
     private final WifiManager.ActionListener mConnectionListener;
+    private final boolean mShowAddNetworkRow;
 
     private List<AccessPoint> mAccessPoints;
 
@@ -65,8 +66,10 @@
             @NonNull Context context,
             CarWifiManager carWifiManager,
             @NonNull List<AccessPoint> accesssPoints,
+            boolean showAddNetworkRow,
             BaseFragment.FragmentController fragmentController) {
         mContext = context;
+        mShowAddNetworkRow = showAddNetworkRow;
         mFragmentController = fragmentController;
         mCarWifiManager = carWifiManager;
         mAccessPoints = accesssPoints;
@@ -184,7 +187,7 @@
     @Override
     public int getItemCount() {
         // number of rows include one per device and a row for add network.
-        return mAccessPoints.size() + 1;
+        return mShowAddNetworkRow ? mAccessPoints.size() + 1 : mAccessPoints.size();
     }
 
     @Override
diff --git a/src/com/android/car/settings/wifi/CarWifiManager.java b/src/com/android/car/settings/wifi/CarWifiManager.java
index 07bd79b..872c222 100644
--- a/src/com/android/car/settings/wifi/CarWifiManager.java
+++ b/src/com/android/car/settings/wifi/CarWifiManager.java
@@ -100,12 +100,26 @@
         mWifiTracker.onDestroy();
     }
 
-    public List<AccessPoint> getAccessPoints() {
+    /**
+     * Returns a list of all reachable access points.
+     */
+    public List<AccessPoint> getAllAccessPoints() {
+        return getAccessPoints(false);
+    }
+
+    /**
+     * Returns a list of saved access points.
+     */
+    public List<AccessPoint> getSavedAccessPoints() {
+        return getAccessPoints(true);
+    }
+
+    private List<AccessPoint> getAccessPoints(boolean saved) {
         List<AccessPoint> accessPoints = new ArrayList<AccessPoint>();
         if (mWifiManager.isWifiEnabled()) {
             for (AccessPoint accessPoint : mWifiTracker.getAccessPoints()) {
                 // ignore out of reach access points.
-                if (accessPoint.isReachable()) {
+                if (shouldIncludeAp(accessPoint, saved)) {
                     accessPoints.add(accessPoint);
                 }
             }
@@ -113,9 +127,14 @@
         return accessPoints;
     }
 
+    private boolean shouldIncludeAp(AccessPoint accessPoint, boolean saved) {
+        return saved ? accessPoint.isReachable() && accessPoint.isSaved()
+                : accessPoint.isReachable();
+    }
+
     @Nullable
     public AccessPoint getConnectedAccessPoint() {
-        for (AccessPoint accessPoint : getAccessPoints()) {
+        for (AccessPoint accessPoint : getAllAccessPoints()) {
             if (accessPoint.getDetailedState() == NetworkInfo.DetailedState.CONNECTED) {
                 return accessPoint;
             }
diff --git a/src/com/android/car/settings/wifi/WifiSettingsFragment.java b/src/com/android/car/settings/wifi/WifiSettingsFragment.java
index 4c19cc7..1bf5536 100644
--- a/src/com/android/car/settings/wifi/WifiSettingsFragment.java
+++ b/src/com/android/car/settings/wifi/WifiSettingsFragment.java
@@ -15,7 +15,9 @@
  */
 package com.android.car.settings.wifi;
 
+import android.annotation.NonNull;
 import android.annotation.StringRes;
+import android.car.drivingstate.CarUxRestrictions;
 import android.net.wifi.WifiManager;
 import android.os.Bundle;
 import android.view.View;
@@ -24,11 +26,11 @@
 import android.widget.TextView;
 import android.widget.ViewSwitcher;
 
+import androidx.car.widget.PagedListView;
+
 import com.android.car.settings.R;
 import com.android.car.settings.common.BaseFragment;
-
-import androidx.car.widget.DayNightStyle;
-import androidx.car.widget.PagedListView;
+import com.android.car.settings.common.CarUxRestrictionsHelper;
 
 /**
  * Main page to host Wifi related preferences.
@@ -43,6 +45,7 @@
     private PagedListView mListView;
     private TextView mMessageView;
     private ViewSwitcher mViewSwitcher;
+    private boolean mShowSavedApOnly;
 
     public static WifiSettingsFragment getInstance() {
         WifiSettingsFragment wifiSettingsFragment = new WifiSettingsFragment();
@@ -54,6 +57,14 @@
         return wifiSettingsFragment;
     }
 
+    /**
+     * Shows only saved wifi network.
+     */
+    public WifiSettingsFragment showSavedApOnly(boolean showSavedApOnly) {
+        mShowSavedApOnly = showSavedApOnly;
+        return this;
+    }
+
     @Override
     public void onActivityCreated(Bundle savedInstanceState) {
         super.onActivityCreated(savedInstanceState);
@@ -73,7 +84,10 @@
         mAdapter = new AccessPointListAdapter(
                 getContext(),
                 mCarWifiManager,
-                mCarWifiManager.getAccessPoints(),
+                mShowSavedApOnly
+                        ? mCarWifiManager.getSavedAccessPoints()
+                        : mCarWifiManager.getAllAccessPoints(),
+                !mShowSavedApOnly,
                 mFragmentController);
         mListView.setAdapter(mAdapter);
     }
@@ -118,6 +132,20 @@
         }
     }
 
+    /**
+     * This fragment will adapt to restriction, so can always be shown.
+     */
+    @Override
+    public boolean canBeShown(CarUxRestrictions carUxRestrictions) {
+        return true;
+    }
+
+    @Override
+    public void onUxRestrictionChanged(@NonNull CarUxRestrictions carUxRestrictions) {
+        mShowSavedApOnly = CarUxRestrictionsHelper.isNoSetup(carUxRestrictions);
+        refreshData();
+    }
+
     private  void setProgressBarVisible(boolean visible) {
         if (mProgressBar != null) {
             mProgressBar.setVisibility(visible ? View.VISIBLE : View.GONE);
@@ -126,7 +154,9 @@
 
     private void refreshData() {
         if (mAdapter != null) {
-            mAdapter.updateAccessPoints(mCarWifiManager.getAccessPoints());
+            mAdapter.updateAccessPoints(mShowSavedApOnly
+                    ? mCarWifiManager.getSavedAccessPoints()
+                    : mCarWifiManager.getAllAccessPoints());
             // if the list is empty, keep showing the progress bar, the list should reset
             // every couple seconds.
             // TODO: Consider show a message in the list view place.
@@ -134,7 +164,9 @@
                 setProgressBarVisible(false);
             }
         }
-        mWifiSwitch.setChecked(mCarWifiManager.isWifiEnabled());
+        if (mCarWifiManager != null) {
+            mWifiSwitch.setChecked(mCarWifiManager.isWifiEnabled());
+        }
     }
 
     private void showMessage(@StringRes int resId) {
