Support setting screen orientation on physical devices

PiperOrigin-RevId: 536509405

Author: Paige McAuliffe

espresso/device/java/androidx/test/espresso/device/action/ScreenOrientationAction.kt

@@ -18,27 +18,29 @@ package androidx.test.espresso.device.action
 
 import android.app.Activity
 import android.content.ComponentCallbacks
-import android.content.ContentResolver
 import android.content.Context
 import android.content.pm.ActivityInfo.CONFIG_ORIENTATION
 import android.content.res.Configuration
-import android.database.ContentObserver
 import android.os.Handler
 import android.os.HandlerThread
 import android.provider.Settings.System
 import android.util.Log
 import androidx.test.espresso.device.context.ActionContext
+import androidx.test.espresso.device.controller.DeviceControllerOperationException
+import androidx.test.espresso.device.util.SettingsObserver
 import androidx.test.espresso.device.util.executeShellCommand
 import androidx.test.espresso.device.util.getDeviceApiLevel
 import androidx.test.espresso.device.util.getResumedActivityOrNull
 import androidx.test.espresso.device.util.isConfigurationChangeHandled
 import androidx.test.espresso.device.util.isRobolectricTest
+import androidx.test.espresso.device.util.isTestDeviceAnEmulator
 import androidx.test.platform.device.DeviceController
 import androidx.test.platform.device.UnsupportedDeviceOperationException
 import androidx.test.runner.lifecycle.ActivityLifecycleCallback
 import androidx.test.runner.lifecycle.ActivityLifecycleMonitorRegistry
 import androidx.test.runner.lifecycle.Stage
 import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
 
 /** Action to set the test device to the provided screen orientation. */
 internal class ScreenOrientationAction(val screenOrientation: ScreenOrientation) : DeviceAction {
@@ -66,12 +68,7 @@ internal class ScreenOrientationAction(val screenOrientation: ScreenOrientation)
    * @param deviceController the controller to use to interact with the device.
    */
   override fun perform(context: ActionContext, deviceController: DeviceController) {
-    var currentOrientation =
-      context.applicationContext.getResources().getConfiguration().orientation
-    val requestedOrientation =
-      if (screenOrientation == ScreenOrientation.LANDSCAPE) Configuration.ORIENTATION_LANDSCAPE
-      else Configuration.ORIENTATION_PORTRAIT
-    if (currentOrientation == requestedOrientation) {
+    if (screenOrientation == getCurrentScreenOrientation(context)) {
       if (Log.isLoggable(TAG, Log.DEBUG)) {
         Log.d(TAG, "Device screen is already in the requested orientation, no need to rotate.")
       }
@@ -84,7 +81,8 @@ internal class ScreenOrientationAction(val screenOrientation: ScreenOrientation)
     }
 
     var oldAccelRotationSetting = getAccelerometerRotationSetting(context.applicationContext)
-    if (oldAccelRotationSetting != AccelerometerRotation.ENABLED) {
+    // For emulators, auto-rotate must be enabled. For physical devices, it must be disabled.
+    if (isTestDeviceAnEmulator() && oldAccelRotationSetting != AccelerometerRotation.ENABLED) {
       // Executing shell commands requires API 21+.
       if (getDeviceApiLevel() >= 21) {
         Log.d(TAG, "Enabling auto-rotate.")
@@ -94,6 +92,17 @@ internal class ScreenOrientationAction(val screenOrientation: ScreenOrientation)
           "Screen orientation cannot be set on this device because auto-rotate is disabled. Please manually enable auto-rotate and try again."
         )
       }
+    } else if (
+      !isTestDeviceAnEmulator() && oldAccelRotationSetting != AccelerometerRotation.DISABLED
+    ) {
+      if (getDeviceApiLevel() >= 21) {
+        Log.d(TAG, "Disabling auto-rotate.")
+        setAccelerometerRotation(AccelerometerRotation.DISABLED, context.applicationContext)
+      } else {
+        throw UnsupportedDeviceOperationException(
+          "Screen orientation cannot be set on this device because auto-rotate is enabled. Please manually disable auto-rotate and try again."
+        )
+      }
     }
 
     val currentActivity = getResumedActivityOrNull()
@@ -106,6 +115,9 @@ internal class ScreenOrientationAction(val screenOrientation: ScreenOrientation)
       }
 
     val latch: CountDownLatch = CountDownLatch(1)
+    val requestedOrientation =
+      if (screenOrientation == ScreenOrientation.LANDSCAPE) Configuration.ORIENTATION_LANDSCAPE
+      else Configuration.ORIENTATION_PORTRAIT
 
     if (currentActivity == null || configChangesHandled) {
       if (currentActivity == null) {
@@ -124,6 +136,7 @@ internal class ScreenOrientationAction(val screenOrientation: ScreenOrientation)
               latch.countDown()
             }
           }
+
           override fun onLowMemory() {}
         }
       )
