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

Commit 4ba1a4de authored by Kenneth Ford's avatar Kenneth Ford
Browse files

Update PosturesHelper to use DeviceStateManager API's 

PosturesHelper updated to use the DeviceStateManager API's
to determine what states map to being folded/unfolded etc
instead of using the config overlay values

Bug: 336640888
Test: PosturesHelperTest
Test: DeviceStateRotationLockSettingControllerTest
Test: DeviceStateRotationLockSettingsManagerTest
Flag: android.hardware.devicestate.feature.flags.device_state_property_migration
Change-Id: I6280934063e49658b129d0405f8d5feb71ff4901
parent ff75fcf3

packages/SettingsLib/DeviceStateRotationLock/src/com.android.settingslib.devicestate/DeviceStateRotationLockSettingsManager.java

+13 −1
Original line number Diff line number Diff line
@@ -20,10 +20,13 @@ import static android.provider.Settings.Secure.DEVICE_STATE_ROTATION_LOCK_IGNORE 
import static android.provider.Settings.Secure.DEVICE_STATE_ROTATION_LOCK_LOCKED;

import static android.provider.Settings.Secure.DEVICE_STATE_ROTATION_LOCK_UNLOCKED;



import android.annotation.Nullable;

import android.content.ContentResolver;

import android.content.Context;

import android.content.res.Resources;

import android.database.ContentObserver;

import android.hardware.devicestate.DeviceStateManager;

import android.os.Build;

import android.os.Handler;

import android.os.Looper;

