react-native-orientation-director 2.6.4 → 3.0.0

package/README.md

@@ -6,7 +6,10 @@
 
 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.
+Written in Kotlin, Swift and Typescript.
+
+Kindly note that this library only supports the new architecture since v3.0.0, if you are looking for a version that
+supports the old architecture, please check older versions.
 
 This library takes inspiration from and builds upon the following amazing alternatives:
 
@@ -112,40 +115,20 @@ Nothing else is required for Android.
 
 #### iOS
 
-To properly handle interface orientation changes in iOS, you need to update your AppDelegate file. Since React Native
-0.77, the AppDelegate has been migrated to Swift, so see the instructions below for both Swift and Objective-C.
+To properly handle interface orientation changes in iOS, you need to update your AppDelegate file. Follow the instructions
+below to set it up:
 
-##### Objective-C
+In your AppDelegate.swift file, implement the supportedInterfaceOrientationsFor method as follows:
 
-In your AppDelegate.mm file, import "OrientationDirector.h" and implement supportedInterfaceOrientationsForWindow method as follows:
+```swift
 
-```objc
-#import <OrientationDirector.h>
+import OrientationDirector
 
-- (UIInterfaceOrientationMask)application:(UIApplication *)application supportedInterfaceOrientationsForWindow:(UIWindow *)window
-{
-  return [OrientationDirector getSupportedInterfaceOrientationsForWindow];
+func application(_ application: UIApplication, supportedInterfaceOrientationsFor window: UIWindow?) -> UIInterfaceOrientationMask {
+  return SharedOrientationDirectorImpl.shared.supportedInterfaceOrientations
 }
-```
-
-##### Swift
-
-You need to create a [bridging header](https://developer.apple.com/documentation/swift/importing-objective-c-into-swift#Import-Code-Within-an-App-Target)
-to import the library, as shown below:
 
 ```
-#import "OrientationDirector.h"
-```
-
-Then, in your AppDelegate.swift file, implement the supportedInterfaceOrientationsFor method as follows:
-
-```swift
-override func application(_ application: UIApplication, supportedInterfaceOrientationsFor window: UIWindow?) -> UIInterfaceOrientationMask {
-  return OrientationDirector.getSupportedInterfaceOrientationsForWindow()
-}
-```
-
-Note: if you are targeting react-native > 79.x, you can omit the `override` keyword.
 
 If you need help, you can check the example project.
 
@@ -212,11 +195,6 @@ differently than on iOS, mainly in the following ways:
 
 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 JS 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.

package/android/build.gradle

@@ -1,6 +1,17 @@
 buildscript {
-  ext.getExtOrDefault = {name ->
-    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['OrientationDirector_' + name]
+  ext.OrientationDirector = [
+    kotlinVersion: "2.0.21",
+    minSdkVersion: 24,
+    compileSdkVersion: 36,
+    targetSdkVersion: 36
+  ]
+
+  ext.getExtOrDefault = { prop ->
+    if (rootProject.ext.has(prop)) {
+      return rootProject.ext.get(prop)
+    }
+
+    return OrientationDirector[prop]
   }
 
   repositories {
@@ -16,51 +27,19 @@ buildscript {
 }
 
 
-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 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()
-  def minor = parsed[1].toInteger()
-
-  // Namespace support was added in 7.3.0
-  return (major == 7 && minor >= 3) || major >= 8
-}
+apply plugin: "com.facebook.react"
 
 android {
-  if (supportsNamespace()) {
-    namespace "com.orientationdirector"
+  namespace "com.orientationdirector"
 
-    sourceSets {
-      main {
-        manifest.srcFile "src/main/AndroidManifestNew.xml"
-      }
-    }
-  }
-
-  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
 
   defaultConfig {
-    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
-    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
-    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+    minSdkVersion getExtOrDefault("minSdkVersion")
+    targetSdkVersion getExtOrDefault("targetSdkVersion")
   }
 
   buildFeatures {
@@ -73,7 +52,7 @@ android {
     }
   }
 
-  lintOptions {
+  lint {
     disable "GradleCompatible"
   }
 
@@ -81,47 +60,8 @@ android {
     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")
-def junit_version = getDefault("junitVersion")
-def android_x_core_version = getDefault("androidXCoreVersion")
-def robolectric_version = getDefault("robolectricVersion")
-def mockito_core_version = getDefault("mockitoCoreVersion")
-
 dependencies {
   implementation "com.facebook.react:react-android"
-  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()) {
-  react {
-    jsRootDir = file("../src/")
-    libraryName = "OrientationDirector"
-    codegenJavaPackageName = "com.orientationdirector"
-  }
 }

package/android/src/main/AndroidManifest.xml

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

package/android/src/{newarch → main/java/com/orientationdirector}/OrientationDirectorModule.kt

@@ -2,36 +2,33 @@ package com.orientationdirector
 
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.orientationdirector.implementation.EventManagerDelegate
 import com.orientationdirector.implementation.OrientationDirectorModuleImpl
 
-class OrientationDirectorModule internal constructor(context: ReactApplicationContext) :
-  NativeOrientationDirectorSpec(context) {
+class OrientationDirectorModule(reactContext: ReactApplicationContext) :
+  NativeOrientationDirectorSpec(reactContext), EventManagerDelegate {
 
-  private var implementation = OrientationDirectorModuleImpl(context)
-
-  override fun getName() = OrientationDirectorModuleImpl.NAME
+  override fun getName() = NAME
 
+  private var implementation = OrientationDirectorModuleImpl(reactContext, this)
 
   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()
   }
@@ -52,8 +49,20 @@ class OrientationDirectorModule internal constructor(context: ReactApplicationCo
     return implementation.disableOrientationSensors()
   }
 
-  override fun addListener(eventName: String) {}
+  override fun sendOnDeviceOrientationChanged(params: WritableMap) {
+    emitOnDeviceOrientationChanged(params)
+  }
 
-  override fun removeListeners(count: Double) {}
+  override fun sendOnInterfaceOrientationChanged(params: WritableMap) {
+    emitOnInterfaceOrientationChanged(params)
+  }
+
+  override fun sendOnLockChanged(params: WritableMap) {
+    emitOnLockChanged(params)
+  }
+
+  companion object {
+    const val NAME = OrientationDirectorModuleImpl.NAME
+  }
 
 }

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

@@ -1,35 +1,30 @@
 package com.orientationdirector
 
 import com.facebook.react.BaseReactPackage
-import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.NativeModule
-import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.module.model.ReactModuleInfo
-import com.orientationdirector.implementation.OrientationDirectorModuleImpl
-import java.util.HashMap
+import com.facebook.react.module.model.ReactModuleInfoProvider
 
 class OrientationDirectorPackage : BaseReactPackage() {
-  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
-    return if (name == OrientationDirectorModuleImpl.NAME) {
+
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
+    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[OrientationDirectorModuleImpl.NAME] = ReactModuleInfo(
-        OrientationDirectorModuleImpl.NAME,
-        OrientationDirectorModuleImpl.NAME,
-        false,  // canOverrideExistingModule
-        false,  // needsEagerInit
-        false,  // isCxxModule
-        isTurboModule // isTurboModule
+  override fun getReactModuleInfoProvider() = ReactModuleInfoProvider {
+    mapOf(
+      OrientationDirectorModule.NAME to ReactModuleInfo(
+        name = OrientationDirectorModule.NAME,
+        className = OrientationDirectorModule.NAME,
+        canOverrideExistingModule = false,
+        needsEagerInit = false,
+        isCxxModule = false,
+        isTurboModule = true
       )
-      moduleInfos
-    }
+    )
   }
 }

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

@@ -5,39 +5,26 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
 
-enum class Event {
-  DeviceOrientationDidChange,
-  InterfaceOrientationDidChange,
-  LockDidChange,
-}
-
-class EventManager(private val context: ReactApplicationContext) {
-
+class EventManager(private val delegate: EventManagerDelegate) {
   fun sendDeviceOrientationDidChange(orientationValue: Int) {
     val params = Arguments.createMap().apply {
       putInt("orientation", orientationValue)
     }
-    sendEvent(Event.DeviceOrientationDidChange, params)
+    delegate.sendOnDeviceOrientationChanged(params)
   }
 
   fun sendInterfaceOrientationDidChange(orientationValue: Int) {
     val params = Arguments.createMap().apply {
       putInt("orientation", orientationValue)
     }
-    sendEvent(Event.InterfaceOrientationDidChange, params)
+    delegate.sendOnInterfaceOrientationChanged(params)
   }
 
   fun sendLockDidChange(value: Boolean) {
     val params = Arguments.createMap().apply {
       putBoolean("locked", value)
     }
-    sendEvent(Event.LockDidChange, params)
-  }
-
-  private fun sendEvent(eventName: Event, params: WritableMap?) {
-    context
-      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-      .emit(eventName.name, params)
+    delegate.sendOnLockChanged(params)
   }
 
   companion object {

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

@@ -0,0 +1,9 @@
+   package com.orientationdirector.implementation
+
+   import com.facebook.react.bridge.WritableMap
+
+   interface EventManagerDelegate {
+       fun sendOnDeviceOrientationChanged(params: WritableMap)
+       fun sendOnInterfaceOrientationChanged(params: WritableMap)
+       fun sendOnLockChanged(params: WritableMap)
+   }

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

@@ -5,9 +5,9 @@ import android.os.Handler
 import android.os.Looper
 import com.facebook.react.bridge.ReactApplicationContext
 
-class OrientationDirectorModuleImpl internal constructor(private val context: ReactApplicationContext) {
+class OrientationDirectorModuleImpl internal constructor(private val context: ReactApplicationContext, eventManagerDelegate: EventManagerDelegate) {
   private var mUtils = Utils(context)
-  private var mEventManager = EventManager(context)
+  private var mEventManager = EventManager(eventManagerDelegate)
   private var mOrientationSensorsEventListener = OrientationSensorsEventListener(context)
   private var mAutoRotationObserver = AutoRotationObserver(
     context, Handler(
@@ -26,8 +26,8 @@ class OrientationDirectorModuleImpl internal constructor(private val context: Re
   private var didComputeInitialDeviceOrientation = false;
 
   init {
-    mOrientationSensorsEventListener.setOnOrientationAnglesChangedCallback { orientation ->
-      onOrientationAnglesChanged(orientation)
+    mOrientationSensorsEventListener.setOnDeviceOrientationChangedCallback { orientation ->
+      onDeviceOrientationChanged(orientation)
     }
 
     mAutoRotationObserver.enable()
@@ -36,6 +36,9 @@ class OrientationDirectorModuleImpl internal constructor(private val context: Re
       checkInterfaceOrientation(false)
     }
 
+    // NOTE(1.init): This is needed to compute the initial device orientation
+    mOrientationSensorsEventListener.enable()
+
     context.addLifecycleEventListener(mLifecycleListener)
     mLifecycleListener.setOnHostResumeCallback {
       if (!didComputeInitialDeviceOrientation || areOrientationSensorsEnabled) {
@@ -45,17 +48,17 @@ class OrientationDirectorModuleImpl internal constructor(private val context: Re
       mBroadcastReceiver.register()
     }
     mLifecycleListener.setOnHostPauseCallback {
-      if (initialized && areOrientationSensorsEnabled) {
+      if (!didComputeInitialDeviceOrientation || areOrientationSensorsEnabled) {
         mOrientationSensorsEventListener.disable()
-        mAutoRotationObserver.disable()
       }
+      mAutoRotationObserver.disable()
       mBroadcastReceiver.unregister()
     }
     mLifecycleListener.setOnHostDestroyCallback {
-      if (areOrientationSensorsEnabled) {
+      if (!didComputeInitialDeviceOrientation || areOrientationSensorsEnabled) {
         mOrientationSensorsEventListener.disable()
-        mAutoRotationObserver.disable()
       }
+      mAutoRotationObserver.disable()
       mBroadcastReceiver.unregister()
     }
 
@@ -148,35 +151,31 @@ class OrientationDirectorModuleImpl internal constructor(private val context: Re
     ).contains(activity.requestedOrientation)
   }
 
-  private fun onOrientationAnglesChanged(orientationAngles: FloatArray) {
-    val deviceOrientation = mUtils.convertToDeviceOrientationFrom(orientationAngles)
-    if (deviceOrientation == Orientation.UNKNOWN) {
-      return
-    }
+  private fun onDeviceOrientationChanged(deviceOrientation: Orientation) {
+    if (deviceOrientation == Orientation.UNKNOWN) return
 
-    if (lastDeviceOrientation == deviceOrientation) {
-      return
-    }
+    if (lastDeviceOrientation == deviceOrientation) return
 
     mEventManager.sendDeviceOrientationDidChange(deviceOrientation.ordinal)
     lastDeviceOrientation = deviceOrientation
 
     checkInterfaceOrientation()
 
-    if (!didComputeInitialDeviceOrientation) {
-      didComputeInitialDeviceOrientation = true
+    // NOTE(2.init): This is needed to disable sensors if they were needed just for the initial
+    //  device computation.
+    if (didComputeInitialDeviceOrientation) return
+
+    didComputeInitialDeviceOrientation = true
+
+    if (!areOrientationSensorsEnabled) {
       mOrientationSensorsEventListener.disable()
     }
   }
 
   private fun checkInterfaceOrientation(skipIfAutoRotationIsDisabled: Boolean = true) {
-    if (skipIfAutoRotationIsDisabled && !mAutoRotationObserver.getLastAutoRotationStatus()) {
-      return
-    }
+    if (skipIfAutoRotationIsDisabled && !mAutoRotationObserver.getLastAutoRotationStatus()) return
 
-    if (isLocked) {
-      return
-    }
+    if (isLocked) return
 
     if (lastDeviceOrientation != Orientation.LANDSCAPE_RIGHT && lastDeviceOrientation != Orientation.LANDSCAPE_LEFT) {
       val rotation = mUtils.getInterfaceRotation()