react-native-nami-sdk 3.3.2 → 3.3.3-2

package/android/build.gradle

@@ -85,8 +85,8 @@ dependencies {
     implementation fileTree(dir: 'libs', include: ['*.jar'])
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
 
-    playImplementation "com.namiml:sdk-android:3.3.2.2"
-    amazonImplementation "com.namiml:sdk-amazon:3.3.2.2"
+    playImplementation "com.namiml:sdk-android:3.3.3.1"
+    amazonImplementation "com.namiml:sdk-amazon:3.3.3.1"
 
     implementation "com.facebook.react:react-native:+"  // From node_modules
     coreLibraryDesugaring "com.android.tools:desugar_jdk_libs:2.0.4"

package/android/src/main/AndroidManifest.xml

@@ -1,3 +1,16 @@
-<manifest package="com.namiml.reactnative">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.namiml.reactnative">
 
+
+    <application>
+        <activity
+            android:name=".ReactOverlayActivity"
+            android:theme="@style/Theme.TransparentReact"
+            android:exported="false"
+            android:launchMode="singleTop"
+            android:taskAffinity=""
+            android:noHistory="true"
+            android:excludeFromRecents="true"
+            android:configChanges="keyboard|keyboardHidden|orientation|screenSize|uiMode" />
+    </application>
 </manifest>

package/android/src/main/java/com/namiml/reactnative/NamiBridgePackage.java

@@ -29,6 +29,8 @@ public class NamiBridgePackage extends TurboReactPackage {
             case NamiPaywallManagerBridgeModule.NAME -> new NamiPaywallManagerBridgeModule(context);
             case NamiPurchaseManagerBridgeModule.NAME ->
                     new NamiPurchaseManagerBridgeModule(context);
+            case NamiOverlayControlBridgeModule.NAME ->
+                    new NamiOverlayControlBridgeModule(context);
             default -> null;
         };
     }
@@ -129,6 +131,19 @@ public class NamiBridgePackage extends TurboReactPackage {
                             BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
                     )
             );
+
+            moduleInfos.put(
+                    NamiOverlayControlBridgeModule.NAME,
+                    new ReactModuleInfo(
+                            NamiOverlayControlBridgeModule.NAME,
+                            NamiOverlayControlBridgeModule.NAME,
+                            false,
+                            false,
+                            true,
+                            false,
+                            BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+                    )
+            );
             return moduleInfos;
         };
     }

package/android/src/main/java/com/namiml/reactnative/NamiFlowManagerBridge.kt

@@ -4,39 +4,40 @@ import android.os.Handler
 import android.os.Looper
 import android.util.Log
 import com.facebook.react.bridge.*
