react-native-orientation-director 1.0.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2024 gladius
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,87 @@
+# react-native-orientation-director
+
+A simple library that allows you to handle orientation changes in your React Native app.
+Written in Kotlin, Swift and Typescript. It supports both the Old and New React Native architecture.
+
+## Features
+
+- [x] Get the current orientation of the device
+- [x] Get the current orientation of the interface
+- [x] Listen to device orientation changes
+- [x] Listen to interface orientation changes
+- [x] Lock the interface orientation to a specific orientation
+- [x] Unlock the interface orientation
+
+## Installation
+
+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
+
+## Setup
+
+To properly handle interface orientation changes in iOS, you need to update your AppDelegate.mm file.
+In your AppDelegate.mm file, import "OrientationDirector.h" and implement supportedInterfaceOrientationsForWindow method as follows:
+
+```objc
+#import <OrientationDirector.h>
+
+- (UIInterfaceOrientationMask)application:(UIApplication *)application supportedInterfaceOrientationsForWindow:(UIWindow *)window
+{
+  return [OrientationDirector getSupportedInterfaceOrientationsForWindow];
+}
+```
+
+If you need help, you can check the example project.
+
+There is no need to do anything in Android, it works out of the box.
+
+## Usage
+
+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                                                            |
+| listenForDeviceOrientationChanges       | Triggers a provided callback each time the device orientation changes           |
+| listenForInterfaceOrientationChanges    | Triggers a provided callback each time the interface orientation 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 |
+
+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    |
+
+Head over to the [example project](example) to see how to use the library.
+
+## Roadmap
+
+- [ ] Add support for Expo
+- [ ] Add JS side tests
+- [ ] Add Android side tests
+- [ ] Add iOS side tests
+
+## Contributing
+
+See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/android/build.gradle

@@ -0,0 +1,120 @@
+buildscript {
+  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
+  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["OrientationDirector_kotlinVersion"]
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:7.2.1"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["OrientationDirector_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["OrientationDirector_" + name]).toInteger()
+}
+
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
+}
+
+android {
+  if (supportsNamespace()) {
+    namespace "com.orientationdirector"
+
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
+      }
+    }
+  }
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      if (isNewArchitectureEnabled()) {
+        java.srcDirs += [
+          "src/newarch",
+          // This is needed to build Kotlin project with NewArch enabled
+          "${project.buildDir}/generated/source/codegen/java"
+        ]
+      } else {
+        java.srcDirs += ["src/oldarch"]
+      }
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "OrientationDirector"
+    codegenJavaPackageName = "com.orientationdirector"
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+OrientationDirector_kotlinVersion=1.7.0
+OrientationDirector_minSdkVersion=21
+OrientationDirector_targetSdkVersion=31
+OrientationDirector_compileSdkVersion=31
+OrientationDirector_ndkversion=21.4.7075529

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.orientationdirector">
+</manifest>

package/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

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

@@ -0,0 +1,50 @@
+package com.orientationdirector
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.Promise
+import com.orientationdirector.implementation.OrientationDirectorImpl
+
+class OrientationDirectorModule internal constructor(context: ReactApplicationContext) :
+  OrientationDirectorSpec(context) {
+
+  private var orientationDirectorImpl: OrientationDirectorImpl
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  init {
+    orientationDirectorImpl = OrientationDirectorImpl(context)
+  }
+
+  @ReactMethod()
+  override fun getInterfaceOrientation(promise: Promise) {
+    promise.resolve(orientationDirectorImpl.getInterfaceOrientation().ordinal)
+  }
+
+  @ReactMethod()
+  override fun getDeviceOrientation(promise: Promise) {
+    promise.resolve(orientationDirectorImpl.getDeviceOrientation().ordinal)
+  }
+
+  @ReactMethod()
+  override fun lockTo(orientation: Double) {
+    orientationDirectorImpl.lockTo(orientation.toInt())
+  }
+
+  @ReactMethod()
+  override fun unlock() {
+    orientationDirectorImpl.unlock()
+  }
+
+  @ReactMethod()
+  override fun addListener(eventName: String) {}
+
+  @ReactMethod()
+  override fun removeListeners(count: Double) {}
+
+  companion object {
+    const val NAME = "OrientationDirector"
+  }
+}

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

