expo-screen-orientation 5.1.1 → 6.0.0-beta.1

package/CHANGELOG.md

@@ -10,6 +10,29 @@
 
 ### 💡 Others
 
+## 6.0.0-beta.1 — 2023-06-13
+
+### 🎉 New features
+
+- Added support for React Native 0.72. ([#22588](https://github.com/expo/expo/pull/22588) by [@kudo](https://github.com/kudo))
+
+### 🐛 Bug fixes
+
+- Fixed Android build warnings for Gradle version 8. ([#22537](https://github.com/expo/expo/pull/22537), [#22609](https://github.com/expo/expo/pull/22609) by [@kudo](https://github.com/kudo))
+- [iOS] Fixed screen orientation on iOS 16. ([#22152](https://github.com/expo/expo/pull/22152) by [@behenate](https://github.com/behenate))
+- [iOS] Fixed status bar and navigation bar following the device's orientation regardless of applied orientation lock. ([#22152](https://github.com/expo/expo/pull/22152) by [@behenate](https://github.com/behenate))
+- [iOS] Fixed SafeAreaViews failing after pulling down quick settings when the device is in a different orientation than the current orientation lock allows. ([#22152](https://github.com/expo/expo/pull/22152) by [@behenate](https://github.com/behenate))
+
+### 💡 Others
+
+- [iOS] Migrated to new modules API. ([#22152](https://github.com/expo/expo/pull/22152) by [@behenate](https://github.com/behenate))
+
+## 5.2.0 — 2023-05-08
+
+### 🎉 New features
+
+- Migrated to new modules API on Android ([#22019](https://github.com/expo/expo/pull/22019) by [@behenate](https://github.com/behenate))
+
 ## 5.1.1 — 2023-02-09
 
 _This version does not introduce any user-facing changes._

package/README.md

@@ -9,7 +9,7 @@ Allows you to manage the orientation of your app's interface.
 
 # Installation in managed Expo projects
 
-For [managed](https://docs.expo.dev/versions/latest/introduction/managed-vs-bare/) Expo projects, please follow the installation instructions in the [API documentation for the latest stable release](https://docs.expo.dev/versions/latest/sdk/screen-orientation/). If you follow the link and there is no documentation available then this library is not yet usable within managed projects — it is likely to be included in an upcoming Expo SDK release.
+For [managed](https://docs.expo.dev/archive/managed-vs-bare/) Expo projects, please follow the installation instructions in the [API documentation for the latest stable release](https://docs.expo.dev/versions/latest/sdk/screen-orientation/). If you follow the link and there is no documentation available then this library is not yet usable within managed projects — it is likely to be included in an upcoming Expo SDK release.
 
 # Installation in bare React Native projects
 

package/android/build.gradle

@@ -3,7 +3,7 @@ apply plugin: 'kotlin-android'
 apply plugin: 'maven-publish'
 
 group = 'host.exp.exponent'
-version = '5.1.1'
+version = '6.0.0-beta.1'
 
 buildscript {
   def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
@@ -35,19 +35,11 @@ buildscript {
   }
 }
 
-// Creating sources with comments
-task androidSourcesJar(type: Jar) {
-  classifier = 'sources'
-  from android.sourceSets.main.java.srcDirs
-}
-
 afterEvaluate {
   publishing {
     publications {
       release(MavenPublication) {
         from components.release
-        // Add additional sourcesJar to artifacts
-        artifact(androidSourcesJar)
       }
     }
     repositories {
@@ -70,15 +62,21 @@ android {
     jvmTarget = JavaVersion.VERSION_11.majorVersion
   }
 
+  namespace "expo.modules.screenorientation"
   defaultConfig {
     minSdkVersion safeExtGet("minSdkVersion", 21)
     targetSdkVersion safeExtGet("targetSdkVersion", 33)
     versionCode 7
-    versionName '5.1.1'
+    versionName '6.0.0-beta.1'
   }
   lintOptions {
     abortOnError false
   }
+  publishing {
+    singleVariant("release") {
+      withSourcesJar()
+    }
+  }
 }
 
 dependencies {

package/android/src/main/AndroidManifest.xml

@@ -1,2 +1,2 @@
-<manifest package="expo.modules.screenorientation">
+<manifest>
 </manifest>

package/android/src/main/java/expo/modules/screenorientation/ScreenOrientationExceptions.kt

@@ -0,0 +1,12 @@
+package expo.modules.screenorientation
+
+import expo.modules.kotlin.exception.CodedException
+
+internal class InvalidOrientationLockException(orientationLock: Int, cause: Exception) :
+  CodedException("An invalid OrientationLock was passed in: $orientationLock", cause)
+
+internal class GetOrientationLockException(cause: Exception) :
+  CodedException("Could not get the current screen orientation lock: ", cause)
+
+internal class GetPlatformOrientationLockException(cause: Exception) :
+  CodedException("Could not get the current screen orientation platform lock", cause)

package/android/src/main/java/expo/modules/screenorientation/ScreenOrientationModule.kt

@@ -1,146 +1,117 @@
 package expo.modules.screenorientation
 
 import android.app.Activity
-import android.content.Context
-import android.content.pm.ActivityInfo
+import android.os.Build
 import android.util.DisplayMetrics
 import android.view.Surface
-import expo.modules.core.ExportedModule
-import expo.modules.core.ModuleRegistry
-import expo.modules.core.Promise
+import android.view.WindowInsets
+
 import expo.modules.core.errors.InvalidArgumentException
-import expo.modules.core.interfaces.ActivityProvider
-import expo.modules.core.interfaces.ExpoMethod
 import expo.modules.core.interfaces.LifecycleEventListener
 import expo.modules.core.interfaces.services.UIManager
+import expo.modules.kotlin.exception.Exceptions
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.screenorientation.enums.Orientation
+import expo.modules.screenorientation.enums.OrientationAttr
+import expo.modules.screenorientation.enums.OrientationLock
 
-private const val ERR_SCREEN_ORIENTATION_UNSUPPORTED_ORIENTATION_LOCK = "ERR_SCREEN_ORIENTATION_UNSUPPORTED_ORIENTATION_LOCK"
-private const val ERR_SCREEN_ORIENTATION_INVALID_ORIENTATION_LOCK = "ERR_SCREEN_ORIENTATION_INVALID_ORIENTATION_LOCK"
-private const val ERR_SCREEN_ORIENTATION_GET_ORIENTATION_LOCK = "ERR_SCREEN_ORIENTATION_GET_ORIENTATION_LOCK"
-private const val ERR_SCREEN_ORIENTATION_GET_PLATFORM_ORIENTATION_LOCK = "ERR_SCREEN_ORIENTATION_GET_PLATFORM_ORIENTATION_LOCK"
-private const val ERR_SCREEN_ORIENTATION_MISSING_ACTIVITY = "ERR_SCREEN_ORIENTATION_MISSING_ACTIVITY"
+class ScreenOrientationModule : Module(), LifecycleEventListener {
+  private val weakCurrentActivity
+    get() = appContext.activityProvider?.currentActivity
 
-class ScreenOrientationModule(context: Context) : ExportedModule(context), LifecycleEventListener {
-  private lateinit var mActivityProvider: ActivityProvider
-  private var mInitialOrientation: Int? = null
+  private val currentActivity
+    get() = weakCurrentActivity ?: throw Exceptions.MissingActivity()
 
-  override fun getName() = "ExpoScreenOrientation"
+  private val uiManager
+    get() = appContext.legacyModuleRegistry.getModule(UIManager::class.java)
+      ?: throw IllegalStateException("Could not find implementation for UIManager.")
 
-  override fun onCreate(moduleRegistry: ModuleRegistry) {
-    mActivityProvider = moduleRegistry.getModule(ActivityProvider::class.java)
-      ?: throw IllegalStateException("Could not find implementation for ActivityProvider.")
+  private var initialOrientation: Int? = null
 
-    (
-      moduleRegistry.getModule(UIManager::class.java)
-        ?: throw IllegalStateException("Could not find implementation for UIManager.")
-      )
-      .registerLifecycleEventListener(this)
-  }
+  override fun definition() = ModuleDefinition {
+    Name("ExpoScreenOrientation")
 
-  override fun onHostResume() {
-    mActivityProvider.currentActivity?.let {
-      if (mInitialOrientation == null) {
-        mInitialOrientation = it.requestedOrientation
+    AsyncFunction("lockAsync") { orientationLock: OrientationLock ->
+      try {
+        currentActivity.requestedOrientation = orientationLock.toPlatformInt()
+      } catch (e: InvalidArgumentException) {
+        throw InvalidOrientationLockException(orientationLock.value, e)
       }
     }
-  }
 
-  override fun onHostPause() = Unit
-
-  override fun onHostDestroy() = Unit
+    AsyncFunction("lockPlatformAsync") { orientationAttr: OrientationAttr ->
+      currentActivity.requestedOrientation = orientationAttr.value
+    }
 
-  override fun onDestroy() {
-    mActivityProvider.currentActivity?.let { activity ->
-      mInitialOrientation?.let {
-        activity.requestedOrientation = it
-      }
+    AsyncFunction("getOrientationAsync") {
+      return@AsyncFunction getScreenOrientation(currentActivity).value
     }
-  }
 
-  @ExpoMethod
-  fun lockAsync(orientationLock: Int, promise: Promise) {
-    mActivityProvider.currentActivity?.let {
-      return try {
-        it.requestedOrientation = importOrientationLock(orientationLock)
-        promise.resolve(null)
-      } catch (e: InvalidArgumentException) {
-        promise.reject(ERR_SCREEN_ORIENTATION_INVALID_ORIENTATION_LOCK, "An invalid OrientationLock was passed in: $orientationLock", e)
+    AsyncFunction("getOrientationLockAsync") {
+      try {
+        return@AsyncFunction OrientationLock.fromPlatformInt(currentActivity.requestedOrientation)
       } catch (e: Exception) {
-        promise.reject(ERR_SCREEN_ORIENTATION_UNSUPPORTED_ORIENTATION_LOCK, "Could not apply the ScreenOrientation lock: $orientationLock", e)
+        throw GetOrientationLockException(e)
       }
     }
 
-    promise.reject(ERR_SCREEN_ORIENTATION_MISSING_ACTIVITY, "Could not find activity.", null)
-  }
-
-  @ExpoMethod
-  fun lockPlatformAsync(orientationAttr: Int, promise: Promise) {
-    mActivityProvider.currentActivity?.let {
-      return try {
-        it.requestedOrientation = orientationAttr
-        promise.resolve(null)
+    AsyncFunction("getPlatformOrientationLockAsync") {
+      try {
+        return@AsyncFunction currentActivity.requestedOrientation
       } catch (e: Exception) {
-        promise.reject(ERR_SCREEN_ORIENTATION_UNSUPPORTED_ORIENTATION_LOCK, "Could not apply the ScreenOrientation platform lock: $orientationAttr", e)
+        throw GetPlatformOrientationLockException(e)
       }
     }
 
-    promise.reject(ERR_SCREEN_ORIENTATION_MISSING_ACTIVITY, "Could not find activity.", null)
-  }
-
-  @ExpoMethod
-  fun getOrientationAsync(promise: Promise) {
-    mActivityProvider.currentActivity?.let {
-      return promise.resolve(getScreenOrientation(it).value)
+    AsyncFunction("supportsOrientationLockAsync") { orientationLock: Int ->
+      return@AsyncFunction OrientationLock.supportsOrientationLock(orientationLock)
     }
 
-    promise.reject(ERR_SCREEN_ORIENTATION_MISSING_ACTIVITY, "Could not find activity.", null)
-  }
-
-  @ExpoMethod
-  fun getOrientationLockAsync(promise: Promise) {
-    mActivityProvider.currentActivity?.let {
-      return try {
-        promise.resolve(exportOrientationLock(it.requestedOrientation))
-      } catch (e: Exception) {
-        promise.reject(ERR_SCREEN_ORIENTATION_GET_ORIENTATION_LOCK, "Could not get the current screen orientation lock", e)
-      }
+    OnCreate {
+      uiManager.registerLifecycleEventListener(this@ScreenOrientationModule)
     }
 
-    promise.reject(ERR_SCREEN_ORIENTATION_MISSING_ACTIVITY, "Could not find activity.", null)
-  }
-
-  @ExpoMethod
-  fun getPlatformOrientationLockAsync(promise: Promise) {
-    mActivityProvider.currentActivity?.let {
-      return try {
-        promise.resolve(it.requestedOrientation)
-      } catch (e: Exception) {
-        promise.reject(ERR_SCREEN_ORIENTATION_GET_PLATFORM_ORIENTATION_LOCK, "Could not get the current screen orientation platform lock", e)
+    OnDestroy {
+      uiManager.unregisterLifecycleEventListener(this@ScreenOrientationModule)
+      initialOrientation?.let {
+        weakCurrentActivity?.requestedOrientation = it
       }
     }
-
-    promise.reject(ERR_SCREEN_ORIENTATION_MISSING_ACTIVITY, "Could not find activity.", null)
   }
 
-  @ExpoMethod
-  fun supportsOrientationLockAsync(orientationLock: Int, promise: Promise) {
-    try {
-      importOrientationLock(orientationLock)
-      promise.resolve(true)
-    } catch (e: Exception) {
-      promise.resolve(false)
-    }
+  override fun onHostResume() {
+    initialOrientation = initialOrientation ?: weakCurrentActivity?.requestedOrientation
   }
 
+  override fun onHostPause() = Unit
+
+  override fun onHostDestroy() = Unit
+
   // https://stackoverflow.com/a/10383164/1123156
   // Will not work in all cases as surface rotation is not standardized across android devices, but this is best effort
   private fun getScreenOrientation(activity: Activity): Orientation {
     val windowManager = activity.windowManager ?: return Orientation.UNKNOWN
-    val rotation = windowManager.defaultDisplay.rotation
-    val dm = DisplayMetrics().also(windowManager.defaultDisplay::getMetrics)
 
-    val currentOrientation: Orientation
+    val rotation = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      currentActivity.window.context.display?.rotation ?: return Orientation.UNKNOWN
+    } else {
+      windowManager.defaultDisplay.rotation
+    }
 
+    val dm = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      val windowMetrics = windowManager.currentWindowMetrics
+      val insets = windowMetrics.windowInsets
+        .getInsetsIgnoringVisibility(WindowInsets.Type.systemBars())
+      DisplayMetrics().apply {
+        widthPixels = windowMetrics.bounds.width() - insets.left - insets.right
+        heightPixels = windowMetrics.bounds.height() - insets.top - insets.bottom
+      }
+    } else {
+      DisplayMetrics().also(windowManager.defaultDisplay::getMetrics)
+    }
+
+    val currentOrientation: Orientation
     if (isPortraitNaturalOrientation(rotation, dm.widthPixels, dm.heightPixels)) {
       currentOrientation = when (rotation) {
         Surface.ROTATION_0 -> Orientation.PORTRAIT_UP
@@ -172,33 +143,4 @@ class ScreenOrientationModule(context: Context) : ExportedModule(context), Lifec
       height > width || (rotation == Surface.ROTATION_90 || rotation == Surface.ROTATION_270) &&
       width > height
   }
-
-  private fun exportOrientationLock(nativeOrientationLock: Int): Int {
-    return when (nativeOrientationLock) {
-      ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED -> 0
-      ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR -> 1
-      ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT -> 2
-      ActivityInfo.SCREEN_ORIENTATION_PORTRAIT -> 3
-      ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT -> 4
-      ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE -> 5
-      ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE -> 6
-      ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE -> 7
-      else -> 8 // other orientation
-    }
-  }
-
-  @Throws(InvalidArgumentException::class)
-  private fun importOrientationLock(orientationLock: Int): Int {
-    return when (orientationLock) {
-      0 -> ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
-      1 -> ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR
-      2 -> ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT
-      3 -> ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
-      4 -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT
-      5 -> ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
-      6 -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
-      7 -> ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
-      else -> throw InvalidArgumentException("OrientationLock $orientationLock is not mappable to a native Android orientation attr")
-    }
-  }
 }

package/android/src/main/java/expo/modules/screenorientation/{Orientation.kt → enums/Orientation.kt}

@@ -1,4 +1,4 @@
-package expo.modules.screenorientation
+package expo.modules.screenorientation.enums
 
 /*
  * Enum representing a screen orientation.

package/android/src/main/java/expo/modules/screenorientation/enums/OrientationAttr.kt

@@ -0,0 +1,39 @@
+package expo.modules.screenorientation.enums
+
+import android.content.pm.ActivityInfo
+import expo.modules.core.errors.InvalidArgumentException
+import expo.modules.kotlin.types.Enumerable
+
+enum class OrientationAttr(val value: Int) : Enumerable {
+  Behind(ActivityInfo.SCREEN_ORIENTATION_BEHIND),
+  Landscape(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE),
+  Portrait(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT),
+  FullSensor(ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR),
+  Unspecified(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED),
+  Locked(ActivityInfo.SCREEN_ORIENTATION_LOCKED),
+  FullUser(ActivityInfo.SCREEN_ORIENTATION_FULL_USER),
+  NoSensor(ActivityInfo.SCREEN_ORIENTATION_NOSENSOR),
+  ReverseLandscape(ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE),
+  ReversePortrait(ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT),
+  Sensor(ActivityInfo.SCREEN_ORIENTATION_SENSOR),
+  SensorPortrait(ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT),
+  SensorLandscape(ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE),
+  User(ActivityInfo.SCREEN_ORIENTATION_USER),
+  UserPortrait(ActivityInfo.SCREEN_ORIENTATION_USER_PORTRAIT),
+  UserLandscape(ActivityInfo.SCREEN_ORIENTATION_USER_LANDSCAPE);
+
+  internal fun toOrientationLock() = try {
+    OrientationLock.values().first { it.name == this@OrientationAttr.name }
+  } catch (e: NoSuchElementException) {
+    OrientationLock.Other
+  }
+
+  companion object {
+    @Throws(InvalidArgumentException::class)
+    fun fromInt(value: Int) = try {
+      OrientationAttr.values().first { it.value == value }
+    } catch (e: NoSuchElementException) {
+      throw InvalidArgumentException("Platform orientation $value is not a valid Android orientation attr")
+    }
+  }
+}

package/android/src/main/java/expo/modules/screenorientation/enums/OrientationLock.kt

@@ -0,0 +1,39 @@
+package expo.modules.screenorientation.enums
+
+import expo.modules.core.errors.InvalidArgumentException
+import expo.modules.kotlin.types.Enumerable
+
+enum class OrientationLock(val value: Int) : Enumerable {
+  Unspecified(0),
+  FullSensor(1),
+  SensorPortrait(2),
+  Portrait(3),
+  ReversePortrait(4),
+  SensorLandscape(5),
+  ReverseLandscape(6),
+  Landscape(7),
+  Other(8),
+
+  // Not used for anything in the native code, but it should be possible to assign an "Unknown" value to OrientationLock
+  // https://docs.expo.dev/versions/latest/sdk/screen-orientation/#unknown-1
+  Unknown(9);
+
+  @Throws(InvalidArgumentException::class)
+  internal fun toOrientationAttr() = try {
+    OrientationAttr.values().first { it.name == this@OrientationLock.name }
+  } catch (e: NoSuchElementException) {
+    throw InvalidArgumentException("OrientationLock ${this@OrientationLock} is not mappable to a native Android orientation attr")
+  }
+
+  @Throws(InvalidArgumentException::class)
+  internal fun toPlatformInt() = toOrientationAttr().value
+
+  companion object {
+    @Throws(InvalidArgumentException::class)
+    fun fromPlatformInt(value: Int) = OrientationAttr.fromInt(value).toOrientationLock()
+
+    // Other and Unknown can be assigned but are not valid orientation locks
+    fun supportsOrientationLock(value: Int): Boolean =
+      OrientationLock.values().any { it.value == value } && value != Other.value && value != Unknown.value
+  }
+}

package/build/ExpoScreenOrientation.d.ts

@@ -1,3 +1,3 @@
-declare const _default: import("expo-modules-core").ProxyNativeModule;
+declare const _default: any;
 export default _default;
 //# sourceMappingURL=ExpoScreenOrientation.d.ts.map

package/build/ExpoScreenOrientation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ExpoScreenOrientation.d.ts","sourceRoot":"","sources":["../src/ExpoScreenOrientation.ts"],"names":[],"mappings":";AAEA,wBAA8D"}
+{"version":3,"file":"ExpoScreenOrientation.d.ts","sourceRoot":"","sources":["../src/ExpoScreenOrientation.ts"],"names":[],"mappings":";AAEA,wBAA4D"}

package/build/ExpoScreenOrientation.js

@@ -1,3 +1,3 @@
-import { NativeModulesProxy } from 'expo-modules-core';
-export default NativeModulesProxy.ExpoScreenOrientation || {};
+import { requireNativeModule } from 'expo-modules-core';
+export default requireNativeModule('ExpoScreenOrientation');
 //# sourceMappingURL=ExpoScreenOrientation.js.map

package/build/ExpoScreenOrientation.js.map

@@ -1 +1 @@
-{"version":3,"file":"ExpoScreenOrientation.js","sourceRoot":"","sources":["../src/ExpoScreenOrientation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEvD,eAAe,kBAAkB,CAAC,qBAAqB,IAAI,EAAE,CAAC","sourcesContent":["import { NativeModulesProxy } from 'expo-modules-core';\n\nexport default NativeModulesProxy.ExpoScreenOrientation || {};\n"]}
+{"version":3,"file":"ExpoScreenOrientation.js","sourceRoot":"","sources":["../src/ExpoScreenOrientation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD,eAAe,mBAAmB,CAAC,uBAAuB,CAAC,CAAC","sourcesContent":["import { requireNativeModule } from 'expo-modules-core';\n\nexport default requireNativeModule('ExpoScreenOrientation');\n"]}

package/build/ScreenOrientation.d.ts

@@ -7,13 +7,6 @@ export { Orientation, OrientationLock, PlatformOrientationInfo, OrientationChang
  * enum for possible values.
  * @return Returns a promise with `void` value, which fulfils when the orientation is set.
  *
- * # Error codes
- * - `ERR_SCREEN_ORIENTATION_INVALID_ORIENTATION_LOCK` - An invalid [`OrientationLock`](#orientationlock)
- *   was passed in.
- * - `ERR_SCREEN_ORIENTATION_UNSUPPORTED_ORIENTATION_LOCK` - The platform does not support the
- *   orientation lock policy.
- * - `ERR_SCREEN_ORIENTATION_MISSING_ACTIVITY` - __Android Only.__ Could not get the current activity.
- *
  * @example
  * ```ts
  * async function changeScreenOrientation() {
@@ -27,52 +20,29 @@ export declare function lockAsync(orientationLock: OrientationLock): Promise<voi
  * object type for the different platform formats.
  * @return Returns a promise with `void` value, resolving when the orientation is set and rejecting
  * if an invalid option or value is passed.
- *
- * # Error codes
- * - `ERR_SCREEN_ORIENTATION_INVALID_ORIENTATION_LOCK` - __iOS Only.__ An invalid [`OrientationLock`](#orientationlock)
- *   was passed in.
- * - `ERR_SCREEN_ORIENTATION_UNSUPPORTED_ORIENTATION_LOCK` - The platform does not support the
- *   orientation lock policy.
- * - `ERR_SCREEN_ORIENTATION_MISSING_ACTIVITY` - __Android Only.__ Could not get the current activity.
- *
  */
 export declare function lockPlatformAsync(options: PlatformOrientationInfo): Promise<void>;
 /**
  * Sets the screen orientation back to the `OrientationLock.DEFAULT` policy.
  * @return Returns a promise with `void` value, which fulfils when the orientation is set.
- *
- * # Error codes
- * - `ERR_SCREEN_ORIENTATION_MISSING_ACTIVITY` - __Android Only.__ Could not get the current activity.
  */
 export declare function unlockAsync(): Promise<void>;
 /**
  * Gets the current screen orientation.
  * @return Returns a promise that fulfils with an [`Orientation`](#screenorientationorientation)
  * value that reflects the current screen orientation.
- *
- * # Error codes
- * - `ERR_SCREEN_ORIENTATION_GET_ORIENTATION_LOCK` - __Android Only.__ An unknown error occurred
- *   when trying to get the system lock.
- * - `ERR_SCREEN_ORIENTATION_MISSING_ACTIVITY` - __Android Only.__ Could not get the current activity.
  */
 export declare function getOrientationAsync(): Promise<Orientation>;
 /**
  * Gets the current screen orientation lock type.
  * @return Returns a promise which fulfils with an [`OrientationLock`](#orientationlock)
  * value.
- *
- * # Error codes
- * - `ERR_SCREEN_ORIENTATION_MISSING_ACTIVITY` - __Android Only.__ Could not get the current activity.
  */
 export declare function getOrientationLockAsync(): Promise<OrientationLock>;
 /**
  * Gets the platform specific screen orientation lock type.
  * @return Returns a promise which fulfils with a [`PlatformOrientationInfo`](#platformorientationinfo)
  * value.
- *
- * # Error codes
- * - `ERR_SCREEN_ORIENTATION_GET_PLATFORM_ORIENTATION_LOCK`
- * - `ERR_SCREEN_ORIENTATION_MISSING_ACTIVITY` - __Android Only.__ Could not get the current activity.
  */
 export declare function getPlatformOrientationLockAsync(): Promise<PlatformOrientationInfo>;
 /**

package/build/ScreenOrientation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ScreenOrientation.d.ts","sourceRoot":"","sources":["../src/ScreenOrientation.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,YAAY,EAAuB,MAAM,mBAAmB,CAAC;AAG9F,OAAO,EACL,WAAW,EACX,sBAAsB,EACtB,yBAAyB,EACzB,eAAe,EACf,uBAAuB,EACvB,kBAAkB,EAClB,cAAc,EACd,YAAY,EACZ,qBAAqB,EACtB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EACL,WAAW,EACX,eAAe,EACf,uBAAuB,EACvB,yBAAyB,EACzB,sBAAsB,EACtB,kBAAkB,EAClB,cAAc,EACd,YAAY,EACZ,qBAAqB,EACrB,YAAY,GACb,CAAC;AAQF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,SAAS,CAAC,eAAe,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAgB/E;AAGD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC,CA4CvF;AAGD;;;;;;GAMG;AACH,wBAAsB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAKjD;AAGD;;;;;;;;;GASG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC,CAKhE;AAGD;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,eAAe,CAAC,CAKxE;AAGD;;;;;;;;GAQG;AACH,wBAAsB,+BAA+B,IAAI,OAAO,CAAC,uBAAuB,CAAC,CAiBxF;AAGD;;;;;;GAMG;AACH,wBAAsB,4BAA4B,CAChD,eAAe,EAAE,eAAe,GAC/B,OAAO,CAAC,OAAO,CAAC,CAWlB;AAaD;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,yBAAyB,GAAG,YAAY,CA2B9F;AAMD;;GAEG;AACH,wBAAgB,gCAAgC,IAAI,IAAI,CAUvD;AAGD;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI,CAQhF"}
+{"version":3,"file":"ScreenOrientation.d.ts","sourceRoot":"","sources":["../src/ScreenOrientation.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,YAAY,EAAuB,MAAM,mBAAmB,CAAC;AAG9F,OAAO,EACL,WAAW,EACX,sBAAsB,EACtB,yBAAyB,EACzB,eAAe,EACf,uBAAuB,EACvB,kBAAkB,EAClB,cAAc,EACd,YAAY,EACZ,qBAAqB,EACtB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EACL,WAAW,EACX,eAAe,EACf,uBAAuB,EACvB,yBAAyB,EACzB,sBAAsB,EACtB,kBAAkB,EAClB,cAAc,EACd,YAAY,EACZ,qBAAqB,EACrB,YAAY,GACb,CAAC;AAQF;;;;;;;;;;;;GAYG;AACH,wBAAsB,SAAS,CAAC,eAAe,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAgB/E;AAGD;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC,CA4CvF;AAGD;;;GAGG;AACH,wBAAsB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAKjD;AAGD;;;;GAIG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC,CAKhE;AAGD;;;;GAIG;AACH,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,eAAe,CAAC,CAKxE;AAGD;;;;GAIG;AACH,wBAAsB,+BAA+B,IAAI,OAAO,CAAC,uBAAuB,CAAC,CAiBxF;AAGD;;;;;;GAMG;AACH,wBAAsB,4BAA4B,CAChD,eAAe,EAAE,eAAe,GAC/B,OAAO,CAAC,OAAO,CAAC,CAWlB;AAaD;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,yBAAyB,GAAG,YAAY,CA2B9F;AAMD;;GAEG;AACH,wBAAgB,gCAAgC,IAAI,IAAI,CAUvD;AAGD;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI,CAQhF"}

package/build/ScreenOrientation.js

@@ -12,13 +12,6 @@ let _lastOrientationLock = OrientationLock.UNKNOWN;
  * enum for possible values.
  * @return Returns a promise with `void` value, which fulfils when the orientation is set.
  *
- * # Error codes
- * - `ERR_SCREEN_ORIENTATION_INVALID_ORIENTATION_LOCK` - An invalid [`OrientationLock`](#orientationlock)
- *   was passed in.
- * - `ERR_SCREEN_ORIENTATION_UNSUPPORTED_ORIENTATION_LOCK` - The platform does not support the
- *   orientation lock policy.
- * - `ERR_SCREEN_ORIENTATION_MISSING_ACTIVITY` - __Android Only.__ Could not get the current activity.
- *
  * @example
  * ```ts
  * async function changeScreenOrientation() {
@@ -46,14 +39,6 @@ export async function lockAsync(orientationLock) {
  * object type for the different platform formats.
  * @return Returns a promise with `void` value, resolving when the orientation is set and rejecting
  * if an invalid option or value is passed.
- *
- * # Error codes
- * - `ERR_SCREEN_ORIENTATION_INVALID_ORIENTATION_LOCK` - __iOS Only.__ An invalid [`OrientationLock`](#orientationlock)
- *   was passed in.
- * - `ERR_SCREEN_ORIENTATION_UNSUPPORTED_ORIENTATION_LOCK` - The platform does not support the
- *   orientation lock policy.
- * - `ERR_SCREEN_ORIENTATION_MISSING_ACTIVITY` - __Android Only.__ Could not get the current activity.
- *
  */
 export async function lockPlatformAsync(options) {
     if (!ExpoScreenOrientation.lockPlatformAsync) {
@@ -96,9 +81,6 @@ export async function lockPlatformAsync(options) {
 /**
  * Sets the screen orientation back to the `OrientationLock.DEFAULT` policy.
  * @return Returns a promise with `void` value, which fulfils when the orientation is set.
- *
- * # Error codes
- * - `ERR_SCREEN_ORIENTATION_MISSING_ACTIVITY` - __Android Only.__ Could not get the current activity.
  */
 export async function unlockAsync() {
     if (!ExpoScreenOrientation.lockAsync) {
@@ -111,11 +93,6 @@ export async function unlockAsync() {
  * Gets the current screen orientation.
  * @return Returns a promise that fulfils with an [`Orientation`](#screenorientationorientation)
  * value that reflects the current screen orientation.
- *
- * # Error codes
- * - `ERR_SCREEN_ORIENTATION_GET_ORIENTATION_LOCK` - __Android Only.__ An unknown error occurred
- *   when trying to get the system lock.
- * - `ERR_SCREEN_ORIENTATION_MISSING_ACTIVITY` - __Android Only.__ Could not get the current activity.
  */
 export async function getOrientationAsync() {
     if (!ExpoScreenOrientation.getOrientationAsync) {
@@ -128,9 +105,6 @@ export async function getOrientationAsync() {
  * Gets the current screen orientation lock type.
  * @return Returns a promise which fulfils with an [`OrientationLock`](#orientationlock)
  * value.
- *
- * # Error codes
- * - `ERR_SCREEN_ORIENTATION_MISSING_ACTIVITY` - __Android Only.__ Could not get the current activity.
  */
 export async function getOrientationLockAsync() {
     if (!ExpoScreenOrientation.getOrientationLockAsync) {
@@ -143,10 +117,6 @@ export async function getOrientationLockAsync() {
  * Gets the platform specific screen orientation lock type.
  * @return Returns a promise which fulfils with a [`PlatformOrientationInfo`](#platformorientationinfo)
  * value.
- *
- * # Error codes
- * - `ERR_SCREEN_ORIENTATION_GET_PLATFORM_ORIENTATION_LOCK`
- * - `ERR_SCREEN_ORIENTATION_MISSING_ACTIVITY` - __Android Only.__ Could not get the current activity.
  */
 export async function getPlatformOrientationLockAsync() {
     const platformOrientationLock = await ExpoScreenOrientation.getPlatformOrientationLockAsync();