-import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.facebook.react.turbomodule.core.interfaces.TurboModule
 import com.namiml.flow.NamiFlowManager
 
 @ReactModule(name = NamiFlowManagerBridgeModule.NAME)
 class NamiFlowManagerBridgeModule internal constructor(
-    reactContext: ReactApplicationContext
-) : ReactContextBaseJavaModule(reactContext), TurboModule {
-
+    reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext),
+    TurboModule {
     companion object {
         const val NAME = "RNNamiFlowManager"
     }
 
-    override fun getName(): String {
-        return NAME
-    }
+    override fun getName(): String = NAME
 
     @ReactMethod
     fun registerStepHandoff() {
         NamiFlowManager.registerStepHandoff { handoffTag, handoffData ->
-            val payload = Arguments.createMap().apply {
-                putString("handoffTag", handoffTag)
-                if (handoffData != null) {
-                    try {
-                        val map = Arguments.makeNativeMap(handoffData)
-                        putMap("handoffData", map)
-                    } catch (e: Exception) {
-                        Log.d(NAME, "Failed to convert handoffData to NativeMap: ${e.localizedMessage}")
+            val payload =
+                Arguments.createMap().apply {
+                    putString("handoffTag", handoffTag)
+                    if (handoffData != null) {
+                        try {
+                            putMap("handoffData", Arguments.makeNativeMap(handoffData))
+                        } catch (e: Exception) {
+                            Log.d(NAME, "Failed to convert handoffData to NativeMap: ${e.localizedMessage}")
+                        }
                     }
                 }
+
+            reactApplicationContext.runOnUiQueueThread {
+                sendEvent("Handoff", payload)
             }
-            sendEvent("Handoff", payload)
         }
     }
 
@@ -74,7 +75,10 @@ class NamiFlowManagerBridgeModule internal constructor(
         promise.resolve(NamiFlowManager.isFlowOpen())
     }
 
-    private fun sendEvent(eventName: String, params: WritableMap?) {
+    private fun sendEvent(
+        eventName: String,
+        params: WritableMap?,
+    ) {
         reactApplicationContext
             .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
             .emit(eventName, params)
@@ -82,5 +86,6 @@ class NamiFlowManagerBridgeModule internal constructor(
 
     // Required for RN EventEmitter support
     @ReactMethod fun addListener(eventName: String?) {}
+
     @ReactMethod fun removeListeners(count: Int?) {}
 }

package/android/src/main/java/com/namiml/reactnative/NamiOverlayControlBridge.kt

@@ -0,0 +1,171 @@
+package com.namiml.reactnative
+
+import android.app.Activity
+import android.content.Intent
+import android.os.Build
+import android.util.Log
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.turbomodule.core.interfaces.TurboModule
+import com.facebook.react.bridge.UiThreadUtil
+
+@ReactModule(name = NamiOverlayControlBridgeModule.NAME)
+class NamiOverlayControlBridgeModule(private val ctx: ReactApplicationContext)
+  : ReactContextBaseJavaModule(ctx), TurboModule {
+
+  companion object {
+    const val NAME = "RNNamiOverlayControl"
+    var currentOverlayActivity: ReactOverlayActivity? = null
+    var lastValidActivity: Activity? = null
+  }
+
+  override fun getName() = NAME
+
+  @ReactMethod
+  fun presentOverlay(promise: Promise) {
+    var theActivity: Activity? = null
+    if (reactApplicationContext.hasCurrentActivity()) {
+      theActivity = reactApplicationContext.currentActivity
+
+      // Check if it's the overlay activity that's finishing
+      if (theActivity is ReactOverlayActivity) {
+        if (theActivity.isFinishing || theActivity.isDestroyed) {
+          theActivity = lastValidActivity
+          if (theActivity == null || theActivity.isFinishing || theActivity.isDestroyed) {
+            promise.reject("NO_ACTIVITY", "No valid activity available")
+            return
+          }
+        } else {
+          lastValidActivity = theActivity
+        }
+      } else {
+        lastValidActivity = theActivity
+      }
+    } else {
+      theActivity = lastValidActivity
+      if (theActivity == null || theActivity.isFinishing || theActivity.isDestroyed) {
+        promise.reject("NO_ACTIVITY", "No valid activity available")
+        return
+      }
+    }
+
+    if (theActivity == null) {
+      promise.reject("NO_ACTIVITY", "No activity available")
+      return
+    }
+
+    startOverlayActivity(theActivity, promise)
+  }
+
+  private fun startOverlayActivity(activity: Activity, promise: Promise) {
+    try {
+      UiThreadUtil.runOnUiThread {
+        try {
+          val intent = Intent(activity, ReactOverlayActivity::class.java)
+          intent.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION)
+          activity.startActivity(intent)
+          // Use modern transition API for Android 14+ (API 34+)
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+            activity.overrideActivityTransition(Activity.OVERRIDE_TRANSITION_OPEN, 0, 0)
+          } else {
+            @Suppress("DEPRECATION")
+            activity.overridePendingTransition(0, 0)
+          }
+
+          // Emit ready event after a short delay to ensure activity is started
+          android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+            try {
+              if (ctx.catalystInstance != null) {
+                ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                  .emit("NamiOverlayReady", null)
+              }
+            } catch (e: Exception) {
+              Log.e(NAME, "Failed to emit NamiOverlayReady: ${e.message}")
+            }
+          }, 100)
+
+          promise.resolve(null)
+        } catch (uiError: Exception) {
+          Log.e(NAME, "Error in UI thread: ${uiError.message}", uiError)
+          promise.reject("UI_THREAD_ERROR", "Failed in UI thread: ${uiError.message}", uiError)
+        }
+      }
+    } catch (e: Exception) {
+      Log.e(NAME, "Error presenting overlay: ${e.message}", e)
+      promise.reject("PRESENT_OVERLAY_ERROR", "Failed to present overlay: ${e.message}", e)
+    }
+  }
+
+  @ReactMethod
+  fun addListener(eventName: String?) {
+    // Required for NativeEventEmitter - no-op since we emit events directly
+  }
+
+  @ReactMethod
+  fun removeListeners(count: Int?) {
+    // Required for NativeEventEmitter - no-op since we emit events directly
+  }
+
+  @ReactMethod
+  fun finishOverlay(result: ReadableMap?, promise: Promise) {
+    try {
+      // Emit result to main app listeners
+      val payload: WritableMap = Arguments.createMap().apply {
+        if (result != null) {
+          merge(result)
+        }
+      }
+      try {
+        if (ctx.catalystInstance != null) {
+          ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit("NamiOverlayResult", payload)
+        }
+      } catch (e: Exception) {
+        Log.e(NAME, "Failed to emit NamiOverlayResult: ${e.message}")
+      }
+
+      UiThreadUtil.runOnUiThread {
+        // Try to finish the tracked overlay activity first
+        currentOverlayActivity?.let { overlay ->
+          overlay.finish()
+          // Use modern transition API for Android 14+ (API 34+)
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+            overlay.overrideActivityTransition(Activity.OVERRIDE_TRANSITION_CLOSE, 0, 0)
+          } else {
+            @Suppress("DEPRECATION")
+            overlay.overridePendingTransition(0, 0)
+          }
+          currentOverlayActivity = null
+
+          // Wait for activity to actually finish before resolving promise
+          android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+            promise.resolve(null)
+          }, 100)
+        } ?: run {
+          // Fallback to current activity if it's an overlay
+          (ctx.currentActivity as? ReactOverlayActivity)?.apply {
+            finish()
+            // Use modern transition API for Android 14+ (API 34+)
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+              overrideActivityTransition(Activity.OVERRIDE_TRANSITION_CLOSE, 0, 0)
+            } else {
+              @Suppress("DEPRECATION")
+              overridePendingTransition(0, 0)
+            }
+
+            // Wait for activity to actually finish before resolving promise
+            android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+              promise.resolve(null)
+            }, 100)
+          } ?: run {
+            promise.resolve(null)
+          }
+        }
+      }
+    } catch (e: Exception) {
+      Log.e(NAME, "Failed to finish overlay: ${e.message}", e)
+      promise.reject("FINISH_OVERLAY_ERROR", "Failed to finish overlay", e)
+    }
+  }
+}

