react-native-nami-sdk 3.3.0-beta.1 → 3.3.0-beta.22

package/.prettierrc

@@ -0,0 +1,4 @@
+{
+  "singleQuote": true,
+  "trailingComma": "all"
+}

package/README.md

@@ -2,14 +2,14 @@
 
 # React Native Bridge for the Nami SDK
 
-Nami ML gives you everything you need to power your paywall, streamline subscription management, and drive revenue growth through instantly deployable paywalls, precise targeting and segmentation, and enterprise-grade security and scaleability.
+Nami ML gives you everything you need to power your paywall, streamline subscription management, and drive revenue growth through instantly deployable paywalls, precise targeting and segmentation, and enterprise-grade security and scalability.
 
 Go beyond basic IAP and focus on results with:
 
-* Library of smart paywall templates to choose from, implemented natively
-* No-code paywall creator so you can launch a new paywall design instantly, without submitting an app update
-* Experimentation engine to run paywall A/B tests so you can improve your conversion rates
-* Built-in IAP & subscription management and analytics, so you don't need another solution
+- Library of smart paywall templates to choose from, implemented natively
+- No-code paywall creator so you can launch a new paywall design instantly, without submitting an app update
+- Experimentation engine to run paywall A/B tests so you can improve your conversion rates
+- Built-in IAP & subscription management and analytics, so you don't need another solution
 
 Nami is simple adopt while giving you the tools you need to improve revenue. Our free tier is generous, and gives you everything you need to get started. [Sign up for a free account](https://app.namiml.com/join/)
 
@@ -20,18 +20,18 @@ Get started by heading over to our [quick start guide](https://learn.namiml.com/
 ### Build the Bridge Locally
 
 ```
-yarn pack
+npm run prepare && npm pack
 ```
 
-This will generate a file `react-native-nami-sdk-vx.x.x.tgz` with the current version number of the bridge.   You can add this to a project by
+This will generate a file `react-native-nami-sdk-vx.x.x.tgz` with the current version number of the bridge. You can add this to a project by
 
 ```
-yarn add file:react-native-nami-sdk-vx.x.x.tgz
+npm install react-native-nami-sdk-vx.x.x.tgz
 ```
 
 ### Installing from NPM
 
-The bridge is also available as a package on NPM.  You can install it via yarn or npm
+The bridge is also available as a package on NPM. You can install it via yarn or npm
 
 ```
 npm install react-native-nami-sdk --save

package/android/README.md

@@ -1,14 +1,15 @@
-README
-======
+# README
 
 If you want to publish the lib as a maven dependency, follow these steps before publishing a new version to npm:
 
 1. Be sure to have the Android [SDK](https://developer.android.com/studio/index.html) and [NDK](https://developer.android.com/ndk/guides/index.html) installed
 2. Be sure to have a `local.properties` file in this folder that points to the Android SDK and NDK
+
 ```
 ndk.dir=/Users/{username}/Library/Android/sdk/ndk-bundle
 sdk.dir=/Users/{username}/Library/Android/sdk
 ```
+
 3. Delete the `maven` folder
 4. Run `./gradlew installArchives`
 5. Verify that latest set of generated files is in the maven folder with the correct version number

package/android/build.gradle

@@ -1,22 +1,21 @@
-// android/build.gradle
-// based on:
-//
-// * https://github.com/facebook/react-native/blob/0.60-stable/template/android/build.gradle
-//   original location:
-//   - https://github.com/facebook/react-native/blob/0.58-stable/local-cli/templates/HelloWorld/android/build.gradle
-//
-// * https://github.com/facebook/react-native/blob/0.60-stable/template/android/app/build.gradle
-//   original location:
-//   - https://github.com/facebook/react-native/blob/0.58-stable/local-cli/templates/HelloWorld/android/app/build.gradle
-def DEFAULT_BUILD_TOOLS_VERSION = '34.0.0'
+def DEFAULT_BUILD_TOOLS_VERSION = '35.0.0'
 def safeExtGet(prop, fallback) {
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
 }
+
+ def isNewArchitectureEnabled() {
+    return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
+}
+
+if (isNewArchitectureEnabled()) {
+    apply plugin: 'com.facebook.react'
+}
+
 apply plugin: 'com.android.library'
 // apply plugin: 'maven'
 apply plugin: "kotlin-android"
 buildscript {
-    ext.kotlin_version = '1.8.20'
+    ext.kotlin_version = '1.9.20'
     // The Android Gradle plugin is only required when opening the android folder stand-alone.
     // This avoids unnecessary downloads and potential conflicts when the library is included as a
     // module dependency in an application project.
@@ -27,19 +26,20 @@ buildscript {
             google()
         }
         dependencies {
-            classpath 'com.android.tools.build:gradle:7.4.2'
+            classpath 'com.android.tools.build:gradle:8.6.1'
             classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
         }
     }
 }
 android {
-    compileSdkVersion 34
+    compileSdkVersion 35
     buildToolsVersion safeExtGet('buildToolsVersion', DEFAULT_BUILD_TOOLS_VERSION)
     defaultConfig {
-        minSdkVersion 22
-        targetSdkVersion 34
+        minSdkVersion 23
+        targetSdkVersion 35
         versionCode 1
         versionName "1.0"
+        buildConfigField("boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString())
     }
     compileOptions {
         coreLibraryDesugaringEnabled true
@@ -85,12 +85,20 @@ dependencies {
     implementation fileTree(dir: 'libs', include: ['*.jar'])
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
 
-    playImplementation "com.namiml:sdk-android:3.2.11"
-    amazonImplementation "com.namiml:sdk-amazon:3.2.11"
+    playImplementation "com.namiml:sdk-android:3.3.0-beta.10"
+    amazonImplementation "com.namiml:sdk-amazon:3.3.0-beta.10"
 
     implementation "com.facebook.react:react-native:+"  // From node_modules
-    coreLibraryDesugaring "com.android.tools:desugar_jdk_libs:1.1.5"
+    coreLibraryDesugaring "com.android.tools:desugar_jdk_libs:2.0.4"
+
+}
 
+if (isNewArchitectureEnabled()) {
+    react {
+        jsRootDir = file("../src/")
+        libraryName = "Nami"
+        codegenJavaPackageName = "com.namiml.reactnative"
+    }
 }
 
 configurations {

package/android/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 #Wed May 26 17:12:26 EDT 2021
 distributionBase=GRADLE_USER_HOME
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
 distributionPath=wrapper/dists
 zipStorePath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME

package/android/src/main/AndroidManifest.xml

@@ -1,3 +1,3 @@
-<manifest package="com.nami.reactlibrary">
+<manifest package="com.namiml.reactnative">
 
 </manifest>

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

@@ -0,0 +1,3 @@
+package com.namiml.reactnative
+
+const val LOG_TAG = "RNNami"

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

@@ -0,0 +1,91 @@
+package com.namiml.reactnative
+
+import com.facebook.react.bridge.*
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.turbomodule.core.interfaces.TurboModule
+import com.namiml.Nami
+import com.namiml.NamiConfiguration
+import com.namiml.NamiLanguageCode
+import com.namiml.NamiLogLevel
+import android.util.Log
+
+@ReactModule(name = NamiBridgeModule.NAME)
+class NamiBridgeModule internal constructor(
+    private val context: ReactApplicationContext
+) : ReactContextBaseJavaModule(context), TurboModule {
+
+    companion object {
+        const val NAME = "RNNami"
+
+        private const val CONFIG_MAP_PLATFORM_ID_KEY = "appPlatformID"
+        private const val CONFIG_MAP_LOG_LEVEL_KEY = "logLevel"
+        private const val CONFIG_MAP_DEVELOPMENT_MODE_KEY = "developmentMode"
+        private const val CONFIG_MAP_NAMI_COMMANDS_KEY = "namiCommands"
+        private const val CONFIG_MAP_LANGUAGE_CODE_KEY = "namiLanguageCode"
+        private const val CONFIG_MAP_INITIAL_CONFIG_KEY = "initialConfig"
+
+        private const val PLATFORM_ID_ERROR_VALUE = "APPPLATFORMID_NOT_FOUND"
+    }
+
+    override fun getName(): String = NAME
+
+    @ReactMethod
+    fun sdkConfigured(promise: Promise) {
+        promise.resolve(Nami.isInitialized())
+    }
+
+    @ReactMethod
+    fun configure(configDict: ReadableMap, promise: Promise) {
+        logNewArchitectureStatus()
+
+        val appPlatformID = configDict.getString(CONFIG_MAP_PLATFORM_ID_KEY) ?: PLATFORM_ID_ERROR_VALUE
+        val builder = NamiConfiguration.Builder(context.applicationContext, appPlatformID)
+
+        when (configDict.getString(CONFIG_MAP_LOG_LEVEL_KEY)) {
+            "INFO" -> builder.logLevel(NamiLogLevel.INFO)
+            "WARN" -> builder.logLevel(NamiLogLevel.WARN)
+            "ERROR" -> builder.logLevel(NamiLogLevel.ERROR)
+            else -> builder.logLevel(NamiLogLevel.DEBUG)
+        }
+
+        if (configDict.hasKey(CONFIG_MAP_DEVELOPMENT_MODE_KEY) &&
+            configDict.getBoolean(CONFIG_MAP_DEVELOPMENT_MODE_KEY)) {
+            builder.developmentMode = true
+        }
+
+        configDict.getString(CONFIG_MAP_LANGUAGE_CODE_KEY)?.let { code ->
+            NamiLanguageCode.values().find { it.code == code }?.let {
+                builder.namiLanguageCode = it
+            }
+        }
+
+        configDict.getArray(CONFIG_MAP_NAMI_COMMANDS_KEY)?.let { commandsArray ->
+            val settingsList = mutableListOf<String>()
+            for (i in 0 until commandsArray.size()) {
+                commandsArray.getString(i)?.let { settingsList.add(it) }
+            }
+            builder.settingsList = settingsList
+        }
+
+        configDict.getString(CONFIG_MAP_INITIAL_CONFIG_KEY)?.let {
+            builder.initialConfig = it
+        }
+
+        context.runOnUiQueueThread {
+            Nami.configure(builder.build()) { result ->
+                val resultMap = Arguments.createMap().apply {
+                    putBoolean("success", result)
+                }
+                promise.resolve(resultMap)
+            }
+        }
+    }
+
+    fun logNewArchitectureStatus() {
+        val isNewArch = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+        Log.d("RNNami", "New Architecture is ${if (isNewArch) "ENABLED" else "DISABLED"}")
+    }
+
+    @ReactMethod fun addListener(eventName: String?) {}
+    @ReactMethod fun removeListeners(count: Int?) {}
+}

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

@@ -0,0 +1,140 @@
+package com.namiml.reactnative;
+
+import com.facebook.react.TurboReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfo;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+import com.facebook.react.uimanager.ViewManager;
+import com.namiml.reactnative.BuildConfig;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class NamiBridgePackage extends TurboReactPackage {
+
+    @Override
+    public NativeModule getModule(String name, ReactApplicationContext context) {
+        return switch (name) {
+            case NamiBridgeModule.NAME -> new NamiBridgeModule(context);
+            case NamiCampaignManagerBridgeModule.NAME ->
+                    new NamiCampaignManagerBridgeModule(context);
+            case NamiEntitlementManagerBridgeModule.NAME ->
+                    new NamiEntitlementManagerBridgeModule(context);
+            case NamiCustomerManagerBridgeModule.NAME ->
+                    new NamiCustomerManagerBridgeModule(context);
+            case NamiFlowManagerBridgeModule.NAME -> new NamiFlowManagerBridgeModule(context);
+            case NamiPaywallManagerBridgeModule.NAME -> new NamiPaywallManagerBridgeModule(context);
+            case NamiPurchaseManagerBridgeModule.NAME ->
+                    new NamiPurchaseManagerBridgeModule(context);
+            default -> null;
+        };
+    }
+
+    @Override
+    public ReactModuleInfoProvider getReactModuleInfoProvider() {
+        return () -> {
+            final Map<String, ReactModuleInfo> moduleInfos = new HashMap<>();
+
+            // Declare all TurboModules here
+            moduleInfos.put(
+                    NamiBridgeModule.NAME,
+                    new ReactModuleInfo(
+                            NamiBridgeModule.NAME,
+                            NamiBridgeModule.NAME,
+                            false,
+                            false,
+                            true,
+                            false,
+                            BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+                    )
+            );
+
+            moduleInfos.put(
+                    NamiCampaignManagerBridgeModule.NAME,
+                    new ReactModuleInfo(
+                            NamiCampaignManagerBridgeModule.NAME,
+                            NamiCampaignManagerBridgeModule.NAME,
+                            false,
+                            false,
+                            true,
+                            false,
+                            BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+                    )
+            );
+
+            moduleInfos.put(
+                    NamiEntitlementManagerBridgeModule.NAME,
+                    new ReactModuleInfo(
+                            NamiEntitlementManagerBridgeModule.NAME,
+                            NamiEntitlementManagerBridgeModule.NAME,
+                            false,
+                            false,
+                            true,
+                            false,
+                            BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+                    )
+            );
+
+            moduleInfos.put(
+                    NamiCustomerManagerBridgeModule.NAME,
+                    new ReactModuleInfo(
+                            NamiCustomerManagerBridgeModule.NAME,
+                            NamiCustomerManagerBridgeModule.NAME,
+                            false,
+                            false,
+                            true,
+                            false,
+                            BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+                    )
+            );
+
+            moduleInfos.put(
+                    NamiFlowManagerBridgeModule.NAME,
+                    new ReactModuleInfo(
+                            NamiFlowManagerBridgeModule.NAME,
+                            NamiFlowManagerBridgeModule.NAME,
+                            false,
+                            false,
+                            true,
+                            false,
+                            BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+                    )
+            );
+
+            moduleInfos.put(
+                    NamiPaywallManagerBridgeModule.NAME,
+                    new ReactModuleInfo(
+                            NamiPaywallManagerBridgeModule.NAME,
+                            NamiPaywallManagerBridgeModule.NAME,
+                            false,
+                            false,
+                            true,
+                            false,
+                            BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+                    )
+            );
+
+            moduleInfos.put(
+                    NamiPurchaseManagerBridgeModule.NAME,
+                    new ReactModuleInfo(
+                            NamiPurchaseManagerBridgeModule.NAME,
+                            NamiPurchaseManagerBridgeModule.NAME,
+                            false,
+                            false,
+                            true,
+                            false,
+                            BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+                    )
+            );
+            return moduleInfos;
+        };
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext context) {
+        return Collections.emptyList();
+    }
+}

package/android/src/main/java/com/{nami/reactlibrary → namiml/reactnative}/NamiCampaignManagerBridge.kt

@@ -1,22 +1,27 @@
-package com.nami.reactlibrary
+package com.namiml.reactnative
 
 import android.app.Activity
-import android.content.Intent
 import android.net.Uri
 import android.util.Log
 import com.facebook.react.bridge.*
+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.billing.NamiPurchase
 import com.namiml.campaign.LaunchCampaignResult
 import com.namiml.campaign.NamiCampaign
 import com.namiml.campaign.NamiCampaignManager
 import com.namiml.paywall.model.NamiPaywallEvent
 import com.namiml.paywall.model.PaywallLaunchContext
+import androidx.core.net.toUri
+
+@ReactModule(name = NamiCampaignManagerBridgeModule.NAME)
+class NamiCampaignManagerBridgeModule internal constructor(
+    private val reactContext: ReactApplicationContext
+) : ReactContextBaseJavaModule(reactContext), TurboModule {
 
-class NamiCampaignManagerBridgeModule(reactContext: ReactApplicationContext) :
-    ReactContextBaseJavaModule(reactContext), ActivityEventListener {
-    // handlePaywallCallback metadata
     companion object {
+        const val NAME = "RNNamiCampaignManager"
         const val CAMPAIGN_ID = "campaignId"
         const val CAMPAIGN_LABEL = "campaignLabel"
         const val PAYWALL_ID = "paywallId"
@@ -34,11 +39,12 @@ class NamiCampaignManagerBridgeModule(reactContext: ReactApplicationContext) :
         const val DEEP_LINK_URL = "deeplinkUrl"
         const val TIME_SPENT_ON_PAYWALL = "timeSpentOnPaywall"
         const val VIDEO_METADATA = "videoMetadata"
-        const val _RESULT_CAMPAIGN = "ResultCampaign"
+        const val NAMI_PAYWALL_EVENT = "NamiPaywallEvent"
     }
 
+
     override fun getName(): String {
-        return "RNNamiCampaignManager"
+        return NAME
     }
 
     private fun campaignToReadableMap(campaign: NamiCampaign): ReadableMap {
@@ -60,26 +66,24 @@ class NamiCampaignManagerBridgeModule(reactContext: ReactApplicationContext) :
     ) {
         var theActivity: Activity? = null
         if (reactApplicationContext.hasCurrentActivity()) {
-            theActivity = reactApplicationContext.getCurrentActivity()
+            theActivity = reactApplicationContext.currentActivity
         }
 
         var paywallLaunchContext: PaywallLaunchContext? = null
         if (context != null) {
             val productGroups: MutableList<String> = mutableListOf()
-            val customAttributes: MutableMap<String, String> = mutableMapOf()
-            var customObject: MutableMap<String, Any> = mutableMapOf()
+            val customAttributes: MutableMap<String, Any> = mutableMapOf()
+            var customObject: MutableMap<String, Any?> = mutableMapOf()
 
             if (context.hasKey("productGroups")) {
                 val groups = context.getArray("productGroups")
                 if (groups != null) {
                     for (i in 0 until groups.size()) {
                         val groupString = groups.getString(i)
-                        if (groupString != null) {
-                            productGroups.add(groupString)
-                        }
+                        productGroups.add(groupString)
                     }
                 }
-                Log.d(LOG_TAG, "productGroups $productGroups")
+                Log.d(NAME, "productGroups $productGroups")
             }
 
             if (context.hasKey("customAttributes")) {
@@ -90,7 +94,7 @@ class NamiCampaignManagerBridgeModule(reactContext: ReactApplicationContext) :
                         val key = keyIterator.nextKey()
                         customAttributes[key] = attr.getString(key) ?: ""
                     }
-                    Log.d(LOG_TAG, "customAttributes $customAttributes")
+                    Log.d(NAME, "customAttributes $customAttributes")
                 }
             }
 
@@ -100,7 +104,7 @@ class NamiCampaignManagerBridgeModule(reactContext: ReactApplicationContext) :
                     try {
                         customObject = attr.toHashMap().toMutableMap()
                     } catch (e: Exception) {
-                        Log.d(LOG_TAG, "Unable to parse PaywallLaunchContext customObject $customObject")
+                        Log.d(NAME, "Unable to parse PaywallLaunchContext customObject $customObject")
                     }
                 }
             }
@@ -122,7 +126,7 @@ class NamiCampaignManagerBridgeModule(reactContext: ReactApplicationContext) :
                     )
                 }
 
-                val uriObject: Uri? = if (withUrl != null) Uri.parse(withUrl) else null
+                val uriObject: Uri? = if (withUrl != null) withUrl.toUri() else null
 
                 if (label != null) {
                     NamiCampaignManager.launch(
@@ -214,7 +218,7 @@ class NamiCampaignManagerBridgeModule(reactContext: ReactApplicationContext) :
             resultMap.putDouble(TIME_SPENT_ON_PAYWALL, paywallEvent.timeSpentOnPaywall ?: 0.0)
         }
 
-        emitEvent(_RESULT_CAMPAIGN, resultMap)
+        emitEvent(NAMI_PAYWALL_EVENT, resultMap)
     }
 
     private fun createPurchaseArray(purchases: List<NamiPurchase>?): WritableArray {
@@ -223,7 +227,7 @@ class NamiCampaignManagerBridgeModule(reactContext: ReactApplicationContext) :
                 try {
                     pushMap(purchase.toPurchaseDict())
                 } catch (e: Exception) {
-                    Log.e(LOG_TAG, "Error while converting data in createPurchaseArray to a Map", e)
+                    Log.e(NAME, "Error while converting data in createPurchaseArray to a Map", e)
                 }
             }
         }
@@ -237,7 +241,7 @@ class NamiCampaignManagerBridgeModule(reactContext: ReactApplicationContext) :
         if (emitter is DeviceEventManagerModule.RCTDeviceEventEmitter) {
             emitter.emit(event, map)
         } else {
-            Log.w(LOG_TAG, "Cannot emit $event event: RCTDeviceEventEmitter instance is null")
+            Log.w(NAME, "Cannot emit $event event: RCTDeviceEventEmitter instance is null")
         }
     }
 
@@ -256,19 +260,6 @@ class NamiCampaignManagerBridgeModule(reactContext: ReactApplicationContext) :
         }
     }
 
-    override fun onActivityResult(
-        activity: Activity?,
-        requestCode: Int,
-        resultCode: Int,
-        intent: Intent?,
-    ) {
-        Log.d(LOG_TAG, "Nami Activity result listener activated, code is $requestCode")
-    }
-
-    override fun onNewIntent(intent: Intent?) {
-        // do nothing
-    }
-
     @ReactMethod
     fun allCampaigns(promise: Promise) {
         val campaigns = NamiCampaignManager.allCampaigns()
@@ -287,14 +278,15 @@ class NamiCampaignManagerBridgeModule(reactContext: ReactApplicationContext) :
         val isCampaignAvailable =
             when {
                 campaignSource == null -> NamiCampaignManager.isCampaignAvailable()
-                Uri.parse(campaignSource)?.scheme != null -> NamiCampaignManager.isCampaignAvailable(Uri.parse(campaignSource))
+                campaignSource.toUri().scheme != null -> NamiCampaignManager.isCampaignAvailable(
+                    campaignSource.toUri())
                 else -> NamiCampaignManager.isCampaignAvailable(campaignSource)
             }
         promise.resolve(isCampaignAvailable)
     }
 
     @ReactMethod
-     fun refresh(promise: Promise) {
+    fun refresh(promise: Promise) {
         NamiCampaignManager.refresh { campaigns ->
             val array = WritableNativeArray()
             campaigns?.forEach { campaign ->

package/android/src/main/java/com/{nami/reactlibrary → namiml/reactnative}/NamiCustomerManagerBridge.kt

@@ -1,15 +1,23 @@
-package com.nami.reactlibrary
+package com.namiml.reactnative
 
 import com.facebook.react.bridge.*
+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.customer.CustomerJourneyState
 import com.namiml.customer.NamiCustomerManager
 
-class NamiCustomerManagerBridgeModule(reactContext: ReactApplicationContext) :
-    ReactContextBaseJavaModule(reactContext) {
+@ReactModule(name = NamiCustomerManagerBridgeModule.NAME)
+class NamiCustomerManagerBridgeModule internal constructor(
+    private val reactContext: ReactApplicationContext
+) : ReactContextBaseJavaModule(reactContext), TurboModule {
+
+    companion object {
+        const val NAME = "RNNamiCustomerManager"
+    }
 
     override fun getName(): String {
-        return "RNNamiCustomerManager"
+        return NAME
     }
 
     private fun journeyStateToReadableMap(journeyState: CustomerJourneyState): ReadableMap {
@@ -109,7 +117,7 @@ class NamiCustomerManagerBridgeModule(reactContext: ReactApplicationContext) :
     fun registerJourneyStateHandler() {
         NamiCustomerManager.registerJourneyStateHandler { journeyState ->
             val handledJourneyState = journeyStateToReadableMap(journeyState)
-            reactApplicationContext
+            reactContext
                 .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
                 .emit("JourneyStateChanged", handledJourneyState)
         }
@@ -122,7 +130,7 @@ class NamiCustomerManagerBridgeModule(reactContext: ReactApplicationContext) :
             body.putString("action", action.toString())
             body.putBoolean("success", success)
             body.putString("error", error.toString())
-            reactApplicationContext
+            reactContext
                 .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
                 .emit("AccountStateChanged", body)
         }