PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Change dark theme screen to toggle

Browse Source 
The dark theme screen has been removed in favor of a simple
toggle with a dialog that shows up the first time a user
tries to enable dark theme when in light theme.

Test: robotests pass
Bug: 130251804
Change-Id: I48f8e24a2b2a117e5a8054c5bc0b240ba68fe1ad
This commit is contained in:
Salvador Martinez
2019-04-11 14:06:08 -07:00
parent 80584fe1f7
commit ef7ce46657
13 changed files with 243 additions and 323 deletions
Download Patch File Download Diff File Expand all files Collapse all files

93
src/com/android/settings/display/DarkUIInfoDialogFragment.java Normal file
View File

@@ -0,0 +1,93 @@
/*
* 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);
}
}
}

53
src/com/android/settings/display/DarkUIPreferenceController.java
View File

@@ -18,37 +18,66 @@ package com.android.settings.display;
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;
}
public void setParentFragment(Fragment fragment) {
mFragment = fragment;
}
@Override
public int getAvailabilityStatus() {
return AVAILABLE;
}
@Override
public CharSequence getSummary() {
return DarkUISettingsRadioButtonsController.modeToDescription(
mContext, mUiModeManager.getNightMode());
}
}

145
src/com/android/settings/display/DarkUISettings.java
View File

@@ -1,145 +0,0 @@
/*
* 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);
}
};
}

86
src/com/android/settings/display/DarkUISettingsRadioButtonsController.java
View File

@@ -1,86 +0,0 @@
/*
* 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];
}
}
}