package/android/src/main/java/com/namiml/reactnative/ReactOverlayActivity.kt

@@ -0,0 +1,29 @@
+package com.namiml.reactnative
+
+import android.os.Bundle
+import com.facebook.react.ReactActivity
+
+class ReactOverlayActivity : ReactActivity() {
+  override fun getMainComponentName(): String = "NamiOverlayHost"
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    overridePendingTransition(0, 0)
+
+    // Register this activity with the bridge module
+    NamiOverlayControlBridgeModule.currentOverlayActivity = this
+  }
+
+  override fun onBackPressed() {
+    finish()
+    overridePendingTransition(0, 0)
+  }
+
+  override fun onDestroy() {
+    super.onDestroy()
+    // Clear the reference when activity is destroyed
+    if (NamiOverlayControlBridgeModule.currentOverlayActivity == this) {
+      NamiOverlayControlBridgeModule.currentOverlayActivity = null
+    }
+  }
+}

package/android/src/main/res/values/styles.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <style name="Theme.TransparentReact" parent="Theme.MaterialComponents.DayNight.NoActionBar">
+        <item name="android:windowIsTranslucent">true</item>
+        <item name="android:windowBackground">@android:color/transparent</item>
+        <item name="android:windowNoTitle">true</item>
+        <item name="android:statusBarColor">@android:color/transparent</item>
+        <item name="android:navigationBarColor">@android:color/transparent</item>
+    </style>
+</resources>

package/dist/index.d.ts

@@ -5,4 +5,5 @@ export { NamiEntitlementManager } from './src/NamiEntitlementManager';
 export { NamiPurchaseManager } from './src/NamiPurchaseManager';
 export { NamiPaywallManager } from './src/NamiPaywallManager';
 export { NamiFlowManager } from './src/NamiFlowManager';
