react-native-orientation-director 1.2.3 → 2.0.0

package/src/EventEmitter.ts

@@ -0,0 +1,70 @@
+import { Platform, type EmitterSubscription } from 'react-native';
+import Module, { ModuleEventEmitter } from './module';
+import Event from './types/Event.enum';
+import type { OrientationEvent } from './types/OrientationEvent.interface';
+import type { LockedEvent } from './types/LockedEvent.interface';
+
+class EventEmitter {
+  static addDeviceOrientationDidChangeListener(
+    callback: (orientation: OrientationEvent) => void
+  ) {
+    let listener = ModuleEventEmitter.addListener(
+      Event.DeviceOrientationDidChange,
+      callback
+    );
+
+    if (Platform.OS !== 'android') {
+      return listener;
+    }
+
+    const listenerCount = ModuleEventEmitter.listenerCount(
+      Event.DeviceOrientationDidChange
+    );
+
+    if (listenerCount === 1) {
+      Module.enableOrientationSensors();
+    }
+
+    return EventEmitter.createDeviceOrientationListenerProxy(listener);
+  }
+
+  static addInterfaceOrientationDidChangeListener(
+    callback: (orientation: OrientationEvent) => void
+  ) {
+    return ModuleEventEmitter.addListener(
+      Event.InterfaceOrientationDidChange,
+      callback
+    );
+  }
+
+  static addLockDidChangeListener(callback: (event: LockedEvent) => void) {
+    return ModuleEventEmitter.addListener(Event.LockDidChange, callback);
+  }
+
+  private static createDeviceOrientationListenerProxy(
+    listener: EmitterSubscription
+  ) {
+    const handler: ProxyHandler<EmitterSubscription> = {
+      get(target, propertyKey, receiver) {
+        if (propertyKey === 'remove') {
+          disableOrientationSensorsIfLastListener();
+        }
+        return Reflect.get(target, propertyKey, receiver);
+      },
+    };
+
+    return new Proxy(listener, handler);
+
+    function disableOrientationSensorsIfLastListener() {
+      const listenerCount = ModuleEventEmitter.listenerCount(
+        Event.DeviceOrientationDidChange
+      );
+
+      if (listenerCount === 1) {
+        Module.disableOrientationSensors();
+      }
+    }
+  }
+}
+
+export default EventEmitter;

package/src/NativeOrientationDirector.ts

@@ -7,9 +7,20 @@ export interface Spec extends TurboModule {
   lockTo(orientation: number): void;
   unlock(): void;
   isLocked(): boolean;
-  isAutoRotationEnabled(): boolean;
   resetSupportedInterfaceOrientations(): void;
 
+  ////////////////////////////////////
+  //
+  // ANDROID ONLY
+  //
+
+  isAutoRotationEnabled(): boolean;
+  enableOrientationSensors(): void;
+  disableOrientationSensors(): void;
+
+  //
+  ////////////////////////////////////
+
   addListener: (eventType: string) => void;
   removeListeners: (count: number) => void;
 }

package/src/RNOrientationDirector.ts

@@ -1,15 +1,16 @@
 import { Platform } from 'react-native';
-import Module, { EventEmitter } from './module';
-import Event from './types/Event.enum';
-import type { InterfaceOrientationToLocalizedStringProvider } from './types/InterfaceOrientationToLocalizedStringProvider.type';
+import Module from './module';
+import type { HumanReadableOrientationsResource } from './types/HumanReadableOrientationsResource.type';
 import { Orientation } from './types/Orientation.enum';
 import { AutoRotation } from './types/AutoRotation.enum';
 import type { OrientationEvent } from './types/OrientationEvent.interface';
 import type { LockableOrientation } from './types/LockableOrientation.type';
 import type { LockedEvent } from './types/LockedEvent.interface';
