Add night display pref controllers and change UX

- Convert NightDisplaySettings to a DashboardFragment
- Add preference controllers for all Night Display settings
- Change UX for activation from a toggle to a button

Bug: 73739388
Bug: 69912911
Test: make -j100 and make RunSettingsRoboTests -j100
Change-Id: Ia173f16207ba59bf57eb7546cbb1e2dbca67b063

9 files changed, 542 insertions, 167 deletions

diff --git a/src/com/android/settings/display/NightDisplayActivationPreferenceController.java b/src/com/android/settings/display/NightDisplayActivationPreferenceController.java
new file mode 100644
index 0000000000..6b07ea0df2
--- /dev/null
+++ b/src/com/android/settings/display/NightDisplayActivationPreferenceController.java
@@ -0,0 +1,126 @@
+/*
+ * 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.display;
+
+import android.content.Context;
+import androidx.preference.Preference;
+import androidx.preference.PreferenceScreen;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import com.android.internal.app.ColorDisplayController;
+import com.android.settings.R;
+import com.android.settings.applications.LayoutPreference;
+import com.android.settings.core.TogglePreferenceController;
+
+public class NightDisplayActivationPreferenceController extends TogglePreferenceController {
+
+    private ColorDisplayController mController;
+    private NightDisplayTimeFormatter mTimeFormatter;
+    private Button mTurnOffButton;
+    private Button mTurnOnButton;
+
+    private final OnClickListener mListener = new OnClickListener() {
+        @Override
+        public void onClick(View v) {
+            mController.setActivated(!mController.isActivated());
+            updateStateInternal();
+        }
+    };
+
+    public NightDisplayActivationPreferenceController(Context context, String key) {
+        super(context, key);
+        mController = new ColorDisplayController(context);
+        mTimeFormatter = new NightDisplayTimeFormatter(context);
+    }
+
+    @Override
+    public int getAvailabilityStatus() {
+        return ColorDisplayController.isAvailable(mContext) ? AVAILABLE : DISABLED_UNSUPPORTED;
+    }
+
+    @Override
+    public void displayPreference(PreferenceScreen screen) {
+        super.displayPreference(screen);
+
+        final LayoutPreference preference = (LayoutPreference) screen.findPreference(
+                getPreferenceKey());
+        mTurnOnButton = preference.findViewById(R.id.night_display_turn_on_button);
+        mTurnOnButton.setOnClickListener(mListener);
+        mTurnOffButton = preference.findViewById(R.id.night_display_turn_off_button);
+        mTurnOffButton.setOnClickListener(mListener);
+    }
+
+    @Override
+    public final void updateState(Preference preference) {
+        updateStateInternal();
+    }
+
+    /** FOR SLICES */
+
+    @Override
+    public boolean isChecked() {
+        return mController.isActivated();
+    }
+
+    @Override
+    public boolean setChecked(boolean isChecked) {
+        return mController.setActivated(isChecked);
+    }
+
+    @Override
+    public CharSequence getSummary() {
+        return mTimeFormatter.getAutoModeTimeSummary(mContext, mController);
+    }
+
+    private void updateStateInternal() {
+        if (mTurnOnButton == null || mTurnOffButton == null) {
+            return;
+        }
+
+        final boolean isActivated = mController.isActivated();
+        final int autoMode = mController.getAutoMode();
+
+        String buttonText;
+        if (autoMode == ColorDisplayController.AUTO_MODE_CUSTOM) {
+            buttonText = mContext.getString(isActivated
+                            ? R.string.night_display_activation_off_custom
+                            : R.string.night_display_activation_on_custom,
+                    mTimeFormatter.getFormattedTimeString(isActivated
+                            ? mController.getCustomStartTime()
+                            : mController.getCustomEndTime()));
+        } else if (autoMode == ColorDisplayController.AUTO_MODE_TWILIGHT) {
+            buttonText = mContext.getString(isActivated
+                    ? R.string.night_display_activation_off_twilight
+                    : R.string.night_display_activation_on_twilight);
+        } else {
+            buttonText = mContext.getString(isActivated
+                    ? R.string.night_display_activation_off_manual
+                    : R.string.night_display_activation_on_manual);
+        }
+
+        if (isActivated) {
+            mTurnOnButton.setVisibility(View.GONE);
+            mTurnOffButton.setVisibility(View.VISIBLE);
+            mTurnOffButton.setText(buttonText);
+        } else {
+            mTurnOnButton.setVisibility(View.VISIBLE);
+            mTurnOffButton.setVisibility(View.GONE);
+            mTurnOnButton.setText(buttonText);
+        }
+    }
+}
diff --git a/src/com/android/settings/display/NightDisplayAutoModePreferenceController.java b/src/com/android/settings/display/NightDisplayAutoModePreferenceController.java
new file mode 100644
index 0000000000..31810982df
--- /dev/null
+++ b/src/com/android/settings/display/NightDisplayAutoModePreferenceController.java
@@ -0,0 +1,70 @@
+/*
+ * 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.display;
+
+import android.content.Context;
+import androidx.preference.DropDownPreference;
+import androidx.preference.Preference;
+import androidx.preference.PreferenceScreen;
+import com.android.internal.app.ColorDisplayController;
+import com.android.settings.R;
+import com.android.settings.core.BasePreferenceController;
+
+public class NightDisplayAutoModePreferenceController extends BasePreferenceController
+        implements Preference.OnPreferenceChangeListener {
+
+    private DropDownPreference mPreference;
+    private ColorDisplayController mController;
+
+    public NightDisplayAutoModePreferenceController(Context context, String key) {
+        super(context, key);
+        mController = new ColorDisplayController(context);
+    }
+
+    @Override
+    public int getAvailabilityStatus() {
+        return ColorDisplayController.isAvailable(mContext) ? AVAILABLE : DISABLED_UNSUPPORTED;
+    }
+
+    @Override
+    public void displayPreference(PreferenceScreen screen) {
+        super.displayPreference(screen);
+
+        mPreference = (DropDownPreference) screen.findPreference(getPreferenceKey());
+
+        mPreference.setEntries(new CharSequence[]{
+                mContext.getString(R.string.night_display_auto_mode_never),
+                mContext.getString(R.string.night_display_auto_mode_custom),
+                mContext.getString(R.string.night_display_auto_mode_twilight)
+        });
+        mPreference.setEntryValues(new CharSequence[]{
+                String.valueOf(ColorDisplayController.AUTO_MODE_DISABLED),
+                String.valueOf(ColorDisplayController.AUTO_MODE_CUSTOM),
+                String.valueOf(ColorDisplayController.AUTO_MODE_TWILIGHT)
+        });
+    }
+
+    @Override
+    public final void updateState(Preference preference) {
+        mPreference.setValue(String.valueOf(mController.getAutoMode()));
+    }
+
+    @Override
+    public final boolean onPreferenceChange(Preference preference, Object newValue) {
+        return mController.setAutoMode(Integer.parseInt((String) newValue));
+    }
+}
diff --git a/src/com/android/settings/display/NightDisplayCustomEndTimePreferenceController.java b/src/com/android/settings/display/NightDisplayCustomEndTimePreferenceController.java
new file mode 100644
index 0000000000..76b362e4fd
--- /dev/null
+++ b/src/com/android/settings/display/NightDisplayCustomEndTimePreferenceController.java
@@ -0,0 +1,47 @@
+/*
+ * 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.display;
+
+import android.content.Context;
+import androidx.preference.Preference;
+import com.android.internal.app.ColorDisplayController;
+import com.android.settings.core.BasePreferenceController;
+
+public class NightDisplayCustomEndTimePreferenceController extends BasePreferenceController {
+
+    private ColorDisplayController mController;
+    private NightDisplayTimeFormatter mTimeFormatter;
+
+    public NightDisplayCustomEndTimePreferenceController(Context context, String key) {
+        super(context, key);
+
+        mController = new ColorDisplayController(context);
+        mTimeFormatter = new NightDisplayTimeFormatter(context);
+    }
+
+    @Override
+    public int getAvailabilityStatus() {
+        return ColorDisplayController.isAvailable(mContext) ? AVAILABLE : DISABLED_UNSUPPORTED;
+    }
+
+    @Override
+    public final void updateState(Preference preference) {
+        preference.setVisible(mController.getAutoMode() == ColorDisplayController.AUTO_MODE_CUSTOM);
+        preference.setSummary(mTimeFormatter.getFormattedTimeString(
+                mController.getCustomEndTime()));
+    }
+}
diff --git a/src/com/android/settings/display/NightDisplayCustomStartTimePreferenceController.java b/src/com/android/settings/display/NightDisplayCustomStartTimePreferenceController.java
new file mode 100644
index 0000000000..f1ac54e162
--- /dev/null
+++ b/src/com/android/settings/display/NightDisplayCustomStartTimePreferenceController.java
@@ -0,0 +1,47 @@
+/*
+ * 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.display;
+
+import android.content.Context;
+import androidx.preference.Preference;
+import com.android.internal.app.ColorDisplayController;
+import com.android.settings.core.BasePreferenceController;
+
+public class NightDisplayCustomStartTimePreferenceController extends BasePreferenceController {
+
+    private ColorDisplayController mController;
+    private NightDisplayTimeFormatter mTimeFormatter;
+
+    public NightDisplayCustomStartTimePreferenceController(Context context, String key) {
+        super(context, key);
+
+        mController = new ColorDisplayController(context);
+        mTimeFormatter = new NightDisplayTimeFormatter(context);
+    }
+
+    @Override
+    public int getAvailabilityStatus() {
+        return ColorDisplayController.isAvailable(mContext) ? AVAILABLE : DISABLED_UNSUPPORTED;
+    }
+
+    @Override
+    public final void updateState(Preference preference) {
+        preference.setVisible(mController.getAutoMode() == ColorDisplayController.AUTO_MODE_CUSTOM);
+        preference.setSummary(mTimeFormatter.getFormattedTimeString(
+                mController.getCustomStartTime()));
+    }
+}
diff --git a/src/com/android/settings/display/NightDisplayFooterPreferenceController.java b/src/com/android/settings/display/NightDisplayFooterPreferenceController.java
new file mode 100644
index 0000000000..bd04d120db
--- /dev/null
+++ b/src/com/android/settings/display/NightDisplayFooterPreferenceController.java
@@ -0,0 +1,41 @@
+/*
+ * 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.display;
+
+import android.content.Context;
+import androidx.preference.Preference;
+import com.android.internal.app.ColorDisplayController;
+import com.android.settings.R;
+import com.android.settings.core.BasePreferenceController;
+import com.android.settingslib.widget.FooterPreference;
+
+public class NightDisplayFooterPreferenceController extends BasePreferenceController {
+
+    public NightDisplayFooterPreferenceController(Context context) {
+        super(context, FooterPreference.KEY_FOOTER);
+    }
+
+    @Override
+    public int getAvailabilityStatus() {
+        return ColorDisplayController.isAvailable(mContext) ? AVAILABLE : DISABLED_UNSUPPORTED;
+    }
+
+    @Override
+    public void updateState(Preference preference) {
+        preference.setTitle(R.string.night_display_text);
+    }
+}
diff --git a/src/com/android/settings/display/NightDisplayIntensityPreferenceController.java b/src/com/android/settings/display/NightDisplayIntensityPreferenceController.java
new file mode 100644
index 0000000000..c3efdc0ae3
--- /dev/null
+++ b/src/com/android/settings/display/NightDisplayIntensityPreferenceController.java
@@ -0,0 +1,83 @@
+/*
+ * 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.display;
+
+import android.content.Context;
+import androidx.preference.Preference;
+import androidx.preference.PreferenceScreen;
+import com.android.internal.app.ColorDisplayController;
+import com.android.settings.core.SliderPreferenceController;
+import com.android.settings.widget.SeekBarPreference;
+
+public class NightDisplayIntensityPreferenceController extends SliderPreferenceController {
+
+    private ColorDisplayController mController;
+
+    public NightDisplayIntensityPreferenceController(Context context, String key) {
+        super(context, key);
+        mController = new ColorDisplayController(context);
+    }
+
+    @Override
+    public int getAvailabilityStatus() {
+        if (!ColorDisplayController.isAvailable(mContext)) {
+            return DISABLED_UNSUPPORTED;
+        } else if (!mController.isActivated()) {
+            return DISABLED_DEPENDENT_SETTING;
+        }
+        return AVAILABLE;
+    }
+
+    @Override
+    public void displayPreference(PreferenceScreen screen) {
+        super.displayPreference(screen);
+        final SeekBarPreference preference = (SeekBarPreference) screen.findPreference(
+            getPreferenceKey());
+        preference.setContinuousUpdates(true);
+        preference.setMax(getMaxSteps());
+    }
+
+    @Override
+    public final void updateState(Preference preference) {
+        super.updateState(preference);
+        preference.setEnabled(mController.isActivated());
+    }
+
+    @Override
+    public int getSliderPosition() {
+        return convertTemperature(mController.getColorTemperature());
+    }
+
+    @Override
+    public boolean setSliderPosition(int position) {
+        return mController.setColorTemperature(convertTemperature(position));
+    }
+
+    @Override
+    public int getMaxSteps() {
+        return convertTemperature(mController.getMinimumColorTemperature());
+    }
+
+    /**
+     * Inverts and range-adjusts a raw value from the SeekBar (i.e. [0, maxTemp-minTemp]), or
+     * converts an inverted and range-adjusted value to the raw SeekBar value, depending on the
+     * adjustment status of the input.
+     */
+    private int convertTemperature(int temperature) {
+        return mController.getMaximumColorTemperature() - temperature;
+    }
+}
\ No newline at end of file
diff --git a/src/com/android/settings/display/NightDisplayPreference.java b/src/com/android/settings/display/NightDisplayPreference.java
index 09928878fd..a1608d75e0 100644
--- a/src/com/android/settings/display/NightDisplayPreference.java
+++ b/src/com/android/settings/display/NightDisplayPreference.java
@@ -19,25 +19,20 @@ import androidx.preference.SwitchPreference;
 import android.util.AttributeSet;
 
 import com.android.internal.app.ColorDisplayController;
