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

Commit 1142053f authored by Santos Cordon's avatar Santos Cordon
Browse files

Treat changes in device-state as user-activity. 

PowerManager will now treat changes in the device state from
DeviceStateManager as user-activity for the purposes of calculating
idle timeouts.

Bug: 199993642
Test: Check logs to verify that user-activity is updated when
      changing device states.
Test: atest PowerManagerServiceMockingTest
Change-Id: Ib5e543dd502d6b9b8ef1fef7e1b0f8a188f3cf1e
parent 5068021c

core/java/android/os/PowerManager.java

+6 −0
Original line number Diff line number Diff line
@@ -334,6 +334,12 @@ public final class PowerManager { 
     */

    public static final int USER_ACTIVITY_EVENT_FACE_DOWN = 5;



    /**

     * User activity event type: There is a change in the device state.

     * @hide

     */

    public static final int USER_ACTIVITY_EVENT_DEVICE_STATE = 6;



    /**

     * User activity flag: If already dimmed, extend the dim timeout

     * but do not brighten.  This flag is useful for keeping the screen on

services/core/java/com/android/server/power/PowerManagerService.java

+26 −0
Original line number Diff line number Diff line
@@ -49,6 +49,7 @@ import android.content.res.Resources; 
import android.database.ContentObserver;

import android.hardware.SensorManager;

import android.hardware.SystemSensorManager;

import android.hardware.devicestate.DeviceStateManager;

import android.hardware.display.AmbientDisplayConfiguration;

import android.hardware.display.DisplayManagerInternal;

import android.hardware.display.DisplayManagerInternal.DisplayPowerRequest;
@@ -60,6 +61,7 @@ import android.os.BatteryManagerInternal; 
import android.os.BatterySaverPolicyConfig;

import android.os.Binder;

import android.os.Handler;

import android.os.HandlerExecutor;

import android.os.IBinder;

import android.os.IPowerManager;

import android.os.Looper;
@@ -1151,6 +1153,9 @@ public final class PowerManagerService extends SystemService 
                            PowerManager.GO_TO_SLEEP_REASON_QUIESCENT,

                            PowerManager.GO_TO_SLEEP_FLAG_NO_DOZE, Process.SYSTEM_UID);

                }



                mContext.getSystemService(DeviceStateManager.class).registerCallback(

                        new HandlerExecutor(mHandler), new DeviceStateListener());

            }

        }

    }
@@ -6349,4 +6354,25 @@ public final class PowerManagerService extends SystemService 
            return interceptPowerKeyDownInternal(event);

        }

    }



    /**

     * Listens to changes in device state and updates the interactivity time.

     * Any changes to the device state are treated as user interactions.

     */

    class DeviceStateListener implements DeviceStateManager.DeviceStateCallback {

        private int mDeviceState = DeviceStateManager.INVALID_DEVICE_STATE;



        @Override

        public void onStateChanged(int deviceState) {

            if (mDeviceState != deviceState) {

                mDeviceState = deviceState;

                // Device-state interactions are applied to the default display so that they

                // are reflected only with the default power group.

                userActivityInternal(Display.DEFAULT_DISPLAY, mClock.uptimeMillis(),

                        PowerManager.USER_ACTIVITY_EVENT_DEVICE_STATE, /* flags= */0,

                        Process.SYSTEM_UID);

            }

        }

    };



}

services/tests/mockingservicestests/Android.bp

+13 −13
Original line number Diff line number Diff line
@@ -40,26 +40,26 @@ android_test { 
    ],



    static_libs: [

        "frameworks-base-testutils",

        "services.core",

        "services.devicepolicy",

        "services.net",

        "services.usage",

        "service-jobscheduler",

        "service-permission.impl",

        "service-blobstore",

        "androidx.test.core",

        "androidx.test.runner",

        "androidx.test.ext.truth",

        "mockito-target-extended-minus-junit4",

        "platform-test-annotations",

        "truth-prebuilt",

        "frameworks-base-testutils",

        "hamcrest-library",

        "servicestests-utils-mockito-extended",

        "kotlin-test",

        "mockingservicestests-utils-mockito",

        "mockito-target-extended-minus-junit4",

        "platform-test-annotations",

        "service-blobstore",

        "service-jobscheduler",

        "service-permission.impl",

        "services.core",

        "services.devicepolicy",

        "services.net",

        "services.usage",

        "servicestests-core-utils",

        "servicestests-utils-mockito-extended",

        "testables",

        "kotlin-test",

        "truth-prebuilt",

        // TODO: remove once Android migrates to JUnit 4.12, which provides assertThrows

        "testng",

    ],