+export { NamiOverlayControl } from './src/NamiOverlayControl';
 export * from './src/types';

package/dist/specs/NativeNamiFlowManager.d.ts

@@ -6,6 +6,7 @@ export interface Spec extends TurboModule {
     resume(): void;
     pause(): void;
     registerEventHandler(): void;
+    purchaseSuccess(): void;
 }
 declare const _default: Spec;
 export default _default;

package/dist/specs/NativeNamiOverlayControl.d.ts

@@ -0,0 +1,9 @@
+import type { TurboModule } from 'react-native';
+export interface Spec extends TurboModule {
+    presentOverlay(): Promise<void>;
+    finishOverlay(result?: {
+        [key: string]: unknown;
+    } | null): Promise<void>;
+}
+declare const _default: Spec;
+export default _default;

package/dist/src/NamiOverlayControl.d.ts

@@ -0,0 +1,9 @@
+import { NativeEventEmitter } from 'react-native';
+export declare const NamiOverlayControl: {
+    emitter: NativeEventEmitter;
+    presentOverlay(): Promise<void>;
+    finishOverlay(result?: any): Promise<void>;
+    onOverlayReady(handler: () => void): () => void;
+    onOverlayResult(handler: (result: any) => void): () => void;
+};
+export default function NamiOverlayHost(): any;

package/dist/src/NamiOverlayHost.d.ts

@@ -0,0 +1 @@
+export default function NamiOverlayHost(): null;

package/dist/src/overlay.d.ts

@@ -0,0 +1,4 @@
+export declare function presentOverlay(): Promise<void>;
+export declare function finishOverlay(result?: any): Promise<void>;
+export declare function onOverlayReady(handler: () => void): () => void;
+export declare function onOverlayResult(handler: (result: any) => void): () => void;

package/dist/src/registerOverlay.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/version.d.ts

@@ -2,4 +2,4 @@
  * Auto-generated file. Do not edit manually.
  * React Native Nami SDK version.
  */
-export declare const NAMI_REACT_NATIVE_VERSION = "3.3.2";
+export declare const NAMI_REACT_NATIVE_VERSION = "3.3.3-2";

package/index.ts

@@ -5,4 +5,5 @@ export { NamiEntitlementManager } from './src/NamiEntitlementManager';
 export { NamiPurchaseManager } from './src/NamiPurchaseManager';
 export { NamiPaywallManager } from './src/NamiPaywallManager';
 export { NamiFlowManager } from './src/NamiFlowManager';
+export { NamiOverlayControl } from './src/NamiOverlayControl';
 export * from './src/types';

package/ios/Nami.swift

@@ -8,10 +8,6 @@ import Foundation
 import NamiApple
 import React
 