@@ -0,0 +1,35 @@
+package com.orientationdirector
+
+import com.facebook.react.TurboReactPackage
+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 java.util.HashMap
+
+class OrientationDirectorPackage : TurboReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == OrientationDirectorModule.NAME) {
+      OrientationDirectorModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      val isTurboModule: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+      moduleInfos[OrientationDirectorModule.NAME] = ReactModuleInfo(
+        OrientationDirectorModule.NAME,
+        OrientationDirectorModule.NAME,
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        true,  // hasConstants
+        false,  // isCxxModule
+        isTurboModule // isTurboModule
+      )
+      moduleInfos
+    }
+  }
+}

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

@@ -0,0 +1,12 @@
+package com.orientationdirector.implementation
+
+/*
+   Don't change values positions
+ */
+enum class Orientation {
+  UNKNOWN,
+  PORTRAIT,
+  LANDSCAPE_RIGHT,
+  PORTRAIT_UPSIDE_DOWN,
+  LANDSCAPE_LEFT,
+}

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

@@ -0,0 +1,117 @@
+package com.orientationdirector.implementation
+
+import android.content.pm.ActivityInfo
+import com.facebook.react.bridge.ReactApplicationContext
+
+class OrientationDirectorImpl internal constructor(private val context: ReactApplicationContext) {
+  private var mUtils = OrientationDirectorUtilsImpl()
+  private var mEventEmitter = OrientationEventManager(context)
+  private var mSensorListener = OrientationSensorListener(context)
+  private var mLifecycleListener = OrientationLifecycleListener()
+  private var isLocked: Boolean = false
+  private var lastInterfaceOrientation = Orientation.UNKNOWN
+  private var lastDeviceOrientation = Orientation.UNKNOWN
+  private var initialized = false
+
+  init {
+    mSensorListener.setOnOrientationChangedCallback { orientation ->
+      onOrientationChanged(orientation)
+    }
+
+    if (mSensorListener.canDetectOrientation()) {
+      mSensorListener.enable()
+    } else {
+      mSensorListener.disable()
+    }
+
+    context.addLifecycleEventListener(mLifecycleListener)
+    mLifecycleListener.setOnHostResumeCallback {
+      if (mSensorListener.canDetectOrientation()) {
+        mSensorListener.enable()
+      }
+    }
+    mLifecycleListener.setOnHostPauseCallback {
+      if (initialized) {
+        mSensorListener.disable()
+      }
+    }
+    mLifecycleListener.setOnHostDestroyCallback {
+      mSensorListener.disable()
+    }
+
+    lastInterfaceOrientation = initInterfaceOrientation()
+    lastDeviceOrientation = initDeviceOrientation()
+
+    initialized = true
+  }
+
+  fun getInterfaceOrientation(): Orientation {
+    return lastInterfaceOrientation
+  }
+
+  fun getDeviceOrientation(): Orientation {
+    return lastDeviceOrientation
+  }
+
+  fun lockTo(jsOrientation: Int) {
+    val interfaceOrientation = mUtils.getOrientationEnumFrom(jsOrientation)
+    val screenOrientation =
+      mUtils.getActivityOrientationFrom(interfaceOrientation)
+    context.currentActivity?.requestedOrientation = screenOrientation
+    mEventEmitter.sendInterfaceOrientationDidChange(interfaceOrientation.ordinal)
+    lastInterfaceOrientation = interfaceOrientation
+    isLocked = true
+  }
+
+  fun unlock() {
+    context.currentActivity?.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
+    isLocked = false
+    adaptInterfaceTo(getDeviceOrientation())
+  }
+
+  private fun initInterfaceOrientation(): Orientation {
+    val activityOrientation = context.currentActivity!!.requestedOrientation
+    if (
+      mUtils.isActivityInPortraitOrientation(activityOrientation) ||
+      mUtils.isActivityInLandscapeOrientation(activityOrientation)
+    ) {
+      return mUtils.getInterfaceOrientationFrom(activityOrientation)
+    }
+
+    val lastRotationDetected = mSensorListener.getLastRotationDetected()
+      ?: return lastInterfaceOrientation
+
+    return mUtils.getDeviceOrientationFrom(lastRotationDetected)
+  }
+
+  private fun initDeviceOrientation(): Orientation {
+    val lastRotationDetected = mSensorListener.getLastRotationDetected()
+      ?: return Orientation.UNKNOWN
+
+    return mUtils.getDeviceOrientationFrom(lastRotationDetected)
+  }
+
+  private fun onOrientationChanged(rawDeviceOrientation: Int) {
+    val deviceOrientation = mUtils.getDeviceOrientationFrom(rawDeviceOrientation)
+    mEventEmitter.sendDeviceOrientationDidChange(deviceOrientation.ordinal)
+    lastDeviceOrientation = deviceOrientation
+    adaptInterfaceTo(deviceOrientation)
+  }
+
+  private fun adaptInterfaceTo(deviceOrientation: Orientation) {
+    if (isLocked) {
+      return
+    }
+
+    if (lastInterfaceOrientation == deviceOrientation) {
+      return
+    }
+
+    lastInterfaceOrientation = deviceOrientation
+    mEventEmitter.sendInterfaceOrientationDidChange(lastInterfaceOrientation.ordinal)
+  }
+
+  companion object {
+    const val NAME = "OrientationDirectorImpl"
+  }
+}

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

