react-native-orientation-director 1.2.3 → 2.0.0

package/README.md

@@ -4,7 +4,8 @@
 
 # react-native-orientation-director
 
-A simple library that allows you to handle orientation changes in your React Native app.
+A React Native library that allows you to listen to orientation changes, lock interface orientation
+to a selected one and get current orientation.
 Written in Kotlin, Swift and Typescript. It supports both the Old and New React Native architecture.
 
 This library takes inspiration from and builds upon the following amazing alternatives:
@@ -27,17 +28,29 @@ This library takes inspiration from and builds upon the following amazing altern
 
 ## Installation
 
+### React Native Bare
+
 You can install the package via npm or yarn:
 
 ```sh
 npm install react-native-orientation-director
 ```
+
 ```sh
 yarn add react-native-orientation-director
 ```
 
 Don't forget to run pod-install.
 
+### Expo
+
+This library can be installed only for [Development Builds](https://docs.expo.dev/develop/development-builds/introduction/)
+using the following command:
+
+```sh
+npx expo install react-native-orientation-director
+```
+
 ## Setup
 
 To properly handle interface orientation changes in iOS, you need to update your AppDelegate.mm file.
@@ -60,36 +73,47 @@ There is no need to do anything in Android, it works out of the box.
 
 This library exports a class called: [RNOrientationDirector](https://github.com/gladiuscode/react-native-orientation-director/blob/main/src/RNOrientationDirector.ts) that exposes the following methods:
 
-| Method                                  | Description                                                                     |
-|-----------------------------------------|---------------------------------------------------------------------------------|
-| getInterfaceOrientation                 | Returns the last interface orientation                                          |
-| getDeviceOrientation                    | Returns the last device orientation                                             |
-| lockTo                                  | Locks the interface to a specific orientation                                   |
-| unlock                                  | Unlock the interface                                                            |
-| isLocked                                | Returns the current interface orientation status (locked / unlocked)            |
-| isAutoRotationEnabled                   | (Android Only) Returns if auto rotation is enabled                              |
-| listenForDeviceOrientationChanges       | Triggers a provided callback each time the device orientation changes           |
-| listenForInterfaceOrientationChanges    | Triggers a provided callback each time the interface orientation changes        |
-| listenForLockChanges                    | Triggers a provided callback each time the interface orientation status changes |
-| convertOrientationToHumanReadableString | Returns a human readable string based on the given orientation                  |
-| setLocalizedStringProvider              | Sets the mapping needed to convert orientation values to human readable strings |
-| resetSupportedInterfaceOrientations     | Resets the supported interface orientations to settings                         |
+| Method                                   | Description                                                                       |
+| ---------------------------------------- | --------------------------------------------------------------------------------- |
+| getInterfaceOrientation                  | Returns the last interface orientation                                            |
+| getDeviceOrientation                     | Returns the last device orientation                                               |
+| lockTo                                   | Locks the interface to a specific orientation                                     |
+| unlock                                   | Unlock the interface                                                              |
+| isLocked                                 | Returns the current interface orientation status (locked / unlocked)              |
+| isAutoRotationEnabled                    | (Android Only) Returns if auto rotation is enabled                                |
+| listenForDeviceOrientationChanges        | Triggers a provided callback each time the device orientation changes             |
+| listenForInterfaceOrientationChanges     | Triggers a provided callback each time the interface orientation changes          |
+| listenForLockChanges                     | Triggers a provided callback each time the interface orientation status changes   |
+| convertOrientationToHumanReadableString  | Returns a human readable string based on the given orientation                    |
+| convertAutoRotationToHumanReadableString | Returns a human readable string based on the given auto rotation                  |
+| setHumanReadableOrientations             | Sets the mapping needed to convert orientation values to human readable strings   |
+| setHumanReadableAutoRotations            | Sets the mapping needed to convert auto rotation values to human readable strings |
+| resetSupportedInterfaceOrientations      | Resets the supported interface orientations to settings                           |
 
 In addition, the library exposes the following hooks:
 
 | Hook                                                                                                                                                            | Description                                                             |
-|-----------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------|
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
 | [useInterfaceOrientation](https://github.com/gladiuscode/react-native-orientation-director/blob/main/src/hooks/useInterfaceOrientation.hook.ts)                 | Returns the current interface orientation and listens to changes        |
 | [useDeviceOrientation](https://github.com/gladiuscode/react-native-orientation-director/blob/main/src/hooks/useDeviceOrientation.hook.ts)                       | Returns the current device orientation and listens to changes           |
 | [useIsInterfaceOrientationLocked](https://github.com/gladiuscode/react-native-orientation-director/blob/main/src/hooks/useIsInterfaceOrientationLocked.hook.ts) | Returns the current interface orientation status and listens to changes |
 
 Head over to the [example project](example) to see how to use the library.
 
+### Android
+
+Since on Android we need to deal with sensors and their usage, it is worth noting that the device orientation computation works
+differently than on iOS, mainly in the following ways:
+
+1. Upon start up, all required sensors are enabled just for the initial device orientation computation, then they are disabled;
+2. Each time a new device orientation listener is added, all required sensors are enabled if disabled;
+3. After the last device orientation listener is removed, all required sensors are disabled;
+
+This behavior allows us to follow Google's best practices related to the Sensors Framework. More [here](https://developer.android.com/develop/sensors-and-location/sensors/sensors_overview#sensors-practices).
+
 ## Roadmap
 
-- [ ] Add support for Expo
 - [ ] Add JS side tests
-- [ ] Add Android side tests
 - [ ] Add iOS side tests
 
 ## Contributing

package/android/build.gradle

@@ -33,6 +33,10 @@ def getExtOrIntegerDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["OrientationDirector_" + name]).toInteger()
 }
 
+def getDefault(name) {
+  return project.properties["OrientationDirector_" + name]
+}
+
 def supportsNamespace() {
   def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
   def major = parsed[0].toInteger()
@@ -59,7 +63,6 @@ android {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
-
   }
 
   buildFeatures {
@@ -102,6 +105,10 @@ repositories {
 }
 
 def kotlin_version = getExtOrDefault("kotlinVersion")
+def junit_version = getDefault("junitVersion")
+def android_x_core_version = getDefault("androidXCoreVersion")
+def robolectric_version = getDefault("robolectricVersion")
+def mockito_core_version = getDefault("mockitoCoreVersion")
 
 dependencies {
   // For < 0.71, this will be from the local maven repo
@@ -109,6 +116,11 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+  testImplementation "junit:junit:$junit_version"
+  testImplementation "androidx.test:core:$android_x_core_version"
+  testImplementation "org.robolectric:robolectric:$robolectric_version"
+  testImplementation "org.mockito:mockito-core:$mockito_core_version"
 }
 
 if (isNewArchitectureEnabled()) {

package/android/gradle.properties

@@ -3,3 +3,15 @@ OrientationDirector_minSdkVersion=21
 OrientationDirector_targetSdkVersion=31
 OrientationDirector_compileSdkVersion=31
 OrientationDirector_ndkversion=21.4.7075529
+
+#########################
+#   TESTING
+#
+
+OrientationDirector_junitVersion=4.13.2
+OrientationDirector_androidXCoreVersion=1.5.+
+OrientationDirector_robolectricVersion=4.13
+OrientationDirector_mockitoCoreVersion=5.14.2
+
+#
+#########################

package/android/src/main/java/com/orientationdirector/OrientationDirectorPackage.kt

@@ -5,11 +5,12 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.module.model.ReactModuleInfoProvider
 import com.facebook.react.module.model.ReactModuleInfo
+import com.orientationdirector.implementation.OrientationDirectorModuleImpl
 import java.util.HashMap
 
 class OrientationDirectorPackage : TurboReactPackage() {
   override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
-    return if (name == OrientationDirectorModule.NAME) {
+    return if (name == OrientationDirectorModuleImpl.NAME) {
       OrientationDirectorModule(reactContext)
     } else {
       null
@@ -20,9 +21,9 @@ class OrientationDirectorPackage : TurboReactPackage() {
     return ReactModuleInfoProvider {
       val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
       val isTurboModule: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
-      moduleInfos[OrientationDirectorModule.NAME] = ReactModuleInfo(
-        OrientationDirectorModule.NAME,
-        OrientationDirectorModule.NAME,
+      moduleInfos[OrientationDirectorModuleImpl.NAME] = ReactModuleInfo(
+        OrientationDirectorModuleImpl.NAME,
+        OrientationDirectorModuleImpl.NAME,
         false,  // canOverrideExistingModule
         false,  // needsEagerInit
         true,  // hasConstants

package/android/src/main/java/com/orientationdirector/implementation/EventManager.kt

@@ -1,6 +1,5 @@
 package com.orientationdirector.implementation
 
-import android.util.Log
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.WritableMap

package/android/src/main/java/com/orientationdirector/implementation/LifecycleListener.kt

@@ -2,7 +2,7 @@ package com.orientationdirector.implementation
 
 import com.facebook.react.bridge.LifecycleEventListener
 
-class LifecycleListener() : LifecycleEventListener {
+class LifecycleListener : LifecycleEventListener {
 
   private var onHostResumeCallback: (() -> Unit)? = null
   private var onHostPauseCallback: (() -> Unit)? = null

package/android/src/main/java/com/orientationdirector/implementation/Orientation.kt

@@ -9,4 +9,6 @@ enum class Orientation {
   LANDSCAPE_RIGHT,
   PORTRAIT_UPSIDE_DOWN,
   LANDSCAPE_LEFT,
+  FACE_UP,
+  FACE_DOWN,
 }

package/android/src/main/java/com/orientationdirector/implementation/{OrientationDirectorImpl.kt → OrientationDirectorModuleImpl.kt}

@@ -3,13 +3,12 @@ package com.orientationdirector.implementation
 import android.content.pm.ActivityInfo
 import android.os.Handler
 import android.os.Looper
-import android.view.OrientationEventListener.ORIENTATION_UNKNOWN
 import com.facebook.react.bridge.ReactApplicationContext
 
-class OrientationDirectorImpl internal constructor(private val context: ReactApplicationContext) {
+class OrientationDirectorModuleImpl internal constructor(private val context: ReactApplicationContext) {
   private var mUtils = Utils(context)
   private var mEventManager = EventManager(context)
-  private var mSensorListener = SensorListener(context)
+  private var mOrientationSensorsEventListener = OrientationSensorsEventListener(context)
   private var mAutoRotationObserver = AutoRotationObserver(
     context, Handler(
       Looper.getMainLooper()
@@ -22,43 +21,39 @@ class OrientationDirectorImpl internal constructor(private val context: ReactApp
   private var lastDeviceOrientation = Orientation.UNKNOWN
   private var initialized = false
   private var isLocked: Boolean = false
+  private var areOrientationSensorsEnabled = false;
+  private var didComputeInitialDeviceOrientation = false;
 
   init {
-    mSensorListener.setOnOrientationChangedCallback { orientation ->
-      onOrientationChanged(orientation)
-    }
-
-    if (mSensorListener.canDetectOrientation()) {
-      mSensorListener.enable()
-    } else {
-      mSensorListener.disable()
+    mOrientationSensorsEventListener.setOnOrientationAnglesChangedCallback { orientation ->
+      onOrientationAnglesChanged(orientation)
     }
 
     mAutoRotationObserver.enable()
 
     context.addLifecycleEventListener(mLifecycleListener)
     mLifecycleListener.setOnHostResumeCallback {
-      if (mSensorListener.canDetectOrientation()) {
-        mSensorListener.enable()
+      if (!didComputeInitialDeviceOrientation || areOrientationSensorsEnabled) {
+        mOrientationSensorsEventListener.enable()
       }
-
       mAutoRotationObserver.enable()
     }
     mLifecycleListener.setOnHostPauseCallback {
-      if (initialized) {
-        mSensorListener.disable()
+      if (initialized && areOrientationSensorsEnabled) {
+        mOrientationSensorsEventListener.disable()
         mAutoRotationObserver.disable()
       }
     }
     mLifecycleListener.setOnHostDestroyCallback {
-      mSensorListener.disable()
-      mAutoRotationObserver.disable()
+      if (areOrientationSensorsEnabled) {
+        mOrientationSensorsEventListener.disable()
+        mAutoRotationObserver.disable()
+      }
     }
 
     initialSupportedInterfaceOrientations =
       context.currentActivity?.requestedOrientation ?: initialSupportedInterfaceOrientations
     lastInterfaceOrientation = initInterfaceOrientation()
-    lastDeviceOrientation = initDeviceOrientation()
     isLocked = initIsLocked()
 
     initialized = true
@@ -103,16 +98,19 @@ class OrientationDirectorImpl internal constructor(private val context: ReactApp
     updateLastInterfaceOrientationTo(initInterfaceOrientation())
   }
 
-  private fun initInterfaceOrientation(): Orientation {
-    val rotation = mUtils.getInterfaceRotation()
-    return mUtils.convertToOrientationFromScreenRotation(rotation)
+  fun enableOrientationSensors() {
+    areOrientationSensorsEnabled = true
+    mOrientationSensorsEventListener.enable()
   }
 
-  private fun initDeviceOrientation(): Orientation {
-    val lastRotationDetected = mSensorListener.getLastRotationDetected()
-      ?: return Orientation.UNKNOWN
+  fun disableOrientationSensors() {
+    areOrientationSensorsEnabled = false
+    mOrientationSensorsEventListener.disable()
+  }
 
-    return mUtils.convertToDeviceOrientationFrom(lastRotationDetected)
+  private fun initInterfaceOrientation(): Orientation {
+    val rotation = mUtils.getInterfaceRotation()
+    return mUtils.convertToOrientationFromScreenRotation(rotation)
   }
 
   private fun initIsLocked(): Boolean {
@@ -126,11 +124,10 @@ class OrientationDirectorImpl internal constructor(private val context: ReactApp
     ).contains(activity.requestedOrientation)
   }
 
-  private fun onOrientationChanged(rawDeviceOrientation: Int) {
-    val deviceOrientation = mUtils.convertToDeviceOrientationFrom(rawDeviceOrientation)
-
-    if (rawDeviceOrientation != ORIENTATION_UNKNOWN && deviceOrientation == Orientation.UNKNOWN) {
-      return;
+  private fun onOrientationAnglesChanged(orientationAngles: FloatArray) {
+    val deviceOrientation = mUtils.convertToDeviceOrientationFrom(orientationAngles)
+    if (deviceOrientation == Orientation.UNKNOWN) {
+      return
     }
 
     if (lastDeviceOrientation == deviceOrientation) {
@@ -141,6 +138,11 @@ class OrientationDirectorImpl internal constructor(private val context: ReactApp
     lastDeviceOrientation = deviceOrientation
 
     adaptInterfaceTo(deviceOrientation)
+
+    if (!didComputeInitialDeviceOrientation) {
+      didComputeInitialDeviceOrientation = true
+      mOrientationSensorsEventListener.disable()
+    }
   }
 
   private fun adaptInterfaceTo(deviceOrientation: Orientation) {
@@ -152,7 +154,19 @@ class OrientationDirectorImpl internal constructor(private val context: ReactApp
       return
     }
 
-    val newInterfaceOrientation = mUtils.convertToInterfaceOrientationFrom(deviceOrientation);
+    var newInterfaceOrientation = mUtils.convertToInterfaceOrientationFrom(deviceOrientation);
+
+    /**
+     * When the device orientation is either face up or face down,
+     * we can't match it to an interface orientation, because
+     * it could be either portrait or any landscape.
+     * So we read it from the system itself.
+     */
+    if (newInterfaceOrientation == Orientation.UNKNOWN) {
+      val rotation = mUtils.getInterfaceRotation()
+      newInterfaceOrientation = mUtils.convertToOrientationFromScreenRotation(rotation)
+    }
+
     if (newInterfaceOrientation == lastInterfaceOrientation) {
       return
     }
@@ -171,6 +185,6 @@ class OrientationDirectorImpl internal constructor(private val context: ReactApp
   }
 
   companion object {
-    const val NAME = "OrientationDirectorImpl"
+    const val NAME = "OrientationDirector"
   }
 }

package/android/src/main/java/com/orientationdirector/implementation/OrientationSensorsEventListener.kt

@@ -0,0 +1,79 @@
+package com.orientationdirector.implementation
+
+import android.content.Context.SENSOR_SERVICE
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener
+import android.hardware.SensorManager
+import com.facebook.react.bridge.ReactApplicationContext
+
+class OrientationSensorsEventListener(
+  context: ReactApplicationContext,
+) : SensorEventListener {
+  private var mSensorManager: SensorManager = context.getSystemService(SENSOR_SERVICE) as SensorManager
+
+  private var mAccelerometerSensor: Sensor? = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
+  private var mMagneticFieldSensor: Sensor? = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD)
+
+  private var hasRequiredSensors: Boolean = mAccelerometerSensor != null && mMagneticFieldSensor != null
+
+  private val accelerometerReading = FloatArray(3)
+  private val magnetometerReading = FloatArray(3)
+
+  private var lastComputedOrientationAngles = FloatArray(3)
+  private var onOrientationAnglesChangedCallback: ((orientationAngles: FloatArray) -> Unit)? = null
+
+  fun setOnOrientationAnglesChangedCallback(callback: (orientation: FloatArray) -> Unit) {
+    onOrientationAnglesChangedCallback = callback
+  }
+
+  override fun onSensorChanged(event: SensorEvent?) {
+    if (event == null) {
+      return
+    }
+
+    if (event.sensor.type == Sensor.TYPE_ACCELEROMETER) {
+      System.arraycopy(event.values, 0, accelerometerReading, 0, accelerometerReading.size)
+    }
+
+    if (event.sensor.type == Sensor.TYPE_MAGNETIC_FIELD) {
+      System.arraycopy(event.values, 0, magnetometerReading, 0, magnetometerReading.size)
+    }
+
+    val rotationMatrix = FloatArray(9)
+    val didComputeMatrix = SensorManager.getRotationMatrix(
+      rotationMatrix,
+      null,
+      accelerometerReading,
+      magnetometerReading
+    )
+    if (!didComputeMatrix) {
+      return
+    }
+
+    val orientationAngles = FloatArray(3)
+    SensorManager.getOrientation(rotationMatrix, orientationAngles)
+
+    if (lastComputedOrientationAngles.contentEquals(orientationAngles)) {
+      return
+    }
+
+    onOrientationAnglesChangedCallback?.invoke(orientationAngles)
+    lastComputedOrientationAngles = orientationAngles
+  }
+
+  override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {}
+
+  fun enable() {
+    if (!hasRequiredSensors) {
+      return
+    }
+
+    mSensorManager.registerListener(this, mAccelerometerSensor, SensorManager.SENSOR_DELAY_NORMAL)
+    mSensorManager.registerListener(this, mMagneticFieldSensor, SensorManager.SENSOR_DELAY_NORMAL)
+  }
+
+  fun disable() {
+    mSensorManager.unregisterListener(this)
+  }
+}

package/android/src/main/java/com/orientationdirector/implementation/Utils.kt

@@ -19,19 +19,32 @@ class Utils(private val context: ReactContext) {
     }
   }
 
-  fun convertToDeviceOrientationFrom(deviceRotation: Int): Orientation {
-    return if (deviceRotation == -1) {
-      Orientation.UNKNOWN
-    } else if (deviceRotation > 355 || deviceRotation < 5) {
-      Orientation.PORTRAIT
-    } else if (deviceRotation in 86..94) {
-      Orientation.LANDSCAPE_RIGHT
-    } else if (deviceRotation in 176..184) {
-      Orientation.PORTRAIT_UPSIDE_DOWN
-    } else if (deviceRotation in 266..274) {
-      Orientation.LANDSCAPE_LEFT
-    } else {
-      return Orientation.UNKNOWN
+  fun convertToDeviceOrientationFrom(orientationAngles: FloatArray): Orientation {
+    val (_, pitchRadians, rollRadians) = orientationAngles;
+
+    val pitchDegrees = Math.toDegrees(pitchRadians.toDouble()).toFloat()
+    val rollDegrees = Math.toDegrees(rollRadians.toDouble()).toFloat()
+
+    // This is needed to account for inaccuracy due to subtle movements such as tilting
+    val tolerance = 20f
+
+    //////////////////////////////////////
+    // These limits are set based on SensorManager.getOrientation reference
+    // https://developer.android.com/develop/sensors-and-location/sensors/sensors_position#sensors-pos-orient
+    //
+    val portraitLimit = -90f
+    val landscapeRightLimit = 180f
+    val landscapeLeftLimit = -180f
+    //
+    //////////////////////////////////////
+
+    return when {
+      rollDegrees.equals(-0f) && (pitchDegrees.equals(0f) || pitchDegrees.equals(-0f)) -> Orientation.FACE_UP
+      rollDegrees.equals(-180f) && (pitchDegrees.equals(0f) || pitchDegrees.equals(-0f)) -> Orientation.FACE_DOWN
+      rollDegrees in tolerance..landscapeRightLimit - tolerance -> Orientation.LANDSCAPE_RIGHT
+      rollDegrees in landscapeLeftLimit + tolerance..-tolerance -> Orientation.LANDSCAPE_LEFT
+      pitchDegrees in portraitLimit..-0f -> Orientation.PORTRAIT
+      else -> Orientation.PORTRAIT_UPSIDE_DOWN
     }
   }
 
@@ -54,7 +67,7 @@ class Utils(private val context: ReactContext) {
   }
 
   fun convertToOrientationFromScreenRotation(screenRotation: Int): Orientation {
-    return when(screenRotation) {
+    return when (screenRotation) {
       Surface.ROTATION_270 -> Orientation.LANDSCAPE_RIGHT
       Surface.ROTATION_90 -> Orientation.LANDSCAPE_LEFT
       Surface.ROTATION_180 -> Orientation.PORTRAIT_UPSIDE_DOWN
@@ -63,7 +76,7 @@ class Utils(private val context: ReactContext) {
   }
 
   fun convertToInterfaceOrientationFrom(deviceOrientation: Orientation): Orientation {
-    return when(deviceOrientation) {
+    return when (deviceOrientation) {
       Orientation.PORTRAIT -> Orientation.PORTRAIT
       Orientation.LANDSCAPE_RIGHT -> Orientation.LANDSCAPE_LEFT
       Orientation.PORTRAIT_UPSIDE_DOWN -> Orientation.PORTRAIT_UPSIDE_DOWN

package/android/src/newarch/OrientationDirectorModule.kt

@@ -0,0 +1,59 @@
+package com.orientationdirector
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.orientationdirector.implementation.OrientationDirectorModuleImpl
+
+class OrientationDirectorModule internal constructor(context: ReactApplicationContext) :
+  NativeOrientationDirectorSpec(context) {
+
+  private var implementation = OrientationDirectorModuleImpl(context)
+
+  override fun getName() = OrientationDirectorModuleImpl.NAME
+
+
+  override fun getInterfaceOrientation(promise: Promise) {
+    promise.resolve(implementation.getInterfaceOrientation().ordinal)
+  }
+
+
+  override fun getDeviceOrientation(promise: Promise) {
+    promise.resolve(implementation.getDeviceOrientation().ordinal)
+  }
+
+
+  override fun lockTo(orientation: Double) {
+    implementation.lockTo(orientation.toInt())
+  }
+
+
+  override fun unlock() {
+    implementation.unlock()
+  }
+
+
+  override fun resetSupportedInterfaceOrientations() {
+    implementation.resetSupportedInterfaceOrientations()
+  }
+
+  override fun isLocked(): Boolean {
+    return implementation.getIsLocked()
+  }
+
+  override fun isAutoRotationEnabled(): Boolean {
+    return implementation.getIsAutoRotationEnabled()
+  }
+
+  override fun enableOrientationSensors() {
+    return implementation.enableOrientationSensors()
+  }
+
+  override fun disableOrientationSensors() {
+    return implementation.disableOrientationSensors()
+  }
+
+  override fun addListener(eventName: String) {}
+
+  override fun removeListeners(count: Double) {}
+
+}

package/android/src/oldarch/OrientationDirectorModule.kt

@@ -0,0 +1,66 @@
+package com.orientationdirector
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactMethod
+import com.orientationdirector.implementation.OrientationDirectorModuleImpl
+
+class OrientationDirectorModule internal constructor(context: ReactApplicationContext) :
+  ReactContextBaseJavaModule(context) {
+
+  private var implementation = OrientationDirectorModuleImpl(context)
+
+  override fun getName() = OrientationDirectorModuleImpl.NAME
+
+  @ReactMethod()
+  fun getInterfaceOrientation(promise: Promise) {
+    promise.resolve(implementation.getInterfaceOrientation().ordinal)
+  }
+
+  @ReactMethod()
+  fun getDeviceOrientation(promise: Promise) {
+    promise.resolve(implementation.getDeviceOrientation().ordinal)
+  }
+
+  @ReactMethod()
+  fun lockTo(orientation: Double) {
+    implementation.lockTo(orientation.toInt())
+  }
+
+  @ReactMethod()
+  fun unlock() {
+    implementation.unlock()
+  }
+
+  @ReactMethod()
+  fun resetSupportedInterfaceOrientations() {
+    implementation.resetSupportedInterfaceOrientations()
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun isLocked(): Boolean {
+    return implementation.getIsLocked()
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun isAutoRotationEnabled(): Boolean {
+    return implementation.getIsAutoRotationEnabled()
+  }
+
+  @ReactMethod()
+  fun enableOrientationSensors() {
+    return implementation.enableOrientationSensors()
+  }
+
+  @ReactMethod()
+  fun disableOrientationSensors() {
+    return implementation.disableOrientationSensors()
+  }
+
+  @ReactMethod()
+  fun addListener(eventName: String) {}
+
+  @ReactMethod()
+  fun removeListeners(count: Double) {}
+}