react-native-nami-sdk 2.0.5 → 3.0.8

package/.github/workflows/app_stg.yaml

@@ -0,0 +1,203 @@
+name: Generate Test React STG
+on:
+  workflow_dispatch:
+    inputs:
+      ref:
+        default: develop
+        description: "Git Tag, Branch or SHA to build"
+        required: true
+    secrets:
+      BUILD_USER_PAT:
+        required: true
+
+  pull_request:
+    types:
+      - closed
+    branches:
+      - develop
+    secrets:
+      BUILD_USER_PAT:
+        required: true
+
+jobs:
+  build-android:
+    name: Generate Play Store STG
+    permissions:
+      actions: write
+      contents: write
+      id-token: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/setup-node@v3
+        with:
+          node-version: "16"
+
+      - name: 'Checkout ${{ inputs.ref }}'
+        uses: actions/checkout@v2
+        with:
+          path: source
+          ref: '${{ inputs.ref }}'
+
+      - name: Install Google API python client
+        run: |
+          pip install google-api-python-client
+
+      - name: Get new version code
+        run: |
+          echo $GOOGLE_PLAY_SERVICE_ACCOUNT > $RUNNER_TEMP/.service_account
+          python3 build-utils/get_version_code.py $RUNNER_TEMP/.service_account com.namiml.stg.testreactnative internal  --quiet >> $RUNNER_TEMP/.new_version_code
+          rm -f .service_account
+        env:
+          GOOGLE_PLAY_SERVICE_ACCOUNT: '${{ secrets.GOOGLE_PLAY_SERVICE_ACCOUNT }}'
+        working-directory: source
+
+      - name: Update version code
+        working-directory: source/examples/Basic/android/app
+        run: |
+          NEW_VERSION_CODE=`cat $RUNNER_TEMP/.new_version_code`
+          echo $NEW_VERSION_CODE
+          sed -i "s/versionCode 1/versionCode $NEW_VERSION_CODE/" build.gradle
+
+      - name: Create the Keystore
+        run: |
+          # import keystore from secrets
+          echo $KEYSTORE_BASE64 | base64 -d > $RUNNER_TEMP/my_production.keystore
+        env:
+          KEYSTORE_BASE64: '${{ secrets.KEY_STORE_BASE64 }}'
+
+      - name: Install test app dependencies
+        run: |
+          yarn install
+        working-directory: source/examples/Basic
+
+      - name: Build Android App Bundle
+        run: |
+          ./gradlew clean bundleStagingRelease
+        working-directory: source/examples/Basic/android
+
+      - name: Sign Android App Bundle
+        run: |
+          jarsigner -keystore $RUNNER_TEMP/my_production.keystore -storepass '${{ secrets.KEY_STORE_PASSWORD }}' -keypass '${{ secrets.KEY_PASSWORD }}' -sigalg SHA256withRSA -digestalg SHA-256 -signedjar build/outputs/bundle/stagingRelease/app-staging-release-signed.aab build/outputs/bundle/stagingRelease/app-staging-release.aab '${{ secrets.KEY_ALIAS }}'
+        working-directory: source/examples/Basic/android/app
+
+      - name: Uploading to test track
+        uses: r0adkll/upload-google-play@v1.0.17
+        with:
+          packageName: 'com.namiml.stg.testreactnative'
+          releaseFiles: source/examples/Basic/android/app/build/outputs/bundle/stagingRelease/app-staging-release-signed.aab
+          serviceAccountJsonPlainText: '${{ secrets.GOOGLE_PLAY_SERVICE_ACCOUNT }}'
+          status: completed
+          track: internal
+  build-ios:
+    name: Generate Apple STG
+    permissions:
+      actions: write
+      contents: write
+      id-token: write
+    runs-on: macos-12
+    timeout-minutes: 40
+    steps:
+      - uses: actions/setup-node@v3
+        with:
+          node-version: "16"
+
+      - name: "Checkout ${{ inputs.ref }}"
+        uses: actions/checkout@v2
+        with:
+          path: source
+          ref: "${{ inputs.ref }}"
+
+      - name: Checkout appstoreconnect-build-tools
+        uses: actions/checkout@v2
+        with:
+          path: appstoreconnect-build-tools
+          ref: main
+          repository: namiml/appstoreconnect-build-tools
+
+      - name: Set up Python
+        uses: actions/setup-python@v1
+        with:
+          python-version: "3.10"
+
+      - name: Get expected build number
+        run: |
+          pip3 install requests
+          pip3 install pydantic
+          pip3 install cryptography
+          pip3 install PyJWT
+          echo "1.0" > $RUNNER_TEMP/.current_version
+          export CURRENT_VERSION=`cat $RUNNER_TEMP/.current_version`
+          python3 get_next_build.py com.namiml.stg.testreactnative --prerelease --version=$CURRENT_VERSION > $RUNNER_TEMP/.next_build_number
+        working-directory: appstoreconnect-build-tools
+        env:
+          APPSTORE_API_KEY_ID: "${{ secrets.APPSTORE_API_KEY_ID }}"
+          APPSTORE_API_PRIVATE_KEY: "${{ secrets.APPSTORE_API_PRIVATE_KEY }}"
+          APPSTORE_ISSUER_ID: "${{ secrets.APPSTORE_ISSUER_ID }}"
+
+      - name: Install Apple Certificate
+        uses: apple-actions/import-codesign-certs@v1
+        with:
+          p12-file-base64: "${{ secrets.IOS_P12_BASE64 }}"
+          p12-password: "${{ secrets.IOS_CERTIFICATE_PASSWORD }}"
+
+      - name: Install the provisioning profile
+        run: |
+          PP_PATH=$RUNNER_TEMP/build_pp.mobileprovision
+          echo -n "$PROVISIONING_CERTIFICATE_BASE64" | base64 --decode --output $PP_PATH
+          mkdir -p ~/Library/MobileDevice/Provisioning\ Profiles
+          cp $PP_PATH ~/Library/MobileDevice/Provisioning\ Profiles
+        env:
+          PROVISIONING_CERTIFICATE_BASE64: "${{ secrets.IOS_MOBILE_PROVISION_BASE64_TEST_REACT_STG }}"
+
+      - name: Store App Store Private Key
+        run: |
+          mkdir ~/.private_keys
+          echo '${{ secrets.APPSTORE_API_PRIVATE_KEY }}' > ~/.private_keys/AuthKey_'${{ secrets.APPSTORE_API_KEY_ID }}'.p8
+
+      - name: Update ExportOptions.plist
+        run: |
+          sed -i '' -e "s/APPSTORE_TEAM_ID/${{ secrets.APPSTORE_TEAM_ID }}/" ExportOptions.plist
+          sed -i '' -e "s/APPSTORE_PROVISIONING_PROFILE_UUID/${{ secrets.APPSTORE_PROV_PROFILE_UUID_TEST_REACT_STG }}/g" ExportOptions.plist
+        working-directory: source/examples/Basic/ios
+
+      - name: Adjust version & build number
+        run: |-
+           export CURRENT_VERSION=`cat $RUNNER_TEMP/.current_version`
+           export BUILD_NUMBER=`cat $RUNNER_TEMP/.next_build_number`
+           sed -i '' -e "s/CURRENT_PROJECT_VERSION = 1/CURRENT_PROJECT_VERSION = $BUILD_NUMBER/" ios/Basic.xcodeproj/project.pbxproj
+           sed -i '' -e "s/MARKETING_VERSION = 1.0/MARKETING_VERSION = $CURRENT_VERSION/" ios/Basic.xcodeproj/project.pbxproj
+           sed -i '' -e "s/<string>1<\/string>/<string>$BUILD_NUMBER<\/string>/"  ios/Basic/Info.plist
+        working-directory: source/examples/Basic
+
+      - name: Install test app dependencies
+        run: |
+          yarn install
+        working-directory: source/examples/Basic
+
+      - name: Install test iOS dependencies
+        run: |
+          pod install
+        working-directory: source/examples/Basic/ios
+
+      - name: Build resolve Swift dependencies
+        run: |
+          xcodebuild -resolvePackageDependencies -workspace ios/Basic.xcworkspace -scheme Basic -configuration Release
+        working-directory: source/examples/Basic
+
+      - name: Build xArchive
+        run: |
+          xcodebuild -workspace ios/Basic.xcworkspace -scheme Basic -configuration Release DEVELOPMENT_TEAM='${{ secrets.APPSTORE_TEAM_ID }}' -sdk 'iphoneos' -destination 'generic/platform=iOS' -archivePath build-output/app-stg.xcarchive PROVISIONING_PROFILE='${{ secrets.APPSTORE_PROV_PROFILE_UUID_TEST_REACT_STG }}' clean archive CODE_SIGN_IDENTITY='${{ secrets.CODE_SIGNING_IDENTITY }}'
+        working-directory: source/examples/Basic
+
+      - name: Export IPA
+        run: |
+          xcodebuild -exportArchive -archivePath build-output/app-stg.xcarchive -exportPath build-output/ios-stg -exportOptionsPlist ios/ExportOptions.plist
+        working-directory: source/examples/Basic
+
+      - name: Upload app to TestFlight
+        run: |
+          xcrun altool --upload-app --type ios --file build-output/ios-stg/Basic.ipa --apiKey $APPSTORE_API_KEY_ID --apiIssuer $APPSTORE_ISSUER_ID
+        working-directory: source/examples/Basic
+        env:
+          APPSTORE_API_KEY_ID: "${{ secrets.APPSTORE_API_KEY_ID }}"
+          APPSTORE_ISSUER_ID: "${{ secrets.APPSTORE_ISSUER_ID }}"

