react-native-orientation-director 1.3.0 → 2.1.0

package/android/src/test/java/com/orientationdirector/implementation/OrientationDirectorModuleImplTest.kt

@@ -0,0 +1,188 @@
+package com.orientationdirector.implementation
+
+import android.os.Looper
+import androidx.test.core.app.ApplicationProvider
+import com.facebook.react.bridge.BridgeReactContext
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.InjectMocks
+import org.mockito.Mock
+import org.mockito.Mockito.`when`
+import org.mockito.MockitoAnnotations
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+class OrientationDirectorModuleImplTest {
+  private var context = BridgeReactContext(ApplicationProvider.getApplicationContext())
+
+  @Mock
+  private val mockEventManager = EventManager(context)
+
+  @Mock
+  private val mockAutoRotationObserver = AutoRotationObserver(
+    context,
+    android.os.Handler(Looper.getMainLooper())
+  )
+
+  @InjectMocks
+  private val mModule = OrientationDirectorModuleImpl(context)
+
+  @Before
+  fun setup() {
+    MockitoAnnotations.openMocks(this)
+
+    // We stub this method because adaptInterfaceTo checks it
+    `when`(mockAutoRotationObserver.getLastAutoRotationStatus()).thenReturn(true)
+  }
+
+  @Test
+  @Config(
+    qualifiers = "port"
+  )
+  fun assert_initial_orientation_matches_portrait() {
+    val orientation = mModule.getInterfaceOrientation()
+
+    assertEquals(
+      "When user starts the app with the device in portrait, the initial interface should be portrait",
+      Orientation.PORTRAIT,
+      orientation
+    )
+  }
+
+  @Test
+  @Config(
+    qualifiers = "land"
+  )
+  fun assert_initial_orientation_matches_landscape_left() {
+    val orientation = mModule.getInterfaceOrientation()
+
+    assertEquals(
+      "When user starts the app with the device in landscape, the initial interface should be landscape left",
+      Orientation.LANDSCAPE_LEFT,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_initial_device_orientation_matches_unknown_at_startup() {
+    val orientation = mModule.getDeviceOrientation()
+
+    assertEquals(
+      "When user starts the app, the initial device orientation should be unknown",
+      Orientation.UNKNOWN,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_initial_is_locked_matches_false_at_startup() {
+    val isLocked = mModule.getIsLocked()
+
+    assertEquals(
+      "When user starts the app, interface orientation shouldn't be locked",
+      false,
+      isLocked
+    )
+  }
+
+  @Test
+  fun assert_is_locked_matches_true_after_lock_to_gets_executed() {
+    mModule.lockTo(1)
+    val isLocked = mModule.getIsLocked()
+
+    assertEquals(
+      "When lockTo is executed, getIsLocked should match true",
+      true,
+      isLocked
+    )
+  }
+
+  @Test
+  fun assert_interface_orientation_matches_locked_to_portrait() {
+    mModule.lockTo(1)
+
+    assertEquals(
+      "When the interface is locked to portrait, getInterfaceOrientation should return portrait",
+      Orientation.PORTRAIT,
+      mModule.getInterfaceOrientation()
+    )
+  }
+
+  @Test
+  fun assert_interface_orientation_matches_locked_to_landscape_right() {
+    mModule.lockTo(2)
+
+    assertEquals(
+      "When the interface is locked to landscape right, getInterfaceOrientation should return landscape right",
+      Orientation.LANDSCAPE_RIGHT,
+      mModule.getInterfaceOrientation()
+    )
+  }
+
+  @Test
+  fun assert_interface_orientation_matches_locked_to_portrait_upside_down() {
+    mModule.lockTo(3)
+
+    assertEquals(
+      "When the interface is locked to portrait upside down, getInterfaceOrientation should return portrait upside down",
+      Orientation.PORTRAIT_UPSIDE_DOWN,
+      mModule.getInterfaceOrientation()
+    )
+  }
+
+  @Test
+  fun assert_interface_orientation_matches_locked_to_landscape_left() {
+    mModule.lockTo(4)
+
+    assertEquals(
+      "When the interface is locked to landscape left, getInterfaceOrientation should return landscape left",
+      Orientation.LANDSCAPE_LEFT,
+      mModule.getInterfaceOrientation()
+    )
+  }
+
+  @Test
+  fun assert_is_locked_reset_when_unlock_is_executed() {
+    mModule.lockTo(1)
+    mModule.unlock()
+
+    assertEquals(
+      "When unlock is executed, getIsLocked should return false",
+      false,
+      mModule.getIsLocked()
+    )
+  }
+
+  @Test
+  @Config(
+    qualifiers = "port"
+  )
+  fun assert_interface_reset_to_portrait_on_unlock() {
+    mModule.lockTo(2)
+    mModule.unlock()
+
+    assertEquals(
+      "When unlock is executed, getInterfaceOrientation should match portrait when device is in portrait",
+      Orientation.PORTRAIT,
+      mModule.getInterfaceOrientation()
+    )
+  }
+
+  @Test
+  @Config(
+    qualifiers = "land"
+  )
+  fun assert_interface_reset_to_landscape_left_on_unlock() {
+    mModule.lockTo(2)
+    mModule.unlock()
+
+    assertEquals(
+      "When unlock is executed, getInterfaceOrientation should match landscape left when device is in landscape right",
+      Orientation.LANDSCAPE_LEFT,
+      mModule.getInterfaceOrientation()
+    )
+  }
+}

package/android/src/test/java/com/orientationdirector/implementation/UtilsTest.kt

@@ -0,0 +1,314 @@
+package com.orientationdirector.implementation
+
+import android.content.pm.ActivityInfo
+import android.os.Build
+import android.view.Surface
+import androidx.test.core.app.ApplicationProvider
+import com.facebook.react.bridge.BridgeReactContext
+import org.junit.Assert.*
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+class UtilsTest {
+  private var context = BridgeReactContext(ApplicationProvider.getApplicationContext())
+  private var mUtils = Utils(context)
+
+  @Config(
+    sdk = [Build.VERSION_CODES.N],
+    qualifiers = "land"
+  )
+  @Test
+  fun assert_interface_rotation_matches_current_landscape() {
+    val rotation = mUtils.getInterfaceRotation()
+
+    assertEquals(
+      "When current interface orientation is landscape, rotation should be 1",
+      Surface.ROTATION_90,
+      rotation
+    )
+  }
+
+  @Config(
+    sdk = [Build.VERSION_CODES.R],
+    qualifiers = "port"
+  )
+  @Test
+  fun assert_interface_rotation_matches_current_portrait() {
+    val rotation = mUtils.getInterfaceRotation()
+
+    assertEquals(
+      "When current interface orientation is portrait, rotation should be 0",
+      Surface.ROTATION_0,
+      rotation
+    )
+  }
+
+  @Test
+  fun assert_device_orientation_is_portrait() {
+    val orientationAngles = FloatArray(3)
+    orientationAngles[1] = -(Math.PI / 2).toFloat()
+    orientationAngles[2] = -0f
+
+    val orientation = mUtils.convertToDeviceOrientationFrom(orientationAngles)
+
+    assertEquals(
+      "When pitch is half PI radians and roll is -0 radians, orientation should be portrait",
+      Orientation.PORTRAIT,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_device_orientation_is_landscape_right() {
+    val orientationAngles = FloatArray(3)
+    orientationAngles[1] = 0f
+    orientationAngles[2] = (Math.PI / 2).toFloat()
+
+    val orientation = mUtils.convertToDeviceOrientationFrom(orientationAngles)
+
+    assertEquals(
+      "When pitch is 0 radians and roll is half PI radians, orientation should be landscape right",
+      Orientation.LANDSCAPE_RIGHT,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_device_orientation_is_portrait_upside_down() {
+    val orientationAngles = FloatArray(3)
+    orientationAngles[1] = (Math.PI / 2).toFloat()
+    orientationAngles[2] = 0f
+
+    val orientation = mUtils.convertToDeviceOrientationFrom(orientationAngles)
+
+    assertEquals(
+      "When pitch is half PI radians and roll is 0 radians, orientation should be portrait upside down",
+      Orientation.PORTRAIT_UPSIDE_DOWN, orientation
+    )
+  }
+
+  @Test
+  fun assert_device_orientation_is_landscape_left() {
+    val orientationAngles = FloatArray(3)
+    orientationAngles[1] = 0f
+    orientationAngles[2] = -(Math.PI / 2).toFloat()
+
+    val orientation = mUtils.convertToDeviceOrientationFrom(orientationAngles)
+
+    assertEquals(
+      "When pitch is 0 radians and roll is negative half PI radians, orientation should be landscape left",
+      Orientation.LANDSCAPE_LEFT,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_device_orientation_is_face_down() {
+    val orientationAngles = FloatArray(3)
+    orientationAngles[1] = 0f
+    orientationAngles[2] = -(Math.PI).toFloat()
+
+    val orientation = mUtils.convertToDeviceOrientationFrom(orientationAngles)
+
+    assertEquals(
+      "When pitch is 0 radians and roll is negative PI radians, orientation should be face down",
+      Orientation.FACE_DOWN,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_device_orientation_is_face_up() {
+    val orientationAngles = FloatArray(3)
+    orientationAngles[1] = 0f
+    orientationAngles[2] = -0f
+
+    val orientation = mUtils.convertToDeviceOrientationFrom(orientationAngles)
+
+    assertEquals(
+      "When pitch is 0 radians and roll is negative 0 radians, orientation should be face up",
+      Orientation.FACE_UP,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_activity_orientation_conversion_from_portrait() {
+    val activityOrientation = mUtils.convertToActivityOrientationFrom(Orientation.PORTRAIT);
+
+    assertEquals(
+      "When orientation is portrait, activity orientation should be portrait",
+      ActivityInfo.SCREEN_ORIENTATION_PORTRAIT,
+      activityOrientation
+    )
+  }
+
+  @Test
+  fun assert_activity_orientation_conversion_from_landscape_right() {
+    val activityOrientation = mUtils.convertToActivityOrientationFrom(Orientation.LANDSCAPE_RIGHT);
+
+    assertEquals(
+      "When orientation is landscape right, activity orientation should be landscape",
+      ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE,
+      activityOrientation
+    )
+  }
+
+  @Test
+  fun assert_activity_orientation_conversion_from_portrait_upside_down() {
+    val activityOrientation =
+      mUtils.convertToActivityOrientationFrom(Orientation.PORTRAIT_UPSIDE_DOWN);
+
+    assertEquals(
+      "When orientation is portrait upside down, activity orientation should be reverse portrait",
+      ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT,
+      activityOrientation
+    )
+  }
+
+  @Test
+  fun assert_activity_orientation_conversion_from_landscape_left() {
+    val activityOrientation = mUtils.convertToActivityOrientationFrom(Orientation.LANDSCAPE_LEFT);
+
+    assertEquals(
+      "When orientation is landscape left, activity orientation should be reverse landscape",
+      ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE,
+      activityOrientation
+    )
+  }
+
+  @Test
+  fun assert_orientation_conversion_from_js_portrait() {
+    val orientation = mUtils.convertToOrientationFromJsValue(1)
+
+    assertEquals(
+      "When js value is 1, orientation should be portrait",
+      Orientation.PORTRAIT,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_orientation_conversion_from_js_landscape_right() {
+    val orientation = mUtils.convertToOrientationFromJsValue(2)
+
+    assertEquals(
+      "When js value is 2, orientation should be landscape right",
+      Orientation.LANDSCAPE_RIGHT,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_orientation_conversion_from_js_portrait_upside_down() {
+    val orientation = mUtils.convertToOrientationFromJsValue(3)
+
+    assertEquals(
+      "When js value is 3, orientation should be portrait upside down",
+      Orientation.PORTRAIT_UPSIDE_DOWN,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_orientation_conversion_from_js_landscape_left() {
+    val orientation = mUtils.convertToOrientationFromJsValue(4)
+
+    assertEquals(
+      "When js value is 4, orientation should be landscape left",
+      Orientation.LANDSCAPE_LEFT,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_orientation_conversion_from_screen_rotation_0() {
+    val orientation = mUtils.convertToOrientationFromScreenRotation(Surface.ROTATION_0)
+
+    assertEquals(
+      "When screen rotation is 0, orientation should be portrait",
+      Orientation.PORTRAIT,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_orientation_conversion_from_screen_rotation_90() {
+    val orientation = mUtils.convertToOrientationFromScreenRotation(Surface.ROTATION_90)
+
+    assertEquals(
+      "When screen rotation is 90, orientation should be landscape left",
+      Orientation.LANDSCAPE_LEFT,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_orientation_conversion_from_screen_rotation_180() {
+    val orientation = mUtils.convertToOrientationFromScreenRotation(Surface.ROTATION_180)
+
+    assertEquals(
+      "When screen rotation is 180, orientation should be portrait upside down",
+      Orientation.PORTRAIT_UPSIDE_DOWN,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_orientation_conversion_from_screen_rotation_270() {
+    val orientation = mUtils.convertToOrientationFromScreenRotation(Surface.ROTATION_270)
+
+    assertEquals(
+      "When screen rotation is 270, orientation should be landscape right",
+      Orientation.LANDSCAPE_RIGHT,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_interface_orientation_conversion_from_device_portrait() {
+    val orientation = mUtils.convertToInterfaceOrientationFrom(Orientation.PORTRAIT)
+
+    assertEquals(
+      "When device orientation is portrait, interface orientation should be portrait",
+      Orientation.PORTRAIT,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_interface_orientation_conversion_from_device_landscape_right() {
+    val orientation = mUtils.convertToInterfaceOrientationFrom(Orientation.LANDSCAPE_RIGHT)
+
+    assertEquals(
+      "When device orientation is landscape right, interface orientation should be landscape left",
+      Orientation.LANDSCAPE_LEFT,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_interface_orientation_conversion_from_device_portrait_upside_down() {
+    val orientation = mUtils.convertToInterfaceOrientationFrom(Orientation.PORTRAIT_UPSIDE_DOWN)
+
+    assertEquals(
+      "When device orientation is portrait upside down, interface orientation should be portrait upside down",
+      Orientation.PORTRAIT_UPSIDE_DOWN,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_interface_orientation_conversion_from_device_landscape_left() {
+    val orientation = mUtils.convertToInterfaceOrientationFrom(Orientation.LANDSCAPE_LEFT)
+
+    assertEquals(
+      "When device orientation is landscape left, interface orientation should be landscape right",
+      Orientation.LANDSCAPE_RIGHT,
+      orientation
+    )
+  }
+}

package/ios/OrientationDirector.mm

@@ -41,6 +41,11 @@ RCT_EXPORT_MODULE()
     return YES;
 }
 
++ (UIInterfaceOrientationMask)getSupportedInterfaceOrientationsForWindow
+{
+    return [_director supportedInterfaceOrientations];
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////
 ///         EVENT EMITTER SETUP
 ///
@@ -62,49 +67,31 @@ RCT_EXPORT_MODULE()
 ///
 ///////////////////////////////////////////////////////////////////////////////////////
 
-+ (UIInterfaceOrientationMask)getSupportedInterfaceOrientationsForWindow
-{
-    return [_director supportedInterfaceOrientations];
-}
-
-#ifdef RCT_NEW_ARCH_ENABLED
-- (void)getInterfaceOrientation:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
-#else
+///////////////////////////////////////////////////////////////////////////////////////
+///         EXPORTED METHODS
+///
 RCT_EXPORT_METHOD(getInterfaceOrientation:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-#endif
+                  reject:(RCTPromiseRejectBlock)reject)
 {
     dispatch_async(dispatch_get_main_queue(), ^{
         resolve(@([_director getInterfaceOrientation]));
     });
 }
 
-#ifdef RCT_NEW_ARCH_ENABLED
-- (void)getDeviceOrientation:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
-#else
 RCT_EXPORT_METHOD(getDeviceOrientation:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-#endif
+                  reject:(RCTPromiseRejectBlock)reject)
 {
     dispatch_async(dispatch_get_main_queue(), ^{
         resolve(@([_director getDeviceOrientation]));
     });
 }
 
-#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
 RCT_EXPORT_METHOD(lockTo:(double)jsOrientation)
-#endif
 {
     NSNumber *jsOrientationNumber = @(jsOrientation);
     dispatch_async(dispatch_get_main_queue(), ^{
@@ -112,22 +99,14 @@ RCT_EXPORT_METHOD(lockTo:(double)jsOrientation)
     });
 }
 
-#ifdef RCT_NEW_ARCH_ENABLED
-- (void)unlock
-#else
 RCT_EXPORT_METHOD(unlock)
-#endif
 {
     dispatch_async(dispatch_get_main_queue(), ^{
         [_director unlock];
     });
 }
 
-#ifdef RCT_NEW_ARCH_ENABLED
-- (void)resetSupportedInterfaceOrientations
-#else
 RCT_EXPORT_METHOD(resetSupportedInterfaceOrientations)
-#endif
 {
     dispatch_async(dispatch_get_main_queue(), ^{
         [_director resetSupportedInterfaceOrientations];
@@ -137,16 +116,12 @@ RCT_EXPORT_METHOD(resetSupportedInterfaceOrientations)
 /**
  This method is a pure stub since we cannot access auto rotation setting in iOS
  */
-#ifdef RCT_NEW_ARCH_ENABLED
-- (NSNumber *)isAutoRotationEnabled
-#else
 RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(isAutoRotationEnabled)
-#endif
 {
     return @(NO);
 }
-
-
+///
+///////////////////////////////////////////////////////////////////////////////////////
 
 // Don't compile this code when we build for the old architecture.
 #ifdef RCT_NEW_ARCH_ENABLED

package/ios/implementation/OrientationDirectorImpl.swift

@@ -104,10 +104,8 @@ import UIKit
         return supportedInterfaceOrientations.reduce(UIInterfaceOrientationMask()) { $0.union($1) }
     }
 
-    // TODO: FIX BECAUSE IT ALWAYS RETURNS PORTRAIT AND ITS BROKEN
     private func initInterfaceOrientation() -> Orientation {
-        let interfaceOrientation = utils.getInterfaceOrientation()
-        return utils.convertToOrientationFrom(uiInterfaceOrientation: interfaceOrientation)
+        return self.getOrientationFromInterface()
     }
 
     private func initDeviceOrientation() -> Orientation {
@@ -163,18 +161,8 @@ import UIKit
         if (deviceOrientation == Orientation.FACE_UP || deviceOrientation == Orientation.FACE_DOWN) {
             return
         }
-
-        let newInterfaceOrientationMask = utils.convertToMaskFrom(deviceOrientation: deviceOrientation)
-        let isSupported = self.supportedInterfaceOrientations.contains(newInterfaceOrientationMask)
-        if (!isSupported) {
-            return
-        }
-
-        let newInterfaceOrientation = utils.convertToOrientationFrom(mask: newInterfaceOrientationMask)
-        if (newInterfaceOrientation == lastInterfaceOrientation) {
-            return
-        }
-
+        
+        let newInterfaceOrientation = self.getOrientationFromInterface()
         updateLastInterfaceOrientationTo(value: newInterfaceOrientation)
     }
 
@@ -187,4 +175,9 @@ import UIKit
         self.eventManager.sendInterfaceOrientationDidChange(orientationValue: value.rawValue)
         lastInterfaceOrientation = value
     }
+    
+    private func getOrientationFromInterface() -> Orientation {
+        let interfaceOrientation = utils.getInterfaceOrientation()
+        return utils.convertToOrientationFrom(uiInterfaceOrientation: interfaceOrientation)
+    }
 }

package/ios/implementation/Utils.swift

@@ -55,19 +55,6 @@ class Utils {
         }
     }
 
-    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
@@ -87,25 +74,6 @@ class Utils {
         }
     }
 
-    /**
-     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