-import com.android.settings.R;
 
-import java.text.DateFormat;
 import java.time.LocalTime;
-import java.util.Calendar;
-import java.util.TimeZone;
 
 public class NightDisplayPreference extends SwitchPreference
         implements ColorDisplayController.Callback {
 
     private ColorDisplayController mController;
-    private DateFormat mTimeFormatter;
+    private NightDisplayTimeFormatter mTimeFormatter;
 
     public NightDisplayPreference(Context context, AttributeSet attrs) {
         super(context, attrs);
 
         mController = new ColorDisplayController(context);
-        mTimeFormatter = android.text.format.DateFormat.getTimeFormat(context);
-        mTimeFormatter.setTimeZone(TimeZone.getTimeZone("UTC"));
+        mTimeFormatter = new NightDisplayTimeFormatter(context);
     }
 
     @Override
@@ -59,53 +54,6 @@ public class NightDisplayPreference extends SwitchPreference
         mController.setListener(null);
     }
 
-    private String getFormattedTimeString(LocalTime localTime) {
-        final Calendar c = Calendar.getInstance();
-        c.setTimeZone(mTimeFormatter.getTimeZone());
-        c.set(Calendar.HOUR_OF_DAY, localTime.getHour());
-        c.set(Calendar.MINUTE, localTime.getMinute());
-        c.set(Calendar.SECOND, 0);
-        c.set(Calendar.MILLISECOND, 0);
-        return mTimeFormatter.format(c.getTime());
-    }
-
-    private void updateSummary() {
-        final Context context = getContext();
-
-        final boolean isActivated = mController.isActivated();
-        final int autoMode = mController.getAutoMode();
-
-        final String autoModeSummary;
-        switch (autoMode) {
-            default:
-            case ColorDisplayController.AUTO_MODE_DISABLED:
-                autoModeSummary = context.getString(isActivated
-                        ? R.string.night_display_summary_on_auto_mode_never
-                        : R.string.night_display_summary_off_auto_mode_never);
-                break;
-            case ColorDisplayController.AUTO_MODE_CUSTOM:
-                if (isActivated) {
-                    autoModeSummary = context.getString(
-                            R.string.night_display_summary_on_auto_mode_custom,
-                            getFormattedTimeString(mController.getCustomEndTime()));
-                } else {
-                    autoModeSummary = context.getString(
-                            R.string.night_display_summary_off_auto_mode_custom,
-                            getFormattedTimeString(mController.getCustomStartTime()));
-                }
-                break;
-            case ColorDisplayController.AUTO_MODE_TWILIGHT:
-                autoModeSummary = context.getString(isActivated
-                        ? R.string.night_display_summary_on_auto_mode_twilight
-                        : R.string.night_display_summary_off_auto_mode_twilight);
-                break;
-        }
-
-        final int summaryFormatResId = isActivated ? R.string.night_display_summary_on
-                : R.string.night_display_summary_off;
-        setSummary(context.getString(summaryFormatResId, autoModeSummary));
-    }
-
     @Override
     public void onActivated(boolean activated) {
         updateSummary();
@@ -125,4 +73,8 @@ public class NightDisplayPreference extends SwitchPreference
     public void onCustomEndTimeChanged(LocalTime endTime) {
         updateSummary();
     }
+
+    private void updateSummary() {
+        setSummary(mTimeFormatter.getAutoModeTimeSummary(getContext(), mController));
+    }
 }
