Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 552fc292 authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge "Revert "Listen to brigtness updates to update brightness summary."" into oc-dev

parents 8025906b 0811fd54
Loading
Loading
Loading
Loading
+1 −1
Original line number Diff line number Diff line
@@ -104,7 +104,7 @@ public class DisplaySettings extends DashboardFragment {
        controllers.add(new VrDisplayPreferenceController(context));
        controllers.add(new WallpaperPreferenceController(context));
        controllers.add(new ThemePreferenceController(context));
        controllers.add(new BrightnessLevelPreferenceController(context, lifecycle));
        controllers.add(new BrightnessLevelPreferenceController(context));
        return controllers;
    }

+7 −122
Original line number Diff line number Diff line
@@ -13,79 +13,20 @@
 */
package com.android.settings.display;

import android.content.ContentResolver;
import static android.provider.Settings.System.SCREEN_BRIGHTNESS;

import android.content.Context;
import android.database.ContentObserver;
import android.net.Uri;
import android.os.Handler;
import android.os.PowerManager;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.provider.Settings;
import android.provider.Settings.System;
import android.service.vr.IVrManager;
import android.support.annotation.VisibleForTesting;
import android.support.v7.preference.Preference;
import android.support.v7.preference.PreferenceScreen;
import android.util.Log;

import com.android.settings.core.PreferenceController;
import com.android.settings.core.lifecycle.Lifecycle;
import com.android.settings.core.lifecycle.LifecycleObserver;
import com.android.settings.core.lifecycle.events.OnPause;
import com.android.settings.core.lifecycle.events.OnResume;

import java.text.NumberFormat;

