react-native-mapp-plugin 1.4.1 → 2.0.0-beta.1

package/android/build.gradle

@@ -1,9 +1,20 @@
 apply plugin: "com.android.library"
 
+import groovy.json.JsonSlurper
+
 def getExtOrDefault = { name, fallback ->
     rootProject.ext.has(name) ? rootProject.ext.get(name) : fallback
 }
 
+def reactNativePackage = [
+    file("../node_modules/react-native/package.json"),
+    file("../../react-native/package.json")
+].find { it.exists() }
+if (reactNativePackage == null) {
+    throw new GradleException("react-native-mapp-plugin could not resolve react-native/package.json")
+}
+def resolvedReactNativeVersion = new JsonSlurper().parse(reactNativePackage).version
+
 android {
     namespace "com.reactlibrary"
     compileSdk = getExtOrDefault("compileSdkVersion", 36)
@@ -29,34 +40,153 @@ android {
 }
 
 dependencies {
-    //noinspection GradleDynamicVersion
-    implementation "com.facebook.react:react-native:+"
+    implementation "com.facebook.react:react-android:${resolvedReactNativeVersion}"
+    api platform("org.jetbrains.kotlinx:kotlinx-coroutines-bom:1.11.0")
+    api enforcedPlatform("org.jetbrains.kotlin:kotlin-bom:2.1.20")
     constraints {
-        implementation("androidx.core:core") {
+        api("androidx.core:core") {
             version {
                 strictly "1.18.0"
             }
             because "androidx.core 1.19.0 requires AGP 9.1+, while React Native dependencies currently require the app to stay on AGP 8"
         }
-        implementation("androidx.core:core-ktx") {
+        api("androidx.core:core-ktx") {
             version {
                 strictly "1.18.0"
             }
-            because "androidx.core-ktx 1.19.0 requires AGP 9.1+, while React Native dependencies currently require the app to stay on AGP 8"
+                because "androidx.core-ktx 1.19.0 requires AGP 9.1+, while React Native dependencies currently require the app to stay on AGP 8"
+        }
+        ["work-runtime", "work-runtime-ktx"].each { module ->
+            api("androidx.work:${module}") {
+                version { strictly "2.10.5" }
+                because "Expo SDK 57 uses AGP 8.12 and cannot consume WorkManager 2.11 metadata"
+            }
+        }
+        [
+            "lifecycle-common",
+            "lifecycle-common-java8",
+            "lifecycle-livedata-core",
+            "lifecycle-livedata-core-ktx",
+            "lifecycle-process",
+            "lifecycle-runtime",
+            "lifecycle-runtime-android",
+            "lifecycle-runtime-ktx",
+            "lifecycle-service",
+            "lifecycle-viewmodel",
+            "lifecycle-viewmodel-android",
+            "lifecycle-viewmodel-ktx",
+            "lifecycle-viewmodel-savedstate"
+        ].each { module ->
+            api("androidx.lifecycle:${module}") {
+                version { strictly "2.10.0" }
+                because "Expo SDK 57 uses AGP 8.12 and cannot consume Lifecycle 2.11 metadata"
+            }
+        }
+        api("com.google.android.gms:play-services-location") {
+            version { strictly "21.3.0" }
+            because "21.4.0 requires an Android toolchain newer than the Expo SDK 57 baseline"
+        }
+        ["kotlinx-coroutines-android", "kotlinx-coroutines-core", "kotlinx-coroutines-core-jvm"].each { module ->
+            api("org.jetbrains.kotlinx:${module}") {
+                version { strictly "1.11.0" }
+                because "Mapp Engage 7.1.2 native in-app UI requires the coroutines 1.11 Job ABI"
+            }
         }
     }
     implementation 'com.google.code.gson:gson:2.14.0'
     implementation 'androidx.appcompat:appcompat:1.7.1'
     implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.8.7'
-    implementation platform('com.google.firebase:firebase-bom:33.16.0')
     implementation('com.google.firebase:firebase-messaging')
     api('com.google.android.gms:play-services-location:21.3.0')
     implementation 'androidx.media:media:1.8.0'
     implementation 'androidx.legacy:legacy-support-v13:1.0.0'
-    implementation("com.mapp.sdk:engage-android:7.1.1")
+    implementation("com.mapp.sdk:engage-android:7.1.2") {
+        exclude group: "androidx.lifecycle", module: "lifecycle-extensions"
+    }
     testImplementation 'junit:junit:4.13.2'
     testImplementation 'org.mockito:mockito-core:5.23.0'
     testImplementation 'org.mockito:mockito-inline:5.2.0'
     testImplementation 'org.json:json:20260522'
     testImplementation 'org.robolectric:robolectric:4.16.1'
 }
+
+tasks.register("verifyExpo57RuntimeDependencies") {
+    group = "verification"
+    description = "Checks the Expo SDK 57 runtime pins and Mapp's required coroutines ABI."
+    doLast {
+        def expected = [
+            "androidx.core:core": "1.18.0",
+            "androidx.core:core-ktx": "1.18.0",
+            "androidx.work:work-runtime": "2.10.5",
+            "androidx.lifecycle:lifecycle-runtime": "2.10.0",
+            "com.google.android.gms:play-services-location": "21.3.0",
+            "org.jetbrains.kotlin:kotlin-stdlib": "2.1.20",
+            "org.jetbrains.kotlinx:kotlinx-coroutines-android": "1.11.0",
+            "org.jetbrains.kotlinx:kotlinx-coroutines-core-jvm": "1.11.0"
+        ]
+        def artifacts = configurations.debugRuntimeClasspath.resolvedConfiguration.resolvedArtifacts
+        def selected = configurations.debugRuntimeClasspath.incoming.resolutionResult.allComponents
+                .findAll { it.moduleVersion != null }
+                .collectEntries { component ->
+            [("${component.moduleVersion.group}:${component.moduleVersion.name}".toString()): component.moduleVersion.version]
+        }
+        expected.each { module, version ->
+            if (selected[module] != version) {
+                throw new GradleException("Expected ${module}:${version}, resolved ${selected[module] ?: 'nothing'}")
+            }
+        }
+        selected.findAll { module, ignored -> module.startsWith("androidx.lifecycle:") }.each { module, version ->
+            if (module != "androidx.lifecycle:lifecycle-extensions" && version != "2.10.0") {
+                throw new GradleException("Expected Lifecycle 2.10.0, resolved ${module}:${version}")
+            }
+        }
+        if (selected.containsKey("androidx.lifecycle:lifecycle-extensions")) {
+            throw new GradleException("lifecycle-extensions must not be present in the runtime graph")
+        }
+
+        def coroutineJar = artifacts.find {
+            it.moduleVersion.id.group == "org.jetbrains.kotlinx"
+                    && it.moduleVersion.id.name == "kotlinx-coroutines-core-jvm"
+        }?.file
+        if (coroutineJar == null) {
+            throw new GradleException("Could not inspect kotlinx-coroutines-core-jvm")
+        }
+        def javap = new ProcessBuilder(
+                "${System.getProperty('java.home')}/bin/javap",
+                "-classpath",
+                coroutineJar.absolutePath,
+                "kotlinx.coroutines.Job"
+        ).redirectErrorStream(true).start()
+        def javapOutput = javap.inputStream.getText("UTF-8")
+        if (javap.waitFor() != 0) {
+            throw new GradleException("Unable to inspect the resolved coroutines Job ABI:\n${javapOutput}")
+        }
+        if (!javapOutput.contains('cancel$default(kotlinx.coroutines.Job, java.util.concurrent.CancellationException, int, java.lang.Object)')) {
+            throw new GradleException("Resolved coroutines Job is missing Mapp's required cancel\$default ABI")
+        }
+
+        def apiElements = configurations.getByName("releaseApiElements")
+        def exportedConstraints = apiElements.allDependencyConstraints.collect {
+            "${it.group}:${it.name}:${it.versionConstraint.strictVersion}".toString()
+        }
+        [
+            "androidx.work:work-runtime:2.10.5",
+            "androidx.lifecycle:lifecycle-runtime:2.10.0",
+            "org.jetbrains.kotlinx:kotlinx-coroutines-core-jvm:1.11.0"
+        ].each { constraint ->
+            if (!exportedConstraints.contains(constraint)) {
+                throw new GradleException("Compatibility constraint is not exported: ${constraint}")
+            }
+        }
+        def exportedDependencies = apiElements.allDependencies.collect {
+            "${it.group}:${it.name}:${it.version}".toString()
+        }
+        if (!exportedDependencies.contains("org.jetbrains.kotlin:kotlin-bom:2.1.20")) {
+            throw new GradleException("The Expo Kotlin compatibility platform is not exported")
+        }
+    }
+}
+
+tasks.named("check").configure {
+    dependsOn("verifyExpo57RuntimeDependencies")
+}

package/android/gradle.properties

@@ -38,5 +38,3 @@ newArchEnabled=true
 # Use this property to enable or disable the Hermes JS engine.
 # If set to false, you will be using JSC instead.
 hermesEnabled=false
-
-org.gradle.java.home=/Library/Java/JavaVirtualMachines/jdk-17.jdk/Contents/Home

package/android/settings.gradle

@@ -1,13 +1,14 @@
 pluginManagement {
+    includeBuild("../node_modules/@react-native/gradle-plugin")
     repositories {
         google()
         mavenCentral()
         gradlePluginPortal()
     }
-    plugins {
-        id("com.android.library") version("9.1.1") // 👈 for library
-        id("com.facebook.react") version("0.84.1")  // 👈 for React Native
-    }
+}
+
+plugins {
+    id("com.android.library") version("8.12.0") apply false
 }
 
 dependencyResolutionManagement {
@@ -17,6 +18,4 @@ dependencyResolutionManagement {
         mavenCentral()
     }
 }
-includeBuild("../node_modules/@react-native/gradle-plugin")
-
 rootProject.name="MappEngagePlugin"

package/android/src/main/AndroidManifest.xml

@@ -42,6 +42,14 @@
 
             </intent-filter>
         </activity>
+        <service
+            android:name="com.appoxee.shared.MappMessagingService"
+            tools:node="remove"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="com.google.firebase.MESSAGING_EVENT" />
+            </intent-filter>
+        </service>
         <service
             android:name="com.appoxee.push.fcm.MappMessagingService"
             tools:node="remove"
@@ -71,4 +79,3 @@
     </application>
 
 </manifest>
-  

package/android/src/main/java/com/reactlibrary/MappEngagementDispatcher.java

@@ -0,0 +1,102 @@
+package com.reactlibrary;
+
+import android.app.Application;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.appoxee.Appoxee;
+import com.appoxee.shared.AppoxeeOptions;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/** Keeps every Appoxee.engage call on Android's main looper. */
+final class MappEngagementDispatcher {
+    private static final String TAG = "MappEngage";
+    static final long ENGAGE_TIMEOUT_MILLIS = 5_000;
+
+    private MappEngagementDispatcher() {}
+
+    static void engageAsync(
+            @NonNull Application application,
+            @Nullable AppoxeeOptions options,
+            @Nullable Runnable afterEngage
+    ) {
+        Runnable operation = () -> {
+            if (engageNow(application, options) && afterEngage != null) {
+                afterEngage.run();
+            }
+        };
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            operation.run();
+            return;
+        }
+        if (!new Handler(Looper.getMainLooper()).post(operation)) {
+            Log.e(TAG, "Unable to post Mapp initialization to the main looper");
+        }
+    }
+
+    static boolean engageBlocking(@NonNull Application application, @Nullable AppoxeeOptions options) {
+        return engageBlocking(
+                application,
+                options,
+                new Handler(Looper.getMainLooper()),
+                ENGAGE_TIMEOUT_MILLIS
+        );
+    }
+
+    static boolean engageBlocking(
+            @NonNull Application application,
+            @Nullable AppoxeeOptions options,
+            @NonNull Handler mainHandler,
+            long timeoutMillis
+    ) {
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            return engageNow(application, options);
+        }
+
+        CountDownLatch completion = new CountDownLatch(1);
+        AtomicBoolean engaged = new AtomicBoolean(false);
+        boolean posted = mainHandler.post(() -> {
+            try {
+                engaged.set(engageNow(application, options));
+            } finally {
+                completion.countDown();
+            }
+        });
+        if (!posted) {
+            Log.e(TAG, "Unable to post Mapp initialization to the main looper");
+            return false;
+        }
+
+        try {
+            if (!completion.await(timeoutMillis, TimeUnit.MILLISECONDS)) {
+                Log.e(TAG, "Mapp initialization timed out on the main looper");
+                return false;
+            }
+            return engaged.get();
+        } catch (InterruptedException interrupted) {
+            Thread.currentThread().interrupt();
+            Log.w(TAG, "Interrupted while waiting for Mapp initialization", interrupted);
+            return false;
+        }
+    }
+
+    private static boolean engageNow(
+            @NonNull Application application,
+            @Nullable AppoxeeOptions options
+    ) {
+        try {
+            Appoxee.engage(application, options);
+            return true;
+        } catch (RuntimeException error) {
+            Log.e(TAG, "Mapp initialization failed", error);
+            return false;
+        }
+    }
+}

package/android/src/main/java/com/reactlibrary/MappPushHelper.java

@@ -0,0 +1,126 @@
+package com.reactlibrary;
+
+import android.app.Application;
+import android.os.Handler;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+
+import com.appoxee.Appoxee;
+import com.google.firebase.messaging.RemoteMessage;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Native entry points for applications that own their FirebaseMessagingService.
+ * This API does not require a running React Native JavaScript runtime.
+ */
+public final class MappPushHelper {
+    private static final String TAG = "MappPushHelper";
+    private static final int READY_ATTEMPTS = 15;
+    private static final long READY_INTERVAL_MILLIS = 300;
+
+    private MappPushHelper() {}
+
+    /** Engage Mapp using AppoxeeConfig/native defaults if it has not been engaged yet. */
+    public static boolean initialize(@NonNull Application application) {
+        return MappEngagementDispatcher.engageBlocking(application, null);
+    }
+
+    static boolean initialize(@NonNull Application application, @NonNull Handler handler, long timeoutMillis) {
+        return MappEngagementDispatcher.engageBlocking(application, null, handler, timeoutMillis);
+    }
+
+    /** Return true only when the native Mapp SDK identifies this payload as its own. */
+    public static boolean isMappMessage(@NonNull RemoteMessage remoteMessage) {
+        try {
+            return Appoxee.instance().isPushMessageFromMapp(remoteMessage);
+        } catch (RuntimeException error) {
+            Log.e(TAG, "Unable to inspect remote message", error);
+            return false;
+        }
+    }
+
+    /** Forward a Mapp message. Returns false for non-Mapp payloads or SDK failures. */
+    public static boolean handleMessage(@NonNull Application application, @NonNull RemoteMessage remoteMessage) {
+        return handleMessage(application, remoteMessage, null, MappEngagementDispatcher.ENGAGE_TIMEOUT_MILLIS);
+    }
+
+    static boolean handleMessage(
+            @NonNull Application application,
+            @NonNull RemoteMessage remoteMessage,
+            Handler handler,
+            long timeoutMillis
+    ) {
+        boolean initialized = handler == null
+                ? initialize(application)
+                : initialize(application, handler, timeoutMillis);
+        if (!initialized) {
+            return false;
+        }
+        if (!isMappMessage(remoteMessage) || !waitUntilReady()) {
+            return false;
+        }
+        try {
+            Appoxee.instance().handlePushMessage(remoteMessage);
+            return true;
+        } catch (RuntimeException error) {
+            Log.e(TAG, "Unable to forward remote message", error);
+            return false;
+        }
+    }
+
+    /** Forward a refreshed native FCM token without requiring JavaScript. */
+    public static boolean handleNewToken(@NonNull Application application, @NonNull String token) {
+        return handleNewToken(application, token, null, MappEngagementDispatcher.ENGAGE_TIMEOUT_MILLIS);
+    }
+
+    static boolean handleNewToken(
+            @NonNull Application application,
+            @NonNull String token,
+            Handler handler,
+            long timeoutMillis
+    ) {
+        if (token.trim().isEmpty()) {
+            return false;
+        }
+        boolean initialized = handler == null
+                ? initialize(application)
+                : initialize(application, handler, timeoutMillis);
+        if (!initialized) {
+            return false;
+        }
+        if (!waitUntilReady()) {
+            return false;
+        }
+        try {
+            Appoxee.instance().updateFirebaseToken(token).enqueue(result -> {});
+            return true;
+        } catch (RuntimeException error) {
+            Log.e(TAG, "Unable to forward Firebase token", error);
+            return false;
+        }
+    }
+
+    public static boolean waitUntilReady() {
+        for (int attempt = 0; attempt <= READY_ATTEMPTS; attempt++) {
+            try {
+                if (Appoxee.instance().isReady()) {
+                    return true;
+                }
+                if (attempt < READY_ATTEMPTS) {
+                    TimeUnit.MILLISECONDS.sleep(READY_INTERVAL_MILLIS);
+                }
+            } catch (InterruptedException interrupted) {
+                Thread.currentThread().interrupt();
+                Log.w(TAG, "Interrupted while waiting for Mapp initialization", interrupted);
+                return false;
+            } catch (RuntimeException error) {
+                Log.e(TAG, "Mapp initialization failed", error);
+                return false;
+            }
+        }
+        Log.w(TAG, "Mapp was not ready before the bounded wait expired");
+        return false;
+    }
+}

package/android/src/main/java/com/reactlibrary/MessageService.java

@@ -4,13 +4,9 @@ import android.util.Log;
 
 import androidx.annotation.NonNull;
 
-import com.appoxee.Appoxee;
-import com.appoxee.shared.AppoxeeOptions;
 import com.google.firebase.messaging.FirebaseMessagingService;
 import com.google.firebase.messaging.RemoteMessage;
 
-import java.util.concurrent.TimeUnit;
-
 
 /**
  * Updated for Engage SDK v7:
@@ -23,36 +19,20 @@ public class MessageService extends FirebaseMessagingService {
     @Override
     public void onCreate() {
         super.onCreate();
-        Appoxee.engage(getApplication(), null);
+        MappPushHelper.initialize(getApplication());
     }
 
     @Override
     public void onMessageReceived(@NonNull RemoteMessage remoteMessage) {
         Log.d("onMessageReceived", remoteMessage.toString());
-        if (Appoxee.instance().isPushMessageFromMapp(remoteMessage)) {
-            waitInitialization();
-            Appoxee.instance().handlePushMessage(remoteMessage);
-        } else {
+        if (!MappPushHelper.handleMessage(getApplication(), remoteMessage)) {
             super.onMessageReceived(remoteMessage);
         }
     }
 
     @Override
     public void onNewToken(@NonNull String token) {
-        waitInitialization();
-        Appoxee.instance().updateFirebaseToken(token).enqueue(result -> {});
+        MappPushHelper.handleNewToken(getApplication(), token);
         super.onNewToken(token);
     }
-
-    private void waitInitialization() {
-        int limit = 15;
-        try {
-            while (limit >= 0 && !Appoxee.instance().isReady()) {
-                TimeUnit.MILLISECONDS.sleep(300);
-                limit--;
-            }
-        } catch (Exception e) {
-            Log.e("MessageService", "waitInitialization interrupted", e);
-        }
-    }
 }