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

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

Merge "Revert "Support AOD in the Universal Settings API"" into pi-dev

parents 108c5452 f75edca0

res/xml/ambient_display_settings.xml

+1 −2
Original line number Diff line number Diff line
@@ -29,8 +29,7 @@ 
        <SwitchPreference

            android:key="ambient_display_always_on"

            android:title="@string/doze_always_on_title"

            android:summary="@string/doze_always_on_summary"

            settings:controller="com.android.settings.display.AmbientDisplayAlwaysOnPreferenceController" />

            android:summary="@string/doze_always_on_summary" />



        <Preference

            android:key="ambient_display_double_tap"

src/com/android/settings/display/AmbientDisplayAlwaysOnPreferenceController.java

+35 −23
Original line number Diff line number Diff line
@@ -19,45 +19,59 @@ import android.content.Context; 
import android.content.Intent;

import android.os.UserHandle;

import android.provider.Settings;

import android.support.v14.preference.SwitchPreference;

import android.support.v7.preference.Preference;

import android.support.annotation.VisibleForTesting;



import com.android.internal.hardware.AmbientDisplayConfiguration;

import com.android.settings.R;

import com.android.settings.core.TogglePreferenceController;

import com.android.settings.core.PreferenceControllerMixin;

import com.android.settings.search.DatabaseIndexingUtils;

import com.android.settings.search.InlineSwitchPayload;

import com.android.settings.search.ResultPayload;

import com.android.settingslib.core.AbstractPreferenceController;



public class AmbientDisplayAlwaysOnPreferenceController extends TogglePreferenceController {

public class AmbientDisplayAlwaysOnPreferenceController extends

        AbstractPreferenceController implements PreferenceControllerMixin,