services/tests/mockingservicestests/src/com/android/server/power/PowerManagerServiceMockingTest.java

0 → 100644
+303 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2022 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.server.power;



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



import static org.mockito.ArgumentMatchers.any;

import static org.mockito.ArgumentMatchers.anyBoolean;

import static org.mockito.ArgumentMatchers.anyInt;

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;



import android.app.ActivityManagerInternal;

import android.attention.AttentionManagerInternal;

import android.content.Context;

import android.content.ContextWrapper;

import android.content.res.Resources;

import android.hardware.SensorManager;

import android.hardware.devicestate.DeviceStateManager;

import android.hardware.devicestate.DeviceStateManager.DeviceStateCallback;

import android.hardware.display.AmbientDisplayConfiguration;

import android.hardware.display.DisplayManagerInternal;

import android.os.BatteryManagerInternal;

import android.os.Handler;

import android.os.Looper;

import android.os.PowerManager;

import android.os.PowerSaveState;

import android.os.test.TestLooper;

import android.provider.Settings;

import android.service.dreams.DreamManagerInternal;

import android.test.mock.MockContentResolver;

import android.view.Display;

import android.view.DisplayInfo;



import androidx.test.InstrumentationRegistry;



import com.android.internal.app.IBatteryStats;

import com.android.internal.util.test.FakeSettingsProvider;

import com.android.server.LocalServices;

import com.android.server.SystemService;

import com.android.server.lights.LightsManager;

import com.android.server.policy.WindowManagerPolicy;

import com.android.server.power.PowerManagerService.BatteryReceiver;

import com.android.server.power.PowerManagerService.Injector;

import com.android.server.power.PowerManagerService.NativeWrapper;

import com.android.server.power.PowerManagerService.UserSwitchedReceiver;

import com.android.server.power.batterysaver.BatterySaverController;

import com.android.server.power.batterysaver.BatterySaverPolicy;

import com.android.server.power.batterysaver.BatterySaverStateMachine;

import com.android.server.power.batterysaver.BatterySavingStats;

import com.android.server.testutils.OffsettableClock;



import org.junit.After;

import org.junit.Before;

import org.junit.Test;

import org.mockito.ArgumentCaptor;

import org.mockito.Mock;

import org.mockito.MockitoAnnotations;



/**

 * Tests for {@link com.android.server.power.PowerManagerService}.

 *

 * Build/Install/Run:

 *  atest FrameworksServicesTests:PowerManagerServiceMockingTest

 */

public class PowerManagerServiceMockingTest {

    private static final String SYSTEM_PROPERTY_QUIESCENT = "ro.boot.quiescent";

    private static final String SYSTEM_PROPERTY_REBOOT_REASON = "sys.boot.reason";



    private static final float BRIGHTNESS_FACTOR = 0.7f;

    private static final boolean BATTERY_SAVER_ENABLED = true;



    @Mock private BatterySaverController mBatterySaverControllerMock;

    @Mock private BatterySaverPolicy mBatterySaverPolicyMock;

    @Mock private BatterySaverStateMachine mBatterySaverStateMachineMock;

    @Mock private LightsManager mLightsManagerMock;

    @Mock private DisplayManagerInternal mDisplayManagerInternalMock;

    @Mock private BatteryManagerInternal mBatteryManagerInternalMock;

    @Mock private ActivityManagerInternal mActivityManagerInternalMock;

    @Mock private AttentionManagerInternal mAttentionManagerInternalMock;

    @Mock private DreamManagerInternal mDreamManagerInternalMock;

    @Mock private PowerManagerService.NativeWrapper mNativeWrapperMock;

    @Mock private Notifier mNotifierMock;

    @Mock private WirelessChargerDetector mWirelessChargerDetectorMock;

    @Mock private AmbientDisplayConfiguration mAmbientDisplayConfigurationMock;