diff --git a/src/com/android/settings/display/NightDisplaySettings.java b/src/com/android/settings/display/NightDisplaySettings.java
index b2e6ba68f6..f713617b3b 100644
--- a/src/com/android/settings/display/NightDisplaySettings.java
+++ b/src/com/android/settings/display/NightDisplaySettings.java
@@ -21,53 +21,34 @@ import android.app.TimePickerDialog;
 import android.content.Context;
 import android.os.Bundle;
 import android.provider.SearchIndexableResource;
-import androidx.preference.DropDownPreference;
 import androidx.preference.Preference;
-import androidx.preference.TwoStatePreference;
 
 import com.android.internal.app.ColorDisplayController;
 import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
 import com.android.settings.R;
+import com.android.settings.dashboard.DashboardFragment;
 import com.android.settings.search.BaseSearchIndexProvider;
 import com.android.settings.search.Indexable;
-import com.android.settings.widget.SeekBarPreference;
-import com.android.settings.SettingsPreferenceFragment;
 import com.android.settingslib.core.AbstractPreferenceController;
 import com.android.settingslib.search.SearchIndexable;
 
-import java.text.DateFormat;
 import java.time.LocalTime;
 import java.util.ArrayList;
-import java.util.Calendar;
 import java.util.List;
-import java.util.TimeZone;
 
 /**
  * Settings screen for Night display.
- * TODO (b/69912911) Upgrade to Dashboard fragment
  */
 @SearchIndexable(forTarget = SearchIndexable.ALL & ~SearchIndexable.ARC)
