<DropDownPreference
android:key="dark_ui_auto_mode"
android:title="@string/dark_ui_auto_mode_title"
- android:summary="%s"
+ android:summary="@string/summary_placeholder"
android:entries="@array/dark_ui_scheduler_preference_titles"
android:entryValues="@array/dark_ui_scheduler_preference_titles"
settings:controller="com.android.settings.display.darkmode.DarkModeScheduleSelectorController"
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;
Settings.Secure.DARK_MODE_DIALOG_SEEN, 0) == DIALOG_SEEN;
if (!dialogSeen && isChecked) {
showDarkModeDialog();
- return false;
}
return mUiModeManager.setNightModeActivated(isChecked);
}
import android.app.UiModeManager;
import android.content.Context;
import android.content.res.Configuration;
+import android.os.PowerManager;
import android.view.View;
import android.widget.Button;
import androidx.preference.Preference;
*/
public class DarkModeActivationPreferenceController extends BasePreferenceController {
private final UiModeManager mUiModeManager;
+ private PowerManager mPowerManager;
private Button mTurnOffButton;
private Button mTurnOnButton;
public DarkModeActivationPreferenceController(Context context,
String preferenceKey) {
super(context, preferenceKey);
-
+ mPowerManager = context.getSystemService(PowerManager.class);
mUiModeManager = context.getSystemService(UiModeManager.class);
}
@Override
public final void updateState(Preference preference) {
+
+ final boolean batterySaver = mPowerManager.isPowerSaveMode();
+ if (batterySaver) {
+ mTurnOnButton.setVisibility(View.GONE);
+ mTurnOffButton.setVisibility(View.GONE);
+ return;
+ }
+
final boolean active = (mContext.getResources().getConfiguration().uiMode
& Configuration.UI_MODE_NIGHT_YES) != 0;
updateNightMode(active);
package com.android.settings.display.darkmode;
+import android.content.BroadcastReceiver;
import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
import android.database.ContentObserver;
import android.net.Uri;
import android.os.Handler;
import android.os.Looper;
+import android.os.PowerManager;
import android.provider.Settings;
+import android.util.Log;
import com.android.internal.annotations.VisibleForTesting;
/**
* Observes changes for dark night settings*/
public class DarkModeObserver {
+ private static final String TAG = "DarkModeObserver";
private ContentObserver mContentObserver;
+ private final BroadcastReceiver mBatterySaverReceiver = new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ mCallback.run();
+ }
+ };
private Runnable mCallback;
private Context mContext;
mCallback = callback;
final Uri uri = Settings.Secure.getUriFor(Settings.Secure.UI_NIGHT_MODE);
mContext.getContentResolver().registerContentObserver(uri, false, mContentObserver);
+ final IntentFilter batteryFilter = new IntentFilter();
+ batteryFilter.addAction(PowerManager.ACTION_POWER_SAVE_MODE_CHANGED);
+ mContext.registerReceiver(
+ mBatterySaverReceiver, batteryFilter);
}
/**
*/
public void unsubscribe() {
mContext.getContentResolver().unregisterContentObserver(mContentObserver);
+ try {
+ mContext.unregisterReceiver(mBatterySaverReceiver);
+ } catch (IllegalArgumentException e) {
+ /* Ignore: unregistering an unregistered receiver */
+ Log.w(TAG, e.getMessage());
+ }
+ // NO-OP
mCallback = null;
}
import android.app.UiModeManager;
import android.content.Context;
import android.content.res.Configuration;
+import android.os.PowerManager;
import android.util.AttributeSet;
import com.android.settings.R;
import com.android.settings.widget.MasterSwitchPreference;
private UiModeManager mUiModeManager;
private DarkModeObserver mDarkModeObserver;
+ private PowerManager mPowerManager;
private Runnable mCallback;
public DarkModePreference(Context context, AttributeSet attrs) {
super(context, attrs);
mDarkModeObserver = new DarkModeObserver(context);
mUiModeManager = context.getSystemService(UiModeManager.class);
+ mPowerManager = context.getSystemService(PowerManager.class);
mCallback = () -> {
- updateSummary();
+ final boolean batterySaver = mPowerManager.isPowerSaveMode();
+ final boolean active = (getContext().getResources().getConfiguration().uiMode
+ & Configuration.UI_MODE_NIGHT_YES) != 0;
+ setSwitchEnabled(!batterySaver);
+ updateSummary(batterySaver, active);
};
mDarkModeObserver.subscribe(mCallback);
}
mDarkModeObserver.unsubscribe();
}
- private void updateSummary() {
- final boolean active = (getContext().getResources().getConfiguration().uiMode
- & Configuration.UI_MODE_NIGHT_YES) != 0;
+ private void updateSummary(boolean batterySaver, boolean active) {
+ if (batterySaver) {
+ final int stringId = active ? R.string.dark_ui_mode_disabled_summary_dark_theme_on
+ : R.string.dark_ui_mode_disabled_summary_dark_theme_off;
+ setSummary(getContext().getString(stringId));
+ return;
+ }
final boolean auto = mUiModeManager.getNightMode() == UiModeManager.MODE_NIGHT_AUTO;
String detail;
import android.app.UiModeManager;
import android.content.Context;
import android.content.res.Configuration;
+import android.os.PowerManager;
import androidx.preference.DropDownPreference;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
implements Preference.OnPreferenceChangeListener {
private final UiModeManager mUiModeManager;
- private boolean mPreferenceSet = false;
+ private PowerManager mPowerManager;
private DropDownPreference mPreference;
private String mCurrentMode;
public DarkModeScheduleSelectorController(Context context, String key) {
super(context, key);
mUiModeManager = context.getSystemService(UiModeManager.class);
+ mPowerManager = context.getSystemService(PowerManager.class);
}
@Override
@Override
public final void updateState(Preference preference) {
+ final boolean batterySaver = mPowerManager.isPowerSaveMode();
+ mPreference.setEnabled(!batterySaver);
mCurrentMode =
mUiModeManager.getNightMode() == UiModeManager.MODE_NIGHT_AUTO
? mContext.getString(R.string.dark_ui_auto_mode_auto)
import android.content.Context;
import android.content.res.Configuration;
import android.content.res.Resources;
+import android.os.PowerManager;
import android.view.View;
import android.widget.Button;
import androidx.preference.PreferenceScreen;
private Button mTurnOffButton;
@Mock
private Button mTurnOnButton;
+ @Mock
+ private PowerManager mPM;
private Configuration configNightYes = new Configuration();
private Configuration configNightNo = new Configuration();;
mService = mock(UiModeManager.class);
when(mContext.getResources()).thenReturn(res);
when(mContext.getSystemService(UiModeManager.class)).thenReturn(mService);
+ when(mContext.getSystemService(PowerManager.class)).thenReturn(mPM);
when(mScreen.findPreference(anyString())).thenReturn(mPreference);
when(mPreference.findViewById(
eq(R.id.dark_ui_turn_on_button))).thenReturn(mTurnOnButton);
assertEquals(mController.getSummary(), mContext.getString(
R.string.dark_ui_summary_off_auto_mode_auto));
}
+
+ @Test
+ public void buttonVisisbility_hideButton_offWhenInPowerSaveMode() {
+ when(mPM.isPowerSaveMode()).thenReturn(true);
+ mController.updateState(mPreference);
+ verify(mTurnOffButton).setVisibility(eq(View.GONE));
+ verify(mTurnOnButton).setVisibility(eq(View.GONE));
+ }
}
import android.app.UiModeManager;
import android.content.Context;
+import android.os.PowerManager;
import androidx.preference.DropDownPreference;
import androidx.preference.PreferenceScreen;
import org.junit.Before;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
private PreferenceScreen mScreen;
private Context mContext;
@Mock
- private UiModeManager mService;
+ private UiModeManager mUiService;
+ @Mock
+ private PowerManager mPM;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = spy(RuntimeEnvironment.application);
- when(mContext.getSystemService(UiModeManager.class)).thenReturn(mService);
+ when(mContext.getSystemService(UiModeManager.class)).thenReturn(mUiService);
+ when(mContext.getSystemService(PowerManager.class)).thenReturn(mPM);
when(mContext.getString(R.string.dark_ui_auto_mode_never)).thenReturn("never");
when(mContext.getString(R.string.dark_ui_auto_mode_auto)).thenReturn("auto");
mPreference = spy(new DropDownPreference(mContext));
when(mScreen.findPreference(anyString())).thenReturn(mPreference);
- when(mService.setNightModeActivated(anyBoolean())).thenReturn(true);
+ when(mUiService.setNightModeActivated(anyBoolean())).thenReturn(true);
mController = new DarkModeScheduleSelectorController(mContext, mPreferenceKey);
}
@Test
public void nightMode_preferenceChange_preferenceChangeTrueWhenChangedOnly() {
- when(mService.getNightMode()).thenReturn(UiModeManager.MODE_NIGHT_YES);
+ when(mUiService.getNightMode()).thenReturn(UiModeManager.MODE_NIGHT_YES);
mController.displayPreference(mScreen);
boolean changed = mController
.onPreferenceChange(mScreen, mContext.getString(R.string.dark_ui_auto_mode_auto));
@Test
public void nightMode_updateStateNone_dropDownValueChangedToNone() {
- when(mService.getNightMode()).thenReturn(UiModeManager.MODE_NIGHT_YES);
+ when(mUiService.getNightMode()).thenReturn(UiModeManager.MODE_NIGHT_YES);
mController.displayPreference(mScreen);
mController.updateState(mPreference);
verify(mPreference).setValue(mContext.getString(R.string.dark_ui_auto_mode_never));
@Test
public void nightMode_updateStateNone_dropDownValueChangedToAuto() {
- when(mService.getNightMode()).thenReturn(UiModeManager.MODE_NIGHT_AUTO);
+ when(mUiService.getNightMode()).thenReturn(UiModeManager.MODE_NIGHT_AUTO);
mController.displayPreference(mScreen);
mController.updateState(mPreference);
verify(mPreference).setValue(mContext.getString(R.string.dark_ui_auto_mode_auto));
}
+
+ @Test
+ public void batterySaver_dropDown_disabledSelector() {
+ when(mPM.isPowerSaveMode()).thenReturn(true);
+ mController.displayPreference(mScreen);
+ mController.updateState(mPreference);
+ verify(mPreference).setEnabled(eq(false));
+ }
}