public class BrightnessLevelPreferenceController extends PreferenceController implements
        LifecycleObserver, OnResume, OnPause {
public class BrightnessLevelPreferenceController extends PreferenceController {

    private static final String TAG = "BrightnessPrefCtrl";
    private static final String KEY_BRIGHTNESS = "brightness";
    private static final Uri BRIGHTNESS_MODE_URI;
    private static final Uri BRIGHTNESS_URI;
    private static final Uri BRIGHTNESS_FOR_VR_URI;
    private static final Uri BRIGHTNESS_ADJ_URI;

    private final int mMinBrightness;
    private final int mMaxBrightness;
    private final int mMinVrBrightness;
    private final int mMaxVrBrightness;
    private final ContentResolver mContentResolver;

    private Preference mPreference;

    static {
        BRIGHTNESS_MODE_URI = System.getUriFor(System.SCREEN_BRIGHTNESS_MODE);
        BRIGHTNESS_URI = System.getUriFor(System.SCREEN_BRIGHTNESS);
        BRIGHTNESS_FOR_VR_URI = System.getUriFor(System.SCREEN_BRIGHTNESS_FOR_VR);
        BRIGHTNESS_ADJ_URI = System.getUriFor(System.SCREEN_AUTO_BRIGHTNESS_ADJ);
    }

    private ContentObserver mBrightnessObserver = new ContentObserver(new Handler()) {
        @Override
        public void onChange(boolean selfChange) {
            updatedSummary(mPreference);
        }
    };

    public BrightnessLevelPreferenceController(Context context, Lifecycle lifecycle) {
        this(context, lifecycle, new PowerManagerWrapper(
                (PowerManager) context.getSystemService(Context.POWER_SERVICE)));
    }

    @VisibleForTesting
    public BrightnessLevelPreferenceController(Context context, Lifecycle lifecycle,
            PowerManagerWrapper powerManagerWrapper) {
    public BrightnessLevelPreferenceController(Context context) {
        super(context);
        if (lifecycle != null) {
            lifecycle.addObserver(this);
        }
        mMinBrightness = powerManagerWrapper.getMinimumScreenBrightnessSetting();
        mMaxBrightness = powerManagerWrapper.getMaximumScreenBrightnessSetting();
        mMinVrBrightness = powerManagerWrapper.getMinimumScreenBrightnessForVrSetting();
        mMaxVrBrightness = powerManagerWrapper.getMaximumScreenBrightnessForVrSetting();
        mContentResolver = mContext.getContentResolver();
    }

    @Override
@@ -98,67 +39,11 @@ public class BrightnessLevelPreferenceController extends PreferenceController im
        return KEY_BRIGHTNESS;
    }

    @Override
    public void displayPreference(PreferenceScreen screen) {
        super.displayPreference(screen);
        mPreference = screen.findPreference(KEY_BRIGHTNESS);
    }

    @Override
    public void updateState(Preference preference) {
        updatedSummary(preference);
        final double brightness = Settings.System.getInt(mContext.getContentResolver(),
            SCREEN_BRIGHTNESS, 0);
        preference.setSummary(NumberFormat.getPercentInstance().format(brightness / 255));
    }

    @Override
    public void onResume() {
        mContentResolver.registerContentObserver(BRIGHTNESS_MODE_URI, false, mBrightnessObserver);
        mContentResolver.registerContentObserver(BRIGHTNESS_URI, false, mBrightnessObserver);
        mContentResolver.registerContentObserver(BRIGHTNESS_FOR_VR_URI, false, mBrightnessObserver);
        mContentResolver.registerContentObserver(BRIGHTNESS_ADJ_URI, false, mBrightnessObserver);
    }

    @Override
    public void onPause() {
        mContentResolver.unregisterContentObserver(mBrightnessObserver);
    }

    private void updatedSummary(Preference preference) {
        if (preference != null) {
            preference.setSummary(NumberFormat.getPercentInstance().format(getCurrentBrightness()));
        }
    }

    private double getCurrentBrightness() {
        if (isInVrMode()) {
            final double value = System.getInt(mContentResolver, System.SCREEN_BRIGHTNESS_FOR_VR,
                    mMaxBrightness);
            return getPercentage(value, mMinVrBrightness, mMaxVrBrightness);
        }
        final int brightnessMode = Settings.System.getInt(mContentResolver,
                System.SCREEN_BRIGHTNESS_MODE, System.SCREEN_BRIGHTNESS_MODE_MANUAL);
        if (brightnessMode == System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC) {
            final float value = Settings.System.getFloat(mContentResolver,
                    System.SCREEN_AUTO_BRIGHTNESS_ADJ, 0);
            // auto brightness is between -1 and 1
            return ((value + 1)) / 2;
        }
        final double value = Settings.System.getInt(mContentResolver, System.SCREEN_BRIGHTNESS,
                mMinBrightness);
        return getPercentage(value, mMinBrightness, mMaxBrightness);
    }

    private double getPercentage(double value, int min, int max) {
        return (value - min) / (max - min);
    }

    @VisibleForTesting
    boolean isInVrMode() {
        try {
            return IVrManager.Stub.asInterface(ServiceManager.getService(Context.VR_SERVICE))
                    .getVrModeState();
        } catch (RemoteException e) {
            Log.e(TAG, "Failed to check vr mode!", e);
        }
        return false;
    }
}
+0 −49
Original line number Diff line number Diff line
/*
 * Copyright (C) 2017 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.os.PowerManager;

/**
 * This class replicates a subset of the android.os.PowerManager. The class exists so that we can
 * use a thin wrapper around the PowerManager in production code and a mock in tests. We cannot
 * directly mock or shadow the PowerManager, because some of the methods we rely on are newer than
 * the API version supported by Robolectric or are hidden.
 */
public class PowerManagerWrapper {
    private final PowerManager mPowerManager;

    public PowerManagerWrapper(PowerManager powerManager) {
        mPowerManager = powerManager;
    }

    public int getMinimumScreenBrightnessSetting() {
        return mPowerManager.getMinimumScreenBrightnessSetting();
    }

    public int getMaximumScreenBrightnessSetting() {
        return mPowerManager.getMaximumScreenBrightnessSetting();
    }

    public int getMinimumScreenBrightnessForVrSetting() {
        return mPowerManager.getMinimumScreenBrightnessForVrSetting();
    }

    public int getMaximumScreenBrightnessForVrSetting() {
        return mPowerManager.getMaximumScreenBrightnessForVrSetting();
    }
}
+10 −91
Original line number Diff line number Diff line
@@ -16,31 +16,27 @@

package com.android.settings.display;

import static android.provider.Settings.System.SCREEN_BRIGHTNESS;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import android.content.ContentResolver;
import android.content.Context;
import android.provider.Settings.System;
import android.provider.Settings;
import android.support.v7.preference.Preference;
import android.support.v7.preference.PreferenceScreen;

import com.android.settings.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.testutils.shadow.SettingsShadowSystemProperties;

import java.text.NumberFormat;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
import org.robolectric.internal.ShadowExtractor;
import org.robolectric.shadows.ShadowContentResolver;

@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
@@ -50,10 +46,6 @@ public class BrightnessLevelPreferenceControllerTest {
    @Mock
    private ContentResolver mContentResolver;
    @Mock
    private PowerManagerWrapper mPowerManager;
    @Mock
    private PreferenceScreen mScreen;
    @Mock
    private Preference mPreference;

    private BrightnessLevelPreferenceController mController;
@@ -61,15 +53,8 @@ public class BrightnessLevelPreferenceControllerTest {
    @Before
    public void setUp() {
        MockitoAnnotations.initMocks(this);
        when(mContext.getContentResolver()).thenReturn(mContentResolver);
        when(mPowerManager.getMinimumScreenBrightnessSetting()).thenReturn(0);
        when(mPowerManager.getMaximumScreenBrightnessSetting()).thenReturn(100);
        when(mPowerManager.getMinimumScreenBrightnessForVrSetting()).thenReturn(0);
        when(mPowerManager.getMaximumScreenBrightnessForVrSetting()).thenReturn(100);
        when(mScreen.findPreference(anyString())).thenReturn(mPreference);
        mController = spy(new BrightnessLevelPreferenceController(mContext, null, mPowerManager));
        doReturn(false).when(mController).isInVrMode();

        mController = new BrightnessLevelPreferenceController(mContext);
    }

    @Test
@@ -78,80 +63,14 @@ public class BrightnessLevelPreferenceControllerTest {
    }

    @Test
    public void onResume_shouldRegisterObserver() {
        Context context = RuntimeEnvironment.application;
        BrightnessLevelPreferenceController controller =
            new BrightnessLevelPreferenceController(context, null, mPowerManager);
        ShadowContentResolver shadowContentResolver =
            (ShadowContentResolver) ShadowExtractor.extract(context.getContentResolver());

        controller.onResume();

        assertThat(shadowContentResolver.getContentObservers(
            System.getUriFor(System.SCREEN_BRIGHTNESS_MODE))).isNotEmpty();
        assertThat(shadowContentResolver.getContentObservers(
            System.getUriFor(System.SCREEN_BRIGHTNESS))).isNotEmpty();
        assertThat(shadowContentResolver.getContentObservers(
            System.getUriFor(System.SCREEN_BRIGHTNESS_FOR_VR))).isNotEmpty();
        assertThat(shadowContentResolver.getContentObservers(
            System.getUriFor(System.SCREEN_AUTO_BRIGHTNESS_ADJ))).isNotEmpty();
    }

    @Test
    public void onPause_shouldUnregisterObserver() {
        Context context = RuntimeEnvironment.application;
        BrightnessLevelPreferenceController controller =
            new BrightnessLevelPreferenceController(context, null, mPowerManager);
        ShadowContentResolver shadowContentResolver =
            (ShadowContentResolver) ShadowExtractor.extract(context.getContentResolver());

        controller.displayPreference(mScreen);
        controller.onResume();
        controller.onPause();

        assertThat(shadowContentResolver.getContentObservers(
            System.getUriFor(System.SCREEN_BRIGHTNESS_MODE))).isEmpty();
        assertThat(shadowContentResolver.getContentObservers(
            System.getUriFor(System.SCREEN_BRIGHTNESS))).isEmpty();
        assertThat(shadowContentResolver.getContentObservers(
            System.getUriFor(System.SCREEN_BRIGHTNESS_FOR_VR))).isEmpty();
        assertThat(shadowContentResolver.getContentObservers(
            System.getUriFor(System.SCREEN_AUTO_BRIGHTNESS_ADJ))).isEmpty();
    }

    @Test
    public void updateState_inVrMode_shouldSetSummaryToVrBrightness() {
        doReturn(true).when(mController).isInVrMode();
        System.putInt(mContentResolver, System.SCREEN_BRIGHTNESS_FOR_VR, 85);

        mController.updateState(mPreference);

        verify(mPreference).setSummary("85%");
    }

    @Test
    public void updateState_autoBrightness_shouldSetSummaryToVrBrightness() {
        doReturn(false).when(mController).isInVrMode();
        System.putInt(mContentResolver, System.SCREEN_BRIGHTNESS_MODE,
            System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC);

        System.putFloat(mContentResolver, System.SCREEN_AUTO_BRIGHTNESS_ADJ, 0.0f);
    public void updateState_shouldSetSummary() {
        final NumberFormat formatter = NumberFormat.getPercentInstance();
        when(mContext.getContentResolver()).thenReturn(mContentResolver);
        Settings.System.putInt(mContentResolver, SCREEN_BRIGHTNESS, 45);

        mController.updateState(mPreference);

        verify(mPreference).setSummary("50%");
        verify(mPreference).setSummary(formatter.format(45.0 / 255));
    }

    @Test
    public void updateState_manualBrightness_shouldSetSummaryToVrBrightness() {
        doReturn(false).when(mController).isInVrMode();
        System.putInt(mContentResolver, System.SCREEN_BRIGHTNESS_MODE,
            System.SCREEN_BRIGHTNESS_MODE_MANUAL);

        System.putInt(mContentResolver, System.SCREEN_BRIGHTNESS, 45);

        mController.updateState(mPreference);

        verify(mPreference).setSummary("45%");
    }
}
+18 −13
Original line number Diff line number Diff line
@@ -17,30 +17,35 @@

package com.android.settings.search;

import static com.google.common.truth.Truth.assertThat;

import android.content.Context;
import android.util.ArrayMap;

import android.util.ArrayMap;
import com.android.internal.hardware.AmbientDisplayConfiguration;
import com.android.settings.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.core.PreferenceController;
import com.android.settings.deviceinfo.SystemUpdatePreferenceController;
import com.android.settings.display.AutoBrightnessPreferenceController;
import com.android.settings.gestures.DoubleTapPowerPreferenceController;
import com.android.settings.gestures.DoubleTapScreenPreferenceController;
import com.android.settings.gestures.DoubleTwistPreferenceController;
import com.android.settings.gestures.PickupGesturePreferenceController;
import com.android.settings.gestures.SwipeToNotificationPreferenceController;
import com.android.settings.search2.DatabaseIndexingUtils;

import com.android.settings.search2.IntentPayload;
import com.android.settings.search2.ResultPayload;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowApplication;

import java.util.Map;

import static com.google.common.truth.Truth.assertThat;

@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public class DatabaseIndexingUtilsTest {
@@ -52,7 +57,7 @@ public class DatabaseIndexingUtilsTest {
    @Before
    public void setUp() {
        MockitoAnnotations.initMocks(this);
        mContext = RuntimeEnvironment.application;
        mContext = ShadowApplication.getInstance().getApplicationContext();
    }

    @Test
@@ -69,11 +74,11 @@ public class DatabaseIndexingUtilsTest {

    @Test
    public void testGetPreferenceControllerUriMap_CompatibleClass_ReturnsValidMap() {
        final String className = "com.android.settings.system.SystemDashboardFragment";
        final Map<String, PreferenceController> map =
                DatabaseIndexingUtils.getPreferenceControllerUriMap(className, mContext);
        assertThat(map.get("system_update_settings"))
                .isInstanceOf(SystemUpdatePreferenceController.class);
        String className = "com.android.settings.DisplaySettings";

        Map map = DatabaseIndexingUtils.getPreferenceControllerUriMap(className, mContext);
        assertThat(map.get("auto_brightness"))
                .isInstanceOf(AutoBrightnessPreferenceController.class);
    }

    @Test