@@ -153,13 +166,18 @@ internal class ScreenOrientationAction(val screenOrientation: ScreenOrientation)
         )
     }
     deviceController.setScreenOrientation(screenOrientation.orientation)
-    latch.await()
+    latch.await(5, TimeUnit.SECONDS)
     if (
       getDeviceApiLevel() >= 21 &&
         oldAccelRotationSetting != getAccelerometerRotationSetting(context.applicationContext)
     ) {
       setAccelerometerRotation(oldAccelRotationSetting, context.applicationContext)
     }
+    if (getCurrentScreenOrientation(context) != screenOrientation) {
+      throw DeviceControllerOperationException(
+        "Device could not be set to the requested screen orientation."
+      )
+    }
   }
 
   private fun getAccelerometerRotationSetting(context: Context): AccelerometerRotation =
@@ -181,30 +199,26 @@ internal class ScreenOrientationAction(val screenOrientation: ScreenOrientation)
       SettingsObserver(runnableHandler, context, settingsLatch, System.ACCELEROMETER_ROTATION)
     settingsObserver.observe()
     executeShellCommand("settings put system accelerometer_rotation ${accelerometerRotation.value}")
-    settingsLatch.await()
+    settingsLatch.await(5, TimeUnit.SECONDS)
     settingsObserver.stopObserver()
     thread.quitSafely()
-  }
 