+import type { HumanReadableAutoRotationsResource } from './types/HumanReadableAutoRotationsResource.type';
+import EventEmitter from './EventEmitter';
 
 class RNOrientationDirector {
-  private static _localizedStringProvider: InterfaceOrientationToLocalizedStringProvider =
+  private static _humanReadableOrientationsResource: HumanReadableOrientationsResource =
     {
       [Orientation.unknown]: 'Unknown',
       [Orientation.portrait]: 'Portrait',
@@ -20,10 +21,19 @@ class RNOrientationDirector {
       [Orientation.faceDown]: 'Face Down',
     };
 
-  setLocalizedStringProvider(
-    provider: InterfaceOrientationToLocalizedStringProvider
-  ) {
-    RNOrientationDirector._localizedStringProvider = provider;
+  private static _humanReadableAutoRotationsResource: HumanReadableAutoRotationsResource =
+    {
+      [AutoRotation.unknown]: 'Unknown',
+      [AutoRotation.enabled]: 'Enabled',
+      [AutoRotation.disabled]: 'Disabled',
+    };
+
+  setHumanReadableOrientations(resource: HumanReadableOrientationsResource) {
+    RNOrientationDirector._humanReadableOrientationsResource = resource;
+  }
+
+  setHumanReadableAutoRotations(resource: HumanReadableAutoRotationsResource) {
+    RNOrientationDirector._humanReadableAutoRotationsResource = resource;
   }
 
   static getInterfaceOrientation(): Promise<Orientation> {
@@ -46,7 +56,7 @@ class RNOrientationDirector {
     return Module.isLocked();
   }
 
-  static isAutoRotationEnabled(): AutoRotation {
+  static isAutoRotationEnabled() {
     if (Platform.OS !== 'android') {
       return AutoRotation.unknown;
     }
@@ -55,33 +65,36 @@ class RNOrientationDirector {
       : AutoRotation.disabled;
   }
 
-  static resetSupportedInterfaceOrientations(): void {
+  static resetSupportedInterfaceOrientations() {
     Module.resetSupportedInterfaceOrientations();
   }
 
   static listenForDeviceOrientationChanges(
     callback: (orientation: OrientationEvent) => void
   ) {
-    return EventEmitter.addListener(Event.DeviceOrientationDidChange, callback);
+    return EventEmitter.addDeviceOrientationDidChangeListener(callback);
   }
 
   static listenForInterfaceOrientationChanges(
     callback: (orientation: OrientationEvent) => void
   ) {
-    return EventEmitter.addListener(
-      Event.InterfaceOrientationDidChange,
-      callback
-    );
+    return EventEmitter.addInterfaceOrientationDidChangeListener(callback);
+  }
+
+  static listenForLockChanges(callback: (event: LockedEvent) => void) {
+    return EventEmitter.addLockDidChangeListener(callback);
   }
 
-  static listenForLockChanges(callback: (orientation: LockedEvent) => void) {
-    return EventEmitter.addListener(Event.LockDidChange, callback);
+  static convertOrientationToHumanReadableString(orientation: Orientation) {
+    return RNOrientationDirector._humanReadableOrientationsResource[
+      orientation
+    ];
   }
 
-  static convertOrientationToHumanReadableString(
-    orientation: Orientation
-  ): string {
-    return RNOrientationDirector._localizedStringProvider[orientation];
+  static convertAutoRotationToHumanReadableString(autoRotation: AutoRotation) {
+    return RNOrientationDirector._humanReadableAutoRotationsResource[
+      autoRotation
+    ];
   }
 }
 

package/src/module.ts

@@ -25,6 +25,6 @@ const OrientationDirectorModule = Module
       }
     );
 
-export const EventEmitter = new NativeEventEmitter(Module);
+export const ModuleEventEmitter = new NativeEventEmitter(Module);
 
 export default OrientationDirectorModule as Spec;

package/src/types/HumanReadableAutoRotationsResource.type.ts

@@ -0,0 +1,3 @@
+import type { AutoRotation } from './AutoRotation.enum';
+
+export type HumanReadableAutoRotationsResource = Record<AutoRotation, string>;

package/src/types/HumanReadableOrientationsResource.type.ts

@@ -0,0 +1,3 @@
+import type { Orientation } from './Orientation.enum';
+
+export type HumanReadableOrientationsResource = Record<Orientation, string>;

package/src/types/Orientation.enum.ts

@@ -4,8 +4,6 @@ export enum Orientation {
   landscapeRight = 2,
   portraitUpsideDown = 3,
   landscapeLeft = 4,
-
-  // iOS only
   faceUp = 5,
   faceDown = 6,
 }

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

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

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

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

package/android/src/newarch/OrientationDirectorSpec.kt

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

package/android/src/oldarch/OrientationDirectorSpec.kt

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

package/lib/commonjs/types/InterfaceOrientationToLocalizedStringProvider.type.js.map

@@ -1 +0,0 @@
-{"version":3,"names":[],"sourceRoot":"../../../src","sources":["types/InterfaceOrientationToLocalizedStringProvider.type.ts"],"mappings":"","ignoreList":[]}

package/lib/module/types/InterfaceOrientationToLocalizedStringProvider.type.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=InterfaceOrientationToLocalizedStringProvider.type.js.map

package/lib/module/types/InterfaceOrientationToLocalizedStringProvider.type.js.map

@@ -1 +0,0 @@
-{"version":3,"names":[],"sourceRoot":"../../../src","sources":["types/InterfaceOrientationToLocalizedStringProvider.type.ts"],"mappings":"","ignoreList":[]}

package/lib/typescript/src/types/InterfaceOrientationToLocalizedStringProvider.type.d.ts

@@ -1,3 +0,0 @@
-import type { Orientation } from './Orientation.enum';
-export type InterfaceOrientationToLocalizedStringProvider = Record<Orientation, string>;
-//# sourceMappingURL=InterfaceOrientationToLocalizedStringProvider.type.d.ts.map

package/lib/typescript/src/types/InterfaceOrientationToLocalizedStringProvider.type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"InterfaceOrientationToLocalizedStringProvider.type.d.ts","sourceRoot":"","sources":["../../../../src/types/InterfaceOrientationToLocalizedStringProvider.type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEtD,MAAM,MAAM,6CAA6C,GAAG,MAAM,CAChE,WAAW,EACX,MAAM,CACP,CAAC"}

package/src/types/InterfaceOrientationToLocalizedStringProvider.type.ts

@@ -1,6 +0,0 @@
-import type { Orientation } from './Orientation.enum';
-
-export type InterfaceOrientationToLocalizedStringProvider = Record<
-  Orientation,
-  string
->;