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
Loading
Loading
Loading
Loading
+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) {
+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
        }
    }
}
+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);
    }
}
+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()
    }
}
+62 −25

File changed.

Preview size limit exceeded, changes collapsed.