-// #if RCT_NEW_ARCH_ENABLED
-//    extension RNNami: RCTTurboModule {}
-// #endif
-
 @objc(RNNami)
 class RNNami: NSObject {
     static func moduleName() -> String! {
@@ -63,20 +59,37 @@ class RNNami: NSObject {
             config.initialConfig = initialConfig
         }
 
+        var didCallBack = false
         Nami.configure(with: config) { sdkConfigured in
-            resolve(["success": sdkConfigured])
+            didCallBack = true
+            NSLog("RNNami: configure() completion called, sdkConfigured: \(sdkConfigured)")
+            DispatchQueue.main.async {
+                resolve(["success": sdkConfigured])
+            }
+        }
+
+        DispatchQueue.main.asyncAfter(deadline: .now() + 10) {
+            if !didCallBack {
+                NSLog("RNNami: configure() completion NEVER CALLED, reporting failure.")
+                resolve(["success": false])
+            }
         }
     }
 
     @objc
-    func sdkConfigured(_ resolve: RCTPromiseResolveBlock, rejecter _: RCTPromiseRejectBlock) {
-        resolve(Nami.sdkConfigured())
+    func sdkConfigured(_ resolve: @escaping RCTPromiseResolveBlock, rejecter _: RCTPromiseRejectBlock) {
+        let sdkConfigured = Nami.sdkConfigured()
+        DispatchQueue.main.async {
+            resolve(sdkConfigured)
+        }
     }
 
     @objc(sdkVersion:rejecter:)
     func sdkVersion(resolve: @escaping RCTPromiseResolveBlock, reject _: @escaping RCTPromiseRejectBlock) {
         let version = Nami.sdkVersion()
-        resolve(version)
+        DispatchQueue.main.async {
+            resolve(version)
+        }
     }
 
     func isNewArchitectureEnabled() -> Bool {

package/ios/NamiCampaignManagerBridge.m

@@ -6,8 +6,9 @@
 //
 
 #import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
 
-@interface RCT_EXTERN_MODULE(RNNamiCampaignManager, NSObject)
+@interface RCT_EXTERN_MODULE(RNNamiCampaignManager, RCTEventEmitter)
 
 RCT_EXTERN_METHOD(launch:(nullable NSString *)label withUrl:(nullable NSString *)withUrl context:(nullable NSDictionary *)context completion:(RCTResponseSenderBlock)callback paywallCompletion:(RCTResponseSenderBlock)paywallCallback);
 
@@ -20,7 +21,7 @@ RCT_EXTERN_METHOD(refresh:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRe
 RCT_EXTERN_METHOD(registerAvailableCampaignsHandler)
 
 + (BOOL)requiresMainQueueSetup {
-  return NO;
+  return YES;
 }
 
 @end

package/ios/NamiCampaignManagerBridge.swift

@@ -10,17 +10,26 @@ import NamiApple
 import os
 import React
 
-// #if RCT_NEW_ARCH_ENABLED
-//    extension RNNamiCampaignManager: RCTTurboModule {}
-// #endif
-
 @objc(RNNamiCampaignManager)
 class RNNamiCampaignManager: RCTEventEmitter {
     public static var shared: RNNamiCampaignManager?
 
     override init() {
         super.init()
-        RNNamiCampaignManager.shared = self
+    }
+
+    override class func requiresMainQueueSetup() -> Bool { true }
+
+    private var hasListeners = false
+    override func startObserving() { hasListeners = true }
+    override func stopObserving() { hasListeners = false }
+
+    private func safeSend(withName name: String, body: Any?) {
+        guard hasListeners else {
+            print("[RNNamiCampaignManager] Warning: no listeners, so event not being sent to JS.")
+            return
+        } // optional but avoids warnings
+        sendEvent(withName: name, body: body)
     }
 
     override func supportedEvents() -> [String]! {
@@ -138,9 +147,7 @@ class RNNamiCampaignManager: RCTEventEmitter {
             "timeSpentOnPaywall": paywallEvent.timeSpentOnPaywall,
         ]
 
-        DispatchQueue.main.async {
-            RNNamiCampaignManager.shared?.sendEvent(withName: "NamiPaywallEvent", body: payload)
-        }
+        safeSend(withName: "NamiPaywallEvent", body: payload)
     }
 
     func handleLaunch(callback: RCTResponseSenderBlock?, success: Bool, error: Error?) {
@@ -294,9 +301,7 @@ class RNNamiCampaignManager: RCTEventEmitter {
     func registerForAvailableCampaigns() {
         NamiCampaignManager.registerAvailableCampaignsHandler { availableCampaigns in
             let dictionaries = availableCampaigns.map { campaign in self.campaignInToDictionary(campaign) }
-            DispatchQueue.main.async {
-                RNNamiCampaignManager.shared?.sendEvent(withName: "AvailableCampaignsChanged", body: dictionaries)
-            }
+            self.safeSend(withName: "AvailableCampaignsChanged", body: dictionaries)
         }
     }
 }

package/ios/NamiCustomerManager.m

@@ -6,8 +6,9 @@
 //
 
 #import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
 
-@interface RCT_EXTERN_MODULE(RNNamiCustomerManager, NSObject)
+@interface RCT_EXTERN_MODULE(RNNamiCustomerManager, RCTEventEmitter)
 
 RCT_EXTERN_METHOD(setCustomerAttribute:(NSString *)key value:(NSString *)value)
 
@@ -43,7 +44,7 @@ RCT_EXTERN_METHOD(registerAccountStateHandler)
 
 
 + (BOOL)requiresMainQueueSetup {
-  return NO;
+  return YES;
 }
 
 @end