react-native-sdk-pianoio 0.3.6 → 0.3.8

package/android/src/main/java/com/sdkpianoio/ComposerPianoImpl.kt

@@ -1,6 +1,7 @@
 package com.sdkpianoio
 
 import android.content.Context
+import android.util.Log
 import com.facebook.react.bridge.Promise
 import io.piano.android.composer.Composer
 import io.piano.android.composer.listeners.EventTypeListener
@@ -31,6 +32,7 @@ class ComposerPianoImpl {
 
     companion object {
         var aid: String = ""
+        private const val TAG = "ComposerPianoImpl"
     }
 
     // MARK: - Configuration Properties
@@ -45,7 +47,7 @@ class ComposerPianoImpl {
     // MARK: - Initialization
 
     constructor() {
-        println("ComposerPianoImpl: Constructor initialized")
+        Log.d(TAG, "Constructor initialized")
     }
 
     /**
@@ -54,35 +56,36 @@ class ComposerPianoImpl {
      * @param context The Android application context.
      * @param aid The Piano Application ID.
      */
-    fun initializeComposer(context: Context, aid: String) {
-        println("ComposerPianoImpl: Initializing composer with AID: $aid")
+    fun initializeComposer(context: Context, aid: String, isSandbox: Boolean) {
+        Log.d(TAG, "Initializing composer with AID: $aid, isSandbox: $isSandbox")
 
         // Validate input parameter
         if (aid.isBlank()) {
+            Log.e(TAG, "AID cannot be empty")
             throw IllegalArgumentException("AID cannot be empty")
         }
 
         // Configure static AID for the whole class
         ComposerPianoImpl.aid = aid
-        println("ComposerPianoImpl: Static AID configured: ${ComposerPianoImpl.aid}")
+        Log.d(TAG, "Static AID configured: ${ComposerPianoImpl.aid}")
 
         try {
-            // 1. Initialize the Composer SDK statically using the official API
-            Composer.init(context, aid, Composer.Endpoint.PRODUCTION)
-            println("ComposerPianoImpl: Composer SDK initialized for PRODUCTION")
+            val endpoint =
+                    if (isSandbox) Composer.Endpoint.SANDBOX else Composer.Endpoint.PRODUCTION
+            Log.d(TAG, "Using endpoint: $endpoint")
+            Composer.init(context, aid, endpoint)
+            Log.d(TAG, "Composer SDK initialized")
 
-            // 2. Get the singleton instance and store it
             this.composer = Composer.getInstance()
-            println("ComposerPianoImpl: Composer instance retrieved")
+            Log.d(TAG, "Composer instance retrieved")
 
-            // 3. Initialize the TokenService and store it as a property
             this.tokenService = TokenService()
             this.tokenService?.initialize(aid)
-            println("ComposerPianoImpl: TokenService initialized")
+            Log.d(TAG, "TokenService initialized")
 
-            println("ComposerPianoImpl: Initialization completed successfully")
+            Log.d(TAG, "Initialization completed successfully")
         } catch (e: Exception) {
-            println("ComposerPianoImpl: Error during initialization: ${e.message}")
+            Log.e(TAG, "Error during initialization", e)
             throw e
         }
     }
@@ -124,12 +127,14 @@ class ComposerPianoImpl {
     // MARK: - Configuration Methods (Setters)
 
     fun addTag(tag: String) {
+        Log.d(TAG, "Adding tag: $tag")
         if (!this.tags.contains(tag)) {
             this.tags.add(tag)
         }
     }
 
     fun addTags(tags: List<String>) {
+        Log.d(TAG, "Adding tags: $tags")
         for (tag in tags) {
             if (!this.tags.contains(tag)) {
                 this.tags.add(tag)
@@ -138,27 +143,33 @@ class ComposerPianoImpl {
     }
 
     fun setZoneId(zoneId: String) {
+        Log.d(TAG, "Setting zoneId: $zoneId")
         this.zoneId = zoneId
     }
 
     fun setReferrer(referrer: String) {
+        Log.d(TAG, "Setting referrer: $referrer")
         this.referrer = referrer
     }
 
     fun setUrl(url: String) {
+        Log.d(TAG, "Setting url: $url")
         this.url = url
     }
 
     fun setUserToken(token: String) {
+        Log.d(TAG, "Setting userToken")
         this.userToken = token
         composer?.userToken(token)
     }
 
     fun addCustomVariable(key: String, value: String) {
+        Log.d(TAG, "Adding custom variable: $key = $value")
         this.customVariables[key] = value
     }
 
     fun setCustomVariables(variables: Map<String, String>) {
+        Log.d(TAG, "Setting custom variables")
         this.customVariables.clear()
         this.customVariables.putAll(variables)
     }
@@ -166,22 +177,27 @@ class ComposerPianoImpl {
     // MARK: - Cleanup Methods
 
     fun clearTags() {
+        Log.d(TAG, "Clearing tags")
         this.tags.clear()
     }
 
     fun clearCustomVariables() {
+        Log.d(TAG, "Clearing custom variables")
         this.customVariables.clear()
     }
 
     fun removeTag(tag: String) {
+        Log.d(TAG, "Removing tag: $tag")
         this.tags.remove(tag)
     }
 
     fun removeCustomVariable(key: String) {
+        Log.d(TAG, "Removing custom variable: $key")
         this.customVariables.remove(key)
     }
 
     fun clearConfiguration() {
+        Log.d(TAG, "Clearing all configurations")
         this.clearTags()
         this.clearCustomVariables()
         this.zoneId = null
@@ -199,25 +215,25 @@ class ComposerPianoImpl {
      * @throws IllegalStateException if the composer has not been initialized.
      */
     fun executeComposer(promise: Promise) {
-        println("ComposerPianoImpl: Starting composer execution")
+        Log.d(TAG, "Starting composer execution")
 
-        // 1. Validate that the composer has been initialized
         val composerInstance = composer
         if (composerInstance == null) {
             val error =
                     IllegalStateException(
                             "Composer not initialized. Call initializeComposer() first."
                     )
-            println("ComposerPianoImpl: Error - Composer not initialized")
+            Log.e(TAG, "executeComposer failed: Composer not initialized")
             promise.reject("INIT_ERROR", error.message, error)
             return
         }
 
         try {
             val customParams = CustomParameters()
+            Log.d(TAG, "Custom params are: $customParams")
             this.customVariables.forEach { (key, value) -> customParams.request(key, value) }
+            Log.d(TAG, "Custom variables are $customVariables")
 
-            // 2. Build the ExperienceRequest with all stored configurations
             val request =
                     ExperienceRequest.Builder()
                             .tags(this.tags)
@@ -227,38 +243,46 @@ class ComposerPianoImpl {
                             .customParams(customParams)
                             .debug(false)
                             .build()
-            println("ComposerPianoImpl: ExperienceRequest created successfully")
+            Log.d(TAG, "ExperienceRequest created successfully")
 
-            // 3. Define the listeners to handle events from the SDK
             val listeners: List<EventTypeListener<*>> =
                     listOf(
                             UserSegmentListener { event ->
-                                println("UserSegmentListener event: ${event.eventData}")
-                                // You can process user segment data here if needed
+                                Log.d(
+                                        TAG,
+                                        "Listener received: UserSegmentListener event: ${event.eventData}"
+                                )
                             },
                             MeterListener { event ->
-                                println("MeterListener event: ${event.eventData}")
+                                Log.d(
+                                        TAG,
+                                        "Listener received: MeterListener event: ${event.eventData}"
+                                )
                                 promise.resolve(event.eventData.toString())
                             },
                             ShowTemplateListener { event: Event<ShowTemplate> ->
-                                println("ShowTemplateListener event: ${event.eventData}")
+                                Log.d(
+                                        TAG,
+                                        "Listener received: ShowTemplateListener event: ${event.eventData}"
+                                )
                                 promise.resolve(event.eventData.toString())
                             },
                             NonSiteListener { event ->
-                                println("NonSiteListener event: ${event.eventData}")
+                                Log.d(
+                                        TAG,
+                                        "Listener received: NonSiteListener event: ${event.eventData}"
+                                )
                             }
                     )
+            Log.d(TAG, "Event listeners created")
 
-            println("ComposerPianoImpl: Event listeners created")
-
-            // 4. Execute the experience request using the real Piano SDK method
             composerInstance.getExperience(request, listeners) { exception ->
-                println("ComposerPianoImpl: SDK returned an exception: ${exception.message}")
+                Log.e(TAG, "getExperience failed with exception", exception)
                 promise.reject("EXECUTION_ERROR", exception.message, exception)
             }
-            println("ComposerPianoImpl: getExperience() called successfully")
+            Log.d(TAG, "getExperience() called successfully")
         } catch (e: Exception) {
-            println("ComposerPianoImpl: Error during execution setup: ${e.message}")
+            Log.e(TAG, "Error during execution setup", e)
             promise.reject("SETUP_ERROR", e.message, e)
         }
     }

package/android/src/main/java/com/sdkpianoio/SdkPianoioModule.kt

@@ -1,5 +1,6 @@
 package com.sdkpianoio
 
+import android.util.Log
 import androidx.activity.ComponentActivity
 import androidx.activity.result.ActivityResultLauncher
 import com.facebook.react.bridge.Arguments
@@ -22,74 +23,91 @@ import io.piano.android.id.models.PianoIdAuthSuccessResult
  * This module serves as the bridge between JavaScript and the native Android implementation.
  */
 @ReactModule(name = SdkPianoioModule.NAME)
-class SdkPianoioModule(private val reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
-    
+class SdkPianoioModule(private val reactContext: ReactApplicationContext) :
+        ReactContextBaseJavaModule(reactContext) {
+
     private var composerImpl: ComposerPianoImpl? = null
     private var isInitialized: Boolean = false
     private var signInPromise: Promise? = null
 
     private lateinit var authResultLauncher: ActivityResultLauncher<PianoIdClient.SignInContext>
 
+    companion object {
+        const val NAME = "SdkPianoio"
+        private const val TAG = "SdkPianoioModule"
+    }
+
     init {
-        // The ActivityResultLauncher must be registered in the init block or onCreate.
-        // We need to ensure we have a ComponentActivity to access the registry.
+        Log.d(TAG, "Initializing SdkPianoioModule")
         val activity = reactContext.currentActivity
         if (activity is ComponentActivity) {
-            authResultLauncher = activity.activityResultRegistry.register(
-                "piano-id-login",
-                PianoIdAuthResultContract()
-            ) { result ->
-                val promise = signInPromise
-                signInPromise = null // Clean up promise immediately
-                when (result) {
-                    is PianoIdAuthSuccessResult -> {
-                        val token = result.token
-                        composerImpl?.tokenService?.setToken(token)
-                        val user = composerImpl?.tokenService?.getCurrentUser()
-                        if (user != null) {
-                            val resultMap = Arguments.createMap().apply {
-                                putBoolean("success", true)
-                                putString("userId", user.id)
-                                putString("userEmail", user.email)
-                                putString("accessToken", user.accessToken)
+            authResultLauncher =
+                    activity.activityResultRegistry.register(
+                            "piano-id-login",
+                            PianoIdAuthResultContract()
+                    ) { result ->
+                        Log.d(TAG, "ActivityResultLauncher received a result.")
+                        val promise = signInPromise
+                        signInPromise = null
+                        when (result) {
+                            is PianoIdAuthSuccessResult -> {
+                                Log.d(TAG, "Sign-in successful.")
+                                val token = result.token
+                                composerImpl?.tokenService?.setToken(token)
+                                val user = composerImpl?.tokenService?.getCurrentUser()
+                                if (user != null) {
+                                    val resultMap =
+                                            Arguments.createMap().apply {
+                                                putBoolean("success", true)
+                                                putString("userId", user.id)
+                                                putString("userEmail", user.email)
+                                                putString("accessToken", user.accessToken)
+                                            }
+                                    promise?.resolve(resultMap)
+                                } else {
+                                    Log.e(TAG, "Failed to construct user after login.")
+                                    promise?.reject(
+                                            "SIGNIN_ERROR",
+                                            "Failed to construct user after login."
+                                    )
+                                }
+                            }
+                            is PianoIdAuthFailureResult -> {
+                                val exception = result.exception
+                                Log.e(TAG, "Sign-in failed", exception)
+                                promise?.reject("SIGNIN_ERROR", exception.message, exception)
+                            }
+                            null -> {
+                                Log.w(TAG, "Sign-in cancelled by user.")
+                                promise?.reject("CANCELLED", "User cancelled the sign-in process.")
                             }
-                            promise?.resolve(resultMap)
-                        } else {
-                            promise?.reject("SIGNIN_ERROR", "Failed to construct user after login.")
                         }
                     }
-                    is PianoIdAuthFailureResult -> {
-                        val exception = result.exception
-                        promise?.reject("SIGNIN_ERROR", exception.message, exception)
-                    }
-                    null -> {
-                        // This handles the case where the user cancels the flow
-                        promise?.reject("CANCELLED", "User cancelled the sign-in process.")
-                    }
-                }
-            }
         } else {
-            // This is a fallback, though in a normal RN app, currentActivity should be a ComponentActivity.
-            // You might want to log a warning here.
+            Log.e(TAG, "Activity not available for registration. SignIn will not work.")
         }
     }
-    
+
     override fun getName(): String {
         return NAME
     }
-    
+
     @ReactMethod
-    fun initialize(aid: String, promise: Promise) {
+    fun initialize(aid: String, isSandbox: Boolean, promise: Promise) {
+        Log.d(TAG, "initialize called with AID: $aid, isSandbox: $isSandbox")
         try {
             if (isInitialized) {
+                Log.d(TAG, "Already initialized.")
                 promise.resolve(true)
                 return
             }
             composerImpl = ComposerPianoImpl()
-            composerImpl?.initializeComposer(reactContext, aid)
+            composerImpl?.initializeComposer(reactContext, aid, isSandbox)
             isInitialized = true
+            Log.d(TAG, "Initialization successful.")
             promise.resolve(true)
         } catch (e: Exception) {
+            Log.e(TAG, "Initialization failed", e)
             promise.reject("INIT_ERROR", "Failed to initialize Piano SDK", e)
         }
     }
@@ -98,86 +116,103 @@ class SdkPianoioModule(private val reactContext: ReactApplicationContext) : Reac
 
     @ReactMethod
     fun addTag(tag: String, promise: Promise) {
+        Log.d(TAG, "addTag called with: $tag")
         try {
             if (!validateInitialization(promise) || !validateParameter(tag, "tag", promise)) return
             composerImpl?.addTag(tag)
             promise.resolve(true)
         } catch (e: Exception) {
+            Log.e(TAG, "addTag failed", e)
             promise.reject("ADD_TAG_ERROR", "Error adding tag", e)
         }
     }
 
     @ReactMethod
     fun addTags(tagsArray: ReadableArray, promise: Promise) {
+        Log.d(TAG, "addTags called")
         try {
-            if (!validateInitialization(promise) || !validateArray(tagsArray, "tagsArray", promise)) return
+            if (!validateInitialization(promise) || !validateArray(tagsArray, "tagsArray", promise))
+                    return
             val tags = tagsArray.toArrayList().mapNotNull { it?.toString() }
             composerImpl?.addTags(tags)
             promise.resolve(true)
         } catch (e: Exception) {
+            Log.e(TAG, "addTags failed", e)
             promise.reject("ADD_TAGS_ERROR", "Error adding tags", e)
         }
     }
 
     @ReactMethod
     fun setZoneId(zoneId: String, promise: Promise) {
+        Log.d(TAG, "setZoneId called with: $zoneId")
         try {
             if (!validateInitialization(promise)) return
             composerImpl?.setZoneId(zoneId)
             promise.resolve(true)
         } catch (e: Exception) {
+            Log.e(TAG, "setZoneId failed", e)
             promise.reject("SET_ZONEID_ERROR", "Error setting Zone ID", e)
         }
     }
 
     @ReactMethod
     fun setReferrer(referrer: String, promise: Promise) {
+        Log.d(TAG, "setReferrer called with: $referrer")
         try {
             if (!validateInitialization(promise)) return
             composerImpl?.setReferrer(referrer)
             promise.resolve(true)
         } catch (e: Exception) {
+            Log.e(TAG, "setReferrer failed", e)
             promise.reject("SET_REFERRER_ERROR", "Error setting referrer", e)
         }
     }
 
     @ReactMethod
     fun setUrl(url: String, promise: Promise) {
+        Log.d(TAG, "setUrl called with: $url")
         try {
             if (!validateInitialization(promise)) return
             composerImpl?.setUrl(url)
             promise.resolve(true)
         } catch (e: Exception) {
+            Log.e(TAG, "setUrl failed", e)
             promise.reject("SET_URL_ERROR", "Error setting URL", e)
         }
     }
 
     @ReactMethod
     fun setUserToken(token: String, promise: Promise) {
+        Log.d(TAG, "setUserToken called")
         try {
             if (!validateInitialization(promise)) return
             composerImpl?.setUserToken(token)
             promise.resolve(true)
         } catch (e: Exception) {
+            Log.e(TAG, "setUserToken failed", e)
             promise.reject("SET_TOKEN_ERROR", "Error setting user token", e)
         }
     }
 
     @ReactMethod
     fun addCustomVariable(key: String, value: String, promise: Promise) {
+        Log.d(TAG, "addCustomVariable called with: $key = $value")
         try {
             if (!validateInitialization(promise)) return
             composerImpl?.addCustomVariable(key, value)
             promise.resolve(true)
         } catch (e: Exception) {
+            Log.e(TAG, "addCustomVariable failed", e)
             promise.reject("ADD_CUSTOMVAR_ERROR", "Error adding custom variable", e)
         }
     }
-    
+
     @ReactMethod
     fun setCustomVariables(variables: ReadableMap, promise: Promise) {
+        Log.d(TAG, "setCustomVariables called")
         try {
-            if (!validateInitialization(promise) || !validateMap(variables, "variables", promise)) return
+            if (!validateInitialization(promise) || !validateMap(variables, "variables", promise))
+                    return
             val map = mutableMapOf<String, String>()
             val iterator = variables.keySetIterator()
             while (iterator.hasNextKey()) {
@@ -194,6 +229,7 @@ class SdkPianoioModule(private val reactContext: ReactApplicationContext) : Reac
             composerImpl?.setCustomVariables(map)
             promise.resolve(true)
         } catch (e: Exception) {
+            Log.e(TAG, "setCustomVariables failed", e)
             promise.reject("SET_CUSTOMVARS_ERROR", "Error setting custom variables", e)
         }
     }
@@ -202,81 +238,97 @@ class SdkPianoioModule(private val reactContext: ReactApplicationContext) : Reac
 
     @ReactMethod
     fun executeExperience(promise: Promise) {
+        Log.d(TAG, "executeExperience called")
         try {
             if (!validateInitialization(promise)) return
             composerImpl?.executeComposer(promise)
         } catch (e: Exception) {
+            Log.e(TAG, "executeExperience failed", e)
             promise.reject("EXECUTION_ERROR", "Error executing experience", e)
         }
     }
 
     // MARK: - Authentication Methods
-    
+
     @ReactMethod
     fun signIn(promise: Promise) {
+        Log.d(TAG, "signIn called")
         if (signInPromise != null) {
+            Log.w(TAG, "Sign-in already in progress.")
             promise.reject("IN_PROGRESS", "Another sign-in operation is already in progress.")
             return
         }
         try {
             if (!validateInitialization(promise)) return
             this.signInPromise = promise
+            Log.d(TAG, "Launching sign-in flow via TokenService")
             composerImpl?.tokenService?.signIn(authResultLauncher)
         } catch (e: Exception) {
+            Log.e(TAG, "signIn failed", e)
             promise.reject("SIGNIN_ERROR", "Error during sign in", e)
             this.signInPromise = null
         }
     }
-    
+
     @ReactMethod
     fun signOut(promise: Promise) {
+        Log.d(TAG, "signOut called")
         try {
             if (!validateInitialization(promise)) return
             composerImpl?.tokenService?.signOut { success ->
                 if (success) {
+                    Log.d(TAG, "signOut successful")
                     promise.resolve(Arguments.createMap().apply { putBoolean("success", true) })
                 } else {
+                    Log.w(TAG, "signOut failed")
                     promise.reject("SIGNOUT_ERROR", "Sign out failed")
                 }
             }
         } catch (e: Exception) {
+            Log.e(TAG, "signOut failed", e)
             promise.reject("SIGNOUT_ERROR", "Error during sign out", e)
         }
     }
-    
+
     @ReactMethod
     fun getCurrentUser(promise: Promise) {
+        Log.d(TAG, "getCurrentUser called")
         try {
             if (!validateInitialization(promise)) return
             val user = composerImpl?.tokenService?.getCurrentUser()
             if (user != null) {
-                val result = Arguments.createMap().apply {
-                    putBoolean("success", true)
-                    putString("userId", user.id)
-                    putString("userEmail", user.email)
-                    putString("accessToken", user.accessToken)
-                    putBoolean("authenticated", true)
-                }
+                val result =
+                        Arguments.createMap().apply {
+                            putBoolean("success", true)
+                            putString("userId", user.id)
+                            putString("userEmail", user.email)
+                            putString("accessToken", user.accessToken)
+                            putBoolean("authenticated", true)
+                        }
                 promise.resolve(result)
             } else {
-                val result = Arguments.createMap().apply {
-                    putBoolean("success", true)
-                    putBoolean("authenticated", false)
-                }
+                val result =
+                        Arguments.createMap().apply {
+                            putBoolean("success", true)
+                            putBoolean("authenticated", false)
+                        }
                 promise.resolve(result)
             }
         } catch (e: Exception) {
+            Log.e(TAG, "getCurrentUser failed", e)
             promise.reject("USER_ERROR", "Error getting current user", e)
         }
     }
-    
+
     @ReactMethod
     fun isAuthenticated(promise: Promise) {
+        Log.d(TAG, "isAuthenticated called")
         try {
             if (!validateInitialization(promise)) return
             val isAuth = composerImpl?.tokenService?.isAuthenticated() ?: false
             promise.resolve(Arguments.createMap().apply { putBoolean("authenticated", isAuth) })
         } catch (e: Exception) {
+            Log.e(TAG, "isAuthenticated failed", e)
             promise.reject("AUTH_ERROR", "Error checking authentication", e)
         }
     }
@@ -285,18 +337,21 @@ class SdkPianoioModule(private val reactContext: ReactApplicationContext) : Reac
 
     @ReactMethod
     fun clearConfiguration(promise: Promise) {
+        Log.d(TAG, "clearConfiguration called")
         try {
             if (!validateInitialization(promise)) return
             composerImpl?.clearTags()
             composerImpl?.clearCustomVariables()
             promise.resolve(true)
         } catch (e: Exception) {
+            Log.e(TAG, "clearConfiguration failed", e)
             promise.reject("CLEAR_ERROR", "Error clearing configurations", e)
         }
     }
 
     private fun validateInitialization(promise: Promise): Boolean {
         if (!isInitialized || composerImpl == null) {
+            Log.w(TAG, "Validation failed: SDK not initialized.")
             promise.reject("NOT_INITIALIZED", "Piano SDK not initialized. Call initialize() first.")
             return false
         }
@@ -305,6 +360,7 @@ class SdkPianoioModule(private val reactContext: ReactApplicationContext) : Reac
 
     private fun validateParameter(value: String?, paramName: String, promise: Promise): Boolean {
         if (value.isNullOrBlank()) {
+            Log.w(TAG, "Validation failed: Parameter '$paramName' is null or blank.")
             promise.reject("INVALID_PARAMETER", "Parameter '$paramName' cannot be empty")
             return false
         }
@@ -313,6 +369,7 @@ class SdkPianoioModule(private val reactContext: ReactApplicationContext) : Reac
 
     private fun validateArray(array: ReadableArray?, paramName: String, promise: Promise): Boolean {
         if (array == null || array.size() == 0) {
+            Log.w(TAG, "Validation failed: Array '$paramName' is null or empty.")
             promise.reject("INVALID_PARAMETER", "Array '$paramName' cannot be empty")
             return false
         }
@@ -321,13 +378,10 @@ class SdkPianoioModule(private val reactContext: ReactApplicationContext) : Reac
 
     private fun validateMap(map: ReadableMap?, paramName: String, promise: Promise): Boolean {
         if (map == null) {
+            Log.w(TAG, "Validation failed: Map '$paramName' is null.")
             promise.reject("INVALID_PARAMETER", "Map '$paramName' cannot be empty")
             return false
         }
         return true
     }
-    
-    companion object {
-        const val NAME = "SdkPianoio"
-    }
 }