    @Mock private SystemPropertiesWrapper mSystemPropertiesMock;

    @Mock private DeviceStateManager mDeviceStateManagerMock;



    @Mock

    private InattentiveSleepWarningController mInattentiveSleepWarningControllerMock;



    private PowerManagerService mService;

    private PowerSaveState mPowerSaveState;

    private ContextWrapper mContextSpy;

    private BatteryReceiver mBatteryReceiver;

    private UserSwitchedReceiver mUserSwitchedReceiver;

    private Resources mResourcesSpy;

    private OffsettableClock mClock;

    private TestLooper mTestLooper;



    @Before

    public void setUp() throws Exception {

        MockitoAnnotations.initMocks(this);

        FakeSettingsProvider.clearSettingsProvider();



        mPowerSaveState = new PowerSaveState.Builder()

                .setBatterySaverEnabled(BATTERY_SAVER_ENABLED)

                .setBrightnessFactor(BRIGHTNESS_FACTOR)

                .build();

        when(mBatterySaverPolicyMock.getBatterySaverPolicy(

                eq(PowerManager.ServiceType.SCREEN_BRIGHTNESS)))

                .thenReturn(mPowerSaveState);

        when(mBatteryManagerInternalMock.isPowered(anyInt())).thenReturn(false);

        when(mInattentiveSleepWarningControllerMock.isShown()).thenReturn(false);

        when(mDisplayManagerInternalMock.requestPowerState(anyInt(), any(), anyBoolean()))

                .thenReturn(true);

        when(mSystemPropertiesMock.get(eq(SYSTEM_PROPERTY_QUIESCENT), anyString())).thenReturn("");

        when(mAmbientDisplayConfigurationMock.ambientDisplayAvailable()).thenReturn(true);



        addLocalServiceMock(LightsManager.class, mLightsManagerMock);

        addLocalServiceMock(DisplayManagerInternal.class, mDisplayManagerInternalMock);

        addLocalServiceMock(BatteryManagerInternal.class, mBatteryManagerInternalMock);

        addLocalServiceMock(ActivityManagerInternal.class, mActivityManagerInternalMock);

        addLocalServiceMock(AttentionManagerInternal.class, mAttentionManagerInternalMock);

        addLocalServiceMock(DreamManagerInternal.class, mDreamManagerInternalMock);



        mContextSpy = spy(new ContextWrapper(InstrumentationRegistry.getContext()));

        mResourcesSpy = spy(mContextSpy.getResources());

        when(mContextSpy.getResources()).thenReturn(mResourcesSpy);



        MockContentResolver cr = new MockContentResolver(mContextSpy);

        cr.addProvider(Settings.AUTHORITY, new FakeSettingsProvider());

        when(mContextSpy.getContentResolver()).thenReturn(cr);



        when(mContextSpy.getSystemService(DeviceStateManager.class))

                .thenReturn(mDeviceStateManagerMock);



        Settings.Global.putInt(mContextSpy.getContentResolver(),

                Settings.Global.STAY_ON_WHILE_PLUGGED_IN, 0);



        mClock = new OffsettableClock.Stopped();

        mTestLooper = new TestLooper(mClock::now);

    }