import android.os.UserHandle;
@@ -67,7 +70,8 @@ public final class DeviceStateRotationLockSettingsManager { 
    @VisibleForTesting

    DeviceStateRotationLockSettingsManager(Context context, SecureSettings secureSettings) {

        mSecureSettings = secureSettings;

        mPosturesHelper = new PosturesHelper(context);



        mPosturesHelper = new PosturesHelper(context, getDeviceStateManager(context));

        mPostureRotationLockDefaults =

                context.getResources()

                        .getStringArray(R.array.config_perDeviceStateRotationLockDefaults);
@@ -76,6 +80,14 @@ public final class DeviceStateRotationLockSettingsManager { 
        listenForSettingsChange();

    }



    @Nullable

    private DeviceStateManager getDeviceStateManager(Context context) {

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {

            return context.getSystemService(DeviceStateManager.class);

        }

        return null;

    }



    /** Returns a singleton instance of this class */

    public static synchronized DeviceStateRotationLockSettingsManager getInstance(Context context) {

        if (sSingleton == null) {

packages/SettingsLib/DeviceStateRotationLock/src/com.android.settingslib.devicestate/PosturesHelper.kt

+59 −22
Original line number Diff line number Diff line
@@ -17,6 +17,12 @@ 
package com.android.settingslib.devicestate



import android.content.Context

import android.hardware.devicestate.DeviceState

import android.hardware.devicestate.DeviceState.PROPERTY_FEATURE_REAR_DISPLAY

import android.hardware.devicestate.DeviceState.PROPERTY_FOLDABLE_DISPLAY_CONFIGURATION_INNER_PRIMARY

import android.hardware.devicestate.DeviceState.PROPERTY_FOLDABLE_DISPLAY_CONFIGURATION_OUTER_PRIMARY

import android.hardware.devicestate.DeviceState.PROPERTY_FOLDABLE_HARDWARE_CONFIGURATION_FOLD_IN_HALF_OPEN

import android.hardware.devicestate.DeviceStateManager

import android.provider.Settings.Secure.DEVICE_STATE_ROTATION_KEY_FOLDED

import android.provider.Settings.Secure.DEVICE_STATE_ROTATION_KEY_HALF_FOLDED

import android.provider.Settings.Secure.DEVICE_STATE_ROTATION_KEY_REAR_DISPLAY
@@ -24,37 +30,68 @@ import android.provider.Settings.Secure.DEVICE_STATE_ROTATION_KEY_UNFOLDED 
import android.provider.Settings.Secure.DEVICE_STATE_ROTATION_KEY_UNKNOWN

import android.provider.Settings.Secure.DeviceStateRotationLockKey

import com.android.internal.R

import android.hardware.devicestate.feature.flags.Flags as DeviceStateManagerFlags



/** Helps to convert between device state and posture. */

class PosturesHelper(context: Context) {

class PosturesHelper(context: Context, deviceStateManager: DeviceStateManager?) {



    private val foldedDeviceStates =

        context.resources.getIntArray(R.array.config_foldedDeviceStates)

    private val halfFoldedDeviceStates =

        context.resources.getIntArray(R.array.config_halfFoldedDeviceStates)

    private val unfoldedDeviceStates =

        context.resources.getIntArray(R.array.config_openDeviceStates)

    private val rearDisplayDeviceStates =

        context.resources.getIntArray(R.array.config_rearDisplayDeviceStates)

    private val postures: Map<Int, List<Int>>



    init {

        if (deviceStateManager != null && DeviceStateManagerFlags.deviceStatePropertyMigration()) {

            postures =

                deviceStateManager.supportedDeviceStates.groupBy { it.toPosture() }

                    .filterKeys { it != DEVICE_STATE_ROTATION_KEY_UNKNOWN }

                    .mapValues { it.value.map { it.identifier }}

        } else {

            val foldedDeviceStates =

                context.resources.getIntArray(R.array.config_foldedDeviceStates).toList()

            val halfFoldedDeviceStates =

                context.resources.getIntArray(R.array.config_halfFoldedDeviceStates).toList()

            val unfoldedDeviceStates =

                context.resources.getIntArray(R.array.config_openDeviceStates).toList()

            val rearDisplayDeviceStates =

                context.resources.getIntArray(R.array.config_rearDisplayDeviceStates).toList()



            postures =

                mapOf(

                    DEVICE_STATE_ROTATION_KEY_FOLDED to foldedDeviceStates,

                    DEVICE_STATE_ROTATION_KEY_HALF_FOLDED to halfFoldedDeviceStates,

                    DEVICE_STATE_ROTATION_KEY_UNFOLDED to unfoldedDeviceStates,

                    DEVICE_STATE_ROTATION_KEY_REAR_DISPLAY to rearDisplayDeviceStates

                )

        }

    }



    @DeviceStateRotationLockKey

    fun deviceStateToPosture(deviceState: Int): Int {

        return when (deviceState) {

            in foldedDeviceStates -> DEVICE_STATE_ROTATION_KEY_FOLDED

            in halfFoldedDeviceStates -> DEVICE_STATE_ROTATION_KEY_HALF_FOLDED

            in unfoldedDeviceStates -> DEVICE_STATE_ROTATION_KEY_UNFOLDED

            in rearDisplayDeviceStates -> DEVICE_STATE_ROTATION_KEY_REAR_DISPLAY

            else -> DEVICE_STATE_ROTATION_KEY_UNKNOWN

        }

        return postures.filterValues { it.contains(deviceState) }.keys.firstOrNull()

            ?: DEVICE_STATE_ROTATION_KEY_UNKNOWN

    }



    fun postureToDeviceState(@DeviceStateRotationLockKey posture: Int): Int? {

        return when (posture) {

            DEVICE_STATE_ROTATION_KEY_FOLDED -> foldedDeviceStates.firstOrNull()

            DEVICE_STATE_ROTATION_KEY_HALF_FOLDED -> halfFoldedDeviceStates.firstOrNull()

            DEVICE_STATE_ROTATION_KEY_UNFOLDED -> unfoldedDeviceStates.firstOrNull()

            DEVICE_STATE_ROTATION_KEY_REAR_DISPLAY -> rearDisplayDeviceStates.firstOrNull()

            else -> null

        return postures[posture]?.firstOrNull()

    }



    /**

     * Maps a [DeviceState] to the corresponding [DeviceStateRotationLockKey] value based on the

     * properties of the state.

     */

    @DeviceStateRotationLockKey

    private fun DeviceState.toPosture(): Int {

        return if (hasProperty(PROPERTY_FEATURE_REAR_DISPLAY)) {

            DEVICE_STATE_ROTATION_KEY_REAR_DISPLAY

        } else if (hasProperty(PROPERTY_FOLDABLE_DISPLAY_CONFIGURATION_OUTER_PRIMARY)) {

            DEVICE_STATE_ROTATION_KEY_FOLDED

        } else if (hasProperties(

                PROPERTY_FOLDABLE_DISPLAY_CONFIGURATION_INNER_PRIMARY,

                PROPERTY_FOLDABLE_HARDWARE_CONFIGURATION_FOLD_IN_HALF_OPEN

            )) {

            DEVICE_STATE_ROTATION_KEY_HALF_FOLDED

        } else if (hasProperty(PROPERTY_FOLDABLE_DISPLAY_CONFIGURATION_INNER_PRIMARY)) {

            DEVICE_STATE_ROTATION_KEY_UNFOLDED

        } else {

            DEVICE_STATE_ROTATION_KEY_UNKNOWN

        }

    }

}

packages/SettingsLib/tests/integ/src/com/android/settingslib/devicestate/DeviceStateRotationLockSettingsManagerTest.java

+42 −0
Original line number Diff line number Diff line
@@ -16,13 +16,22 @@ 


package com.android.settingslib.devicestate;



import static android.hardware.devicestate.DeviceState.PROPERTY_FOLDABLE_DISPLAY_CONFIGURATION_INNER_PRIMARY;

import static android.hardware.devicestate.DeviceState.PROPERTY_FOLDABLE_DISPLAY_CONFIGURATION_OUTER_PRIMARY;

import static android.hardware.devicestate.DeviceState.PROPERTY_FOLDABLE_HARDWARE_CONFIGURATION_FOLD_IN_CLOSED;

import static android.hardware.devicestate.DeviceState.PROPERTY_FOLDABLE_HARDWARE_CONFIGURATION_FOLD_IN_HALF_OPEN;

import static android.hardware.devicestate.DeviceState.PROPERTY_FOLDABLE_HARDWARE_CONFIGURATION_FOLD_IN_OPEN;



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



import static org.mockito.Mockito.when;



import android.annotation.NonNull;

import android.content.Context;

import android.content.res.Resources;

import android.database.ContentObserver;

import android.hardware.devicestate.DeviceState;

import android.hardware.devicestate.DeviceStateManager;

import android.os.UserHandle;

import android.provider.Settings;
@@ -42,7 +51,10 @@ import org.junit.runner.RunWith; 
import org.mockito.Mock;

import org.mockito.MockitoAnnotations;



import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;



@SmallTest

@RunWith(AndroidJUnit4.class)
@@ -53,6 +65,8 @@ public class DeviceStateRotationLockSettingsManagerTest { 
    @Mock private Context mMockContext;

    @Mock private Resources mMockResources;



    @Mock private DeviceStateManager mDeviceStateManager;



    private DeviceStateRotationLockSettingsManager mManager;

    private int mNumSettingsChanges = 0;

    private final ContentObserver mContentObserver = new ContentObserver(null) {
@@ -70,6 +84,9 @@ public class DeviceStateRotationLockSettingsManagerTest { 
        when(mMockContext.getApplicationContext()).thenReturn(mMockContext);

        when(mMockContext.getResources()).thenReturn(mMockResources);

        when(mMockContext.getContentResolver()).thenReturn(context.getContentResolver());

        when(mMockContext.getSystemService(DeviceStateManager.class)).thenReturn(

                mDeviceStateManager);

        when(mDeviceStateManager.getSupportedDeviceStates()).thenReturn(createDeviceStateList());

        when(mMockResources.getStringArray(R.array.config_perDeviceStateRotationLockDefaults))

                .thenReturn(new String[]{"0:1", "1:0:2", "2:2"});

        when(mMockResources.getIntArray(R.array.config_foldedDeviceStates))
@@ -180,4 +197,29 @@ public class DeviceStateRotationLockSettingsManagerTest { 
                value,

                UserHandle.USER_CURRENT);

    }



    private List<DeviceState> createDeviceStateList() {

        List<DeviceState> deviceStates = new ArrayList<>();

        deviceStates.add(createDeviceState(0 /* identifier */, "folded",

                new HashSet<>(List.of(PROPERTY_FOLDABLE_DISPLAY_CONFIGURATION_OUTER_PRIMARY)),

                new HashSet<>(List.of(PROPERTY_FOLDABLE_HARDWARE_CONFIGURATION_FOLD_IN_CLOSED))));

        deviceStates.add(createDeviceState(1 /* identifier */, "half_folded",

                new HashSet<>(List.of(PROPERTY_FOLDABLE_DISPLAY_CONFIGURATION_INNER_PRIMARY)),

                new HashSet<>(

                        List.of(PROPERTY_FOLDABLE_HARDWARE_CONFIGURATION_FOLD_IN_HALF_OPEN))));

        deviceStates.add(createDeviceState(2, "unfolded",

                new HashSet<>(List.of(PROPERTY_FOLDABLE_DISPLAY_CONFIGURATION_INNER_PRIMARY)),

                new HashSet<>(List.of(PROPERTY_FOLDABLE_HARDWARE_CONFIGURATION_FOLD_IN_OPEN))));



        return deviceStates;

    }



    private DeviceState createDeviceState(int identifier, @NonNull String name,

            @NonNull Set<@DeviceState.SystemDeviceStateProperties Integer> systemProperties,

            @NonNull Set<@DeviceState.PhysicalDeviceStateProperties Integer> physicalProperties) {

        DeviceState.Configuration deviceStateConfiguration = new DeviceState.Configuration.Builder(

                identifier, name).setPhysicalProperties(systemProperties).setPhysicalProperties(

                physicalProperties).build();

        return new DeviceState(deviceStateConfiguration);

    }

}

packages/SettingsLib/tests/integ/src/com/android/settingslib/devicestate/PosturesHelperTest.kt

+106 −20
Original line number Diff line number Diff line
@@ -18,6 +18,16 @@ package com.android.settingslib.devicestate 


import android.content.Context

import android.content.res.Resources

import android.hardware.devicestate.DeviceState

import android.hardware.devicestate.DeviceState.PROPERTY_FEATURE_REAR_DISPLAY

import android.hardware.devicestate.DeviceState.PROPERTY_FOLDABLE_DISPLAY_CONFIGURATION_INNER_PRIMARY

import android.hardware.devicestate.DeviceState.PROPERTY_FOLDABLE_DISPLAY_CONFIGURATION_OUTER_PRIMARY

import android.hardware.devicestate.DeviceState.PROPERTY_FOLDABLE_HARDWARE_CONFIGURATION_FOLD_IN_CLOSED

import android.hardware.devicestate.DeviceState.PROPERTY_FOLDABLE_HARDWARE_CONFIGURATION_FOLD_IN_HALF_OPEN

import android.hardware.devicestate.DeviceState.PROPERTY_FOLDABLE_HARDWARE_CONFIGURATION_FOLD_IN_OPEN

import android.hardware.devicestate.DeviceStateManager

import android.platform.test.annotations.RequiresFlagsDisabled

import android.platform.test.annotations.RequiresFlagsEnabled

import android.provider.Settings.Secure.DEVICE_STATE_ROTATION_KEY_FOLDED

import android.provider.Settings.Secure.DEVICE_STATE_ROTATION_KEY_HALF_FOLDED

import android.provider.Settings.Secure.DEVICE_STATE_ROTATION_KEY_REAR_DISPLAY
@@ -32,14 +42,40 @@ import org.junit.Rule 
import org.junit.Test

import org.junit.runner.RunWith

import org.mockito.Mock

import org.mockito.Mockito.`when` as whenever

import org.mockito.MockitoAnnotations

import android.hardware.devicestate.feature.flags.Flags as DeviceStateManagerFlags

import org.mockito.Mockito.`when` as whenever



private const val DEVICE_STATE_UNKNOWN = 0

private const val DEVICE_STATE_CLOSED = 1

private const val DEVICE_STATE_HALF_FOLDED = 2

private const val DEVICE_STATE_OPEN = 3

private const val DEVICE_STATE_REAR_DISPLAY = 4

private val DEVICE_STATE_CLOSED = DeviceState(

    DeviceState.Configuration.Builder(/* identifier= */ 1, "CLOSED")

        .setSystemProperties(setOf(PROPERTY_FOLDABLE_DISPLAY_CONFIGURATION_OUTER_PRIMARY))

        .setPhysicalProperties(setOf(PROPERTY_FOLDABLE_HARDWARE_CONFIGURATION_FOLD_IN_CLOSED))

        .build()

)

private val DEVICE_STATE_HALF_FOLDED = DeviceState(

    DeviceState.Configuration.Builder(/* identifier= */ 2, "HALF_FOLDED")

        .setSystemProperties(setOf(PROPERTY_FOLDABLE_DISPLAY_CONFIGURATION_INNER_PRIMARY))

        .setPhysicalProperties(setOf(PROPERTY_FOLDABLE_HARDWARE_CONFIGURATION_FOLD_IN_HALF_OPEN))

        .build()

)

private val DEVICE_STATE_OPEN = DeviceState(

    DeviceState.Configuration.Builder(/* identifier= */ 3, "OPEN")

        .setSystemProperties(setOf(PROPERTY_FOLDABLE_DISPLAY_CONFIGURATION_INNER_PRIMARY))

        .setPhysicalProperties(setOf(PROPERTY_FOLDABLE_HARDWARE_CONFIGURATION_FOLD_IN_OPEN))

        .build()

)

private val DEVICE_STATE_REAR_DISPLAY = DeviceState(

    DeviceState.Configuration.Builder(/* identifier= */ 4, "REAR_DISPLAY")

        .setSystemProperties(

            setOf(

                PROPERTY_FOLDABLE_DISPLAY_CONFIGURATION_OUTER_PRIMARY,

                PROPERTY_FEATURE_REAR_DISPLAY

            )

        )

        .setPhysicalProperties(setOf(PROPERTY_FOLDABLE_HARDWARE_CONFIGURATION_FOLD_IN_CLOSED))

        .build()

)



@SmallTest

@RunWith(AndroidJUnit4::class)
@@ -51,6 +87,8 @@ class PosturesHelperTest { 


    @Mock private lateinit var resources: Resources



    @Mock private lateinit var deviceStateManager: DeviceStateManager



    private lateinit var posturesHelper: PosturesHelper



    @Before
@@ -59,30 +97,39 @@ class PosturesHelperTest { 


        whenever(context.resources).thenReturn(resources)

        whenever(resources.getIntArray(R.array.config_foldedDeviceStates))

            .thenReturn(intArrayOf(DEVICE_STATE_CLOSED))

            .thenReturn(intArrayOf(DEVICE_STATE_CLOSED.identifier))

        whenever(resources.getIntArray(R.array.config_halfFoldedDeviceStates))

            .thenReturn(intArrayOf(DEVICE_STATE_HALF_FOLDED))

            .thenReturn(intArrayOf(DEVICE_STATE_HALF_FOLDED.identifier))

        whenever(resources.getIntArray(R.array.config_openDeviceStates))

            .thenReturn(intArrayOf(DEVICE_STATE_OPEN))

            .thenReturn(intArrayOf(DEVICE_STATE_OPEN.identifier))

        whenever(resources.getIntArray(R.array.config_rearDisplayDeviceStates))

            .thenReturn(intArrayOf(DEVICE_STATE_REAR_DISPLAY))

            .thenReturn(intArrayOf(DEVICE_STATE_REAR_DISPLAY.identifier))

        whenever(deviceStateManager.supportedDeviceStates).thenReturn(

            listOf(

                DEVICE_STATE_CLOSED,

                DEVICE_STATE_HALF_FOLDED,

                DEVICE_STATE_OPEN,

                DEVICE_STATE_REAR_DISPLAY

            )

        )



        posturesHelper = PosturesHelper(context)

        posturesHelper = PosturesHelper(context, deviceStateManager)

    }



    @Test

    fun deviceStateToPosture_mapsCorrectly() {

    @RequiresFlagsDisabled(DeviceStateManagerFlags.FLAG_DEVICE_STATE_PROPERTY_MIGRATION)

    fun deviceStateToPosture_mapsCorrectly_overlayConfigurationValues() {

        expect

            .that(posturesHelper.deviceStateToPosture(DEVICE_STATE_CLOSED))

            .that(posturesHelper.deviceStateToPosture(DEVICE_STATE_CLOSED.identifier))

            .isEqualTo(DEVICE_STATE_ROTATION_KEY_FOLDED)

        expect

            .that(posturesHelper.deviceStateToPosture(DEVICE_STATE_HALF_FOLDED))

            .that(posturesHelper.deviceStateToPosture(DEVICE_STATE_HALF_FOLDED.identifier))

            .isEqualTo(DEVICE_STATE_ROTATION_KEY_HALF_FOLDED)

        expect

            .that(posturesHelper.deviceStateToPosture(DEVICE_STATE_OPEN))

            .that(posturesHelper.deviceStateToPosture(DEVICE_STATE_OPEN.identifier))

            .isEqualTo(DEVICE_STATE_ROTATION_KEY_UNFOLDED)

        expect

            .that(posturesHelper.deviceStateToPosture(DEVICE_STATE_REAR_DISPLAY))

            .that(posturesHelper.deviceStateToPosture(DEVICE_STATE_REAR_DISPLAY.identifier))

            .isEqualTo(DEVICE_STATE_ROTATION_KEY_REAR_DISPLAY)

        expect

            .that(posturesHelper.deviceStateToPosture(DEVICE_STATE_UNKNOWN))
@@ -90,19 +137,58 @@ class PosturesHelperTest { 
    }



    @Test

    fun postureToDeviceState_mapsCorrectly() {

    @RequiresFlagsEnabled(DeviceStateManagerFlags.FLAG_DEVICE_STATE_PROPERTY_MIGRATION)

    fun deviceStateToPosture_mapsCorrectly_deviceStateManager() {

        expect

            .that(posturesHelper.deviceStateToPosture(DEVICE_STATE_CLOSED.identifier))

            .isEqualTo(DEVICE_STATE_ROTATION_KEY_FOLDED)

        expect

            .that(posturesHelper.deviceStateToPosture(DEVICE_STATE_HALF_FOLDED.identifier))

            .isEqualTo(DEVICE_STATE_ROTATION_KEY_HALF_FOLDED)

        expect

            .that(posturesHelper.deviceStateToPosture(DEVICE_STATE_OPEN.identifier))

            .isEqualTo(DEVICE_STATE_ROTATION_KEY_UNFOLDED)

        expect

            .that(posturesHelper.deviceStateToPosture(DEVICE_STATE_REAR_DISPLAY.identifier))

            .isEqualTo(DEVICE_STATE_ROTATION_KEY_REAR_DISPLAY)

        expect

            .that(posturesHelper.deviceStateToPosture(DEVICE_STATE_UNKNOWN))

            .isEqualTo(DEVICE_STATE_ROTATION_KEY_UNKNOWN)

    }



    @Test

    @RequiresFlagsDisabled(DeviceStateManagerFlags.FLAG_DEVICE_STATE_PROPERTY_MIGRATION)

    fun postureToDeviceState_mapsCorrectly_overlayConfigurationValues() {

        expect

            .that(posturesHelper.postureToDeviceState(DEVICE_STATE_ROTATION_KEY_FOLDED))

            .isEqualTo(DEVICE_STATE_CLOSED.identifier)

        expect

            .that(posturesHelper.postureToDeviceState(DEVICE_STATE_ROTATION_KEY_HALF_FOLDED))

            .isEqualTo(DEVICE_STATE_HALF_FOLDED.identifier)

        expect

            .that(posturesHelper.postureToDeviceState(DEVICE_STATE_ROTATION_KEY_UNFOLDED))

            .isEqualTo(DEVICE_STATE_OPEN.identifier)

        expect

            .that(posturesHelper.postureToDeviceState(DEVICE_STATE_ROTATION_KEY_REAR_DISPLAY))

            .isEqualTo(DEVICE_STATE_REAR_DISPLAY.identifier)

        expect.that(posturesHelper.postureToDeviceState(DEVICE_STATE_ROTATION_KEY_UNKNOWN)).isNull()

    }



    @Test

    @RequiresFlagsEnabled(DeviceStateManagerFlags.FLAG_DEVICE_STATE_PROPERTY_MIGRATION)

    fun postureToDeviceState_mapsCorrectly_deviceStateManager() {

        expect

            .that(posturesHelper.postureToDeviceState(DEVICE_STATE_ROTATION_KEY_FOLDED))

            .isEqualTo(DEVICE_STATE_CLOSED)

            .isEqualTo(DEVICE_STATE_CLOSED.identifier)

        expect

            .that(posturesHelper.postureToDeviceState(DEVICE_STATE_ROTATION_KEY_HALF_FOLDED))

            .isEqualTo(DEVICE_STATE_HALF_FOLDED)

            .isEqualTo(DEVICE_STATE_HALF_FOLDED.identifier)

        expect

            .that(posturesHelper.postureToDeviceState(DEVICE_STATE_ROTATION_KEY_UNFOLDED))

            .isEqualTo(DEVICE_STATE_OPEN)

            .isEqualTo(DEVICE_STATE_OPEN.identifier)

        expect

            .that(posturesHelper.postureToDeviceState(DEVICE_STATE_ROTATION_KEY_REAR_DISPLAY))

            .isEqualTo(DEVICE_STATE_REAR_DISPLAY)

            .isEqualTo(DEVICE_STATE_REAR_DISPLAY.identifier)

        expect.that(posturesHelper.postureToDeviceState(DEVICE_STATE_ROTATION_KEY_UNKNOWN)).isNull()

    }

}

packages/SystemUI/tests/src/com/android/systemui/statusbar/policy/DeviceStateRotationLockSettingControllerTest.java

+62 −25

File changed.

Preview size limit exceeded, changes collapsed.