-  private class SettingsObserver(
-    handler: Handler,
-    val context: Context,
-    val latch: CountDownLatch,
-    val settingToObserve: String
-  ) : ContentObserver(handler) {
-    fun observe() {
-      val resolver: ContentResolver = context.getContentResolver()
-      resolver.registerContentObserver(System.getUriFor(settingToObserve), false, this)
-    }
-
-    fun stopObserver() {
-      val resolver: ContentResolver = context.getContentResolver()
-      resolver.unregisterContentObserver(this)
+    if (
+      executeShellCommand("settings get system accelerometer_rotation").trim().toInt() !=
+        accelerometerRotation.value
+    ) {
+      throw DeviceControllerOperationException(
+        "Device could not be set to the requested screen orientation."
+      )
     }
+  }
 
-    override fun onChange(selfChange: Boolean) {
-      latch.countDown()
-    }
+  private fun getCurrentScreenOrientation(context: ActionContext): ScreenOrientation {
+    var currentOrientation =
+      context.applicationContext.getResources().getConfiguration().orientation
+    return if (currentOrientation == Configuration.ORIENTATION_LANDSCAPE)
+      ScreenOrientation.LANDSCAPE
+    else ScreenOrientation.PORTRAIT
   }
 
   companion object {

espresso/device/java/androidx/test/espresso/device/controller/BUILD

@@ -32,6 +32,8 @@ kt_android_library(
         "PhysicalDeviceController.kt",
     ],
     deps = [
+        "//espresso/device/java/androidx/test/espresso/device/controller",
+        "//espresso/device/java/androidx/test/espresso/device/util",
         "//runner/monitor",
         "@maven//:androidx_annotation_annotation",
     ],

espresso/device/java/androidx/test/espresso/device/controller/PhysicalDeviceController.kt

@@ -16,27 +16,66 @@
 
 package androidx.test.espresso.device.controller
 
+import android.content.Context
+import android.os.Handler
+import android.os.HandlerThread
+import android.provider.Settings.System
+import android.view.Surface
 import androidx.annotation.RestrictTo
+import androidx.test.espresso.device.util.SettingsObserver
+import androidx.test.espresso.device.util.executeShellCommand
 import androidx.test.platform.device.DeviceController
 import androidx.test.platform.device.UnsupportedDeviceOperationException
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
 
 /**
  * Implementation of {@link DeviceController} for tests run on a physical device.
  *
  * @hide
  */
 @RestrictTo(RestrictTo.Scope.LIBRARY)
-class PhysicalDeviceController : DeviceController {
+class PhysicalDeviceController(private val context: Context) : DeviceController {
   override fun setDeviceMode(deviceMode: Int) {
     throw UnsupportedDeviceOperationException(
       "Setting a device mode is not supported on physical devices."
     )
   }
 
   override fun setScreenOrientation(screenOrientation: Int) {
-    // TODO(b/203092519) Investigate supporting screen orientation rotation on real devices.
-    throw UnsupportedDeviceOperationException(
-      "Setting screen orientation is not supported on physical devices."
-    )
+    // System user_rotation values must be one of the Surface rotation constants and these values
+    // can indicate different orientations on different devices, since we check if the device is
+    // already in correct orientation in ScreenOrientationAction, set user_rotation to its opposite
+    // here to rotate the device to the opposite orientation
+    val startingUserRotation =
+      executeShellCommand("settings get system user_rotation").trim().toInt()
+    val userRotationToSet =
+      if (
+        startingUserRotation == Surface.ROTATION_0 || startingUserRotation == Surface.ROTATION_270
+      ) {
+        Surface.ROTATION_90
+      } else {
+        Surface.ROTATION_0
+      }
+
+    val settingsLatch: CountDownLatch = CountDownLatch(1)
+    val thread: HandlerThread = HandlerThread("Observer_Thread")
+    thread.start()
+    val runnableHandler: Handler = Handler(thread.getLooper())
+    val settingsObserver: SettingsObserver =
+      SettingsObserver(runnableHandler, context, settingsLatch, System.USER_ROTATION)
+    settingsObserver.observe()
+    executeShellCommand("settings put system user_rotation ${userRotationToSet}")
+    settingsLatch.await(5, TimeUnit.SECONDS)
+    settingsObserver.stopObserver()
+    thread.quitSafely()
+
+    if (
+      executeShellCommand("settings get system user_rotation").trim().toInt() != userRotationToSet
+    ) {
+      throw DeviceControllerOperationException(
+        "Device could not be set to the requested screen orientation."
+      )
+    }
   }
 }

espresso/device/java/androidx/test/espresso/device/dagger/DeviceControllerModule.kt

@@ -61,7 +61,7 @@ internal class DeviceControllerModule {
         val connection = getEmulatorConnection()
         return EmulatorController(connection.emulatorController())
       } else {
-        return PhysicalDeviceController()
+        return PhysicalDeviceController(InstrumentationTestActionContext().applicationContext)
       }
     } else {
       return EspressoDeviceControllerAdpater(platformDeviceController)

espresso/device/java/androidx/test/espresso/device/util/SettingsObserver.kt

@@ -0,0 +1,29 @@
+package androidx.test.espresso.device.util
+
+import android.content.ContentResolver
+import android.content.Context
+import android.database.ContentObserver
+import android.os.Handler
+import android.provider.Settings.System
+import java.util.concurrent.CountDownLatch
+
+class SettingsObserver(
+  handler: Handler,
+  val context: Context,
+  val latch: CountDownLatch,
+  val settingToObserve: String
+) : ContentObserver(handler) {
+  fun observe() {
+    val resolver: ContentResolver = context.getContentResolver()
+    resolver.registerContentObserver(System.getUriFor(settingToObserve), false, this)
+  }
+
+  fun stopObserver() {
+    val resolver: ContentResolver = context.getContentResolver()
+    resolver.unregisterContentObserver(this)
+  }
+
+  override fun onChange(selfChange: Boolean) {
+    latch.countDown()
+  }
+}