    private PowerManagerService createService() {

        mService = new PowerManagerService(mContextSpy, new Injector() {

            @Override

            Notifier createNotifier(Looper looper, Context context, IBatteryStats batteryStats,

                    SuspendBlocker suspendBlocker, WindowManagerPolicy policy,

                    FaceDownDetector faceDownDetector, ScreenUndimDetector screenUndimDetector) {

                return mNotifierMock;

            }



            @Override

            SuspendBlocker createSuspendBlocker(PowerManagerService service, String name) {

                return super.createSuspendBlocker(service, name);

            }



            @Override

            BatterySaverPolicy createBatterySaverPolicy(

                    Object lock, Context context, BatterySavingStats batterySavingStats) {

                return mBatterySaverPolicyMock;

            }



            @Override

            BatterySaverController createBatterySaverController(

                    Object lock, Context context, BatterySaverPolicy batterySaverPolicy,

                    BatterySavingStats batterySavingStats) {

                return mBatterySaverControllerMock;

            }



            @Override

            BatterySaverStateMachine createBatterySaverStateMachine(Object lock, Context context,

                    BatterySaverController batterySaverController) {

                return mBatterySaverStateMachineMock;

            }



            @Override

            NativeWrapper createNativeWrapper() {

                return mNativeWrapperMock;

            }



            @Override

            WirelessChargerDetector createWirelessChargerDetector(

                    SensorManager sensorManager, SuspendBlocker suspendBlocker, Handler handler) {

                return mWirelessChargerDetectorMock;

            }



            @Override

            AmbientDisplayConfiguration createAmbientDisplayConfiguration(Context context) {

                return mAmbientDisplayConfigurationMock;

            }



            @Override

            InattentiveSleepWarningController createInattentiveSleepWarningController() {

                return mInattentiveSleepWarningControllerMock;

            }



            @Override

            public SystemPropertiesWrapper createSystemPropertiesWrapper() {

                return mSystemPropertiesMock;

            }



            @Override

            PowerManagerService.Clock createClock() {

                return () -> mClock.now();

            }



            @Override

            Handler createHandler(Looper looper, Handler.Callback callback) {

                return new Handler(mTestLooper.getLooper(), callback);

            }



            @Override

            void invalidateIsInteractiveCaches() {

                // Avoids an SELinux failure.

            }

        });

        return mService;

    }



    @After

    public void tearDown() throws Exception {

        LocalServices.removeServiceForTest(LightsManager.class);

        LocalServices.removeServiceForTest(DisplayManagerInternal.class);

        LocalServices.removeServiceForTest(BatteryManagerInternal.class);

        LocalServices.removeServiceForTest(ActivityManagerInternal.class);

        LocalServices.removeServiceForTest(AttentionManagerInternal.class);

        LocalServices.removeServiceForTest(DreamManagerInternal.class);

        FakeSettingsProvider.clearSettingsProvider();

    }



    /**

     * Creates a mock and registers it to {@link LocalServices}.

     */

    private static <T> void addLocalServiceMock(Class<T> clazz, T mock) {

        LocalServices.removeServiceForTest(clazz);

        LocalServices.addService(clazz, mock);

    }



    private void advanceTime(long timeMs) {

        mClock.fastForward(timeMs);

        mTestLooper.dispatchAll();

    }



    @Test

    public void testUserActivityOnDeviceStateChange() {

        createService();

        mService.systemReady(null);

        mService.onBootPhase(SystemService.PHASE_BOOT_COMPLETED);



        final DisplayInfo info = new DisplayInfo();

        info.displayGroupId = Display.DEFAULT_DISPLAY_GROUP;

        when(mDisplayManagerInternalMock.getDisplayInfo(Display.DEFAULT_DISPLAY)).thenReturn(info);



        final ArgumentCaptor<DeviceStateCallback> deviceStateCallbackCaptor =

                ArgumentCaptor.forClass(DeviceStateCallback.class);

        verify(mDeviceStateManagerMock).registerCallback(any(),

                deviceStateCallbackCaptor.capture());



        // Advance the time 10001 and verify that the device thinks it has been idle

        // for just less than that.

        mService.onUserActivity();

        advanceTime(10001);

        assertThat(mService.wasDeviceIdleForInternal(10000)).isTrue();



        // Send a display state change event and advance the clock 10.

        final DeviceStateCallback deviceStateCallback = deviceStateCallbackCaptor.getValue();

        deviceStateCallback.onStateChanged(1);

        final long timeToAdvance = 10;

        advanceTime(timeToAdvance);



        // Ensure that the device has been idle for only 10 (doesn't include the idle time

        // before the display state event).

        assertThat(mService.wasDeviceIdleForInternal(timeToAdvance - 1)).isTrue();

        assertThat(mService.wasDeviceIdleForInternal(timeToAdvance)).isFalse();



        // Send the same state and ensure that does not trigger an update.

        deviceStateCallback.onStateChanged(1);

        advanceTime(timeToAdvance);

        final long newTime = timeToAdvance * 2;



        assertThat(mService.wasDeviceIdleForInternal(newTime - 1)).isTrue();

        assertThat(mService.wasDeviceIdleForInternal(newTime)).isFalse();

    }

}