react-native-sdk-pianoio 0.3.7 → 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")
     }
 
     /**
@@ -55,36 +57,35 @@ class ComposerPianoImpl {
      * @param aid The Piano Application ID.
      */
     fun initializeComposer(context: Context, aid: String, isSandbox: Boolean) {
-        println("ComposerPianoImpl: Initializing composer with AID: $aid")
+        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
             val endpoint =
                     if (isSandbox) Composer.Endpoint.SANDBOX else Composer.Endpoint.PRODUCTION
+            Log.d(TAG, "Using endpoint: $endpoint")
             Composer.init(context, aid, endpoint)
-            println("ComposerPianoImpl: Composer SDK initialized for PRODUCTION")
+            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
         }
     }
@@ -126,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)
@@ -140,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)
     }
@@ -168,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
@@ -201,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)
@@ -229,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, 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, 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"
-    }
 }

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

@@ -1,24 +1,18 @@
 package com.sdkpianoio
 
+import android.util.Log
 import androidx.activity.result.ActivityResultLauncher
 import io.piano.android.id.PianoId
 import io.piano.android.id.PianoIdClient
 import io.piano.android.id.models.PianoIdToken
 
 /**
- * Represents a user from the Piano ID SDK.
- * This custom class simplifies passing user data back to React Native.
+ * Represents a user from the Piano ID SDK. This custom class simplifies passing user data back to
+ * React Native.
  */
 class User(val id: String, val email: String, val accessToken: String)
 