@@ -0,0 +1,65 @@
+package com.orientationdirector.implementation
+
+import android.content.pm.ActivityInfo
+
+class OrientationDirectorUtilsImpl() {
+
+  fun getDeviceOrientationFrom(rotation: Int): Orientation {
+    var orientation = Orientation.UNKNOWN
+
+    if (rotation == -1) {
+      orientation = Orientation.UNKNOWN
+    } else if (rotation > 355 || rotation < 5) {
+      orientation = Orientation.PORTRAIT
+    } else if (rotation in 86..94) {
+      orientation = Orientation.LANDSCAPE_RIGHT
+    } else if (rotation in 176..184) {
+      orientation = Orientation.PORTRAIT_UPSIDE_DOWN
+    } else if (rotation in 266..274) {
+      orientation = Orientation.LANDSCAPE_LEFT
+    }
+
+    return orientation
+  }
+
+  fun getInterfaceOrientationFrom(activityInfo: Int): Orientation {
+    return when (activityInfo) {
+      ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE -> Orientation.LANDSCAPE_RIGHT
+      ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT -> Orientation.PORTRAIT_UPSIDE_DOWN
+      ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE -> Orientation.LANDSCAPE_LEFT
+      else -> Orientation.PORTRAIT
+    };
+  }
+
+  fun isActivityInLandscapeOrientation(orientation: Int): Boolean {
+    return listOf(
+      ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE,
+      ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE,
+    ).contains(orientation);
+  }
+
+  fun isActivityInPortraitOrientation(orientation: Int): Boolean {
+    return listOf(
+      ActivityInfo.SCREEN_ORIENTATION_PORTRAIT,
+      ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT,
+    ).contains(orientation);
+  }
+
+  fun getActivityOrientationFrom(interfaceOrientation: Orientation): Int {
+    return when (interfaceOrientation) {
+      Orientation.LANDSCAPE_RIGHT -> ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
+      Orientation.PORTRAIT_UPSIDE_DOWN -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT
+      Orientation.LANDSCAPE_LEFT -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
+      else -> ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
+    }
+  }
+
+  fun getOrientationEnumFrom(jsOrientation: Int): Orientation {
+    return when (jsOrientation) {
+      2 -> Orientation.LANDSCAPE_RIGHT
+      3 -> Orientation.PORTRAIT_UPSIDE_DOWN
+      4 -> Orientation.LANDSCAPE_LEFT
+      else -> Orientation.PORTRAIT
+    }
+  }
+}

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

@@ -0,0 +1,42 @@
+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
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+enum class Event {
+  DeviceOrientationDidChange,
+  InterfaceOrientationDidChange,
+}
+
+class OrientationEventManager(private val context: ReactApplicationContext) {
+
+  fun sendDeviceOrientationDidChange(orientationValue: Int) {
+    val params = Arguments.createMap().apply {
+      putInt("orientation", orientationValue)
+    }
+    sendEvent(Event.DeviceOrientationDidChange, params)
+  }
+
+  fun sendInterfaceOrientationDidChange(orientationValue: Int) {
+    val params = Arguments.createMap().apply {
+      putInt("orientation", orientationValue)
+    }
+    sendEvent(Event.InterfaceOrientationDidChange, params)
+  }
+
+  private fun sendEvent(eventName: Event, params: WritableMap?) {
+    Log.d(NAME, "sendEvent - $eventName")
+    Log.d(NAME, "sendEvent - $params")
+    context
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(eventName.name, params)
+  }
+
+  companion object {
+    val NAME = "OrientationEventManager"
+  }
+
+}

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

