react-native-orientation-director 2.3.0 → 2.3.2

package/README.md

@@ -50,7 +50,11 @@ You can install the package like any other Expo package, using the following com
 npx expo install react-native-orientation-director
 ```
 
-Then, you need to add the plugin to your app.json file:
+## Setup
+
+### Expo
+
+Simply add the library plugin to your `app.json` file:
 
 ```json
 {
@@ -64,12 +68,44 @@ Then, you need to add the plugin to your app.json file:
 
 This way, Expo will handle the native setup for you during `prebuild`.
 
-## Setup
+> Note: only SDK 50 and above are supported, the plugin is configured to handle only the kotlin template.
+
+### Bare
+
+#### Android
+
+This library uses a custom broadcast receiver to handle the manual orientation changes: when the user disables the
+autorotation feature and the system prompts the user to rotate the device, the library will listen to the broadcast
+sent by the MainActivity and update the interface orientation accordingly.
+
+To allow the library to listen to the broadcast, you need to override the `onConfigurationChanged` method in your
+MainActivity file, as shown below:
+
+```kotlin
+override fun onConfigurationChanged(newConfig: Configuration) {
+    super.onConfigurationChanged(newConfig)
+
+    val orientationDirectorCustomAction =
+      "${packageName}.${ConfigurationChangedBroadcastReceiver.CUSTOM_INTENT_ACTION}"
+
+    val intent =
+      Intent(orientationDirectorCustomAction).apply {
+        putExtra("newConfig", newConfig)
+        setPackage(packageName)
+      }
+
+    this.sendBroadcast(intent)
+}
+```
+
+Nothing else is required for Android.
+
+#### iOS
 
 To properly handle interface orientation changes in iOS, you need to update your AppDelegate file. Since React Native
 0.77, the AppDelegate has been migrated to Swift, so see the instructions below for both Swift and Objective-C.
 
-### Objective-C
+##### Objective-C
 
 In your AppDelegate.h file, import "OrientationDirector.h" and implement supportedInterfaceOrientationsForWindow method as follows:
 
@@ -82,7 +118,7 @@ In your AppDelegate.h file, import "OrientationDirector.h" and implement support
 }
 ```
 
-### Swift
+##### Swift
 
 You need to create a [bridging header](https://developer.apple.com/documentation/swift/importing-objective-c-into-swift#Import-Code-Within-an-App-Target)
 to import the library, as shown below:
@@ -101,8 +137,6 @@ override func application(_ application: UIApplication, supportedInterfaceOrient
 
 If you need help, you can check the example project.
 
-There is no need to do anything in Android, it works out of the box.
-
 ## Usage
 
 This library exports a class called: [RNOrientationDirector](https://github.com/gladiuscode/react-native-orientation-director/blob/main/src/RNOrientationDirector.ts) that exposes the following methods:

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

@@ -0,0 +1,52 @@
+package com.orientationdirector.implementation
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.os.Build
+import com.facebook.react.bridge.ReactApplicationContext
+
+/**
+ * This custom broadcast receiver is needed to properly update the interface orientation when
+ * the user has disabled the automatic rotation.
+ *
+ * It listens for an explicit intent that the MainActivity can send in the onConfigurationChanged
+ * method and calls a custom callback that is set in the main implementation init
+ */
+class ConfigurationChangedBroadcastReceiver internal constructor(private val context: ReactApplicationContext) :
+  BroadcastReceiver() {
+
+  private var onReceiveCallback: ((intent: Intent?) -> Unit)? = null
+
+  override fun onReceive(context: Context?, intent: Intent?) {
+    this.onReceiveCallback?.invoke(intent)
+  }
+
+  fun setOnReceiveCallback(callback: (intent: Intent?) -> Unit) {
+    onReceiveCallback = callback
+  }
+
+  /**
+   * This method registers the receiver by checking the api we are currently running with.
+   * With the latest changes in Android 14, we need to explicitly set the `Context.RECEIVER_NOT_EXPORTED`
+   * flag.
+   */
+  fun register() {
+    val filter = IntentFilter("${context.packageName}.$CUSTOM_INTENT_ACTION")
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+      context.registerReceiver(this, filter, Context.RECEIVER_NOT_EXPORTED)
+    } else {
+      context.registerReceiver(this, filter)
+    }
+  }
+
+  fun unregister() {
+    context.unregisterReceiver(this)
+  }
+
+  companion object {
+    const val CUSTOM_INTENT_ACTION = "CONFIGURATION_CHANGED"
+  }
+}

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

@@ -15,6 +15,7 @@ class OrientationDirectorModuleImpl internal constructor(private val context: Re
     )
   )
   private var mLifecycleListener = LifecycleListener()
+  private var mBroadcastReceiver = ConfigurationChangedBroadcastReceiver(context)
 
   private var initialSupportedInterfaceOrientations = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
   private var lastInterfaceOrientation = Orientation.UNKNOWN
@@ -31,24 +32,31 @@ class OrientationDirectorModuleImpl internal constructor(private val context: Re
 
     mAutoRotationObserver.enable()
 
+    mBroadcastReceiver.setOnReceiveCallback {
+      adaptInterfaceTo(lastDeviceOrientation, false)
+    }
+
     context.addLifecycleEventListener(mLifecycleListener)
     mLifecycleListener.setOnHostResumeCallback {
       if (!didComputeInitialDeviceOrientation || areOrientationSensorsEnabled) {
         mOrientationSensorsEventListener.enable()
       }
       mAutoRotationObserver.enable()
+      mBroadcastReceiver.register()
     }
     mLifecycleListener.setOnHostPauseCallback {
       if (initialized && areOrientationSensorsEnabled) {
         mOrientationSensorsEventListener.disable()
         mAutoRotationObserver.disable()
       }
+      mBroadcastReceiver.unregister()
     }
     mLifecycleListener.setOnHostDestroyCallback {
       if (areOrientationSensorsEnabled) {
         mOrientationSensorsEventListener.disable()
         mAutoRotationObserver.disable()
       }
+      mBroadcastReceiver.unregister()
     }
 
     initialSupportedInterfaceOrientations =
@@ -89,15 +97,16 @@ class OrientationDirectorModuleImpl internal constructor(private val context: Re
       return
     }
 
-    val lastInterfaceOrientationIsAlreadyInLandscape = lastInterfaceOrientation == Orientation.LANDSCAPE_RIGHT
-      || lastInterfaceOrientation == Orientation.LANDSCAPE_LEFT
-      if (lastInterfaceOrientationIsAlreadyInLandscape) {
-        updateLastInterfaceOrientationTo(lastInterfaceOrientation)
-        return;
-      }
+    val lastInterfaceOrientationIsAlreadyInLandscape =
+      lastInterfaceOrientation == Orientation.LANDSCAPE_RIGHT
+        || lastInterfaceOrientation == Orientation.LANDSCAPE_LEFT
+    if (lastInterfaceOrientationIsAlreadyInLandscape) {
+      updateLastInterfaceOrientationTo(lastInterfaceOrientation)
+      return;
+    }
 
     val systemDefaultLandscapeOrientation = Orientation.LANDSCAPE_RIGHT
-      updateLastInterfaceOrientationTo(systemDefaultLandscapeOrientation)
+    updateLastInterfaceOrientationTo(systemDefaultLandscapeOrientation)
   }
 
   fun unlock() {
@@ -160,12 +169,13 @@ class OrientationDirectorModuleImpl internal constructor(private val context: Re
     }
   }
 
-  private fun adaptInterfaceTo(deviceOrientation: Orientation) {
-    if (!mAutoRotationObserver.getLastAutoRotationStatus()) {
+  private fun adaptInterfaceTo(deviceOrientation: Orientation, checkLastAutoRotationStatus: Boolean = true) {
+    if (checkLastAutoRotationStatus && !mAutoRotationObserver.getLastAutoRotationStatus()) {
       return
     }
 
-    val supportsLandscape = mUtils.getRequestedOrientation() == ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE;
+    val supportsLandscape =
+      mUtils.getRequestedOrientation() == ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE;
     if (isLocked && !supportsLandscape) {
       return
     }
@@ -191,8 +201,9 @@ class OrientationDirectorModuleImpl internal constructor(private val context: Re
      * Instead, we check that its value is either LANDSCAPE_RIGHT or LANDSCAPE_LEFT, otherwise we
      * exit
      */
-    val newInterfaceOrientationIsNotLandscape = newInterfaceOrientation != Orientation.LANDSCAPE_RIGHT
-      && newInterfaceOrientation != Orientation.LANDSCAPE_LEFT;
+    val newInterfaceOrientationIsNotLandscape =
+      newInterfaceOrientation != Orientation.LANDSCAPE_RIGHT
+        && newInterfaceOrientation != Orientation.LANDSCAPE_LEFT;
     if (supportsLandscape && newInterfaceOrientationIsNotLandscape) {
       return
     }

package/lib/typescript/plugin/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../plugin/src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EAGlB,MAAM,sBAAsB,CAAC;;AAyB9B,wBAIE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../plugin/src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EAGlB,MAAM,sBAAsB,CAAC;;AA2B9B,wBAIE"}

package/lib/typescript/plugin/src/withRNOrientationMainActivity.d.ts

@@ -0,0 +1,4 @@
+import { type ConfigPlugin } from '@expo/config-plugins';
+export declare const withRNOrientationMainActivity: ConfigPlugin;
+export declare function ktFileUpdater(originalContents: string): string;
+//# sourceMappingURL=withRNOrientationMainActivity.d.ts.map

package/lib/typescript/plugin/src/withRNOrientationMainActivity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withRNOrientationMainActivity.d.ts","sourceRoot":"","sources":["../../../../plugin/src/withRNOrientationMainActivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EAGlB,MAAM,sBAAsB,CAAC;AAI9B,eAAO,MAAM,6BAA6B,EAAE,YAE3C,CAAC;AA0BF,wBAAgB,aAAa,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,CA8C9D"}

package/package.json

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

package/plugin/build/index.js

@@ -4,6 +4,7 @@ const config_plugins_1 = require("@expo/config-plugins");
 const withBridgingHeader_1 = require("./custom-mod/withBridgingHeader");
 const withRNOrientationAppDelegate_1 = require("./withRNOrientationAppDelegate");
 const withRNOrientationBridgingHeader_1 = require("./withRNOrientationBridgingHeader");
+const withRNOrientationMainActivity_1 = require("./withRNOrientationMainActivity");
 /**
  * So, expo config plugin are awesome and the documentation is well written, but I still needed to look around to see
  * how other projects actually modify the AppDelegate. I've found react-native-firebase to implement a plugin config
@@ -18,6 +19,7 @@ const withRNOrientationDirector = (config) => {
     return (0, config_plugins_1.withPlugins)(config, [
         withRNOrientationAppDelegate_1.withRNOrientationAppDelegate,
         withRNOrientationBridgingHeader_1.withRNOrientationBridgingHeader,
+        withRNOrientationMainActivity_1.withRNOrientationMainActivity,
         withBridgingHeader_1.withAppBridgingHeaderMod,
     ]);
 };

package/plugin/build/withRNOrientationMainActivity.d.ts

@@ -0,0 +1,3 @@
+import { type ConfigPlugin } from '@expo/config-plugins';
+export declare const withRNOrientationMainActivity: ConfigPlugin;
+export declare function ktFileUpdater(originalContents: string): string;

package/plugin/build/withRNOrientationMainActivity.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withRNOrientationMainActivity = void 0;
+exports.ktFileUpdater = ktFileUpdater;
+const config_plugins_1 = require("@expo/config-plugins");
+const generateCode_1 = require("@expo/config-plugins/build/utils/generateCode");
+const withRNOrientationMainActivity = (config) => {
+    return (0, config_plugins_1.withMainActivity)(config, readMainActivityFileAndUpdateContents);
+};
+exports.withRNOrientationMainActivity = withRNOrientationMainActivity;
+async function readMainActivityFileAndUpdateContents(config) {
+    const { modResults: mainActivityFile } = config;
+    const worker = getCompatibleFileUpdater(mainActivityFile.language);
+    mainActivityFile.contents = worker(mainActivityFile.contents);
+    return config;
+}
+function getCompatibleFileUpdater(language) {
+    switch (language) {
+        case 'kt':
+            return ktFileUpdater;
+        default:
+            throw new Error(`Cannot add React Native Orientation Director code to MainActivity of language "${language}"`);
+    }
+}
+function ktFileUpdater(originalContents) {
+    const systemImportsContents = updateContentsWithSystemImports(originalContents);
+    const libraryImportCodeBlock = 'import com.orientationdirector.implementation.ConfigurationChangedBroadcastReceiver';
+    const rightBeforeClassDeclaration = /class MainActivity/g;
+    const importMergeResults = (0, generateCode_1.mergeContents)({
+        tag: '@react-native-orientation-director/library-import',
+        src: systemImportsContents,
+        newSrc: libraryImportCodeBlock,
+        anchor: rightBeforeClassDeclaration,
+        offset: 0,
+        comment: '// React Native Orientation Director',
+    });
+    const onConfigurationChangedCodeBlock = `
+  override fun onConfigurationChanged(newConfig: Configuration) {
+    super.onConfigurationChanged(newConfig)
+
+    val orientationDirectorCustomAction =
+      packageName + "." + ConfigurationChangedBroadcastReceiver.CUSTOM_INTENT_ACTION
+
+    val intent =
+      Intent(orientationDirectorCustomAction).apply {
+        putExtra("newConfig", newConfig)
+        setPackage(packageName)
+      }
+
+    this.sendBroadcast(intent)
+  }\n`;
+    const rightBeforeLastClosingBrace = /super\.onCreate/g;
+    const pasteInTheListJustAfterTheClosingBracket = 2;
+    const implementationMergeResults = (0, generateCode_1.mergeContents)({
+        tag: '@react-native-orientation-director/supportedInterfaceOrientationsFor-implementation',
+        src: importMergeResults.contents,
+        newSrc: onConfigurationChangedCodeBlock,
+        anchor: rightBeforeLastClosingBrace,
+        offset: pasteInTheListJustAfterTheClosingBracket,
+        comment: '// React Native Orientation Director',
+    });
+    return implementationMergeResults.contents;
+}
+function updateContentsWithSystemImports(originalContents) {
+    const rightBeforeClassDeclaration = /class MainActivity/g;
+    let possibleUpdatedContents = originalContents;
+    possibleUpdatedContents = addIntentImportIfNecessary(possibleUpdatedContents);
+    possibleUpdatedContents = addConfigurationImportIfNecessary(possibleUpdatedContents);
+    return possibleUpdatedContents;
+    function addIntentImportIfNecessary(_contents) {
+        const systemIntentImportCodeBlock = 'import android.content.Intent';
+        if (_contents.includes(systemIntentImportCodeBlock)) {
+            return _contents;
+        }
+        const mergeResults = (0, generateCode_1.mergeContents)({
+            tag: '@react-native-orientation-director/system-intent-import',
+            src: _contents,
+            newSrc: systemIntentImportCodeBlock,
+            anchor: rightBeforeClassDeclaration,
+            offset: 0,
+            comment: '// React Native Orientation Director',
+        });
+        return mergeResults.contents;
+    }
+    function addConfigurationImportIfNecessary(_contents) {
+        const systemConfigurationImportCodeBlock = 'import android.content.res.Configuration';
+        if (possibleUpdatedContents.includes(systemConfigurationImportCodeBlock)) {
+            return _contents;
+        }
+        const mergeResults = (0, generateCode_1.mergeContents)({
+            tag: '@react-native-orientation-director/system-configuration-import',
+            src: possibleUpdatedContents,
+            newSrc: systemConfigurationImportCodeBlock,
+            anchor: rightBeforeClassDeclaration,
+            offset: 0,
+            comment: '// React Native Orientation Director',
+        });
+        return mergeResults.contents;
+    }
+}