react-native-mapp-plugin 1.4.2 → 2.0.0

package/BREAKING_CHANGES.md

@@ -0,0 +1,126 @@
+# Breaking changes in 2.0.0
+
+Version 2.0.0 is largely source-compatible with 1.4.2, but it is not fully backward-compatible at the platform and behavioral levels. Not every client will need application code changes.
+
+No documented JavaScript method was removed or renamed, and existing method parameters remain unchanged. The major version is required because some existing builds, native integrations, and runtime assumptions can break—most notably the increased minimum iOS version.
+
+## Changes that may affect 1.4.2 clients
+
+### Minimum iOS deployment target
+
+The minimum supported iOS deployment target is now 15.1 instead of 10.0.
+
+Applications targeting an older iOS version cannot install or build the pod until their deployment target is raised to iOS 15.1 or newer. This platform-support removal is a breaking change even when the application does not need JavaScript changes.
+
+### Android dependency resolution
+
+The plugin exports strict compatibility constraints for the supported Mapp Engage 7.1.2 and Expo SDK 57 runtime:
+
+- Kotlin 2.1.20
+- Coroutines 1.11.0
+- AndroidX Core 1.18.0
+- WorkManager 2.10.5
+- Lifecycle 2.10.0
+- Play Services Location 21.3.0
+
+Gradle may fail dependency resolution when an application explicitly requires incompatible versions. Applications already resolving compatible versions do not need a change.
+
+### Custom Android Firebase handling
+
+The plugin removes the Mapp SDK Firebase service and uses `com.reactlibrary.MessageService` as the default Mapp push owner.
+
+Applications that use the default plugin service do not need to migrate their Firebase callbacks. Applications that own a custom `FirebaseMessagingService` must select custom push ownership and forward callbacks through the native helper:
+
+```java
+@Override
+public void onMessageReceived(RemoteMessage message) {
+    if (!MappPushHelper.handleMessage(getApplication(), message)) {
+        // Handle non-Mapp messages.
+    }
+}
+
+@Override
+public void onNewToken(String token) {
+    MappPushHelper.handleNewToken(getApplication(), token);
+}
+```
+
+For Expo, set `android.pushHandling` to `"custom"`. Successful manifest merging alone does not forward messages to Mapp.
+
+### Geofence permission behavior
+
+In 1.4.2, `Mapp.requestGeofenceLocationPermission()` only checked the current Android permission state. In 2.0.0, it requests foreground location and then background location when required, which can display system dialogs.
+
+Call this method from an appropriate user interaction and only after explaining why the application needs location access.
+
+### Firebase token failure handling
+
+On Android, `Mapp.getToken()` now rejects with `FCM_REGISTRATION_FAILED` when Firebase token registration fails. In 1.4.2, reading the failed Firebase task result could crash.
+
+Consumers awaiting the token should handle rejection:
+
+```js
+try {
+  const token = await Mapp.getToken();
+} catch (error) {
+  // Handle unavailable FCM registration.
+}
+```
+
+On iOS, `Mapp.getToken()` rejects with `APNS_TOKEN_UNAVAILABLE` because Mapp auto-integration owns the native APNs token.
+
+### Inbox status methods now update Mapp
+
+The following Android methods were no-ops in 1.4.2:
+
+```js
+Mapp.inAppMarkAsRead(templateId, eventId);
+Mapp.inAppMarkAsUnRead(templateId, eventId);
+Mapp.inAppMarkAsDeleted(templateId, eventId);
+```
+
+In 2.0.0, they call Mapp Engage 7.1.2 to fetch the inbox message and update its real server-side status to `READ`, `UNREAD`, or `DELETED`. This is the intended behavior, but it introduces an observable network and backend side effect.
+
+The legacy `eventId` argument remains accepted for source compatibility. Mapp Engage 7.1.2 identifies the message using `templateId`.
+
+### Undocumented iOS native methods
+
+Applications directly calling these undocumented bridge methods will break because they are no longer exported separately:
+
+```js
+NativeModules.RNMappPluginModule.autoengage(...);
+NativeModules.RNMappPluginModule.engageInapp(...);
+```
+
+Use the documented public method instead:
+
+```js
+Mapp.engage(sdkKey, googleProjectId, server, appId, tenantId);
+```
+
+On iOS, `Mapp.engage(...)` still initializes push and in-app functionality. `AppoxeeConfig.plist` is the credential source of truth.
+
+## Changes that are not immediate breaks
+
+- `Mapp.engage2()` remains available but is deprecated in favor of `Mapp.engage(...)`.
+- `Mapp.startGeoFencing()` remains available but is deprecated in favor of `Mapp.startGeofencing()`.
+- `Mapp.stopGeoFencing()` remains available but is deprecated in favor of `Mapp.stopGeofencing()`.
+- `Mapp.setRemoteMessage()`, `Mapp.isPushFromMapp()`, and `Mapp.setToken()` remain supported while JavaScript is guaranteed to be running. Use `MappPushHelper` instead for native background or terminated Firebase callbacks.
+- Android minimum SDK remains 24.
+- React Native peer requirement remains `>=0.84`.
+- Node.js requirement remains `>=20.19.4`.
+
+## Who can upgrade without source changes?
+
+An application may not need source changes when all of the following are true:
+
+- Its iOS deployment target is already 15.1 or newer.
+- Its Android dependencies do not conflict with the exported constraints.
+- It uses the plugin's default Android Mapp push service instead of a custom `FirebaseMessagingService`.
+- It already handles promise rejection from `Mapp.getToken()`.
+- It expects inbox status methods to update the real Mapp message status.
+- It does not call undocumented native bridge methods directly.
+
+Even in that case, test push delivery, permission prompts, and inbox status changes on physical devices before releasing the upgrade.
+
+For concrete upgrade steps and replacement examples, continue with the [1.4.2 to 2.0.0 migration guide](MIGRATION_2.0.md).

