--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ Copyright (C) 2019 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="48dp"
+ android:height="48dp"
+ android:viewportWidth="24.0"
+ android:viewportHeight="24.0"
+ android:tint="?android:attr/colorAccent">
+ <path
+ android:fillColor="#FF000000"
+ android:pathData="M12,22C17.52,22 22,17.52 22,12 22,6.48 17.52,2 12,2 6.48,2 2,6.48 2,12 2,17.52 6.48,22 12,22ZM12,3.915c3.889,0 8,4.005 8,8.085 0,4.08 -3.927,7.992 -7.928,7.992z"/>
+</vector>
\ No newline at end of file
<string name="demo_mode">System UI demo mode</string>
<!-- [CHAR LIMIT=60] Name of setting that changes the UI to dark -->
- <string name="dark_ui_mode">Theme</string>
-
- <!-- [CHAR LIMIT=60] Name of dev option that changes the color of the UI -->
- <string name="dark_ui_mode_title">Choose Theme</string>
-
- <!-- [CHAR_LIMIT=NONE] Summary that is shown in the footer when light mode is selected -->
- <string name="dark_ui_settings_light_summary">This setting also applies to apps</string>
+ <string name="dark_ui_mode">Dark Theme</string>
<!-- [CHAR_LIMIT=NONE] Summary that is shown in the footer when dark mode is selected -->
<string name="dark_ui_settings_dark_summary">Supported apps will also switch to dark theme</string>
+ <!-- [CHAR_LIMIT=40] Positive button text in dark theme notification -->
+ <string name="dark_ui_settings_dialog_acknowledge">Got it</string>
+
<!-- [CHAR LIMIT=60] Name of dev option to enable extra quick settings tiles -->
<string name="quick_settings_developer_tiles">Quick settings developer tiles</string>
android:title="@string/screen_zoom_title"
settings:searchable="false"/>
- <Preference
+ <SwitchPreference
android:key="dark_ui_mode_accessibility"
- android:fragment="com.android.settings.display.DarkUISettings"
android:title="@string/dark_ui_mode"
- settings:searchable="false" />
+ settings:searchable="false"/>
<Preference
android:fragment="com.android.settings.accessibility.MagnificationPreferenceFragment"
</com.android.settingslib.RestrictedPreference>
- <Preference
+ <SwitchPreference
android:key="dark_ui_mode"
- android:fragment="com.android.settings.display.DarkUISettings"
android:title="@string/dark_ui_mode"
- settings:searchable="false"
+ settings:keywords="@string/keywords_dark_ui_mode"
settings:controller="com.android.settings.display.DarkUIPreferenceController"/>
<!-- Cross-listed item, if you change this, also change it in power_usage_summary.xml -->
import android.app.settings.SettingsEnums;
import android.content.Context;
+import android.os.Bundle;
import android.provider.SearchIndexableResource;
import com.android.settings.dashboard.DashboardFragment;
import com.android.settings.display.BrightnessLevelPreferenceController;
import com.android.settings.display.CameraGesturePreferenceController;
+import com.android.settings.display.DarkUIPreferenceController;
import com.android.settings.display.LiftToWakePreferenceController;
import com.android.settings.display.NightDisplayPreferenceController;
import com.android.settings.display.NightModePreferenceController;
}
@Override
+ public void onCreate(Bundle icicle) {
+ super.onCreate(icicle);
+ use(DarkUIPreferenceController.class).setParentFragment(this);
+ }
+
+ @Override
protected List<AbstractPreferenceController> createPreferenceControllers(Context context) {
return buildPreferenceControllers(context, getSettingsLifecycle());
}
private SwitchPreference mToggleInversionPreference;
private ColorInversionPreferenceController mInversionPreferenceController;
private AccessibilityHearingAidPreferenceController mHearingAidPreferenceController;
- private Preference mDarkUIModePreference;
+ private SwitchPreference mDarkUIModePreference;
private DarkUIPreferenceController mDarkUIPreferenceController;
private LiveCaptionPreferenceController mLiveCaptionPreferenceController;
mDarkUIModePreference = findPreference(DARK_UI_MODE_PREFERENCE);
mDarkUIPreferenceController = new DarkUIPreferenceController(getContext(),
DARK_UI_MODE_PREFERENCE);
+ mDarkUIPreferenceController.setParentFragment(this);
mDarkUIPreferenceController.displayPreference(getPreferenceScreen());
- mDarkUIModePreference.setSummary(mDarkUIPreferenceController.getSummary());
}
private void updateAllPreferences() {
--- /dev/null
+/*
+ * Copyright (C) 2019 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 static com.android.settings.display.DarkUIPreferenceController.DARK_MODE_PREFS;
+import static com.android.settings.display.DarkUIPreferenceController.PREF_DARK_MODE_DIALOG_SEEN;
+
+import android.app.Dialog;
+import android.app.UiModeManager;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.os.Bundle;
+import android.provider.Settings;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.AlertDialog;
+
+import com.android.settings.R;
+import com.android.settings.core.instrumentation.InstrumentedDialogFragment;
+
+public class DarkUIInfoDialogFragment extends InstrumentedDialogFragment
+ implements DialogInterface.OnClickListener{
+
+ @Override
+ public int getMetricsCategory() {
+ // TODO(b/130251804): Add metrics constant in followup change to avoid merge conflict in
+ // beta cherrypick
+ return 0;
+ }
+
+ @NonNull
+ @Override
+ public Dialog onCreateDialog(@Nullable Bundle savedInstanceState) {
+ Context context = getContext();
+ AlertDialog.Builder dialog = new AlertDialog.Builder(context);
+ LayoutInflater inflater = LayoutInflater.from(dialog.getContext());
+ View titleView = inflater.inflate(R.layout.settings_dialog_title, null);
+ ((ImageView) titleView.findViewById(R.id.settings_icon))
+ .setImageDrawable(context.getDrawable(R.drawable.dark_theme));
+ ((TextView) titleView.findViewById(R.id.settings_title)).setText(R.string.dark_ui_mode);
+
+ dialog.setCustomTitle(titleView)
+ .setMessage(R.string.dark_ui_settings_dark_summary)
+ .setPositiveButton(
+ R.string.dark_ui_settings_dialog_acknowledge,
+ this);
+ return dialog.create();
+ }
+
+ @Override
+ public void onDismiss(@NonNull DialogInterface dialog) {
+ enableDarkTheme();
+ super.onDismiss(dialog);
+ }
+
+ @Override
+ public void onClick(DialogInterface dialogInterface, int i) {
+ // We have to manually dismiss the dialog because changing night mode causes it to
+ // recreate itself.
+ dialogInterface.dismiss();
+ enableDarkTheme();
+ }
+
+ private void enableDarkTheme() {
+ final Context context = getContext();
+ if (context != null) {
+ Settings.Secure.putInt(context.getContentResolver(),
+ Settings.Secure.DARK_MODE_DIALOG_SEEN,
+ DarkUIPreferenceController.DIALOG_SEEN);
+ context.getSystemService(UiModeManager.class)
+ .setNightMode(UiModeManager.MODE_NIGHT_YES);
+ }
+ }
+}
import android.app.UiModeManager;
import android.content.Context;
+import android.provider.Settings;
import androidx.annotation.VisibleForTesting;
-import androidx.preference.ListPreference;
-import androidx.preference.Preference;
-import androidx.preference.PreferenceScreen;
+import androidx.fragment.app.Fragment;
-import com.android.settings.R;
-import com.android.settings.core.BasePreferenceController;
+import com.android.settings.core.TogglePreferenceController;
-public class DarkUIPreferenceController extends BasePreferenceController {
+public class DarkUIPreferenceController extends TogglePreferenceController {
+ public static final String DARK_MODE_PREFS = "dark_mode_prefs";
+ public static final String PREF_DARK_MODE_DIALOG_SEEN = "dark_mode_dialog_seen";
+ public static final int DIALOG_SEEN = 1;
private UiModeManager mUiModeManager;
+ private Context mContext;
+ private Fragment mFragment;
public DarkUIPreferenceController(Context context, String key) {
super(context, key);
+ mContext = context;
mUiModeManager = context.getSystemService(UiModeManager.class);
}
+ @Override
+ public boolean isChecked() {
+ return mUiModeManager.getNightMode() == UiModeManager.MODE_NIGHT_YES;
+ }
+
+ @Override
+ public boolean setChecked(boolean isChecked) {
+ final boolean dialogSeen =
+ Settings.Secure.getInt(mContext.getContentResolver(),
+ Settings.Secure.DARK_MODE_DIALOG_SEEN, 0) == DIALOG_SEEN;
+ if (!dialogSeen && isChecked) {
+ showDarkModeDialog();
+ return false;
+ }
+ mUiModeManager.setNightMode(isChecked
+ ? UiModeManager.MODE_NIGHT_YES
+ : UiModeManager.MODE_NIGHT_NO);
+ return true;
+ }
+
+ private void showDarkModeDialog() {
+ final DarkUIInfoDialogFragment frag = new DarkUIInfoDialogFragment();
+ if (mFragment.getFragmentManager() != null) {
+ frag.show(mFragment.getFragmentManager(), getClass().getName());
+ }
+ }
+
@VisibleForTesting
void setUiModeManager(UiModeManager uiModeManager) {
mUiModeManager = uiModeManager;
}
- @Override
- public int getAvailabilityStatus() {
- return AVAILABLE;
+ public void setParentFragment(Fragment fragment) {
+ mFragment = fragment;
}
@Override
- public CharSequence getSummary() {
- return DarkUISettingsRadioButtonsController.modeToDescription(
- mContext, mUiModeManager.getNightMode());
+ public int getAvailabilityStatus() {
+ return AVAILABLE;
}
}
+++ /dev/null
-/*
- * Copyright (C) 2019 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.app.UiModeManager;
-import android.app.settings.SettingsEnums;
-import android.content.Context;
-import android.graphics.drawable.Drawable;
-import android.provider.SearchIndexableResource;
-import androidx.preference.Preference;
-import androidx.preference.PreferenceScreen;
-import com.android.settings.R;
-import com.android.settings.search.BaseSearchIndexProvider;
-import com.android.settings.search.Indexable;
-import com.android.settings.widget.RadioButtonPickerFragment;
-import com.android.settingslib.search.SearchIndexable;
-import com.android.settingslib.widget.CandidateInfo;
-import com.android.settingslib.widget.FooterPreference;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-/**
- * The screen for selecting the dark theme preference for this device. Automatically updates
- * the associated footer view with any needed information.
- */
-@SearchIndexable(forTarget = SearchIndexable.ALL & ~SearchIndexable.ARC)
-public class DarkUISettings extends RadioButtonPickerFragment implements Indexable {
-
- private DarkUISettingsRadioButtonsController mController;
- private Preference mFooter;
-
- @Override
- protected int getPreferenceScreenResId() {
- return R.xml.dark_ui_settings;
- }
-
- @Override
- public void onAttach(Context context) {
- super.onAttach(context);
- // TODO(b/128686189): add illustration once it is ready
- setIllustration(0, 0);
- mFooter = new FooterPreference(context);
- mFooter.setIcon(android.R.color.transparent);
- mController = new DarkUISettingsRadioButtonsController(context, mFooter);
- }
-
- @Override
- protected List<? extends CandidateInfo> getCandidates() {
- final Context context = getContext();
- final List<CandidateInfo> candidates = new ArrayList<>();
- candidates.add(new DarkUISettingsCandidateInfo(
- DarkUISettingsRadioButtonsController.modeToDescription(
- context, UiModeManager.MODE_NIGHT_YES),
- /* summary */ null,
- DarkUISettingsRadioButtonsController.KEY_DARK,
- /* enabled */ true));
- candidates.add(new DarkUISettingsCandidateInfo(
- DarkUISettingsRadioButtonsController.modeToDescription(
- context, UiModeManager.MODE_NIGHT_NO),
- /* summary */ null,
- DarkUISettingsRadioButtonsController.KEY_LIGHT,
- /* enabled */ true));
- return candidates;
- }
-
- @Override
- protected void addStaticPreferences(PreferenceScreen screen) {
- screen.addPreference(mFooter);
- }
-
- @Override
- protected String getDefaultKey() {
- return mController.getDefaultKey();
- }
-
- @Override
- protected boolean setDefaultKey(String key) {
- return mController.setDefaultKey(key);
- }
-
- @Override
- public int getMetricsCategory() {
- return SettingsEnums.DARK_UI_SETTINGS;
- }
-
- static class DarkUISettingsCandidateInfo extends CandidateInfo {
-
- private final CharSequence mLabel;
- private final CharSequence mSummary;
- private final String mKey;
-
- DarkUISettingsCandidateInfo(CharSequence label, CharSequence summary, String key,
- boolean enabled) {
- super(enabled);
- mLabel = label;
- mKey = key;
- mSummary = summary;
- }
-
- @Override
- public CharSequence loadLabel() {
- return mLabel;
- }
-
- @Override
- public Drawable loadIcon() {
- return null;
- }
-
- @Override
- public String getKey() {
- return mKey;
- }
-
- public CharSequence getSummary() {
- return mSummary;
- }
- }
-
- public static final Indexable.SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
- new BaseSearchIndexProvider() {
- @Override
- public List<SearchIndexableResource> getXmlResourcesToIndex(
- Context context, boolean enabled) {
- final SearchIndexableResource sir = new SearchIndexableResource(context);
- sir.xmlResId = R.xml.dark_ui_settings;
- return Arrays.asList(sir);
- }
- };
-}
+++ /dev/null
-/*
- * Copyright (C) 2019 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.app.UiModeManager;
-import android.content.Context;
-import androidx.preference.Preference;
-import com.android.settings.R;
-import androidx.annotation.VisibleForTesting;
-
-public class DarkUISettingsRadioButtonsController {
-
- public static final String KEY_DARK = "key_dark_ui_settings_dark";
- public static final String KEY_LIGHT = "key_dark_ui_settings_light";
-
- @VisibleForTesting
- UiModeManager mManager;
-
- private Preference mFooter;
-
- public DarkUISettingsRadioButtonsController(Context context, Preference footer) {
- mManager = context.getSystemService(UiModeManager.class);
- mFooter = footer;
- }
-
- public String getDefaultKey() {
- final int mode = mManager.getNightMode();
- updateFooter();
- return mode == UiModeManager.MODE_NIGHT_YES ? KEY_DARK : KEY_LIGHT;
- }
-
- public boolean setDefaultKey(String key) {
- switch(key) {
- case KEY_DARK:
- mManager.setNightMode(UiModeManager.MODE_NIGHT_YES);
- break;
- case KEY_LIGHT:
- mManager.setNightMode(UiModeManager.MODE_NIGHT_NO);
- break;
- default:
- throw new IllegalStateException(
- "Not a valid key for " + this.getClass().getSimpleName() + ": " + key);
- }
- updateFooter();
- return true;
- }
-
- public void updateFooter() {
- final int mode = mManager.getNightMode();
- switch (mode) {
- case UiModeManager.MODE_NIGHT_YES:
- mFooter.setSummary(R.string.dark_ui_settings_dark_summary);
- break;
- case UiModeManager.MODE_NIGHT_NO:
- case UiModeManager.MODE_NIGHT_AUTO:
- default:
- mFooter.setSummary(R.string.dark_ui_settings_light_summary);
- }
- }
-
- public static String modeToDescription(Context context, int mode) {
- final String[] values = context.getResources().getStringArray(R.array.dark_ui_mode_entries);
- switch (mode) {
- case UiModeManager.MODE_NIGHT_YES:
- return values[0];
- case UiModeManager.MODE_NIGHT_NO:
- case UiModeManager.MODE_NIGHT_AUTO:
- default:
- return values[1];
- }
- }
-}
assertThat(preference.getSummary()).isEqualTo(mContext.getResources().getString(resId));
}
- @Test
- public void testDarkUIModePreferenceSummary_shouldUpdateSummary() {
- final Preference darkUIModePreference = new Preference(mContext);
- final DarkUIPreferenceController mController;
- doReturn(darkUIModePreference).when(mSettings).findPreference(
- DARK_UI_MODE_PREFERENCE);
- mController = new DarkUIPreferenceController(mContext, DARK_UI_MODE_PREFERENCE);
- final String darkUIModeDescription = modeToDescription(mUiModeManager.getNightMode());
- darkUIModePreference.setSummary(mController.getSummary());
-
- assertThat(darkUIModePreference.getSummary()).isEqualTo(darkUIModeDescription);
- }
-
private String modeToDescription(int mode) {
String[] values = mContext.getResources().getStringArray(R.array.dark_ui_mode_entries);
switch (mode) {
--- /dev/null
+/*
+ * Copyright (C) 2019 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 static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.SharedPreferences;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+
+@RunWith(RobolectricTestRunner.class)
+public class DarkUIInfoDialogFragmentTest {
+ private DarkUIInfoDialogFragment mFragment;
+ @Mock
+ private DialogInterface dialog;
+
+
+ @Before
+ public void setup() {
+ MockitoAnnotations.initMocks(this);
+ mFragment = spy(new DarkUIInfoDialogFragment());
+ }
+
+ @Test
+ public void dialogDismissedOnConfirmation() {
+ doReturn(RuntimeEnvironment.application).when(mFragment).getContext();
+ SharedPreferences prefs = RuntimeEnvironment.application.getSharedPreferences(
+ DarkUIPreferenceController.DARK_MODE_PREFS,
+ Context.MODE_PRIVATE);
+ assertThat(prefs.getBoolean(DarkUIPreferenceController.PREF_DARK_MODE_DIALOG_SEEN, false))
+ .isFalse();
+ mFragment.onClick(dialog, DialogInterface.BUTTON_POSITIVE);
+ verify(dialog, times(1)).dismiss();
+ assertThat(prefs.getBoolean(DarkUIPreferenceController.PREF_DARK_MODE_DIALOG_SEEN, false))
+ .isTrue();
+
+ }
+}
+++ /dev/null
-package com.android.settings.display;
-
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.verify;
-
-import android.app.UiModeManager;
-import android.content.Context;
-import androidx.preference.Preference;
-import com.android.settings.R;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.robolectric.RobolectricTestRunner;
-import org.robolectric.RuntimeEnvironment;
-
-@RunWith(RobolectricTestRunner.class)
-public class DarkUISettingsRadioButtonsControllerTest {
-
- @Mock
- private UiModeManager mUiModeManager;
- @Mock
- private Preference mFooter;
- private Context mContext;
- private DarkUISettingsRadioButtonsController mController;
-
- @Before
- public void setup() {
- MockitoAnnotations.initMocks(this);
- mContext = RuntimeEnvironment.application;
- mController = new DarkUISettingsRadioButtonsController(mContext, mFooter);
- mController.mManager = mUiModeManager;
- }
-
- @Test
- public void footerUpdatesCorrectly() {
- doReturn(UiModeManager.MODE_NIGHT_YES).when(mUiModeManager).getNightMode();
- mController.updateFooter();
- verify(mFooter).setSummary(eq(R.string.dark_ui_settings_dark_summary));
-
- doReturn(UiModeManager.MODE_NIGHT_NO).when(mUiModeManager).getNightMode();
- mController.updateFooter();
- verify(mFooter).setSummary(eq(R.string.dark_ui_settings_light_summary));
- }
-
- public int getCurrentMode() {
- final UiModeManager uiModeManager = mContext.getSystemService(UiModeManager.class);
- return uiModeManager.getNightMode();
- }
-}
OSDN Git Service