package/.pre-commit-config.yaml

@@ -16,7 +16,7 @@ repos:
       - id: trailing-whitespace
         exclude: ^.*\b(\.(js|jsx|tsx).snap)\b$
   - repo: https://github.com/nicklockwood/SwiftFormat
-    rev: 0.50.8 
+    rev: 0.50.8
     hooks:
       - id: swiftformat
   - repo: https://github.com/macisamuele/language-formatters-pre-commit-hooks

package/android/build.gradle

@@ -15,7 +15,7 @@ def safeExtGet(prop, fallback) {
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
 }
 apply plugin: 'com.android.library'
-apply plugin: 'maven'
+// apply plugin: 'maven'
 apply plugin: "kotlin-android"
 apply plugin: "kotlin-android-extensions"
 buildscript {
@@ -30,17 +30,17 @@ buildscript {
             google()
         }
         dependencies {
-            classpath 'com.android.tools.build:gradle:4.2.1'
+            classpath 'com.android.tools.build:gradle:7.0.4'
             classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
         }
     }
 }
 android {
-    compileSdkVersion 31
+    compileSdkVersion 33
     buildToolsVersion safeExtGet('buildToolsVersion', DEFAULT_BUILD_TOOLS_VERSION)
     defaultConfig {
-        minSdkVersion 26
-        targetSdkVersion 31
+        minSdkVersion 22
+        targetSdkVersion 33
         versionCode 1
         versionName "1.0"
     }
@@ -52,7 +52,10 @@ android {
         abortOnError false
     }
     kotlinOptions {
-        jvmTarget = "1.8"
+        jvmTarget = JavaVersion.VERSION_1_8.toString()
+    }
+    dexOptions {
+        javaMaxHeapSize "4g"
     }
 }
 repositories {
@@ -60,6 +63,7 @@ repositories {
     // ref: https://www.baeldung.com/maven-local-repository
     mavenLocal()
     maven { url("https://packages.namiml.com/NamiSDK/Android/") }
+    maven { url 'https://jitpack.io' }
     maven {
         // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
         url("$rootDir/../node_modules/react-native/android")
@@ -76,7 +80,8 @@ dependencies {
     implementation fileTree(dir: 'libs', include: ['*.jar'])
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
 
-    implementation "com.namiml:sdk-android:2.0.2"
+    implementation 'com.github.jeziellago:compose-markdown:0.3.0'
+    implementation "com.namiml:sdk-android:3.0.8.2"
 
     implementation 'com.facebook.react:react-native:+'  // From node_modules
 }
@@ -104,13 +109,19 @@ def configureReactNativePom(def pom) {
         }
     }
 }
+
+configurations {
+  customConfig.extendsFrom implementation
+}
+
 afterEvaluate { project ->
     // some Gradle build hooks ref:
     // https://www.oreilly.com/library/view/gradle-beyond-the/9781449373801/ch03.html
     task androidJavadoc(type: Javadoc) {
         source = android.sourceSets.main.java.srcDirs
         classpath += files(android.bootClasspath)
-        classpath += files(project.getConfigurations().getByName('compile').asList())
+//         classpath += files(project.getConfigurations().getByName('compile').asList())
+//        classpath += files(project.getConfigurations().getByName('customConfig').asList())
         include '**/*.java'
     }
     task androidJavadocJar(type: Jar, dependsOn: androidJavadoc) {
@@ -135,10 +146,10 @@ afterEvaluate { project ->
     }
     task installArchives(type: Upload) {
         configuration = configurations.archives
-        repositories.mavenDeployer {
-            // Deploy to react-native-event-bridge/maven, ready to publish to npm
-            repository url: "file://${projectDir}/../android/maven"
-            configureReactNativePom pom
-        }
+        // repositories.mavenDeployer {
+        //     // Deploy to react-native-event-bridge/maven, ready to publish to npm
+        //     repository url: "file://${projectDir}/../android/maven"
+        //     configureReactNativePom pom
+        // }
     }
 }

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

@@ -1,6 +1,10 @@
 #Wed May 26 17:12:26 EDT 2021
 distributionBase=GRADLE_USER_HOME
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.7.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.0.2-bin.zip
 distributionPath=wrapper/dists
 zipStorePath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
+org.gradle.jvmargs=-Xmx4096m -XX:MaxPermSize=4096m -XX:+HeapDumpOnOutOfMemoryError
+org.gradle.daemon=true
+org.gradle.parallel=true
+org.gradle.configureondemand=true

package/android/src/main/java/com/nami/reactlibrary/NamiBridgeModule.kt

@@ -14,7 +14,6 @@ import com.facebook.react.bridge.WritableArray
 import com.facebook.react.bridge.WritableNativeArray
 import com.namiml.Nami
 import com.namiml.NamiConfiguration
-import com.namiml.NamiExternalIdentifierType
 import com.namiml.NamiLanguageCode
 import com.namiml.NamiLogLevel
 //import com.namiml.NamiApiResponseHandler
@@ -23,7 +22,7 @@ class NamiBridgeModule(reactContext: ReactApplicationContext) :
     ReactContextBaseJavaModule(reactContext) {
 
     companion object {
-        private const val CONFIG_MAP_PLATFORM_ID_KEY = "appPlatformID-google"
+        private const val CONFIG_MAP_PLATFORM_ID_KEY = "appPlatformID-android"
         private const val CONFIG_MAP_LOG_LEVEL_KEY = "logLevel"
         private const val CONFIG_MAP_DEVELOPMENT_MODE_KEY = "developmentMode"
         private const val CONFIG_MAP_BYPASS_STORE_KEY = "bypassStore"
@@ -37,7 +36,7 @@ class NamiBridgeModule(reactContext: ReactApplicationContext) :
     }
 
     @ReactMethod
-    fun configure(configDict: ReadableMap) {
+    fun configure(configDict: ReadableMap, completion: Callback) {
 
         // Need to be sure we have some valid string.
         val appPlatformID: String = if (configDict.hasKey(CONFIG_MAP_PLATFORM_ID_KEY)) {
@@ -128,7 +127,7 @@ class NamiBridgeModule(reactContext: ReactApplicationContext) :
             } else {
                 Arguments.createArray()
             }
-        val settingsList = mutableListOf("extendedClientInfo:react-native:2.0.5")
+        val settingsList = mutableListOf("extendedClientInfo:react-native:3.0.0")
         namiCommandsReact?.toArrayList()?.filterIsInstance<String>()?.let { commandsFromReact ->
             settingsList.addAll(commandsFromReact)
         }
@@ -141,52 +140,9 @@ class NamiBridgeModule(reactContext: ReactApplicationContext) :
         reactApplicationContext.runOnUiQueueThread {
             // Configure must be called on main thread
             Nami.configure(builtConfig)
-        }
-    }
-
-    @ReactMethod
-    fun setExternalIdentifier(externalIdentifier: String, externalIDType: String, completion: Callback) {
-
-        Log.i(LOG_TAG, "Setting external identifier $externalIdentifier of type $externalIDType")
-
-        val useType: NamiExternalIdentifierType = if (externalIDType == "sha256") {
-            NamiExternalIdentifierType.SHA_256
-        } else {
-            NamiExternalIdentifierType.UUID
-        }
-
-        reactApplicationContext.runOnUiQueueThread {
-            Nami.setExternalIdentifier(externalIdentifier, useType) { success, error ->
-                if (error != null) {
-                    completion.invoke(error)
-                }
-                completion.invoke(null)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun getExternalIdentifier(successCallback: Callback) {
-        reactApplicationContext.runOnUiQueueThread {
-            val externalIdentifierResult: WritableArray = WritableNativeArray()
-            Nami.getExternalIdentifier()?.let { externalIdentifier ->
-                Log.i(LOG_TAG, "getting external identifier, found $externalIdentifier")
-                externalIdentifierResult.pushString(externalIdentifier)
-            }
-            successCallback.invoke(externalIdentifierResult)
-        }
-    }
-
-    @ReactMethod
-    fun clearExternalIdentifier(completion: Callback) {
-        Log.i(LOG_TAG, "Clearing external identifier.")
-        reactApplicationContext.runOnUiQueueThread {
-            Nami.clearExternalIdentifier()  { success, error ->
-                if (error != null) {
-                    completion.invoke(error)
-                }
-                completion.invoke(null)
-            }
+            val resultMap = Arguments.createMap()
+            resultMap.putBoolean("success", true)
+            completion.invoke(resultMap)
         }
     }
 }

package/android/src/main/java/com/nami/reactlibrary/NamiBridgePackage.java

@@ -25,6 +25,7 @@ public class NamiBridgePackage implements ReactPackage {
         moduleList.add(new NamiEntitlementManagerBridgeModule(reactContext));
         moduleList.add(new NamiMLManagerBridgeModule(reactContext));
         moduleList.add(new NamiCustomerManagerBridgeModule(reactContext));
+        moduleList.add(new NamiCampaignManagerBridgeModule(reactContext));
         moduleList.add(new NamiEmitter(reactContext));
 
         return moduleList;

package/android/src/main/java/com/nami/reactlibrary/NamiCampaignManagerBridge.kt

@@ -0,0 +1,133 @@
+package com.nami.reactlibrary
+
+import android.content.Intent
+import android.util.Log
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.namiml.campaign.NamiCampaign
+import com.namiml.campaign.NamiCampaignManager
+import com.namiml.paywall.NamiSKU
+import com.namiml.paywall.model.NamiPaywallAction
+import android.app.Activity
+import com.namiml.billing.NamiPurchase
+import com.namiml.billing.NamiPurchaseState
+import com.namiml.campaign.LaunchCampaignResult
+
+class NamiCampaignManagerBridgeModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext), ActivityEventListener {
+
+    override fun getName(): String {
+        return "RNNamiCampaignManager"
+    }
+
+    private fun campaignToReadableMap(campaign: NamiCampaign): ReadableMap {
+        val readableMap = Arguments.createMap()
+        readableMap.putString("segment", campaign.segment)
+        readableMap.putString("paywall", campaign.paywall)
+        readableMap.putString("value", campaign.value)
+        readableMap.putString("type", campaign.type.toString().lowercase())
+        return readableMap
+    }
+
+    @ReactMethod
+    fun launch(label: String?, resultCallback: Callback, actionCallback: Callback) {
+        reactApplicationContext.runOnUiQueueThread {
+            if (label != null) {
+                NamiCampaignManager.launch(currentActivity!!, label,
+                        paywallActionCallback = { action, sku, purchaseError, purchases ->
+                            handlePaywallCallback(action, sku, purchaseError, purchases, actionCallback)
+                        }
+                ) { result -> handleResult(result, resultCallback) }
+            } else {
+                NamiCampaignManager.launch(currentActivity!!,
+                        paywallActionCallback = { action, sku,purchaseError, purchases  ->
+                            handlePaywallCallback(action, sku, purchaseError, purchases, actionCallback)
+                        }
+                ) { result -> handleResult(result, resultCallback) }
+            }
+        }
+    }
+
+    private fun handlePaywallCallback(action: NamiPaywallAction, sku: NamiSKU?, purchaseError: String?, purchases: List<NamiPurchase>?,  actionCallback: Callback){
+        val actionString = action.toString()
+        val skuString = sku?.skuId.orEmpty()
+        val purchasesArray: WritableArray = WritableNativeArray()
+        if (purchases != null) {
+            for (purchase in purchases) {
+                purchasesArray.pushMap(purchase.toPurchaseDict())
+            }
+        }
+        val resultMap = Arguments.createMap()
+        resultMap.putString("action", actionString)
+        resultMap.putString("skuId", skuString)
+        resultMap.putString("purchaseError", purchaseError)
+        resultMap.putArray("purchases", purchasesArray)
+        reactApplicationContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit("ResultCampaign", resultMap)
+    }
+
+    private fun handleResult(result: LaunchCampaignResult, resultCallback: Callback) {
+        val resultMap = Arguments.createMap()
+        when (result) {
+            is LaunchCampaignResult.Success -> {
+                resultCallback.invoke(true)
+            }
+            is LaunchCampaignResult.Failure -> {
+                resultCallback.invoke(false, "${result.error}")
+            }
+        }
+    }
+
+    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()
+        val array = WritableNativeArray()
+        campaigns.forEach { campaign ->
+            array.pushMap(campaignToReadableMap(campaign))
+        }
+        promise.resolve(array)
+    }
+
+    @ReactMethod
+    fun isCampaignAvailable(label: String?, promise: Promise){
+        val isCampaignAvailable: Boolean
+        if (label != null) {
+            isCampaignAvailable = NamiCampaignManager.isCampaignAvailable(label)
+        } else {
+            isCampaignAvailable = NamiCampaignManager.isCampaignAvailable()
+        }
+        promise.resolve(isCampaignAvailable)
+    }
+
+    @ReactMethod
+    fun refresh(){
+        NamiCampaignManager.refresh() {  }
+    }
+
+    @ReactMethod
+    fun registerAvailableCampaignsHandler() {
+        NamiCampaignManager.registerAvailableCampaignsHandler { availableCampaigns ->
+            val array = WritableNativeArray()
+            availableCampaigns.forEach { campaign ->
+                array.pushMap(campaignToReadableMap(campaign))
+            }
+            reactApplicationContext
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                    .emit("AvailableCampaignsChanged", array)
+        }
+    }
+}

package/android/src/main/java/com/nami/reactlibrary/NamiCustomerManagerBridge.kt

@@ -1,42 +1,111 @@
 package com.nami.reactlibrary
 
 import android.util.Log
-import com.facebook.react.bridge.Callback
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.*
 import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.namiml.campaign.NamiCampaignManager
 import com.namiml.customer.CustomerJourneyState
 import com.namiml.customer.NamiCustomerManager
 
+
 class NamiCustomerManagerBridgeModule(reactContext: ReactApplicationContext) :
     ReactContextBaseJavaModule(reactContext) {
 
     override fun getName(): String {
-        return "NamiCustomerManagerBridge"
+        return "RNNamiCustomerManager"
     }
 
-    init {
-        NamiCustomerManager.registerCustomerJourneyChangedListener { customerJourneyState ->
-            emitCustomerJourneyChanged(customerJourneyState)
-        }
+    private fun journeyStateToReadableMap(journeyState: CustomerJourneyState): ReadableMap {
+        val readableMap = Arguments.createMap()
+        readableMap.putBoolean("formerSubscriber", journeyState.formerSubscriber)
+        readableMap.putBoolean("inGracePeriodl", journeyState.inGracePeriod)
+        readableMap.putBoolean("inTrialPeriod", journeyState.inTrialPeriod)
+        readableMap.putBoolean("inIntroOfferPeriod", journeyState.inIntroOfferPeriod)
+        readableMap.putBoolean("isCancelled", journeyState.isCancelled)
+        readableMap.putBoolean("inPause", journeyState.inPause)
+        readableMap.putBoolean("inAccountHold", journeyState.inAccountHold)
+        return readableMap
+    }
+    @ReactMethod
+    fun setCustomerAttribute(key: String, value: String){
+        NamiCustomerManager.setCustomerAttribute(key, value)
+    }
+
+    @ReactMethod
+    fun getCustomerAttribute(key: String, promise: Promise){
+        val customerAttribute = NamiCustomerManager.getCustomerAttribute(key)
+        promise.resolve(customerAttribute)
+    }
+
+    @ReactMethod
+    fun clearCustomerAttribute(key: String){
+        NamiCustomerManager.clearCustomerAttribute(key)
+    }
+
+    @ReactMethod
+    fun clearAllCustomerAttributes(){
+        NamiCustomerManager.clearAllCustomerAttributes()
+    }
+
+    @ReactMethod
+   fun journeyState(promise: Promise){
+     val journeyState = NamiCustomerManager.journeyState()
+       if (journeyState != null) {
+           val handledJourneyState = journeyStateToReadableMap(journeyState)
+           promise.resolve(handledJourneyState)
+       } else {
+           promise.resolve(null)
+       }
+   }
+
+    @ReactMethod
+    fun isLoggedIn(promise: Promise){
+        val isLoggedIn = NamiCustomerManager.isLoggedIn()
+        promise.resolve(isLoggedIn)
+    }
+
+    @ReactMethod
+    fun loggedInId(promise: Promise){
+        val id = NamiCustomerManager.loggedInId()
+        promise.resolve(id)
+    }
+
+    @ReactMethod
+    fun deviceId(promise: Promise){
+        val id = NamiCustomerManager.deviceId()
+        promise.resolve(id)
     }
 
-    private fun emitCustomerJourneyChanged(customerJourneyState: CustomerJourneyState) {
-        Log.i(LOG_TAG, "Emitting CustomerJourneyState changed")
-        try {
+    @ReactMethod
+    fun login(customerId: String){
+        NamiCustomerManager.login(customerId)
+    }
+
+    @ReactMethod
+    fun logout() {
+        NamiCustomerManager.logout()
+    }
+
+    @ReactMethod
+    fun registerJourneyStateHandler() {
+        NamiCustomerManager.registerJourneyStateHandler { journeyState ->
+            val handledJourneyState = journeyStateToReadableMap(journeyState)
             reactApplicationContext
-                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                .emit("CustomerJourneyStateChanged", customerJourneyState.toDict())
-        } catch (e: Exception) {
-            Log.e(LOG_TAG, "Caught Exception: " + e.message)
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                    .emit("JourneyStateChanged", handledJourneyState)
         }
     }
 
     @ReactMethod
-    fun currentCustomerJourneyState(resultsCallback: Callback) {
-        reactApplicationContext.runOnUiQueueThread {
-            resultsCallback.invoke(NamiCustomerManager.currentCustomerJourneyState().toDict())
+    fun registerAccountStateHandler() {
+        NamiCustomerManager.registerAccountStateHandler { action, success, error ->
+            val body = Arguments.createMap()
+            body.putString("action", action.toString())
+            body.putBoolean("success", success)
+            body.putString("error", error.toString())
+            reactApplicationContext
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                    .emit("AccountStateChanged", body)
         }
     }
 }