-/**
- * TokenService - Manages OAuth tokens and authentication with the Piano ID SDK.
- *
- * This class is responsible for:
- * - Integrating with the real PianoId SDK.
- * - Managing user authentication (sign-in, sign-out).
- * - Storing and providing the current user's token and information.
- */
+/** TokenService - Manages OAuth tokens and authentication with the Piano ID SDK. */
 class TokenService {
 
     // MARK: - Properties
@@ -27,27 +21,28 @@ class TokenService {
     private var isInitialized: Boolean = false
     private var cachedToken: PianoIdToken? = null
 
+    companion object {
+        private const val TAG = "TokenService"
+    }
+
     // MARK: - Initialization
 
-    /**
-     * Initializes the Piano ID SDK. This should ideally be called once per application lifecycle.
-     *
-     * @param aid The Piano Application ID.
-     */
     fun initialize(aid: String) {
-        if (isInitialized) return
-        println("TokenService: Initializing with AID: $aid")
+        if (isInitialized) {
+            Log.d(TAG, "Already initialized.")
+            return
+        }
+        Log.d(TAG, "Initializing with AID: $aid")
         try {
             if (aid.isBlank()) {
                 throw IllegalArgumentException("AID cannot be empty")
             }
-            // Initialize the SDK statically, then get the client instance.
             PianoId.init(PianoId.ENDPOINT_PRODUCTION, aid)
             this.client = PianoId.getInstance()
             isInitialized = true
-            println("TokenService: Initialization completed successfully")
+            Log.d(TAG, "Initialization completed successfully")
         } catch (e: Exception) {
-            println("TokenService: Error during initialization: ${e.message}")
+            Log.e(TAG, "Error during initialization", e)
             throw e
         }
     }
@@ -55,42 +50,44 @@ class TokenService {
     // MARK: - Authentication Methods
 
     fun setToken(token: PianoIdToken?) {
+        Log.d(TAG, "Setting token.")
         this.cachedToken = token
     }
 
     fun signIn(authResultLauncher: ActivityResultLauncher<PianoIdClient.SignInContext>) {
         val localClient = client
         if (localClient == null) {
-            println("TokenService: Not initialized. Call initialize() first.")
+            Log.w(TAG, "signIn called but not initialized.")
             return
         }
-        println("TokenService: Launching sign in flow")
-        val request = localClient.signIn() // This returns a SignInContext
+        Log.d(TAG, "Launching sign in flow")
+        val request = localClient.signIn()
         authResultLauncher.launch(request)
     }
 
     fun signOut(callback: (Boolean) -> Unit) {
+        Log.d(TAG, "signOut called")
         val localClient = client
         if (localClient == null) {
-            println("TokenService: Not initialized.")
+            Log.w(TAG, "signOut called but not initialized.")
             callback(false)
             return
         }
         val token = this.cachedToken?.accessToken
         if (token == null) {
-            println("TokenService: No user is signed in.")
+            Log.d(TAG, "No user is signed in, considering signOut successful.")
             callback(true) // Already signed out
             return
         }
 
-        println("TokenService: Starting sign out")
+        Log.d(TAG, "Starting sign out network request")
         localClient.signOut(token) {
             if (it.isSuccess) {
-                println("TokenService: Sign out successful")
-                this.cachedToken = null // Clear the cached token
+                Log.d(TAG, "Sign out successful")
+                this.cachedToken = null
                 callback(true)
             } else {
-                println("TokenService: Sign out failed: ${it.exceptionOrNull()?.message}")
+                Log.e(TAG, "Sign out failed", it.exceptionOrNull())
                 callback(false)
             }
         }
@@ -99,16 +96,22 @@ class TokenService {
     // MARK: - User Information Methods
 
     fun getCurrentUser(): User? {
-        val token = this.cachedToken ?: return null
-        // Construct a user from the token information using the getInfoField method.
+        Log.d(TAG, "getCurrentUser called")
+        val token =
+                this.cachedToken
+                        ?: run {
+                            Log.d(TAG, "No cached token found, returning null user.")
+                            return null
+                        }
         return User(
-            id = token.getInfoField<String>("user_id") ?: "unknown",
-            email = token.getInfoField<String>("email") ?: "unknown",
-            accessToken = token.accessToken
+                id = token.getInfoField<String>("user_id") ?: "unknown",
+                email = token.getInfoField<String>("email") ?: "unknown",
+                accessToken = token.accessToken
         )
     }
 
     fun isAuthenticated(): Boolean {
+        Log.d(TAG, "isAuthenticated called")
         return this.cachedToken != null
     }
 }

package/ios/ComposerPianoImpl.swift

@@ -4,12 +4,6 @@ import PianoOAuth
 import React
 
 /// ComposerPianoImpl - Main implementation class for the Piano SDK on iOS.
-///
-/// This class is responsible for:
-/// - Managing the Piano SDK's Composer instance.
-/// - Configuring the experience request using a fluent builder pattern.
-/// - Executing Piano experiences and handling results via a delegate.
-/// - Managing React Native promises across asynchronous callbacks.
 @objcMembers public class ComposerPianoImpl: NSObject {
 
     // MARK: - Properties
@@ -36,7 +30,7 @@ import React
      * @param aid The Piano Application ID.
      */
     public func initialize(aid: String, isSandbox: Bool) {
-        print("ComposerPianoImpl: Initializing with AID: \(aid)")
+        print("[ComposerPianoImpl] Initializing with AID: \(aid), isSandbox: \(isSandbox)")
 
         // 1. Initialize and store the TokenService
         self.tokenService = TokenService()
@@ -45,8 +39,8 @@ import React
 
         // 2. Initialize the Composer instance
         let endpoint = isSandbox ? PianoEndpoint.sandbox : PianoEndpoint.production
+        print("[ComposerPianoImpl] Using endpoint: \(endpoint)")
         self.composer = PianoComposer(aid: aid, endpoint: endpoint)
-        print("ComposerPianoImpl: Composer instance created for PRODUCTION")
 
         // 3. Initialize and set up the delegate
         self.delegate = MyComposerDelegate(impl: self)
@@ -83,34 +77,43 @@ import React
     // MARK: - Configuration Methods (Setters)
 
     public func addTag(_ tag: String) {
+        print("[ComposerPianoImpl] Adding tag: \(tag)")
         self.tags.append(tag)
     }
 
     public func addTags(_ tags: [String]) {
+        print("[ComposerPianoImpl] Adding tags: \(tags)")
         self.tags.append(contentsOf: tags)
     }
 
     public func setZoneId(_ zoneId: String) {
+        print("[ComposerPianoImpl] Setting zoneId: \(zoneId)")
         self.zoneId = zoneId
     }
 
     public func setReferrer(_ referrer: String) {
+        print("[ComposerPianoImpl] Setting referrer: \(referrer)")
         self.referrer = referrer
     }
 
     public func setUrl(_ url: String) {
+        print("[ComposerPianoImpl] Setting url: \(url)")
         self.url = url
     }
-
+    
     public func setCustomVariables(_ variables: [String: String]) {
+        print("[ComposerPianoImpl] Setting custom variables")
         self.customVariables = variables
     }
 
     public func addCustomVariable(_ name: String, value: String) {
+        print("[ComposerPianoImpl] Adding custom variable: \(name) = \(value)")
         self.customVariables[name] = value
     }
 
     public func setUserToken(_ token: String) {
+        print("[ComposerPianoImpl] Setting userToken")
+        self.userToken = token
         _ = self.composer?.userToken(token)
     }
 
@@ -133,6 +136,7 @@ import React
     }
 
     public func clearConfiguration() {
+        print("[ComposerPianoImpl] Clearing all configurations")
         self.clearTags()
         self.clearCustomVariables()
         self.zoneId = nil
@@ -148,10 +152,13 @@ import React
         rejecter: @escaping RCTPromiseRejectBlock
     ) {
         guard let composer = self.composer else {
+            print("[ComposerPianoImpl] ERROR: executeExperience called but composer is not initialized.")
             rejecter("INIT_ERROR", "Composer not initialized.", nil)
             return
         }
 
+        print("[ComposerPianoImpl] Executing experience")
+
         self.experienceResolver = resolver
         self.experienceRejecter = rejecter
 
@@ -162,10 +169,18 @@ import React
             .referrer(self.referrer ?? "")
             .url(self.url ?? "")
 
-        for (key, value) in self.customVariables {
-            _ = composer.customVariable(name: key, value: value)
+        if !self.customVariables.isEmpty {
+            print("[ComposerPianoImpl] Applying \(self.customVariables.count) custom variables...")
+            for (key, value) in self.customVariables {
+                print("[ComposerPianoImpl]   - Applying custom variable: '\(key)' = '\(value)'")
+                _ = composer.customVariable(name: key, value: value)
+            }
+            print("[ComposerPianoImpl] Custom variables applied successfully.")
+        } else {
+            print("[ComposerPianoImpl] No custom variables to apply.")
         }
 
+        print("[ComposerPianoImpl] Calling composer.execute()")
         composer.execute()
     }
 }

package/ios/MyComposerDelegate.swift

@@ -2,50 +2,26 @@ import Foundation
 import PianoComposer
 import React
 
-/**
- * MyComposerDelegate - Implements the PianoComposerDelegate protocol to handle
- * events from the native Piano SDK and communicate them back to React Native.
- */
+/// MyComposerDelegate - Implements the PianoComposerDelegate protocol to handle
+/// events from the native Piano SDK and communicate them back to React Native.
 @objcMembers public class MyComposerDelegate: NSObject, PianoComposerDelegate {
 
     // MARK: - Properties
 
-    /**
-     * A weak reference back to the main implementation class.
-     * This is used to access the stored promise resolver and rejecter
-     * and to avoid a strong reference cycle (memory leak).
-     */
     private weak var impl: ComposerPianoImpl?
 
-    // MARK: - Initialization
-
-    /**
-     * Initializes the delegate with a reference back to the main implementation.
-     *
-     * @param impl The instance of ComposerPianoImpl.
-     */
     init(impl: ComposerPianoImpl) {
         self.impl = impl
     }
 
     // MARK: - Promise Handling Helpers
 
-    /**
-     * Resolves the stored promise with the provided event data.
-     *
-     * @param eventData A dictionary representing the event to be sent to JavaScript.
-     */
     private func resolvePromise(with eventData: [String: Any]) {
         guard let resolver = self.impl?.experienceResolver else { return }
         resolver(eventData)
         clearPromiseHandlers()
     }
 
-    /**
-     * Rejects the stored promise with a given error.
-     *
-     * @param error The error that occurred.
-     */
     private func rejectPromise(with error: Error) {
         guard let rejecter = self.impl?.experienceRejecter else { return }
         let errorCode = "EXECUTION_FAILED"
@@ -54,9 +30,6 @@ import React
         clearPromiseHandlers()
     }
 
-    /**
-     * Clears the stored promise handlers to prevent them from being called more than once.
-     */
     private func clearPromiseHandlers() {
         self.impl?.experienceResolver = nil
         self.impl?.experienceRejecter = nil
@@ -64,46 +37,33 @@ import React
 
     // MARK: - PianoComposerDelegate Implementation
 
-    /**
-     * Called when a 'showTemplate' event is received from the Piano backend.
-     * This is the primary event for displaying a paywall or other experience.
-     */
-    public func showTemplate(composer: PianoComposer, event: XpEvent, params: ShowTemplateEventParams?) {
-        print("MyComposerDelegate: Received showTemplate event")
-        let eventData: [String: Any] = [
-            "eventType": "showTemplate",
-            "templateId": params?.templateId ?? "",
-            "templateVariantId": params?.templateVariantId ?? "",
-            "displayMode": params?.displayMode.rawValue ?? "inline",
-            "containerSelector": params?.containerSelector ?? ""
-        ]
+    public func showTemplate(
+        composer: PianoComposer, event: XpEvent, params: ShowTemplateEventParams?
+    ) {
+        var eventData = paramsToDictionary(params)
+        eventData["eventType"] = "showTemplate"
         resolvePromise(with: eventData)
     }
 
-    /**
-     * Called when a meter is active.
-     */
-    public func meterActive(composer: PianoComposer, event: XpEvent, params: PageViewMeterEventParams?) {
-        print("MyComposerDelegate: Received meterActive event")
-        let eventData: [String: Any] = [
-            "eventType": "meterActive",
-            "meterName": params?.meterName ?? "",
-            "views": params?.views ?? 0,
-            "viewsLeft": params?.viewsLeft ?? 0,
-            "maxViews": params?.maxViews ?? 0
-        ]
+    public func meterActive(
+        composer: PianoComposer, event: XpEvent, params: PageViewMeterEventParams?
+    ) {
+        print(
+            "[MyComposerDelegate] Received meterActive event for meter: \(params?.meterName ?? "N/A")"
+        )
+        var eventData = paramsToDictionary(params)
+        eventData["eventType"] = "meterActive"
         resolvePromise(with: eventData)
     }
 
-    /**
-     * Called when a meter has expired.
-     */
-    public func meterExpired(composer: PianoComposer, event: XpEvent, params: PageViewMeterEventParams?) {
-        print("MyComposerDelegate: Received meterExpired event")
-        let eventData: [String: Any] = [
-            "eventType": "meterExpired",
-            "meterName": params?.meterName ?? ""
-        ]
+    public func meterExpired(
+        composer: PianoComposer, event: XpEvent, params: PageViewMeterEventParams?
+    ) {
+        print(
+            "[MyComposerDelegate] Received meterExpired event for meter: \(params?.meterName ?? "N/A")"
+        )
+        var eventData = paramsToDictionary(params)
+        eventData["eventType"] = "meterExpired"
         resolvePromise(with: eventData)
     }
 
@@ -122,20 +82,24 @@ import React
         print("MyComposerDelegate: Received userSegmentFalse event")
         resolvePromise(with: ["eventType": "userSegmentFalse"])
     }
-    
+
     /**
      * A general-purpose callback for when an experience is executed.
      */
-    public func experienceExecute(composer: PianoComposer, event: XpEvent, params: ExperienceExecuteEventParams?) {
-        print("MyComposerDelegate: Received experienceExecute event")
-        // This is often a good place to resolve the promise if no other specific event is expected.
-        resolvePromise(with: ["eventType": "experienceExecute"])
+    public func experienceExecute(
+        composer: PianoComposer, event: XpEvent, params: ExperienceExecuteEventParams?
+    ) {
+        var eventData = paramsToDictionary(params)
+        eventData["eventType"] = "experienceExecute"
+        resolvePromise(with: eventData)
     }
 
     /**
      * Called when an error occurs during the experience execution.
      */
-    public func experienceExecutionFailed(composer: PianoComposer, event: XpEvent, params: FailureEventParams?) {
+    public func experienceExecutionFailed(
+        composer: PianoComposer, event: XpEvent, params: FailureEventParams?
+    ) {
         print("MyComposerDelegate: Received experienceExecutionFailed event")
         let error = NSError(
             domain: "PianoSDK",
@@ -144,5 +108,24 @@ import React
         )
         rejectPromise(with: error)
     }
-}
 
+    // MARK: - Helper Methods
+
+    private func paramsToDictionary(_ params: Any?) -> [String: Any] {
+        var dict = [String: Any]()
+        if let params = params {
+            let mirror = Mirror(reflecting: params)
+            for child in mirror.children {
+                if let label = child.label {
+                    // Handle cases where the value might be an enum
+                    if let rawValue = (child.value as? any RawRepresentable)?.rawValue {
+                        dict[label] = rawValue
+                    } else {
+                        dict[label] = child.value
+                    }
+                }
+            }
+        }
+        return dict
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-sdk-pianoio",
-  "version": "0.3.7",
+  "version": "0.3.8",
   "description": "Piano io sdk integration",
   "source": "./src/index.tsx",
   "main": "./lib/commonjs/index.js",