@@ -0,0 +1,33 @@
+package com.orientationdirector.implementation
+
+import com.facebook.react.bridge.LifecycleEventListener
+
+class OrientationLifecycleListener() : LifecycleEventListener {
+
+  private var onHostResumeCallback: (() -> Unit)? = null
+  private var onHostPauseCallback: (() -> Unit)? = null
+  private var onHostDestroyCallback: (() -> Unit)? = null
+
+  fun setOnHostResumeCallback(callback: () -> Unit) {
+    this.onHostResumeCallback = callback
+  }
+  fun setOnHostPauseCallback(callback: () -> Unit) {
+    this.onHostResumeCallback = callback
+  }
+  fun setOnHostDestroyCallback(callback: () -> Unit) {
+    this.onHostDestroyCallback = callback
+  }
+
+  override fun onHostResume() {
+    this.onHostResumeCallback?.invoke()
+  }
+
+  override fun onHostPause() {
+    this.onHostPauseCallback?.invoke()
+  }
+
+  override fun onHostDestroy() {
+    this.onHostDestroyCallback?.invoke()
+  }
+
+}

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

@@ -0,0 +1,26 @@
+package com.orientationdirector.implementation
+
+import android.hardware.SensorManager
+import android.view.OrientationEventListener
+import com.facebook.react.bridge.ReactApplicationContext
+
+class OrientationSensorListener(
+  context: ReactApplicationContext,
+) : OrientationEventListener(context, SensorManager.SENSOR_DELAY_UI) {
+
+  private var lastRotationDetected: Int? = null
+  private var onOrientationChangedCallback: ((orientation: Int) -> Unit)? = null
+
+  fun getLastRotationDetected(): Int? {
+    return lastRotationDetected
+  }
+
+  fun setOnOrientationChangedCallback(callback: (orientation: Int) -> Unit) {
+    onOrientationChangedCallback = callback
+  }
+
+  override fun onOrientationChanged(orientation: Int) {
+    lastRotationDetected = orientation
+    onOrientationChangedCallback?.invoke(orientation)
+  }
+}

package/android/src/newarch/OrientationDirectorSpec.kt

@@ -0,0 +1,7 @@
+package com.orientationdirector
+
+import com.facebook.react.bridge.ReactApplicationContext
+
+abstract class OrientationDirectorSpec internal constructor(context: ReactApplicationContext) :
+  NativeOrientationDirectorSpec(context) {
+}

package/android/src/oldarch/OrientationDirectorSpec.kt

@@ -0,0 +1,16 @@
+package com.orientationdirector
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.Promise
+
+abstract class OrientationDirectorSpec internal constructor(context: ReactApplicationContext) :
+  ReactContextBaseJavaModule(context) {
+
+  abstract fun getInterfaceOrientation(promise: Promise)
+  abstract fun getDeviceOrientation(promise: Promise)
+  abstract fun lockTo(orientation: Double)
+  abstract fun unlock()
+  abstract fun addListener(eventName: String)
+  abstract fun removeListeners(count: Double)
+}

package/ios/OrientationDirector.h

@@ -0,0 +1,22 @@
+#import <React/RCTEventEmitter.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <RNOrientationDirectorSpec/RNOrientationDirectorSpec.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface OrientationDirector : RCTEventEmitter <NativeOrientationDirectorSpec>
+
+NS_ASSUME_NONNULL_END
+
+#else
+#import <React/RCTBridgeModule.h>
+
+@interface OrientationDirector : RCTEventEmitter <RCTBridgeModule>
+#endif
+
+@property (nonatomic, assign) BOOL isJsListening;
+
++(UIInterfaceOrientationMask)getSupportedInterfaceOrientationsForWindow;
+
+@end