package/CHANGELOG.md

@@ -1,3 +1,28 @@
+## Version 2.0.0 (unreleased)
+
+***Breaking Changes***
+
+- Raised the minimum iOS deployment target from 10.0 to 15.1.
+- Exported strict Android compatibility constraints for the supported Expo SDK 57 toolchain and Mapp Engage 7.1.2 runtime ABI.
+- Changed Android geofence permission handling, FCM service ownership, and inbox status updates.
+- Deprecated `engage2()`, `startGeoFencing()`, and `stopGeoFencing()` in favor of their supported replacements.
+- Review the [breaking changes](BREAKING_CHANGES.md), then follow the [1.4.2 to 2.0.0 migration guide](MIGRATION_2.0.md) for required application changes.
+
+***Bug Fixes***
+
+- Android: Failed Firebase token registration now rejects with `FCM_REGISTRATION_FAILED` instead of crashing while reading a failed task result.
+- Android: All Mapp engage calls run on the main looper. Background Firebase callbacks wait for a bounded engage attempt and safely return failure after SDK errors, timeout, or interruption.
+- Android/Expo: Mapp and custom push ownership now remove the SDK v7 Firebase service and remain idempotent when prebuild runs repeatedly or changes mode.
+- Android/Expo: The config plugin now writes required permissions, the Mapp messaging service, and the push receiver through `withAndroidManifest`; Firebase configuration remains customer-owned through `expo.android.googleServicesFile`.
+- Android: Exported Expo SDK 57 compatibility constraints stabilize WorkManager, Lifecycle, AndroidX Core, Play Services Location, and Kotlin stdlib for API 36/AGP 8.12/Kotlin 2.1.20 builds.
+- Android: Coroutines remain aligned at 1.11.0 to preserve the Mapp 7.1.2 native in-app dismissal ABI.
+- iOS/Expo: The config plugin now creates and embeds a standalone Notification Service Extension for Mapp rich-push media from `ios_apx_media`, with EAS app-extension metadata and no App Group or extra Pod.
+- iOS/Expo: Verified that Expo SDK 57 CocoaPods autolinking discovers `RNMappPlugin.podspec` and processes `RNMappPlugin` under the New Architecture.
+
+***Compatibility***
+
+- Verified baseline: Expo SDK 57, React Native 0.86, New Architecture, Android API 36, AGP 8.12, Kotlin 2.1.20, and JDK 21.
+
 ## Version 1.4.2
 
 ***Dependency Updates***

package/MIGRATION_2.0.md

