react-native-orientation-director 2.6.4 → 3.0.0

package/android/gradle.properties

@@ -1,17 +0,0 @@
-OrientationDirector_kotlinVersion=2.0.21
-OrientationDirector_minSdkVersion=24
-OrientationDirector_targetSdkVersion=34
-OrientationDirector_compileSdkVersion=35
-OrientationDirector_ndkVersion=27.1.12297006
-
-#########################
-#   TESTING
-#
-
-OrientationDirector_junitVersion=4.13.2
-OrientationDirector_androidXCoreVersion=1.5.+
-OrientationDirector_robolectricVersion=4.13
-OrientationDirector_mockitoCoreVersion=5.14.2
-
-#
-#########################

package/android/src/main/AndroidManifestNew.xml

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

package/android/src/oldarch/OrientationDirectorModule.kt

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

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

@@ -1,199 +0,0 @@
-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_interface_orientation_matches_locked_to_landscape() {
-    mModule.lockTo(5)
-
-    assertEquals(
-      "When the interface is locked to landscape, getInterfaceOrientation should return landscape right",
-      Orientation.LANDSCAPE_RIGHT,
-      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

@@ -1,314 +0,0 @@
-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/react-native-orientation-director-Bridging-Header.h

@@ -1,6 +0,0 @@
-//
-//  Use this file to import your target's public headers that you would like to expose to Swift.
-//
-
-#import "React/RCTBridgeModule.h"
-#import "React/RCTEventEmitter.h"

package/lib/commonjs/EventEmitter.js

@@ -1,48 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _reactNative = require("react-native");
-var _module = _interopRequireWildcard(require("./module.js"));
-var _EventEnum = _interopRequireDefault(require("./types/Event.enum.js"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
-class EventEmitter {
-  static addDeviceOrientationDidChangeListener(callback) {
-    let listener = _module.ModuleEventEmitter.addListener(_EventEnum.default.DeviceOrientationDidChange, callback);
-    if (_reactNative.Platform.OS !== 'android') {
-      return listener;
-    }
-    const listenerCount = _module.ModuleEventEmitter.listenerCount(_EventEnum.default.DeviceOrientationDidChange);
-    if (listenerCount === 1) {
-      _module.default.enableOrientationSensors();
-    }
-    return EventEmitter.createDeviceOrientationListenerProxy(listener);
-  }
-  static addInterfaceOrientationDidChangeListener(callback) {
-    return _module.ModuleEventEmitter.addListener(_EventEnum.default.InterfaceOrientationDidChange, callback);
-  }
-  static addLockDidChangeListener(callback) {
-    return _module.ModuleEventEmitter.addListener(_EventEnum.default.LockDidChange, callback);
-  }
-  static createDeviceOrientationListenerProxy(listener) {
-    const handler = {
-      get(target, propertyKey, receiver) {
-        if (propertyKey === 'remove') {
-          disableOrientationSensorsIfLastListener();
-        }
-        return Reflect.get(target, propertyKey, receiver);
-      }
-    };
-    return new Proxy(listener, handler);
-    function disableOrientationSensorsIfLastListener() {
-      const listenerCount = _module.ModuleEventEmitter.listenerCount(_EventEnum.default.DeviceOrientationDidChange);
-      if (listenerCount === 1) {
-        _module.default.disableOrientationSensors();
-      }
-    }
-  }
-}
-var _default = exports.default = EventEmitter;

package/lib/commonjs/NativeOrientationDirector.js

@@ -1,8 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _reactNative = require("react-native");
-var _default = exports.default = _reactNative.TurboModuleRegistry.getEnforcing('OrientationDirector');