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

Commit 9990f220 authored by Priyanka Advani's avatar Priyanka Advani Committed by Android (Google) Code Review
Browse files

Revert "DevicePostureControlller to use the device posture of the device display" 

This reverts commit 4d80678d.

Reason for revert: Likely culprit for b/312755362

Change-Id: I034ca1afdd56aac3d1caf5e8dddaa00ba89ac3e7
parent 4d80678d

packages/SystemUI/src/com/android/systemui/statusbar/policy/DevicePostureController.java

+1 −5
Original line number Diff line number Diff line
@@ -73,11 +73,7 @@ public interface DevicePostureController extends CallbackController<Callback> { 


    /** Callback to be notified about device posture changes. */

    interface Callback {

        /**

         * Called when the posture changes. If there are multiple active displays ("concurrent"),

         * this will report the physical posture of the device (also known as the base device

         * state).

         */

        /** Called when the posture changes. */

        void onPostureChanged(@DevicePostureInt int posture);

    }

}

packages/SystemUI/src/com/android/systemui/statusbar/policy/DevicePostureControllerImpl.java

+6 −30
Original line number Diff line number Diff line
@@ -36,11 +36,8 @@ import javax.inject.Inject; 
/** Implementation of {@link DevicePostureController} using the DeviceStateManager. */

@SysUISingleton

public class DevicePostureControllerImpl implements DevicePostureController {

    /** From androidx.window.common.COMMON_STATE_USE_BASE_STATE */

    private static final int COMMON_STATE_USE_BASE_STATE = 1000;

    private final List<Callback> mListeners = new ArrayList<>();

    private int mCurrentDevicePosture = DEVICE_POSTURE_UNKNOWN;

    private int mCurrentBasePosture = DEVICE_POSTURE_UNKNOWN;



    private final SparseIntArray mDeviceStateToPostureMap = new SparseIntArray();
@@ -73,25 +70,12 @@ public class DevicePostureControllerImpl implements DevicePostureController { 
            mDeviceStateToPostureMap.put(deviceState, posture);

        }



