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

Revert "Revert "Add settings for scheduling dark theme""

Browse Source 
This reverts commit 50c0fa136c.

Reason for revert: Fixed the error which is code incompatibility
Test: run all settings tests
Change-Id: I8f05b50f8198c4b2565bb9b6f62ddda5029c8365
Merged-In: I8f05b50f8198c4b2565bb9b6f62ddda5029c8365
Bug: 141567787
This commit is contained in:
Jay Aliomer
2019-11-22 14:51:08 +00:00
parent 775106e40d
commit 53ad4fedc6
16 changed files with 903 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -21,6 +21,7 @@ import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.res.Configuration;
import android.os.PowerManager;
import android.provider.Settings;
@@ -28,10 +29,10 @@ import androidx.annotation.VisibleForTesting;
import androidx.fragment.app.Fragment;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import androidx.preference.SwitchPreference;
import com.android.settings.R;
import com.android.settings.core.TogglePreferenceController;
import com.android.settings.display.darkmode.DarkModePreference;
import com.android.settingslib.core.lifecycle.LifecycleObserver;
import com.android.settingslib.core.lifecycle.events.OnStart;
import com.android.settingslib.core.lifecycle.events.OnStop;
@@ -44,7 +45,7 @@ public class DarkUIPreferenceController extends TogglePreferenceController imple
public static final int DIALOG_SEEN = 1;
@VisibleForTesting
SwitchPreference mPreference;
Preference mPreference;
private UiModeManager mUiModeManager;
private PowerManager mPowerManager;
@@ -68,7 +69,8 @@ public class DarkUIPreferenceController extends TogglePreferenceController imple
@Override
public boolean isChecked() {
return mUiModeManager.getNightMode() == UiModeManager.MODE_NIGHT_YES;
return (mContext.getResources().getConfiguration().uiMode
& Configuration.UI_MODE_NIGHT_YES) != 0;
}
@Override
@@ -92,10 +94,7 @@ public class DarkUIPreferenceController extends TogglePreferenceController imple
showDarkModeDialog();
return false;
}
mUiModeManager.setNightMode(isChecked
? UiModeManager.MODE_NIGHT_YES
: UiModeManager.MODE_NIGHT_NO);
return true;
return mUiModeManager.setNightModeActivated(isChecked);
}
private void showDarkModeDialog() {
@@ -113,12 +112,10 @@ public class DarkUIPreferenceController extends TogglePreferenceController imple
boolean isBatterySaver = isPowerSaveMode();
mPreference.setEnabled(!isBatterySaver);
if (isBatterySaver) {
int stringId = mUiModeManager.getNightMode() == UiModeManager.MODE_NIGHT_YES
int stringId = isChecked()
? R.string.dark_ui_mode_disabled_summary_dark_theme_on
: R.string.dark_ui_mode_disabled_summary_dark_theme_off;
mPreference.setSummary(mContext.getString(stringId));
} else {
mPreference.setSummary(null);
}
}
@@ -127,22 +124,17 @@ public class DarkUIPreferenceController extends TogglePreferenceController imple
return mPowerManager.isPowerSaveMode();
}
@VisibleForTesting
void setUiModeManager(UiModeManager uiModeManager) {
mUiModeManager = uiModeManager;
}
public void setParentFragment(Fragment fragment) {
mFragment = fragment;
}
@Override
public void onStart() {
mContext.registerReceiver(mReceiver,
new IntentFilter(PowerManager.ACTION_POWER_SAVE_MODE_CHANGED));
}
// used by AccessibilitySettings
public void setParentFragment(Fragment fragment) {
mFragment = fragment;
}
@Override
public void onStop() {
mContext.unregisterReceiver(mReceiver);

115
src/com/android/settings/display/darkmode/DarkModeActivationPreferenceController.java Normal file
View File

@@ -0,0 +1,115 @@
/*
* 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.darkmode;
import android.app.UiModeManager;
import android.content.Context;
import android.content.res.Configuration;
import android.view.View;
import android.widget.Button;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.settings.R;
import com.android.settings.core.BasePreferenceController;
import com.android.settingslib.widget.LayoutPreference;
/**
* Controller for activate/deactivate night mode button
*/
public class DarkModeActivationPreferenceController extends BasePreferenceController {
private final UiModeManager mUiModeManager;
private Button mTurnOffButton;
private Button mTurnOnButton;
public DarkModeActivationPreferenceController(Context context,
String preferenceKey) {
super(context, preferenceKey);
mUiModeManager = context.getSystemService(UiModeManager.class);
}
@Override
public final void updateState(Preference preference) {
final boolean active = (mContext.getResources().getConfiguration().uiMode
& Configuration.UI_MODE_NIGHT_YES) != 0;
updateNightMode(active);
}
private void updateNightMode(boolean active) {
final int autoMode = mUiModeManager.getNightMode();
String buttonText;
if (autoMode == UiModeManager.MODE_NIGHT_AUTO) {
buttonText = mContext.getString(active
? R.string.dark_ui_activation_off_auto
: R.string.dark_ui_activation_on_auto);
} else {
buttonText = mContext.getString(active
? R.string.dark_ui_activation_off_manual
: R.string.dark_ui_activation_on_manual);
}
if (active) {
mTurnOnButton.setVisibility(View.GONE);
mTurnOffButton.setVisibility(View.VISIBLE);
mTurnOffButton.setText(buttonText);
} else {
mTurnOnButton.setVisibility(View.VISIBLE);
mTurnOffButton.setVisibility(View.GONE);
mTurnOnButton.setText(buttonText);
}
}
@Override
public CharSequence getSummary() {
final boolean isActivated = (mContext.getResources().getConfiguration().uiMode
& Configuration.UI_MODE_NIGHT_YES) != 0;
final int autoMode = mUiModeManager.getNightMode();
if (autoMode == UiModeManager.MODE_NIGHT_AUTO) {
return mContext.getString(isActivated
? R.string.dark_ui_summary_on_auto_mode_auto
: R.string.dark_ui_summary_off_auto_mode_auto);
} else {
return mContext.getString(isActivated
? R.string.dark_ui_summary_on_auto_mode_never
: R.string.dark_ui_summary_off_auto_mode_never);
}
}
private final View.OnClickListener mListener = new View.OnClickListener() {
@Override
public void onClick(View v) {
final boolean active = (mContext.getResources().getConfiguration().uiMode
& Configuration.UI_MODE_NIGHT_YES) != 0;
mUiModeManager.setNightModeActivated(!active);
updateNightMode(!active);
}
};
@Override
public void displayPreference(PreferenceScreen screen) {
super.displayPreference(screen);
final LayoutPreference preference = screen.findPreference(getPreferenceKey());
mTurnOnButton = preference.findViewById(R.id.dark_ui_turn_on_button);
mTurnOnButton.setOnClickListener(mListener);
mTurnOffButton = preference.findViewById(R.id.dark_ui_turn_off_button);
mTurnOffButton.setOnClickListener(mListener);
}
@Override
public int getAvailabilityStatus() {
return AVAILABLE;
}
}

80
src/com/android/settings/display/darkmode/DarkModeObserver.java Normal file
View File

@@ -0,0 +1,80 @@
/*
* 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.darkmode;
import android.content.Context;
import android.database.ContentObserver;
import android.net.Uri;
import android.os.Handler;
import android.os.Looper;
import android.provider.Settings;
import com.android.internal.annotations.VisibleForTesting;
/**
* Observes changes for dark night settings*/
public class DarkModeObserver {
private ContentObserver mContentObserver;
private Runnable mCallback;
private Context mContext;
public DarkModeObserver(Context context) {
mContext = context;
mContentObserver = new ContentObserver(new Handler(Looper.getMainLooper())) {
@Override
public void onChange(boolean selfChange, Uri uri) {
super.onChange(selfChange, uri);
final String setting = uri == null ? null : uri.getLastPathSegment();
if (setting != null && mCallback != null) {
switch (setting) {
case Settings.Secure.UI_NIGHT_MODE:
mCallback.run();
break;
default:
}
}
}
};
}
/**
* subscribe callback when night mode changed in the database
*
* @param callback the callback that gets triggered when subscribed
*/
public void subscribe(Runnable callback) {
callback.run();
mCallback = callback;
final Uri uri = Settings.Secure.getUriFor(Settings.Secure.UI_NIGHT_MODE);
mContext.getContentResolver().registerContentObserver(uri, false, mContentObserver);
}
/**
* unsubscribe from dark ui database changes
*/
public void unsubscribe() {
mContext.getContentResolver().unregisterContentObserver(mContentObserver);
mCallback = null;
}
@VisibleForTesting
protected void setContentObserver(ContentObserver co) {
mContentObserver = co;
}
@VisibleForTesting
protected ContentObserver getContentObserver() {
return mContentObserver;
}
}

75
src/com/android/settings/display/darkmode/DarkModePreference.java Normal file
View File

@@ -0,0 +1,75 @@
/*
* 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.darkmode;
import android.app.UiModeManager;
import android.content.Context;
import android.content.res.Configuration;
import android.util.AttributeSet;
import com.android.settings.R;
import com.android.settings.widget.MasterSwitchPreference;
/**
* component for the display settings dark ui summary*/
public class DarkModePreference extends MasterSwitchPreference {
private UiModeManager mUiModeManager;
private DarkModeObserver mDarkModeObserver;
private Runnable mCallback;
public DarkModePreference(Context context, AttributeSet attrs) {
super(context, attrs);
mDarkModeObserver = new DarkModeObserver(context);
mUiModeManager = context.getSystemService(UiModeManager.class);
mCallback = () -> {
updateSummary();
};
mDarkModeObserver.subscribe(mCallback);
}
@Override
public void onAttached() {
super.onAttached();
mDarkModeObserver.subscribe(mCallback);
}
@Override
public void onDetached() {
super.onDetached();
mDarkModeObserver.unsubscribe();
}
private void updateSummary() {
final boolean active = (getContext().getResources().getConfiguration().uiMode
& Configuration.UI_MODE_NIGHT_YES) != 0;
final boolean auto = mUiModeManager.getNightMode() == UiModeManager.MODE_NIGHT_AUTO;
String detail;
if (active) {
detail = getContext().getString(auto
? R.string.dark_ui_summary_on_auto_mode_auto
: R.string.dark_ui_summary_on_auto_mode_never);
} else {
detail = getContext().getString(auto
? R.string.dark_ui_summary_off_auto_mode_auto
: R.string.dark_ui_summary_off_auto_mode_never);
}
String summary = getContext().getString(active
? R.string.dark_ui_summary_on
: R.string.dark_ui_summary_off, detail);
setSummary(summary);
}
}

82
src/com/android/settings/display/darkmode/DarkModeScheduleSelectorController.java Normal file
View File

@@ -0,0 +1,82 @@
/*
* 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.darkmode;
import android.app.UiModeManager;
import android.content.Context;
import android.content.res.Configuration;
import androidx.preference.DropDownPreference;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.settings.R;
import com.android.settings.core.BasePreferenceController;
/**
* Controller for the dark ui option dropdown
*/
public class DarkModeScheduleSelectorController extends BasePreferenceController
implements Preference.OnPreferenceChangeListener {
private final UiModeManager mUiModeManager;
private boolean mPreferenceSet = false;
private DropDownPreference mPreference;
private String mCurrentMode;
public DarkModeScheduleSelectorController(Context context, String key) {
super(context, key);
mUiModeManager = context.getSystemService(UiModeManager.class);
}
@Override
public void displayPreference(PreferenceScreen screen) {
super.displayPreference(screen);
mPreference = screen.findPreference(getPreferenceKey());
}
@Override
public int getAvailabilityStatus() {
return BasePreferenceController.AVAILABLE;
}
@Override
public final void updateState(Preference preference) {
mCurrentMode =
mUiModeManager.getNightMode() == UiModeManager.MODE_NIGHT_AUTO
? mContext.getString(R.string.dark_ui_auto_mode_auto)
: mContext.getString(R.string.dark_ui_auto_mode_never);
mPreference.setValue(mCurrentMode);
}
@Override
public final boolean onPreferenceChange(Preference preference, Object newValue) {
String newMode = (String) newValue;
if (newMode == mCurrentMode) {
return false;
}
mCurrentMode = newMode;
if (mCurrentMode == mContext.getString(R.string.dark_ui_auto_mode_never)) {
boolean active = (mContext.getResources().getConfiguration().uiMode
& Configuration.UI_MODE_NIGHT_YES) != 0;
int mode = active ? UiModeManager.MODE_NIGHT_YES
: UiModeManager.MODE_NIGHT_NO;
mUiModeManager.setNightMode(mode);
} else if (mCurrentMode ==
mContext.getString(R.string.dark_ui_auto_mode_auto)) {
mUiModeManager.setNightMode(UiModeManager.MODE_NIGHT_AUTO);
}
return true;
}
}

81
src/com/android/settings/display/darkmode/DarkModeSettingsFragment.java Normal file
View File

@@ -0,0 +1,81 @@
/*
* 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.darkmode;
import android.content.Context;
import android.os.Bundle;
import android.app.settings.SettingsEnums;
import com.android.settings.R;
import com.android.settings.dashboard.DashboardFragment;
import com.android.settings.search.BaseSearchIndexProvider;
import com.android.settingslib.search.SearchIndexable;
/**
* Settings screen for Dark UI Mode
*/
@SearchIndexable(forTarget = SearchIndexable.ALL & ~SearchIndexable.ARC)
public class DarkModeSettingsFragment extends DashboardFragment {
private static final String TAG = "DarkModeSettingsFragment";
private DarkModeObserver mContentObserver;
private Runnable mCallback = () -> {
updatePreferenceStates();
};
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
final Context context = getContext();
mContentObserver = new DarkModeObserver(context);
}
@Override
public void onStart() {
super.onStart();
// Listen for changes only while visible.
mContentObserver.subscribe(mCallback);
}
@Override
public void onStop() {
super.onStop();
// Stop listening for state changes.
mContentObserver.unsubscribe();
}
@Override
protected int getPreferenceScreenResId() {
return R.xml.dark_mode_settings;
}
@Override
public int getHelpResource() {
return R.string.help_url_dark_theme;
}
@Override
protected String getLogTag() {
return TAG;
}
@Override
public int getMetricsCategory() {
return SettingsEnums.DARK_UI_SETTINGS;
}
public static final BaseSearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
new BaseSearchIndexProvider();
}