react-native-orientation-director 1.2.1 → 1.2.3

package/README.md

@@ -22,6 +22,8 @@ This library takes inspiration from and builds upon the following amazing altern
 - [x] Listen to interface orientation status changes
 - [x] Lock the interface orientation to a specific orientation
 - [x] Unlock the interface orientation
+- [x] Reset supported interface orientations to settings
+- [x] Check if autorotation is enabled (Android only)
 
 ## Installation
 
@@ -65,11 +67,13 @@ This library exports a class called: [RNOrientationDirector](https://github.com/
 | 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                         |
 
 In addition, the library exposes the following hooks:
 

package/android/src/main/java/com/orientationdirector/implementation/{OrientationAutoRotationObserver.kt → AutoRotationObserver.kt}

@@ -3,10 +3,9 @@ package com.orientationdirector.implementation
 import android.database.ContentObserver
 import android.os.Handler
 import android.provider.Settings
-import android.util.Log
 import com.facebook.react.bridge.ReactContext
 
-class OrientationAutoRotationObserver(val context: ReactContext, handler: Handler?) : ContentObserver(handler) {
+class AutoRotationObserver(private val context: ReactContext, handler: Handler?) : ContentObserver(handler) {
   private var lastAutoRotationStatus: Boolean = isAutoRotationEnabled()
 
   fun getLastAutoRotationStatus(): Boolean {

package/android/src/main/java/com/orientationdirector/implementation/{OrientationEventManager.kt → EventManager.kt}

@@ -12,7 +12,7 @@ enum class Event {
   LockDidChange,
 }
 
-class OrientationEventManager(private val context: ReactApplicationContext) {
+class EventManager(private val context: ReactApplicationContext) {
 
   fun sendDeviceOrientationDidChange(orientationValue: Int) {
     val params = Arguments.createMap().apply {
@@ -36,15 +36,13 @@ class OrientationEventManager(private val context: ReactApplicationContext) {
   }
 
   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"
+    const val NAME = "OrientationEventManager"
   }
 
 }

package/android/src/main/java/com/orientationdirector/implementation/{OrientationLifecycleListener.kt → LifecycleListener.kt}

@@ -2,7 +2,7 @@ package com.orientationdirector.implementation
 
 import com.facebook.react.bridge.LifecycleEventListener
 
-class OrientationLifecycleListener() : LifecycleEventListener {
+class LifecycleListener() : LifecycleEventListener {
 
   private var onHostResumeCallback: (() -> Unit)? = null
   private var onHostPauseCallback: (() -> Unit)? = null
@@ -12,7 +12,7 @@ class OrientationLifecycleListener() : LifecycleEventListener {
     this.onHostResumeCallback = callback
   }
   fun setOnHostPauseCallback(callback: () -> Unit) {
-    this.onHostResumeCallback = callback
+    this.onHostPauseCallback = callback
   }
   fun setOnHostDestroyCallback(callback: () -> Unit) {
     this.onHostDestroyCallback = callback

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

@@ -3,18 +3,19 @@ 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) {
-  private var mUtils = OrientationDirectorUtilsImpl(context)
-  private var mEventEmitter = OrientationEventManager(context)
-  private var mSensorListener = OrientationSensorListener(context)
-  private var mAutoRotationObserver = OrientationAutoRotationObserver(
+  private var mUtils = Utils(context)
+  private var mEventManager = EventManager(context)
+  private var mSensorListener = SensorListener(context)
+  private var mAutoRotationObserver = AutoRotationObserver(
     context, Handler(
       Looper.getMainLooper()
     )
   )
-  private var mLifecycleListener = OrientationLifecycleListener()
+  private var mLifecycleListener = LifecycleListener()
 
   private var initialSupportedInterfaceOrientations = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
   private var lastInterfaceOrientation = Orientation.UNKNOWN
@@ -79,10 +80,10 @@ class OrientationDirectorImpl internal constructor(private val context: ReactApp
     return mAutoRotationObserver.getLastAutoRotationStatus()
   }
 
-  fun lockTo(rawJsOrientation: Int) {
-    val jsOrientation = mUtils.getOrientationFromJsOrientation(rawJsOrientation)
+  fun lockTo(jsValue: Int) {
+    val jsOrientation = mUtils.convertToOrientationFromJsValue(jsValue)
     val screenOrientation =
-      mUtils.getActivityOrientationFrom(jsOrientation)
+      mUtils.convertToActivityOrientationFrom(jsOrientation)
     context.currentActivity?.requestedOrientation = screenOrientation
 
     updateIsLockedTo(true)
@@ -104,14 +105,14 @@ class OrientationDirectorImpl internal constructor(private val context: ReactApp
 
   private fun initInterfaceOrientation(): Orientation {
     val rotation = mUtils.getInterfaceRotation()
-    return mUtils.getOrientationFromRotation(rotation)
+    return mUtils.convertToOrientationFromScreenRotation(rotation)
   }
 
   private fun initDeviceOrientation(): Orientation {
     val lastRotationDetected = mSensorListener.getLastRotationDetected()
       ?: return Orientation.UNKNOWN
 
-    return mUtils.getDeviceOrientationFrom(lastRotationDetected)
+    return mUtils.convertToDeviceOrientationFrom(lastRotationDetected)
   }
 
   private fun initIsLocked(): Boolean {
@@ -126,9 +127,19 @@ class OrientationDirectorImpl internal constructor(private val context: ReactApp
   }
 
   private fun onOrientationChanged(rawDeviceOrientation: Int) {
-    val deviceOrientation = mUtils.getDeviceOrientationFrom(rawDeviceOrientation)
-    mEventEmitter.sendDeviceOrientationDidChange(deviceOrientation.ordinal)
+    val deviceOrientation = mUtils.convertToDeviceOrientationFrom(rawDeviceOrientation)
+
+    if (rawDeviceOrientation != ORIENTATION_UNKNOWN && deviceOrientation == Orientation.UNKNOWN) {
+      return;
+    }
+
+    if (lastDeviceOrientation == deviceOrientation) {
+      return
+    }
+
+    mEventManager.sendDeviceOrientationDidChange(deviceOrientation.ordinal)
     lastDeviceOrientation = deviceOrientation
+
     adaptInterfaceTo(deviceOrientation)
   }
 
@@ -141,7 +152,7 @@ class OrientationDirectorImpl internal constructor(private val context: ReactApp
       return
     }
 
-    val newInterfaceOrientation = mUtils.getInterfaceOrientationFromDeviceOrientation(deviceOrientation);
+    val newInterfaceOrientation = mUtils.convertToInterfaceOrientationFrom(deviceOrientation);
     if (newInterfaceOrientation == lastInterfaceOrientation) {
       return
     }
@@ -150,13 +161,13 @@ class OrientationDirectorImpl internal constructor(private val context: ReactApp
   }
 
   private fun updateIsLockedTo(value: Boolean) {
-    mEventEmitter.sendLockDidChange(value)
+    mEventManager.sendLockDidChange(value)
     isLocked = value
   }
 
   private fun updateLastInterfaceOrientationTo(value: Orientation) {
     lastInterfaceOrientation = value
-    mEventEmitter.sendInterfaceOrientationDidChange(value.ordinal)
+    mEventManager.sendInterfaceOrientationDidChange(value.ordinal)
   }
 
   companion object {

package/android/src/main/java/com/orientationdirector/implementation/{OrientationSensorListener.kt → SensorListener.kt}

@@ -4,7 +4,7 @@ import android.hardware.SensorManager
 import android.view.OrientationEventListener
 import com.facebook.react.bridge.ReactApplicationContext
 
-class OrientationSensorListener(
+class SensorListener(
   context: ReactApplicationContext,
 ) : OrientationEventListener(context, SensorManager.SENSOR_DELAY_UI) {
 

package/android/src/main/java/com/orientationdirector/implementation/{OrientationDirectorUtilsImpl.kt → Utils.kt}

@@ -3,12 +3,11 @@ package com.orientationdirector.implementation
 import android.content.Context
 import android.content.pm.ActivityInfo
 import android.os.Build
-import android.provider.Settings
 import android.view.Surface
 import android.view.WindowManager
 import com.facebook.react.bridge.ReactContext
 
-class OrientationDirectorUtilsImpl(val context: ReactContext) {
+class Utils(private val context: ReactContext) {
 
   fun getInterfaceRotation(): Int {
     return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
@@ -20,26 +19,24 @@ class OrientationDirectorUtilsImpl(val context: ReactContext) {
     }
   }
 
-  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
+  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
     }
-
-    return orientation
   }
 
-  fun getActivityOrientationFrom(interfaceOrientation: Orientation): Int {
-    return when (interfaceOrientation) {
+  fun convertToActivityOrientationFrom(orientation: Orientation): Int {
+    return when (orientation) {
       Orientation.LANDSCAPE_RIGHT -> ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
       Orientation.PORTRAIT_UPSIDE_DOWN -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT
       Orientation.LANDSCAPE_LEFT -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
@@ -47,8 +44,8 @@ class OrientationDirectorUtilsImpl(val context: ReactContext) {
     }
   }
 
-  fun getOrientationFromJsOrientation(jsOrientation: Int): Orientation {
-    return when (jsOrientation) {
+  fun convertToOrientationFromJsValue(jsValue: Int): Orientation {
+    return when (jsValue) {
       2 -> Orientation.LANDSCAPE_RIGHT
       3 -> Orientation.PORTRAIT_UPSIDE_DOWN
       4 -> Orientation.LANDSCAPE_LEFT
@@ -56,8 +53,8 @@ class OrientationDirectorUtilsImpl(val context: ReactContext) {
     }
   }
 
-  fun getOrientationFromRotation(rotation: Int): Orientation {
-    return when(rotation) {
+  fun convertToOrientationFromScreenRotation(screenRotation: Int): Orientation {
+    return when(screenRotation) {
       Surface.ROTATION_270 -> Orientation.LANDSCAPE_RIGHT
       Surface.ROTATION_90 -> Orientation.LANDSCAPE_LEFT
       Surface.ROTATION_180 -> Orientation.PORTRAIT_UPSIDE_DOWN
@@ -65,7 +62,7 @@ class OrientationDirectorUtilsImpl(val context: ReactContext) {
     }
   }
 
-  fun getInterfaceOrientationFromDeviceOrientation(deviceOrientation: Orientation): Orientation {
+  fun convertToInterfaceOrientationFrom(deviceOrientation: Orientation): Orientation {
     return when(deviceOrientation) {
       Orientation.PORTRAIT -> Orientation.PORTRAIT
       Orientation.LANDSCAPE_RIGHT -> Orientation.LANDSCAPE_LEFT

package/ios/OrientationDirector.mm

@@ -53,7 +53,7 @@ RCT_EXPORT_MODULE()
 }
 
 - (NSArray<NSString *> *)supportedEvents {
-    return [OrientationEventManager supportedEvents];
+    return [EventManager supportedEvents];
 }
 
 - (void)sendEventWithName:(NSString * _Nonnull)name params:(NSDictionary *)params {
@@ -91,6 +91,15 @@ RCT_EXPORT_METHOD(getDeviceOrientation:(RCTPromiseResolveBlock)resolve
     });
 }
 
+#ifdef RCT_NEW_ARCH_ENABLED
+- (NSNumber *)isLocked
+#else
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(isLocked)
+#endif
+{
+    return @([_director getIsLocked]);
+}
+
 #ifdef RCT_NEW_ARCH_ENABLED
 - (void)lockTo:(double)jsOrientation
 #else
@@ -99,7 +108,7 @@ RCT_EXPORT_METHOD(lockTo:(double)jsOrientation)
 {
     NSNumber *jsOrientationNumber = @(jsOrientation);
     dispatch_async(dispatch_get_main_queue(), ^{
-        [_director lockToRawJsOrientation:jsOrientationNumber];
+        [_director lockToJsValue:jsOrientationNumber];
     });
 }
 
@@ -115,26 +124,30 @@ RCT_EXPORT_METHOD(unlock)
 }
 
 #ifdef RCT_NEW_ARCH_ENABLED
-- (NSNumber *)isLocked
+- (void)resetSupportedInterfaceOrientations
 #else
-RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(isLocked)
+RCT_EXPORT_METHOD(resetSupportedInterfaceOrientations)
 #endif
 {
-    return @([_director isLocked]);
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [_director resetSupportedInterfaceOrientations];
+    });
 }
 
+/**
+ This method is a pure stub since we cannot access auto rotation setting in iOS
+ */
 #ifdef RCT_NEW_ARCH_ENABLED
-- (void)resetSupportedInterfaceOrientations
+- (NSNumber *)isAutoRotationEnabled
 #else
-RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(resetSupportedInterfaceOrientations)
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(isAutoRotationEnabled)
 #endif
 {
-    dispatch_async(dispatch_get_main_queue(), ^{
-        [_director resetSupportedInterfaceOrientations];
-    });
+    return @(NO);
 }
 
 
+
 // Don't compile this code when we build for the old architecture.
 #ifdef RCT_NEW_ARCH_ENABLED
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:

package/ios/implementation/BundleManager.swift

@@ -0,0 +1,45 @@
+//
+//  BundleManager.swift
+//  react-native-orientation-director
+//
+//  Created by gladiuscode on 26/05/2024.
+//
+
+import Foundation
+
+class BundleManager {
+
+    private var supportedInterfaceOrientations: [UIInterfaceOrientationMask] = [UIInterfaceOrientationMask.all]
+
+    init() {
+        supportedInterfaceOrientations = readSupportedInterfaceOrientations()
+    }
+
+    func getSupportedInterfaceOrientations() -> [UIInterfaceOrientationMask] {
+        return supportedInterfaceOrientations
+    }
+
+    private func readSupportedInterfaceOrientations() -> [UIInterfaceOrientationMask] {
+        let orientations = Bundle.main.object(forInfoDictionaryKey: "UISupportedInterfaceOrientations") as? [String]
+
+        guard let orientations = orientations else {
+            return [UIInterfaceOrientationMask.all]
+        }
+
+        return orientations.compactMap { orientation in
+            switch orientation {
+            case "UIInterfaceOrientationPortrait":
+                return UIInterfaceOrientationMask.portrait
+            case "UIInterfaceOrientationLandscapeLeft":
+                return UIInterfaceOrientationMask.landscapeLeft
+            case "UIInterfaceOrientationLandscapeRight":
+                return UIInterfaceOrientationMask.landscapeRight
+            case "UIInterfaceOrientationPortraitUpsideDown":
+                return UIInterfaceOrientationMask.portraitUpsideDown
+            default:
+                return UIInterfaceOrientationMask.allButUpsideDown
+            }
+        }
+    }
+
+}

package/ios/implementation/{OrientationEventManager.swift → EventManager.swift}

@@ -7,7 +7,7 @@
 
 import Foundation
 
-@objc public class OrientationEventManager : NSObject {
+@objc public class EventManager : NSObject {
     @objc public weak var delegate: OrientationEventEmitterDelegate? = nil
 
     func sendDeviceOrientationDidChange(orientationValue: Int) {
@@ -56,7 +56,7 @@ import Foundation
     func sendEvent(name: String, params: NSDictionary)
 }
 
-public extension OrientationEventManager {
+public extension EventManager {
 
   enum Event: String, CaseIterable {
     case DeviceOrientationDidChange

package/ios/implementation/OrientationDirectorImpl.swift

@@ -10,20 +10,23 @@ import UIKit
 
 @objc public class OrientationDirectorImpl : NSObject {
     private static let TAG = "OrientationDirectorImpl"
-    private let sensorListener: OrientationSensorListener
-    private let eventManager: OrientationEventManager
+
+    private let bundleManager: BundleManager = BundleManager()
+    private let utils: Utils = Utils()
+    private let sensorListener: SensorListener = SensorListener()
+    private let eventManager: EventManager = EventManager()
     private var initialSupportedInterfaceOrientations: UIInterfaceOrientationMask = UIInterfaceOrientationMask.all
     private var lastInterfaceOrientation = Orientation.UNKNOWN
     private var lastDeviceOrientation = Orientation.UNKNOWN
+    private var isLocked = false
 
     @objc public var supportedInterfaceOrientations: UIInterfaceOrientationMask = UIInterfaceOrientationMask.all
-    @objc public var isLocked = false
 
     @objc public override init() {
-        eventManager = OrientationEventManager()
-        sensorListener = OrientationSensorListener()
         super.init()
-        sensorListener.setOnOrientationChanged(callback: self.onOrientationChanged)
+
+        sensorListener.setOnOrientationDidChange(callback: self.onOrientationChanged)
+
         initialSupportedInterfaceOrientations = initInitialSupportedInterfaceOrientations()
         lastInterfaceOrientation = initInterfaceOrientation()
         lastDeviceOrientation = initDeviceOrientation()
@@ -47,10 +50,14 @@ import UIKit
     @objc public func getDeviceOrientation() -> Orientation {
         return lastDeviceOrientation
     }
+    
+    @objc public func getIsLocked() -> Bool {
+        return isLocked
+    }
 
-    @objc public func lockTo(rawJsOrientation: NSNumber) {
-        let jsOrientation = OrientationDirectorUtils.getOrientationFrom(jsOrientation: rawJsOrientation)
-        let mask = OrientationDirectorUtils.getMaskFrom(jsOrientation: jsOrientation)
+    @objc public func lockTo(jsValue: NSNumber) {
+        let jsOrientation = utils.convertToOrientationFrom(jsValue: jsValue)
+        let mask = utils.convertToMaskFrom(jsOrientation: jsOrientation)
         self.requestInterfaceUpdateTo(mask: mask)
 
         updateIsLockedTo(value: true)
@@ -69,13 +76,13 @@ import UIKit
         self.requestInterfaceUpdateTo(mask: self.supportedInterfaceOrientations)
         self.updateIsLockedTo(value: self.initIsLocked())
 
-        let lastMask = OrientationDirectorUtils.getMaskFrom(jsOrientation: lastInterfaceOrientation)
+        let lastMask = utils.convertToMaskFrom(jsOrientation: lastInterfaceOrientation)
         let isLastMaskSupported = self.supportedInterfaceOrientations.contains(lastMask)
         if (isLastMaskSupported) {
             return
         }
 
-        let supportedInterfaceOrientations = OrientationDirectorUtils.readSupportedInterfaceOrientationsFromBundle()
+        let supportedInterfaceOrientations = bundleManager.getSupportedInterfaceOrientations()
         if (supportedInterfaceOrientations.contains(UIInterfaceOrientationMask.portrait)) {
             self.updateLastInterfaceOrientationTo(value: Orientation.PORTRAIT)
             return
@@ -93,21 +100,22 @@ import UIKit
     }
 
     private func initInitialSupportedInterfaceOrientations() -> UIInterfaceOrientationMask {
-        let supportedInterfaceOrientations = OrientationDirectorUtils.readSupportedInterfaceOrientationsFromBundle()
+        let supportedInterfaceOrientations = bundleManager.getSupportedInterfaceOrientations()
         return supportedInterfaceOrientations.reduce(UIInterfaceOrientationMask()) { $0.union($1) }
     }
 
+    // TODO: FIX BECAUSE IT ALWAYS RETURNS PORTRAIT AND ITS BROKEN
     private func initInterfaceOrientation() -> Orientation {
-        let interfaceOrientation = OrientationDirectorUtils.getInterfaceOrientation()
-        return OrientationDirectorUtils.getOrientationFrom(uiInterfaceOrientation: interfaceOrientation)
+        let interfaceOrientation = utils.getInterfaceOrientation()
+        return utils.convertToOrientationFrom(uiInterfaceOrientation: interfaceOrientation)
     }
 
     private func initDeviceOrientation() -> Orientation {
-        return OrientationDirectorUtils.getOrientationFrom(deviceOrientation: UIDevice.current.orientation)
+        return utils.convertToOrientationFrom(deviceOrientation: UIDevice.current.orientation)
     }
 
     private func initIsLocked() -> Bool {
-        let supportedOrientations = OrientationDirectorUtils.readSupportedInterfaceOrientationsFromBundle()
+        let supportedOrientations = bundleManager.getSupportedInterfaceOrientations()
         if (supportedOrientations.count > 1) {
             return false
         }
@@ -119,7 +127,7 @@ import UIKit
         self.supportedInterfaceOrientations = mask
 
         if #available(iOS 16.0, *) {
-            let window = OrientationDirectorUtils.getCurrentWindow()
+            let window = utils.getCurrentWindow()
 
             guard let rootViewController = window?.rootViewController else {
                 return
@@ -141,7 +149,7 @@ import UIKit
     }
 
     private func onOrientationChanged(uiDeviceOrientation: UIDeviceOrientation) {
-        let deviceOrientation = OrientationDirectorUtils.getOrientationFrom(deviceOrientation: uiDeviceOrientation)
+        let deviceOrientation = utils.convertToOrientationFrom(deviceOrientation: uiDeviceOrientation)
         self.eventManager.sendDeviceOrientationDidChange(orientationValue: deviceOrientation.rawValue)
         lastDeviceOrientation = deviceOrientation
         adaptInterfaceTo(deviceOrientation: deviceOrientation)
@@ -151,22 +159,22 @@ import UIKit
         if (isLocked) {
             return
         }
-        
+
         if (deviceOrientation == Orientation.FACE_UP || deviceOrientation == Orientation.FACE_DOWN) {
             return
         }
 
-        let newInterfaceOrientationMask = OrientationDirectorUtils.getMaskFrom(deviceOrientation: deviceOrientation)
+        let newInterfaceOrientationMask = utils.convertToMaskFrom(deviceOrientation: deviceOrientation)
         let isSupported = self.supportedInterfaceOrientations.contains(newInterfaceOrientationMask)
         if (!isSupported) {
             return
         }
 
-        let newInterfaceOrientation = OrientationDirectorUtils.getOrientationFrom(mask: newInterfaceOrientationMask)
+        let newInterfaceOrientation = utils.convertToOrientationFrom(mask: newInterfaceOrientationMask)
         if (newInterfaceOrientation == lastInterfaceOrientation) {
             return
         }
-        
+
         updateLastInterfaceOrientationTo(value: newInterfaceOrientation)
     }
 

package/ios/implementation/{OrientationSensorListener.swift → SensorListener.swift}

@@ -7,8 +7,8 @@
 
 import Foundation
 
-public class OrientationSensorListener {
-    private var onOrientationChangedCallback: ((_ deviceOrientation: UIDeviceOrientation) -> Void)? = nil
+public class SensorListener {
+    private var onOrientationDidChangeCallback: ((_ deviceOrientation: UIDeviceOrientation) -> Void)? = nil
 
     init() {
         NotificationCenter.default.addObserver(
@@ -23,15 +23,15 @@ public class OrientationSensorListener {
         NotificationCenter.default.removeObserver(self)
     }
 
-    func setOnOrientationChanged(callback: @escaping (_ deviceOrientation: UIDeviceOrientation) -> Void) {
-        self.onOrientationChangedCallback = callback
+    func setOnOrientationDidChange(callback: @escaping (_ deviceOrientation: UIDeviceOrientation) -> Void) {
+        self.onOrientationDidChangeCallback = callback
     }
 
     @objc func orientationDidChange(_ notification: Notification) {
-        guard let onOrientationChangedCallback = self.onOrientationChangedCallback else {
+        guard let onOrientationDidChangeCallback = self.onOrientationDidChangeCallback else {
             return
         }
 
-        onOrientationChangedCallback(UIDevice.current.orientation)
+        onOrientationDidChangeCallback(UIDevice.current.orientation)
     }
 }

package/ios/implementation/Utils.swift

@@ -0,0 +1,130 @@
+//
+//  OrientationDirectorUtils.swift
+//  react-native-orientation-director
+//
+//  Created by gladiuscode on 18/05/2024.
+//
+
+import Foundation
+
+class Utils {
+
+    private static let TAG = "Utils"
+
+    // TODO: Add .unknown
+    public func convertToOrientationFrom(uiInterfaceOrientation: UIInterfaceOrientation) -> Orientation {
+        switch(uiInterfaceOrientation) {
+        case .landscapeRight:
+            return .LANDSCAPE_RIGHT
+        case .portraitUpsideDown:
+            return .PORTRAIT_UPSIDE_DOWN
+        case .landscapeLeft:
+            return .LANDSCAPE_LEFT
+        default:
+            return .PORTRAIT
+        }
+    }
+
+    public func convertToOrientationFrom(deviceOrientation: UIDeviceOrientation) -> Orientation {
+        switch(deviceOrientation) {
+        case .landscapeRight:
+            return .LANDSCAPE_RIGHT
+        case .portraitUpsideDown:
+            return .PORTRAIT_UPSIDE_DOWN
+        case .landscapeLeft:
+            return .LANDSCAPE_LEFT
+        case .faceUp:
+            return .FACE_UP
+        case .faceDown:
+            return .FACE_DOWN
+        default:
+            return .PORTRAIT
+        }
+    }
+
+    public func convertToOrientationFrom(jsValue: NSNumber) -> Orientation {
+        switch(jsValue) {
+        case 2:
+            return .LANDSCAPE_RIGHT
+        case 3:
+            return .PORTRAIT_UPSIDE_DOWN
+        case 4:
+            return .LANDSCAPE_LEFT
+        default:
+            return .PORTRAIT
+        }
+    }
+
+    public func convertToOrientationFrom(mask: UIInterfaceOrientationMask) -> Orientation {
+        switch(mask) {
+        case .portraitUpsideDown:
+            return .PORTRAIT_UPSIDE_DOWN
+        case .landscapeRight:
+            return .LANDSCAPE_RIGHT
+        case .landscapeLeft:
+            return .LANDSCAPE_LEFT
+        default:
+            return .PORTRAIT
+        }
+    }
+
+    /**
+     Note: .portraitUpsideDown only works for devices with home button and iPads
+     https://developer.apple.com/documentation/uikit/uiviewcontroller/1621435-supportedinterfaceorientations
+     */
+    public func convertToMaskFrom(jsOrientation: Orientation) -> UIInterfaceOrientationMask {
+        switch(jsOrientation) {
+        case .PORTRAIT:
+            return .portrait
+        case .LANDSCAPE_RIGHT:
+            return .landscapeRight
+        case .PORTRAIT_UPSIDE_DOWN:
+            return .portraitUpsideDown
+        case .LANDSCAPE_LEFT:
+            return .landscapeLeft
+        default:
+            return .all
+        }
+    }
+
+    /**
+     Note: .portraitUpsideDown only works for devices with home button and iPads
+     https://developer.apple.com/documentation/uikit/uiviewcontroller/1621435-supportedinterfaceorientations
+     */
+    public func convertToMaskFrom(deviceOrientation: Orientation) -> UIInterfaceOrientationMask {
+        switch(deviceOrientation) {
+        case .PORTRAIT:
+            return .portrait
+        case .LANDSCAPE_RIGHT:
+            return .landscapeLeft
+        case .PORTRAIT_UPSIDE_DOWN:
+            return .portraitUpsideDown
+        case .LANDSCAPE_LEFT:
+            return .landscapeRight
+        default:
+            return .all
+        }
+    }
+
+    public func getInterfaceOrientation() -> UIInterfaceOrientation {
+        guard let windowScene = self.getCurrentWindow()?.windowScene else {
+            return UIInterfaceOrientation.unknown
+        }
+
+        return windowScene.interfaceOrientation;
+    }
+
+    /* This function is needed to get the current available window.
+     Here in React Native we should have only one window tho.
+     https://stackoverflow.com/questions/57134259/how-to-resolve-keywindow-was-deprecated-in-ios-13-0/58031897#58031897
+     */
+    public func getCurrentWindow() -> UIWindow? {
+        return UIApplication
+            .shared
+            .connectedScenes
+            .compactMap { $0 as? UIWindowScene }
+            .flatMap { $0.windows }
+            .last { $0.isKeyWindow }
+    }
+
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-orientation-director",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "A Modern React Native library that allows you to access orientation",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/ios/implementation/OrientationDirectorUtils.swift

@@ -1,166 +0,0 @@
-//
-//  OrientationDirectorUtils.swift
-//  react-native-orientation-director
-//
-//  Created by gladiuscode on 18/05/2024.
-//
-
-import Foundation
-
-class OrientationDirectorUtils {
-
-    private static let TAG = "OrientationDirectorUtils"
-
-    public static func getOrientationFrom(uiInterfaceOrientation: UIInterfaceOrientation) -> Orientation {
-        var orientation = Orientation.UNKNOWN
-
-        switch(uiInterfaceOrientation) {
-        case UIInterfaceOrientation.landscapeRight:
-            orientation = Orientation.LANDSCAPE_RIGHT
-        case UIInterfaceOrientation.portraitUpsideDown:
-            orientation = Orientation.PORTRAIT_UPSIDE_DOWN
-        case UIInterfaceOrientation.landscapeLeft:
-            orientation = Orientation.LANDSCAPE_LEFT
-        default:
-            orientation = Orientation.PORTRAIT
-        }
-
-        return orientation
-    }
-
-    public static func getOrientationFrom(deviceOrientation: UIDeviceOrientation) -> Orientation {
-        var orientation = Orientation.UNKNOWN
-
-        switch(deviceOrientation) {
-        case UIDeviceOrientation.landscapeRight:
-            orientation = Orientation.LANDSCAPE_RIGHT
-        case UIDeviceOrientation.portraitUpsideDown:
-            orientation = Orientation.PORTRAIT_UPSIDE_DOWN
-        case UIDeviceOrientation.landscapeLeft:
-            orientation = Orientation.LANDSCAPE_LEFT
-        case UIDeviceOrientation.faceUp:
-            orientation = Orientation.FACE_UP
-        case UIDeviceOrientation.faceDown:
-            orientation = Orientation.FACE_DOWN
-        default:
-            orientation = Orientation.PORTRAIT
-        }
-
-        return orientation
-    }
-
-    public static func getOrientationFrom(jsOrientation: NSNumber) -> Orientation {
-        var orientation = Orientation.UNKNOWN
-
-        switch(jsOrientation) {
-        case 2:
-            orientation = Orientation.LANDSCAPE_RIGHT
-        case 3:
-            orientation = Orientation.PORTRAIT_UPSIDE_DOWN
-        case 4:
-            orientation = Orientation.LANDSCAPE_LEFT
-        default:
-            orientation = Orientation.PORTRAIT
-        }
-
-        return orientation
-    }
-    
-    public static func getOrientationFrom(mask: UIInterfaceOrientationMask) -> Orientation {
-        var orientation = Orientation.UNKNOWN
-        
-        switch(mask) {
-        case UIInterfaceOrientationMask.portraitUpsideDown:
-            orientation = Orientation.PORTRAIT_UPSIDE_DOWN
-        case UIInterfaceOrientationMask.landscapeRight:
-            orientation = Orientation.LANDSCAPE_RIGHT
-        case UIInterfaceOrientationMask.landscapeLeft:
-            orientation = Orientation.LANDSCAPE_LEFT
-        default:
-            orientation = Orientation.PORTRAIT
-        }
-
-        return orientation
-    }
-
-    /**
-     Note: .portraitUpsideDown only works for devices with home button and iPads
-     https://developer.apple.com/documentation/uikit/uiviewcontroller/1621435-supportedinterfaceorientations
-     */
-    public static func getMaskFrom(jsOrientation: Orientation) -> UIInterfaceOrientationMask {
-        switch(jsOrientation) {
-        case Orientation.PORTRAIT:
-            return UIInterfaceOrientationMask.portrait
-        case Orientation.LANDSCAPE_RIGHT:
-            return UIInterfaceOrientationMask.landscapeRight
-        case Orientation.PORTRAIT_UPSIDE_DOWN:
-            return UIInterfaceOrientationMask.portraitUpsideDown
-        case Orientation.LANDSCAPE_LEFT:
-            return UIInterfaceOrientationMask.landscapeLeft
-        default:
-            return UIInterfaceOrientationMask.all
-        }
-    }
-    
-    /**
-     Note: .portraitUpsideDown only works for devices with home button and iPads
-     https://developer.apple.com/documentation/uikit/uiviewcontroller/1621435-supportedinterfaceorientations
-     */
-    public static func getMaskFrom(deviceOrientation: Orientation) -> UIInterfaceOrientationMask {
-        switch(deviceOrientation) {
-        case Orientation.PORTRAIT:
-            return UIInterfaceOrientationMask.portrait
-        case Orientation.LANDSCAPE_RIGHT:
-            return UIInterfaceOrientationMask.landscapeLeft
-        case Orientation.PORTRAIT_UPSIDE_DOWN:
-            return UIInterfaceOrientationMask.portraitUpsideDown
-        case Orientation.LANDSCAPE_LEFT:
-            return UIInterfaceOrientationMask.landscapeRight
-        default:
-            return UIInterfaceOrientationMask.all
-        }
-    }
-
-    public static func getInterfaceOrientation() -> UIInterfaceOrientation {
-        guard let windowScene = self.getCurrentWindow()?.windowScene else {
-            return UIInterfaceOrientation.unknown
-        }
-
-        return windowScene.interfaceOrientation;
-    }
-
-    /* This function is needed to get the current available window.
-     Here in React Native we should have only one window tho.
-     https://stackoverflow.com/questions/57134259/how-to-resolve-keywindow-was-deprecated-in-ios-13-0/58031897#58031897
-     */
-    public static func getCurrentWindow() -> UIWindow? {
-        return UIApplication
-            .shared
-            .connectedScenes
-            .compactMap { $0 as? UIWindowScene }
-            .flatMap { $0.windows }
-            .last { $0.isKeyWindow }
-    }
-    
-    public static func readSupportedInterfaceOrientationsFromBundle() -> [UIInterfaceOrientationMask] {
-        guard let rawOrientations = Bundle.main.object(forInfoDictionaryKey: "UISupportedInterfaceOrientations") as? [String] else {
-            return [UIInterfaceOrientationMask.all]
-        }
-        
-        return rawOrientations.compactMap { orientation in
-            switch orientation {
-            case "UIInterfaceOrientationPortrait":
-                return UIInterfaceOrientationMask.portrait
-            case "UIInterfaceOrientationLandscapeLeft":
-                return UIInterfaceOrientationMask.landscapeLeft
-            case "UIInterfaceOrientationLandscapeRight":
-                return UIInterfaceOrientationMask.landscapeRight
-            case "UIInterfaceOrientationPortraitUpsideDown":
-                return UIInterfaceOrientationMask.portraitUpsideDown
-            default:
-                return UIInterfaceOrientationMask.allButUpsideDown
-            }
-        }
-    }
-
-}