-public class NightDisplaySettings extends SettingsPreferenceFragment
-        implements ColorDisplayController.Callback, Preference.OnPreferenceChangeListener,
-        Indexable {
+public class NightDisplaySettings extends DashboardFragment
+        implements ColorDisplayController.Callback, Indexable {
 
-    private static final String KEY_NIGHT_DISPLAY_AUTO_MODE = "night_display_auto_mode";
-    private static final String KEY_NIGHT_DISPLAY_START_TIME = "night_display_start_time";
-    private static final String KEY_NIGHT_DISPLAY_END_TIME = "night_display_end_time";
-    private static final String KEY_NIGHT_DISPLAY_ACTIVATED = "night_display_activated";
-    private static final String KEY_NIGHT_DISPLAY_TEMPERATURE = "night_display_temperature";
+    private static final String TAG = "NightDisplaySettings";
 
     private static final int DIALOG_START_TIME = 0;
     private static final int DIALOG_END_TIME = 1;
 
     private ColorDisplayController mController;
-    private DateFormat mTimeFormatter;
-
-    private DropDownPreference mAutoModePreference;
-    private Preference mStartTimePreference;
-    private Preference mEndTimePreference;
-    private TwoStatePreference mActivatedPreference;
-    private SeekBarPreference mTemperaturePreference;
 
     @Override
     public void onCreate(Bundle savedInstanceState) {
@@ -75,45 +56,6 @@ public class NightDisplaySettings extends SettingsPreferenceFragment
 
         final Context context = getContext();
         mController = new ColorDisplayController(context);
-
-        mTimeFormatter = android.text.format.DateFormat.getTimeFormat(context);
-        mTimeFormatter.setTimeZone(TimeZone.getTimeZone("UTC"));
-
-        mTemperaturePreference.setMax(convertTemperature(mController.getMinimumColorTemperature()));
-        mTemperaturePreference.setContinuousUpdates(true);
-    }
-
-    @Override
-    public int getHelpResource() {
-        return R.string.help_url_night_display;
-    }
-
-    @Override
-    public void onCreatePreferences(Bundle savedInstanceState, String rootKey) {
-        super.onCreatePreferences(savedInstanceState, rootKey);
-
-        // Load the preferences from xml.
-        addPreferencesFromResource(R.xml.night_display_settings);
-        mFooterPreferenceMixin.createFooterPreference().setTitle(R.string.night_display_text);
-        mAutoModePreference = (DropDownPreference) findPreference(KEY_NIGHT_DISPLAY_AUTO_MODE);
-        mStartTimePreference = findPreference(KEY_NIGHT_DISPLAY_START_TIME);
-        mEndTimePreference = findPreference(KEY_NIGHT_DISPLAY_END_TIME);
-        mActivatedPreference = (TwoStatePreference) findPreference(KEY_NIGHT_DISPLAY_ACTIVATED);
-        mTemperaturePreference = (SeekBarPreference) findPreference(KEY_NIGHT_DISPLAY_TEMPERATURE);
-
-        mAutoModePreference.setEntries(new CharSequence[]{
-                getString(R.string.night_display_auto_mode_never),
-                getString(R.string.night_display_auto_mode_custom),
-                getString(R.string.night_display_auto_mode_twilight)
-        });
-        mAutoModePreference.setEntryValues(new CharSequence[]{
-                String.valueOf(ColorDisplayController.AUTO_MODE_DISABLED),
-                String.valueOf(ColorDisplayController.AUTO_MODE_CUSTOM),
-                String.valueOf(ColorDisplayController.AUTO_MODE_TWILIGHT)
-        });
-        mAutoModePreference.setOnPreferenceChangeListener(this);
-        mActivatedPreference.setOnPreferenceChangeListener(this);
-        mTemperaturePreference.setOnPreferenceChangeListener(this);
     }
 
     @Override
@@ -122,14 +64,6 @@ public class NightDisplaySettings extends SettingsPreferenceFragment
 
         // Listen for changes only while visible.
         mController.setListener(this);
-
-        // Update the current state since it have changed while not visible.
-        onActivated(mController.isActivated());
-        onAutoModeChanged(mController.getAutoMode());
-        onCustomStartTimeChanged(mController.getCustomStartTime());
-        onCustomEndTimeChanged(mController.getCustomEndTime());
-        onColorTemperatureChanged(mController.getColorTemperature());
-        onDisplayColorModeChanged(mController.getColorMode());
     }
 
     @Override
@@ -142,12 +76,12 @@ public class NightDisplaySettings extends SettingsPreferenceFragment
 
     @Override
     public boolean onPreferenceTreeClick(Preference preference) {
-        if (preference == mStartTimePreference) {
-            showDialog(DIALOG_START_TIME);
-            return true;
-        } else if (preference == mEndTimePreference) {
+        if ("night_display_end_time".equals(preference.getKey())) {
             showDialog(DIALOG_END_TIME);
             return true;
+        } else if ("night_display_start_time".equals(preference.getKey())) {
+            showDialog(DIALOG_START_TIME);
+            return true;
         }
         return super.onPreferenceTreeClick(preference);
     }
@@ -190,63 +124,37 @@ public class NightDisplaySettings extends SettingsPreferenceFragment
 
     @Override
     public void onActivated(boolean activated) {
-        mActivatedPreference.setChecked(activated);
-        mTemperaturePreference.setEnabled(activated);
+        // Update activated and temperature preferences.
+        updatePreferenceStates();
     }
 
     @Override
     public void onAutoModeChanged(int autoMode) {
-        mAutoModePreference.setValue(String.valueOf(autoMode));
-
-        final boolean showCustomSchedule = autoMode == ColorDisplayController.AUTO_MODE_CUSTOM;
-        mStartTimePreference.setVisible(showCustomSchedule);
-        mEndTimePreference.setVisible(showCustomSchedule);
+        // Update auto mode, start time, and end time preferences.
+        updatePreferenceStates();
     }
 
     @Override
     public void onColorTemperatureChanged(int colorTemperature) {
-        mTemperaturePreference.setProgress(convertTemperature(colorTemperature));
-    }
-
-    private String getFormattedTimeString(LocalTime localTime) {
-        final Calendar c = Calendar.getInstance();
-        c.setTimeZone(mTimeFormatter.getTimeZone());
-        c.set(Calendar.HOUR_OF_DAY, localTime.getHour());
-        c.set(Calendar.MINUTE, localTime.getMinute());
-        c.set(Calendar.SECOND, 0);
-        c.set(Calendar.MILLISECOND, 0);
-        return mTimeFormatter.format(c.getTime());
-    }
-
-    /**
-     * Inverts and range-adjusts a raw value from the SeekBar (i.e. [0, maxTemp-minTemp]), or
-     * converts an inverted and range-adjusted value to the raw SeekBar value, depending on the
-     * adjustment status of the input.
-     */
-    private int convertTemperature(int temperature) {
-        return mController.getMaximumColorTemperature() - temperature;
+        // Update temperature preference.
+        updatePreferenceStates();
     }
 
     @Override
     public void onCustomStartTimeChanged(LocalTime startTime) {
-        mStartTimePreference.setSummary(getFormattedTimeString(startTime));
+        // Update start time preference.
+        updatePreferenceStates();
     }
 
     @Override
     public void onCustomEndTimeChanged(LocalTime endTime) {
-        mEndTimePreference.setSummary(getFormattedTimeString(endTime));
+        // Update end time preference.
+        updatePreferenceStates();
     }
 
     @Override
-    public boolean onPreferenceChange(Preference preference, Object newValue) {
-        if (preference == mAutoModePreference) {
-            return mController.setAutoMode(Integer.parseInt((String) newValue));
-        } else if (preference == mActivatedPreference) {
-            return mController.setActivated((Boolean) newValue);
-        } else if (preference == mTemperaturePreference) {
-            return mController.setColorTemperature(convertTemperature((Integer) newValue));
-        }
-        return false;
+    protected int getPreferenceScreenResId() {
+        return R.xml.night_display_settings;
     }
 
     @Override
@@ -254,13 +162,33 @@ public class NightDisplaySettings extends SettingsPreferenceFragment
         return MetricsEvent.NIGHT_DISPLAY_SETTINGS;
     }
 
+    @Override
+    public int getHelpResource() {
+        return R.string.help_url_night_display;
+    }
+
+    @Override
+    protected String getLogTag() {
+        return TAG;
+    }
+
+    @Override
+    protected List<AbstractPreferenceController> createPreferenceControllers(Context context) {
+        return buildPreferenceControllers(context);
+    }
+
+    private static List <AbstractPreferenceController> buildPreferenceControllers(Context context) {
+        final List<AbstractPreferenceController> controllers = new ArrayList<>(1);
+        controllers.add(new NightDisplayFooterPreferenceController(context));
+        return controllers;
+    }
+
     public static final Indexable.SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
             new BaseSearchIndexProvider() {
                 @Override
                 public List<SearchIndexableResource> getXmlResourcesToIndex(Context context,
                         boolean enabled) {
                     final ArrayList<SearchIndexableResource> result = new ArrayList<>();
-
                     final SearchIndexableResource sir = new SearchIndexableResource(context);
                     sir.xmlResId = R.xml.night_display_settings;
                     result.add(sir);
@@ -271,5 +199,11 @@ public class NightDisplaySettings extends SettingsPreferenceFragment
                 protected boolean isPageSearchEnabled(Context context) {
                     return ColorDisplayController.isAvailable(context);
                 }
+
+                @Override
+                public List<AbstractPreferenceController> createPreferenceControllers(
+                    Context context) {
+                    return buildPreferenceControllers(context);
+                }
             };
 }
diff --git a/src/com/android/settings/display/NightDisplayTimeFormatter.java b/src/com/android/settings/display/NightDisplayTimeFormatter.java
new file mode 100644
index 0000000000..48a1994cee
--- /dev/null
+++ b/src/com/android/settings/display/NightDisplayTimeFormatter.java
@@ -0,0 +1,75 @@
+/*
+ * 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.display;
+
+import android.content.Context;
+
+import com.android.internal.app.ColorDisplayController;
+import com.android.settings.R;
+
+import java.text.DateFormat;
+import java.time.LocalTime;
+import java.util.Calendar;
+import java.util.TimeZone;
+
+public class NightDisplayTimeFormatter {
+
+    private DateFormat mTimeFormatter;
+
+    NightDisplayTimeFormatter(Context context) {
+        mTimeFormatter = android.text.format.DateFormat.getTimeFormat(context);
+        mTimeFormatter.setTimeZone(TimeZone.getTimeZone("UTC"));
+    }
+
+    public String getFormattedTimeString(LocalTime localTime) {
+        final Calendar c = Calendar.getInstance();
+        c.setTimeZone(mTimeFormatter.getTimeZone());
+        c.set(Calendar.HOUR_OF_DAY, localTime.getHour());
+        c.set(Calendar.MINUTE, localTime.getMinute());
+        c.set(Calendar.SECOND, 0);
+        c.set(Calendar.MILLISECOND, 0);
+        return mTimeFormatter.format(c.getTime());
+    }
+
+    public String getAutoModeTimeSummary(Context context, ColorDisplayController controller) {
+        final int summaryFormatResId = controller.isActivated() ? R.string.night_display_summary_on
+                : R.string.night_display_summary_off;
+        return context.getString(summaryFormatResId, getAutoModeSummary(context, controller));
+    }
+
+    private String getAutoModeSummary(Context context, ColorDisplayController controller) {
+        final boolean isActivated = controller.isActivated();
+        final int autoMode = controller.getAutoMode();
+        if (autoMode == ColorDisplayController.AUTO_MODE_CUSTOM) {
+            if (isActivated) {
+                return context.getString(R.string.night_display_summary_on_auto_mode_custom,
+                        getFormattedTimeString(controller.getCustomEndTime()));
+            } else {
+                return context.getString(R.string.night_display_summary_off_auto_mode_custom,
+                        getFormattedTimeString(controller.getCustomStartTime()));
+            }
+        } else if (autoMode == ColorDisplayController.AUTO_MODE_TWILIGHT) {
+            return context.getString(isActivated
+                    ? R.string.night_display_summary_on_auto_mode_twilight
+                    : R.string.night_display_summary_off_auto_mode_twilight);
+        } else {
+            return context.getString(isActivated
+                    ? R.string.night_display_summary_on_auto_mode_never
+                    : R.string.night_display_summary_off_auto_mode_never);
+        }
+    }
+}