@@ -0,0 +1,100 @@
+# Migrating from 1.4.2 to 2.0.0
+
+This guide covers upgrading from the latest published 1.4.x release, 1.4.2. The public JavaScript method names and signatures remain available, but 2.0.0 changes platform requirements, Android dependency resolution, push ownership, and the behavior of several existing methods.
+
+Read [Breaking changes in 2.0.0](BREAKING_CHANGES.md) first to determine which changes affect your application.
+
+## Migration checklist
+
+1. Raise the application deployment target to iOS 15.1 or newer.
+2. Use JDK 21 for the supported Android build baseline and remove dependency pins that conflict with the versions below.
+3. If using Expo, configure the plugin and replace Expo Go with a development build.
+4. Review calls to geofence permission and token APIs for their new prompt and rejection behavior.
+5. If the application owns a `FirebaseMessagingService`, forward messages and tokens through `MappPushHelper`.
+6. Replace deprecated methods using the migration table below.
+7. Verify Android inbox read, unread, and deleted operations against a real Mapp message.
+
+## Platform and build requirements
+
+- The minimum iOS deployment target is now 15.1 instead of 10.0. Applications targeting an older iOS version must raise their deployment target before installing 2.0.0.
+- Android still requires a minimum SDK of 24, but the plugin exports strict compatibility constraints for Kotlin 2.1.20, coroutines 1.11.0, AndroidX Core 1.18.0, WorkManager 2.10.5, Lifecycle 2.10.0, and Play Services Location 21.3.0. Remove conflicting application-level pins or align them with these versions.
+- JDK 21 is the supported Android build JDK for the tested Expo SDK 57, AGP 8.12, and API 36 baseline.
+- Expo Go is not supported. Expo applications must use CNG with `expo-dev-client` and create a new native build after changing plugin options.
+
+## Existing methods with changed behavior
+
+| Method | 1.4.2 behavior | 2.0.0 behavior and migration impact |
+| --- | --- | --- |
+| `Mapp.requestGeofenceLocationPermission()` | Android only checked whether permissions had already been granted. | Android now displays the foreground-location request and then the background-location request when needed. Call it from an appropriate user action and expect system dialogs. iOS now has a New Architecture implementation as well. |
+| `Mapp.getToken()` | A failed Android Firebase task could crash while its result was read. The iOS implementation was missing. | Android rejects with `FCM_REGISTRATION_FAILED`; consumers must handle promise rejection. iOS rejects with `APNS_TOKEN_UNAVAILABLE` because Mapp auto-integration owns the APNs token. |
+| `Mapp.setToken(token)` | The iOS bridge did not settle the declared promise. | iOS resolves `true` for a base64-encoded native APNs token and rejects with `INVALID_APNS_TOKEN` for invalid input. An Expo push token is not a native APNs token. |
+| `Mapp.inAppMarkAsRead(templateId, eventId)` | Android no-op. | Android fetches the Mapp Engage 7.1.2 inbox message and updates it to `READ`. |
+| `Mapp.inAppMarkAsUnRead(templateId, eventId)` | Android no-op. | Android fetches the inbox message and updates it to `UNREAD`. |
+| `Mapp.inAppMarkAsDeleted(templateId, eventId)` | Android no-op. | Android fetches the inbox message and updates it to `DELETED`. |
+| `Mapp.engage(...)` | iOS JavaScript called the private native `autoengage` and `engageInapp` methods separately. | All platforms use the public native `engage` entry point. On iOS it still initializes both push and in-app, using `AppoxeeConfig.plist` as the credential source of truth. |
+| iOS event listeners | Events emitted before a JavaScript listener was attached were dropped. | Up to 50 cold-start events are buffered and delivered after a listener attaches. Consumers should tolerate receiving an initial queued event. |
+
+For the Android inbox methods, `eventId` remains accepted for source compatibility but Mapp Engage 7.1.2 identifies and fetches the message using `templateId`.
+
+## Deprecated methods and replacements
+
+| Deprecated method | Replacement |
+| --- | --- |
+| `Mapp.engage2()` | `Mapp.engage(sdkKey, googleProjectId, server, appId, tenantId)` |
+| `Mapp.startGeoFencing()` | `await Mapp.startGeofencing()` |
+| `Mapp.stopGeoFencing()` | `await Mapp.stopGeofencing()` |
+| Direct `NativeModules.RNMappPluginModule.autoengage(...)` or `engageInapp(...)` calls | `Mapp.engage(...)` |
+
+The direct `autoengage` and `engageInapp` bridge methods were never part of the documented JavaScript API and are no longer exported separately.
+
+## New Android native push API
+
+Applications that own a custom `FirebaseMessagingService` can now use `com.reactlibrary.MappPushHelper`. These methods run without a React Native JavaScript runtime and replace JavaScript forwarding from background or terminated callbacks:
+
+| New method | Purpose | Replaces in a native Firebase service |
+| --- | --- | --- |
+| `MappPushHelper.initialize(application)` | Safely engages Mapp on the main looper and waits for the bounded initialization attempt. | Direct background calls to `Appoxee.engage(...)`. |
+| `MappPushHelper.isMappMessage(remoteMessage)` | Returns whether a native `RemoteMessage` belongs to Mapp. | Converting the message to JSON and calling `Mapp.isPushFromMapp(...)`. |
+| `MappPushHelper.handleMessage(application, remoteMessage)` | Initializes Mapp when needed and forwards a Mapp message. It returns `true` only when the message was handled by Mapp. | `Mapp.setRemoteMessage(...)` for background and terminated delivery. |
+| `MappPushHelper.handleNewToken(application, token)` | Initializes Mapp when needed and forwards a new FCM token. | Calling `Mapp.setToken(...)` from a Firebase token callback. |
+| `MappPushHelper.waitUntilReady()` | Waits for the already-engaged SDK to become ready for a bounded period. | Application-owned polling of `Mapp.isReady()`. |
+
+`Mapp.setRemoteMessage(...)`, `Mapp.isPushFromMapp(...)`, and `Mapp.setToken(...)` remain supported when JavaScript is guaranteed to be running. They are not reliable replacements for native Firebase callbacks while the application is backgrounded or terminated.
+
+## Expo configuration
+
+Add the package to the Expo `plugins` array and supply the required iOS Mapp values. The default Android `pushHandling` mode is `"mapp"` and requires `expo.android.googleServicesFile`.
+
+Use `pushHandling: "custom"` when the application or another library owns Firebase callbacks. The config plugin then removes both the plugin and Mapp SDK messaging services so the application service is the sole owner.
+
+See the [Expo configuration example](README.md#expo-cng) for all options.
+
+## Native Android push migration example
+
+```java
+import com.google.firebase.messaging.FirebaseMessagingService;
+import com.google.firebase.messaging.RemoteMessage;
+import com.reactlibrary.MappPushHelper;
+
+public final class ApplicationMessagingService extends FirebaseMessagingService {
+    @Override
+    public void onMessageReceived(RemoteMessage message) {
+        if (!MappPushHelper.handleMessage(getApplication(), message)) {
+            // Handle non-Mapp messages.
+        }
+    }
+
+    @Override
+    public void onNewToken(String token) {
+        MappPushHelper.handleNewToken(getApplication(), token);
+    }
+}
+```
+
+For Expo, rebuild the native projects after changing the plugin configuration:
+
+```bash
+npx expo prebuild --clean
+npx expo run:android
+npx expo run:ios
+```

package/Mapp.js

@@ -108,11 +108,8 @@ export class Mapp {
   }
 
   /**
-   * Engage
-   *
-   * @return {Promise.<string>} A promise with the result.
+   * @deprecated Use engage(sdkKey, googleProjectId, server, appID, tenantID).
    */
-
   static engage2() {
     if (Platform.OS == "android") {
       return RNMappPluginModule.engage2();
@@ -131,10 +128,6 @@ export class Mapp {
     appID: string,
     tenantID: string
   ) {
-    if (Platform.OS == "ios") {
-      RNMappPluginModule.autoengage(server);
-      return RNMappPluginModule.engageInapp(server);
-    }
     return RNMappPluginModule.engage(
       sdkKey,
       googleProjectId,
@@ -335,10 +328,16 @@ export class Mapp {
     return RNMappPluginModule.stopGeofencing();
   }
 
+  /**
+   * @deprecated Use startGeofencing(), which returns the native operation result.
+   */
   static startGeoFencing() {
     return RNMappPluginModule.startGeoFencing();
   }
 
+  /**
+   * @deprecated Use stopGeofencing(), which returns the native operation result.
+   */
   static stopGeoFencing() {
     return RNMappPluginModule.stopGeoFencing();
   }

package/README.md

@@ -1,93 +1,166 @@
-
 # react-native-mapp-plugin
 
-## Getting started
-[Site](https://mapp.com/) |
-[Docs](https://mapp-wiki.atlassian.net/wiki/spaces/MIC/pages/1154875400/React+Native+Integration+for+Mapp+Cloud) 
-|[TestApk](https://github.com/MappCloud/React-Native-Test-Application/) 
+Mapp Engage native SDK integration for React Native CLI and Expo development builds.
+
+## Upgrading from 1.4.x
+
+Version 2.0 raises the minimum iOS target to 15.1 and changes Android dependency constraints, permission handling, push ownership, and inbox status updates.
+
+Review the [breaking changes](BREAKING_CHANGES.md) and follow the [1.4.2 to 2.0.0 migration guide](MIGRATION_2.0.md) before upgrading.
+
+## Expo (CNG)
 
-### Installation from npm:
+Expo Go is not supported because it cannot load this package's custom native code. Use Continuous Native Generation (CNG) with `expo-dev-client`; generated `android/` and `ios/` directories do not need manual changes.
 
-`$ npm install react-native-mapp-plugin --save`
+```bash
+npx expo install react-native-mapp-plugin expo-dev-client
+```
 
-### Mostly automatic installation
+Configure the installed package by name in `app.json` (values shown are examples):
+
+```json
+{
+  "expo": {
+    "name": "Mapp app",
+    "slug": "mapp-app",
+    "newArchEnabled": true,
+    "ios": {
+      "bundleIdentifier": "com.example.mappapp"
+    },
+    "android": {
+      "package": "com.example.mappapp",
+      "googleServicesFile": "./google-services.json"
+    },
+    "plugins": [
+      [
+        "react-native-mapp-plugin",
+        {
+          "android": {
+            "enableGeofencing": false,
+            "pushHandling": "mapp"
+          },
+          "ios": {
+            "appId": "MAPP_APP_ID",
+            "dmcSystemId": 123,
+            "sdkKey": "MAPP_SDK_KEY",
+            "isEu": true,
+            "inAppServerUrl": "MAPP_INAPP_SERVER_URL",
+            "openLandingPageInsideApp": false,
+            "customFields": ["customString", "customNumber", "customDate"],
+            "mediaTimeout": 5,
+            "enableGeofencing": false
+          }
+        }
+      ]
+    ]
+  }
+}
+```
 
-For the old version of RN, 
-`$ react-native link react-native-mapp-plugin`
+The Android package must match the Firebase Android application in `google-services.json`. For iOS, configure an APNs-enabled App ID, matching bundle identifier, and Apple/EAS signing credentials. Values embedded in app config and native resources are public application configuration; do not put service-account keys or signing secrets there.
 
-### Manual installation
+The Firebase file is customer-owned configuration. Point Expo's built-in `expo.android.googleServicesFile` field at it; this plugin does not copy, generate, or modify `google-services.json`.
 
+Generate and run development builds:
 
-#### iOS
+```bash
+npx expo prebuild --clean
+npx expo run:android
+npx expo run:ios
 
-1) Install pods
+# Cloud builds, after configuring EAS
+eas build --profile development --platform all
+eas build --profile preview --platform all
+eas build --profile production --platform all
 ```
-cd ios && pod install
+
+Changing plugin options or native dependencies requires a new binary. JavaScript-only changes may use EAS Update.
+
+### Initialization
+
+Register event listeners at application startup, then initialize Mapp. On iOS the generated `AppoxeeConfig.plist` is the credential source of truth; the existing `engage` arguments remain relevant to Android.
+
+```js
+import { Mapp, MappEventEmitter } from 'react-native-mapp-plugin';
+
+const events = new MappEventEmitter();
+const subscription = events.addListener('com.mapp.deep_link_received', event => {
+  // Route the deep link.
+});
+
+Mapp.engage('ANDROID_SDK_KEY', 'FCM_PROJECT_ID', 'EMC', 'APP_ID', 'TENANT_ID');
 ```
 
-2) Add the following capabilities for your application target:
-  - Push Notification
-  - Background Modes > Remote Notifications
-  - Background Modes > Location updates
+### Android push ownership
+
+`pushHandling: "mapp"` is the default. It requires `expo.android.googleServicesFile` and retains `com.reactlibrary.MessageService` as the sole normal-priority Mapp FCM callback owner. The config plugin removes the Mapp SDK v7 service (`com.appoxee.shared.MappMessagingService`) from the merged app manifest.
 
-3) Create a plist `AppoxeeConfig.plist` and include it in your application’s target:
+Use `pushHandling: "custom"` when another integration, such as a client-owned `FirebaseMessagingService`, owns callbacks. The plugin removes both its `MessageService` and the Mapp SDK service so the consumer service owns callbacks. Repeated prebuilds and switching modes clean up stale generated markers. From native Android code, use `com.reactlibrary.MappPushHelper`:
+
+```java
+@Override public void onMessageReceived(RemoteMessage message) {
+  if (!MappPushHelper.handleMessage(getApplication(), message)) {
+    // Handle non-Mapp messages here.
+  }
+}
+
+@Override public void onNewToken(String token) {
+  MappPushHelper.handleNewToken(getApplication(), token);
+}
 ```
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>inapp</key>
-    <dict>
-        <key>custom_fields</key>
-        <array>
-            <string>customString</string>
-            <string>customNumber</string>
-            <string>customDate</string>
-        </array>
-        <key>media_timeout</key>
-        <integer>5</integer>
-    </dict>
-    <key>sdk</key>
-    <dict>
-        <key>app_id</key>
-        <string>your app id</string>
-        <key>dmc_system_id</key>
-        <integer>your dmc id</integer>
-        <key>sdk_key</key>
-        <string>your sdk key</string>
-        <key>is_eu</key>
-        <true/>
-        <key>open_landing_page_inside_app</key>
-        <false/>
-        <key>jamie_url</key>
-        <string>your inapp server url</string>
-        <key>apx_open_url_internal</key>
-        <string>YES</string>
-    </dict>
-</dict>
-</plist>
+
+`Mapp.setRemoteMessage(...)` remains available when JavaScript is guaranteed to be alive. The native helper is required for reliable background and terminated delivery. `expo-notifications` coexistence must use custom ownership and explicit native forwarding; successful manifest merging alone does not forward payloads.
+
+### Geofencing
+
+Set `enableGeofencing` on each platform that needs it. Android then adds fine/background location permissions and `Mapp.requestGeofenceLocationPermission()` requests foreground permission before background permission. On iOS, also supply non-empty `locationWhenInUsePermission` and `locationAlwaysPermission` messages. Only request location access when your user-facing feature and store policy justify it.
+
+### iOS rich push
+
+The Expo config plugin creates a `MappNotificationService` Notification Service Extension with the bundle identifier `<expo.ios.bundleIdentifier>.mappnotificationservice`. The extension reads the public Mapp `ios_apx_media` payload key, downloads the media, and attaches it to the notification. It follows the app minimum deployment target and is set to iOS 15+, uses an App Group shared with the main app, and does not require an additional CocoaPod or React Native code.
+
+The extension is also declared in Expo's experimental EAS app-extension metadata so EAS can prepare its signing credentials. Regenerate the iOS project after changing the application bundle identifier.
+
+### Tested compatibility
+
+| Component | Tested baseline |
+| --- | --- |
+| Expo SDK | 57 |
+| React Native | 0.86 (Expo SDK 57) |
+| New Architecture | Enabled |
+| Android min / compile / target SDK | 24 / 36 / 36 |
+| Android Gradle Plugin / Kotlin / JDK | 8.12 / 2.1.20 / 21 |
+| iOS deployment target | 16.4 (library minimum: 15.1) |
+| Mapp Android SDK | 7.1.2 |
+| Mapp iOS SDKs | Vendored xcframeworks in this package |
+
+Mapp Engage Android 7.1.2 currently publishes Android dependencies newer than the Expo SDK 57 toolchain can consume. This release exports bounded compatibility constraints for AndroidX Core 1.18.0, WorkManager 2.10.5, Lifecycle 2.10.0, Play Services Location 21.3.0, and Kotlin stdlib 2.1.20. These pins can be removed after the Mapp Android publication adopts the Expo-compatible versions.
+
+Coroutines are intentionally different: Mapp's native in-app UI was compiled against kotlinx-coroutines 1.11.0 and calls an ABI absent from 1.10.x. The plugin therefore exports the coroutines 1.11.0 BOM and strict constraints. Do not downgrade coroutines to 1.10.x; dismissing or replacing a native in-app message can otherwise crash with `Job.cancel$default` `NoSuchMethodError`.
+
+Use JDK 21 for Android builds on this baseline. The config plugin does not alter a consumer's Gradle daemon JVM configuration.
+
+The separately maintained [sample application](https://github.com/MappCloud/React-Native-Test-Application/) is the physical-device integration consumer. Record its tested revision here when its Expo CNG migration is released.
+
+## React Native CLI
+
+```bash
+npm install react-native-mapp-plugin
+cd ios && pod install
 ```
 
-#### Android
-
-1. Open up `android/app/src/main/java/[...]/MainActivity.java`
-  - Add `import com.reactlibrary.RNMappPluginPackage;` to the imports at the top of the file
-  - Add `new RNMappPluginPackage()` to the list returned by the `getPackages()` method
-2. Append the following lines to `android/settings.gradle`:
-  	```
-  	include ':react-native-mapp-plugin'
-  	project(':react-native-mapp-plugin').projectDir = new File(rootProject.projectDir, 	'../node_modules/react-native-mapp-plugin/android')
-  	```
-3. Insert the following lines inside the dependencies block in `android/app/build.gradle`:
-  	```
-      compile project(':react-native-mapp-plugin')
-  	```
-
-## Usage
-```javascript
-import Mapp from 'react-native-mapp-plugin';
-
-// TODO: What to do with the module?
-Mapp;
+Modern React Native autolinking discovers the Android package and CocoaPod automatically. Do not run `react-native link`, edit `settings.gradle`, or add `compile project(...)`.
+
+No `MainActivity` or `MainApplication` edit is required. The native module is registered by autolinking. In Expo projects, the config plugin applies Android permissions, the Mapp messaging service, and the push receiver during prebuild without modifying consumer Gradle files. React Native CLI projects receive the same declarations through the library manifest merge. On iOS, CocoaPods discovers `RNMappPlugin.podspec` automatically; do not add the pod manually.
+
+For a manually maintained iOS native project, add Push Notifications, Remote Notifications background mode, and (only if needed) Location Updates, then include an `AppoxeeConfig.plist` in the application target. Expo clients should use the config plugin above instead.
+
+Basic usage:
+
+```js
+import { Mapp } from 'react-native-mapp-plugin';
+
+Mapp.engage('SDK_KEY', 'FCM_PROJECT_ID', 'EMC', 'APP_ID', 'TENANT_ID');
 ```
-  
+
+See the [Mapp integration documentation](https://mapp-wiki.atlassian.net/wiki/spaces/MIC/pages/1154875400/React+Native+Integration+for+Mapp+Cloud) for the full JavaScript API and native Mapp configuration values.

package/RNMappPlugin.podspec

@@ -12,18 +12,24 @@ Pod::Spec.new do |s|
   s.homepage     = "https://github.com/mapp-digital/Mapp-Engage-ReactNative-Plugin"
   s.license      = "MIT"
   s.author      = "Mapp"
-  s.platforms    = { :ios => "10.0" }
+  s.platforms    = { :ios => "15.1" }
   s.source       = { :git => "https://github.com/mapp-digital/Mapp-Engage-ReactNative-Plugin", :tag => "#{s.version}" }
 
-  s.source_files = "ios/**/*.{h,c,m,swift}"
+  s.source_files = "ios/**/*.{h,c,m,mm,swift}"
   s.exclude_files = "ios/RNMappPluginTests/**/*"
-  s.vendored_framework = "ios/Frameworks/AppoxeeLocationServices.xcframework", "ios/Frameworks/AppoxeeInapp.xcframework"
+  # AppoxeeInapp already contains the push SDK binary. Adding AppoxeeSDK here
+  # produces duplicate symbols, so it remains preserved for headers/resources only.
+  s.vendored_frameworks = "ios/Frameworks/AppoxeeLocationServices.xcframework", "ios/Frameworks/AppoxeeInapp.xcframework"
   s.resources = "ios/Frameworks/AppoxeeSDKResources.bundle", "ios/Frameworks/AppoxeeInappResources.bundle"
   s.preserve_path = "ios/Frameworks/"
   s.public_header_files = "ios/Frameworks/AppoxeeSDK.xcframework/ios-arm64/Headers/", "ios/Frameworks/AppoxeeLocationServices.xcframework/ios-arm64/Headers/", "ios/Frameworks/AppoxeeInapp.xcframework/ios-arm64/Headers/"
   s.requires_arc = true
   s.frameworks = "WebKit"
   s.library = 'sqlite3'
-  s.dependency "React" 
+  if respond_to?(:install_modules_dependencies, true)
+    install_modules_dependencies(s)
+  else
+    s.dependency "React-Core"
+  end
 
 end