        deviceStateManager.registerCallback(executor, new DeviceStateManager.DeviceStateCallback() {

            @Override

            public void onStateChanged(int state) {

        deviceStateManager.registerCallback(executor, state -> {

            Assert.isMainThread();

            mCurrentDevicePosture =

                    mDeviceStateToPostureMap.get(state, DEVICE_POSTURE_UNKNOWN);



                mListeners.forEach(l -> l.onPostureChanged(getDevicePosture()));

            }



            @Override

            public void onBaseStateChanged(int state) {

                Assert.isMainThread();

                mCurrentBasePosture = mDeviceStateToPostureMap.get(state, DEVICE_POSTURE_UNKNOWN);



                if (useBaseState()) {

                    mListeners.forEach(l -> l.onPostureChanged(getDevicePosture()));

                }

            }

            mListeners.forEach(l -> l.onPostureChanged(mCurrentDevicePosture));

        });

    }
@@ -109,14 +93,6 @@ public class DevicePostureControllerImpl implements DevicePostureController { 


    @Override

    public int getDevicePosture() {

        if (useBaseState()) {

            return mCurrentBasePosture;

        } else {

        return mCurrentDevicePosture;

    }

}
 


    private boolean useBaseState() {

        return mCurrentDevicePosture == COMMON_STATE_USE_BASE_STATE;

    }

}

packages/SystemUI/tests/src/com/android/systemui/statusbar/policy/DevicePostureControllerImplTest.kt

deleted100644 → 0
+0 −143
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2021 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.systemui.statusbar.policy



import android.hardware.devicestate.DeviceStateManager

import android.testing.AndroidTestingRunner

import android.testing.TestableLooper

import android.testing.TestableResources

import androidx.test.filters.SmallTest

import com.android.systemui.SysuiTestCase

import com.android.systemui.statusbar.policy.DevicePostureController.DEVICE_POSTURE_CLOSED

import com.android.systemui.statusbar.policy.DevicePostureController.DEVICE_POSTURE_FLIPPED

import com.android.systemui.statusbar.policy.DevicePostureController.DEVICE_POSTURE_HALF_OPENED

import com.android.systemui.statusbar.policy.DevicePostureController.DEVICE_POSTURE_OPENED

import com.android.systemui.statusbar.policy.DevicePostureController.DEVICE_POSTURE_UNKNOWN

import com.android.systemui.statusbar.policy.DevicePostureController.SUPPORTED_POSTURES_SIZE

import com.android.systemui.util.concurrency.FakeExecutor

import com.android.systemui.util.mockito.eq

import com.android.systemui.util.time.FakeSystemClock

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

import org.junit.Before

import org.junit.Test

import org.junit.runner.RunWith

import org.mockito.ArgumentCaptor

import org.mockito.Captor

import org.mockito.Mock

import org.mockito.Mockito.verify

import org.mockito.MockitoAnnotations



@SmallTest

@RunWith(AndroidTestingRunner::class)

@TestableLooper.RunWithLooper(setAsMainLooper = true)

class DevicePostureControllerImplTest : SysuiTestCase() {

    private val useBaseStateDeviceState = SUPPORTED_POSTURES_SIZE

    private val deviceStateToPostureMapping =

        arrayOf(

            "$DEVICE_POSTURE_UNKNOWN:$DEVICE_POSTURE_UNKNOWN",

            "$DEVICE_POSTURE_CLOSED:$DEVICE_POSTURE_CLOSED",

            "$DEVICE_POSTURE_HALF_OPENED:$DEVICE_POSTURE_HALF_OPENED",

            "$DEVICE_POSTURE_OPENED:$DEVICE_POSTURE_OPENED",

            "$DEVICE_POSTURE_FLIPPED:$DEVICE_POSTURE_FLIPPED",

            "$useBaseStateDeviceState:1000"

        )

    @Mock private lateinit var deviceStateManager: DeviceStateManager

    @Captor

    private lateinit var deviceStateCallback: ArgumentCaptor<DeviceStateManager.DeviceStateCallback>



    private lateinit var mainExecutor: FakeExecutor

    private lateinit var testableResources: TestableResources

    private lateinit var underTest: DevicePostureControllerImpl



    @Before

    fun setUp() {

        MockitoAnnotations.initMocks(this)

        mainExecutor = FakeExecutor(FakeSystemClock())

        testableResources = context.getOrCreateTestableResources()

        testableResources.addOverride(

            com.android.internal.R.array.config_device_state_postures,

            deviceStateToPostureMapping

        )

        underTest =

            DevicePostureControllerImpl(

                context,

                deviceStateManager,

                mainExecutor,

            )

        verifyRegistersForDeviceStateCallback()

    }



    @Test

    fun testPostureChanged_updates() {

        var posture = -1

        underTest.addCallback { posture = it }



        deviceStateCallback.value.onStateChanged(DEVICE_POSTURE_UNKNOWN)

        assertThat(posture).isEqualTo(DEVICE_POSTURE_UNKNOWN)



        deviceStateCallback.value.onStateChanged(DEVICE_POSTURE_CLOSED)

        assertThat(posture).isEqualTo(DEVICE_POSTURE_CLOSED)



        deviceStateCallback.value.onStateChanged(DEVICE_POSTURE_HALF_OPENED)

        assertThat(posture).isEqualTo(DEVICE_POSTURE_HALF_OPENED)



        deviceStateCallback.value.onStateChanged(DEVICE_POSTURE_OPENED)

        assertThat(posture).isEqualTo(DEVICE_POSTURE_OPENED)



        deviceStateCallback.value.onStateChanged(DEVICE_POSTURE_FLIPPED)

        assertThat(posture).isEqualTo(DEVICE_POSTURE_FLIPPED)

    }



    @Test

    fun testPostureChanged_useBaseUpdate() {

        var posture = -1

        underTest.addCallback { posture = it }



        deviceStateCallback.value.onStateChanged(DEVICE_POSTURE_HALF_OPENED)

        assertThat(posture).isEqualTo(DEVICE_POSTURE_HALF_OPENED)



        // base state change doesn't change the posture

        deviceStateCallback.value.onBaseStateChanged(DEVICE_POSTURE_CLOSED)

        assertThat(posture).isEqualTo(DEVICE_POSTURE_HALF_OPENED)



        // WHEN the display state maps to using the base state, then posture updates

        deviceStateCallback.value.onStateChanged(useBaseStateDeviceState)

        assertThat(posture).isEqualTo(DEVICE_POSTURE_CLOSED)

    }



    @Test

    fun baseStateChanges_doesNotUpdatePosture() {

        var numPostureChanges = 0

        underTest.addCallback { numPostureChanges++ }



        deviceStateCallback.value.onStateChanged(DEVICE_POSTURE_HALF_OPENED)

        assertThat(numPostureChanges).isEqualTo(1)



        // base state changes doesn't send another posture update since the device state isn't

        // useBaseStateDeviceState

        deviceStateCallback.value.onBaseStateChanged(DEVICE_POSTURE_CLOSED)

        deviceStateCallback.value.onBaseStateChanged(DEVICE_POSTURE_HALF_OPENED)

        deviceStateCallback.value.onBaseStateChanged(DEVICE_POSTURE_FLIPPED)

        deviceStateCallback.value.onBaseStateChanged(DEVICE_POSTURE_OPENED)

        deviceStateCallback.value.onBaseStateChanged(DEVICE_POSTURE_UNKNOWN)

        assertThat(numPostureChanges).isEqualTo(1)

    }



    private fun verifyRegistersForDeviceStateCallback() {

        verify(deviceStateManager).registerCallback(eq(mainExecutor), deviceStateCallback.capture())

    }

}