        Preference.OnPreferenceChangeListener {



    private final int ON = 1;

    private final int OFF = 0;



    public static final String KEY_ALWAYS_ON = "ambient_display_always_on";

    private static final int MY_USER = UserHandle.myUserId();



    private AmbientDisplayConfiguration mConfig;

    private OnPreferenceChangedCallback mCallback;

    private final AmbientDisplayConfiguration mConfig;

    private final OnPreferenceChangedCallback mCallback;



    public interface OnPreferenceChangedCallback {

        void onPreferenceChanged();

    }



    public AmbientDisplayAlwaysOnPreferenceController(Context context, String key) {

        super(context, key);

    public AmbientDisplayAlwaysOnPreferenceController(Context context,

            AmbientDisplayConfiguration config, OnPreferenceChangedCallback callback) {

        super(context);

        mConfig = config;

        mCallback = callback;

    }



    @Override

    public int getAvailabilityStatus() {

        return isAvailable(mConfig) ? AVAILABLE : DISABLED_UNSUPPORTED;

    public String getPreferenceKey() {

        return KEY_ALWAYS_ON;

    }



    @Override

    public boolean isChecked() {

        return mConfig.alwaysOnEnabled(MY_USER);

    public void updateState(Preference preference) {

        ((SwitchPreference) preference).setChecked(isAlwaysOnEnabled(mConfig));

    }



    public static boolean isAlwaysOnEnabled(AmbientDisplayConfiguration config) {

        return config.alwaysOnEnabled(MY_USER);

    }



    @Override

    public boolean setChecked(boolean isChecked) {

        int enabled = isChecked ? ON : OFF;

    public boolean onPreferenceChange(Preference preference, Object newValue) {

        int enabled = (boolean) newValue ? ON : OFF;

        Settings.Secure.putInt(

                mContext.getContentResolver(), Settings.Secure.DOZE_ALWAYS_ON, enabled);

        if (mCallback != null) {
@@ -66,16 +80,9 @@ public class AmbientDisplayAlwaysOnPreferenceController extends TogglePreference 
        return true;

    }



    public void setConfig(AmbientDisplayConfiguration config) {

        mConfig = config;

    }



    public void setCallback(OnPreferenceChangedCallback callback) {

        mCallback = callback;

    }



    public static boolean isAlwaysOnEnabled(AmbientDisplayConfiguration config) {

        return config.alwaysOnEnabled(MY_USER);

    @Override

    public boolean isAvailable() {

        return alwaysOnAvailableForUser(mConfig);

    }



    public static boolean isAvailable(AmbientDisplayConfiguration config) {
@@ -89,11 +96,16 @@ public class AmbientDisplayAlwaysOnPreferenceController extends TogglePreference 
    @Override

    public ResultPayload getResultPayload() {

        final Intent intent = DatabaseIndexingUtils.buildSearchResultPageIntent(mContext,

                AmbientDisplaySettings.class.getName(), getPreferenceKey(),

                AmbientDisplaySettings.class.getName(), KEY_ALWAYS_ON,

                mContext.getString(R.string.ambient_display_screen_title));



        return new InlineSwitchPayload(Settings.Secure.DOZE_ALWAYS_ON,

                ResultPayload.SettingsSource.SECURE, ON /* onValue */, intent, isAvailable(),

                ON /* defaultValue */);

    }



    @VisibleForTesting

    boolean alwaysOnAvailableForUser(AmbientDisplayConfiguration config) {

        return isAvailable(config);

    }

}

src/com/android/settings/display/AmbientDisplaySettings.java

+8 −22
Original line number Diff line number Diff line
@@ -40,23 +40,23 @@ import java.util.List; 
 */

public class AmbientDisplaySettings extends DashboardFragment {



    public static final String KEY_AMBIENT_DISPLAY_ALWAYS_ON = "ambient_display_always_on";



    private static final String TAG = "AmbientDisplaySettings";

    private static final int MY_USER_ID = UserHandle.myUserId();



    private static final String KEY_AMBIENT_DISPLAY_ALWAYS_ON = "ambient_display_always_on";

    private static final String KEY_AMBIENT_DISPLAY_DOUBLE_TAP = "ambient_display_double_tap";

    private static final String KEY_AMBIENT_DISPLAY_PICK_UP = "ambient_display_pick_up";

    private static final String KEY_AMBIENT_DISPLAY_NOTIFICATION = "ambient_display_notification";



    private AmbientDisplayConfiguration mConfig;



    private static List<AbstractPreferenceController> buildPreferenceControllers(Context context,

            Lifecycle lifecycle, AmbientDisplayConfiguration config,

            MetricsFeatureProvider metricsFeatureProvider) {

            MetricsFeatureProvider metricsFeatureProvider,

            AmbientDisplayAlwaysOnPreferenceController.OnPreferenceChangedCallback aodCallback) {

        final List<AbstractPreferenceController> controllers = new ArrayList<>();

        controllers.add(new AmbientDisplayNotificationsPreferenceController(context, config,

                metricsFeatureProvider));

        controllers.add(new AmbientDisplayAlwaysOnPreferenceController(context, config,

                aodCallback));

        controllers.add(new DoubleTapScreenPreferenceController(context, lifecycle, config,

                MY_USER_ID, KEY_AMBIENT_DISPLAY_DOUBLE_TAP));

        controllers.add(new PickupGesturePreferenceController(context, lifecycle, config,
@@ -64,14 +64,6 @@ public class AmbientDisplaySettings extends DashboardFragment { 
        return controllers;

    }



    @Override

    public void onAttach(Context context) {

        super.onAttach(context);

        final AmbientDisplayAlwaysOnPreferenceController controller = use(

                AmbientDisplayAlwaysOnPreferenceController.class);

        controller.setConfig(getConfig(context));

        controller.setCallback(this::updatePreferenceStates);

    }



    @Override

    protected String getLogTag() {
@@ -86,7 +78,8 @@ public class AmbientDisplaySettings extends DashboardFragment { 
    @Override

    protected List<AbstractPreferenceController> createPreferenceControllers(Context context) {

        return buildPreferenceControllers(context, getLifecycle(),

                getConfig(context), mMetricsFeatureProvider);

                new AmbientDisplayConfiguration(context), mMetricsFeatureProvider,

                this::updatePreferenceStates);

    }



    @Override
@@ -111,14 +104,7 @@ public class AmbientDisplaySettings extends DashboardFragment { 
                public List<AbstractPreferenceController> createPreferenceControllers(

                        Context context) {

                    return buildPreferenceControllers(context, null,

                            new AmbientDisplayConfiguration(context), null);

                            new AmbientDisplayConfiguration(context), null, null);

                }

            };



    private AmbientDisplayConfiguration getConfig(Context context) {

        if (mConfig != null) {

            mConfig = new AmbientDisplayConfiguration(context);

        }

        return mConfig;

    }

}

tests/robotests/src/com/android/settings/display/AmbientDisplayAlwaysOnPreferenceControllerTest.java

+45 −35
Original line number Diff line number Diff line
@@ -17,14 +17,17 @@ 
package com.android.settings.display;



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



import static org.mockito.ArgumentMatchers.anyInt;

import static org.mockito.ArgumentMatchers.any;

import static org.mockito.Matchers.anyInt;

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;

import android.support.v14.preference.SwitchPreference;



import com.android.internal.hardware.AmbientDisplayConfiguration;

import com.android.settings.search.InlinePayload;
@@ -46,6 +49,8 @@ public class AmbientDisplayAlwaysOnPreferenceControllerTest { 


    @Mock

    private AmbientDisplayConfiguration mConfig;

    @Mock

    private SwitchPreference mSwitchPreference;



    private Context mContext;
@@ -59,76 +64,81 @@ public class AmbientDisplayAlwaysOnPreferenceControllerTest { 
        MockitoAnnotations.initMocks(this);

        mContext = RuntimeEnvironment.application;

        mContentResolver = mContext.getContentResolver();

        mController = new AmbientDisplayAlwaysOnPreferenceController(mContext, "key");

        mController.setConfig(mConfig);

        mController.setCallback(() -> mCallbackInvoked = true);

        mController = new AmbientDisplayAlwaysOnPreferenceController(mContext, mConfig,

                () -> {

                    mCallbackInvoked = true;

                });

    }



    @Test

    public void getAvailabilityStatus_available() {

        when(mConfig.alwaysOnAvailableForUser(anyInt())).thenReturn(true);



        assertThat(mController.getAvailabilityStatus()).isEqualTo(

                AmbientDisplayAlwaysOnPreferenceController.AVAILABLE);

    }

    public void updateState_enabled() {

        when(mConfig.alwaysOnEnabled(anyInt())).thenReturn(true);



    @Test

    public void getAvailabilityStatus_disabled_unsupported() {

        when(mConfig.alwaysOnAvailableForUser(anyInt())).thenReturn(false);

        mController.updateState(mSwitchPreference);



        assertThat(mController.getAvailabilityStatus()).isEqualTo(

                AmbientDisplayAlwaysOnPreferenceController.DISABLED_UNSUPPORTED);

        verify(mSwitchPreference).setChecked(true);

    }



    @Test

    public void isChecked_enabled() {

        when(mConfig.alwaysOnEnabled(anyInt())).thenReturn(true);

    public void updateState_disabled() {

        when(mConfig.alwaysOnEnabled(anyInt())).thenReturn(false);



        mController.updateState(mSwitchPreference);



        assertThat(mController.isChecked()).isTrue();

        verify(mSwitchPreference).setChecked(false);

    }



    @Test

    public void isChecked_disabled() {

        when(mConfig.alwaysOnEnabled(anyInt())).thenReturn(false);



        assertThat(mController.isChecked()).isFalse();

    public void onPreferenceChange_callback() {

        assertThat(mCallbackInvoked).isFalse();

        mController.onPreferenceChange(mSwitchPreference, true);

        assertThat(mCallbackInvoked).isTrue();

    }



    @Test

    public void setChecked_enabled() {

        mController.setChecked(true);

    public void onPreferenceChange_enable() {

        mController.onPreferenceChange(mSwitchPreference, true);



        assertThat(Settings.Secure.getInt(mContentResolver, Settings.Secure.DOZE_ALWAYS_ON, -1))

            .isEqualTo(1);

    }



    @Test

    public void setChecked_disabled() {

        mController.setChecked(false);

    public void onPreferenceChange_disable() {

        mController.onPreferenceChange(mSwitchPreference, false);



        assertThat(Settings.Secure.getInt(mContentResolver, Settings.Secure.DOZE_ALWAYS_ON, -1))

            .isEqualTo(0);

    }



    @Test

    public void onPreferenceChange_callback() {

        assertThat(mCallbackInvoked).isFalse();

        mController.setChecked(true);

        assertThat(mCallbackInvoked).isTrue();

    public void isAvailable_available() {

        mController = spy(mController);

        doReturn(true).when(mController).alwaysOnAvailableForUser(any());



        assertThat(mController.isAvailable()).isTrue();

    }



    @Test

    public void isAvailable_unavailable() {

        mController = spy(mController);

        doReturn(false).when(mController).alwaysOnAvailableForUser(any());



        assertThat(mController.isAvailable()).isFalse();

    }



    @Test

    public void testPreferenceController_ProperResultPayloadType() {

        when(mConfig.alwaysOnAvailableForUser(anyInt())).thenReturn(false);

        mController = spy(mController);

        doReturn(false).when(mController).alwaysOnAvailableForUser(any());



        assertThat(mController.getResultPayload()).isInstanceOf(InlineSwitchPayload.class);

    }



    @Test

    public void testSetValue_updatesCorrectly() {

        when(mConfig.alwaysOnAvailableForUser(anyInt())).thenReturn(false);

        mController = spy(mController);

        doReturn(false).when(mController).alwaysOnAvailableForUser(any());

        final int newValue = 1;

        Settings.Secure.putInt(mContentResolver, Settings.Secure.DOZE_ALWAYS_ON, 0 /* value */);
@@ -141,8 +151,8 @@ public class AmbientDisplayAlwaysOnPreferenceControllerTest { 


    @Test

    public void testGetValue_correctValueReturned() {

        when(mConfig.alwaysOnAvailableForUser(anyInt())).thenReturn(false);

        mController = spy(mController);

        doReturn(false).when(mController).alwaysOnAvailableForUser(any());

        final int currentValue = 1;

        Settings.Secure.putInt(mContentResolver, Settings.Secure.DOZE_ALWAYS_ON, currentValue);

tests/robotests/src/com/android/settings/display/AmbientDisplaySettingsTest.java

deleted100644 → 0
+0 −69
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 static org.mockito.Mockito.any;

import static org.mockito.Mockito.doReturn;

import static org.mockito.Mockito.mock;

import static org.mockito.Mockito.spy;

import static org.mockito.Mockito.verify;



import android.content.Context;



import com.android.settings.testutils.SettingsRobolectricTestRunner;

import com.android.settingslib.core.AbstractPreferenceController;



import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.MockitoAnnotations;

import org.robolectric.RuntimeEnvironment;



@RunWith(SettingsRobolectricTestRunner.class)

public class AmbientDisplaySettingsTest {



    private TestFragment mTestFragment;



    private Context mContext;



    @Before

    public void setUp() throws Exception {

        MockitoAnnotations.initMocks(this);

        mContext = RuntimeEnvironment.application;

        mTestFragment = spy(new TestFragment());

    }



    @Test

    public void onAttach_shouldSetConfigAndCallback() {

        final AmbientDisplayAlwaysOnPreferenceController controller = mock(

                AmbientDisplayAlwaysOnPreferenceController.class);

        doReturn(controller).when(mTestFragment).use(

                AmbientDisplayAlwaysOnPreferenceController.class);



        mTestFragment.onAttach(mContext);



        verify(controller).setConfig(any());

        verify(controller).setCallback(any());

    }



    public static class TestFragment extends AmbientDisplaySettings {

        @Override

        protected <T extends AbstractPreferenceController> T use(Class<T> clazz) {

            return super.use(clazz);

        }

    }

}
 
 No newline at end of file