react-native-sdk-pianoio 0.3.2 → 0.3.4

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

@@ -1,559 +1,333 @@
 package com.sdkpianoio
 
-import androidx.core.util.Consumer
+import androidx.activity.ComponentActivity
+import androidx.activity.result.ActivityResultLauncher
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
 import com.facebook.react.module.annotations.ReactModule
-
-import io.piano.android.composer.Composer
-import io.piano.android.composer.Composer.Endpoint
-import io.piano.android.composer.ExperienceInterceptor
-import io.piano.android.composer.listeners.ExecuteExperienceListener
-import io.piano.android.composer.listeners.ShowLoginListener
-import io.piano.android.composer.model.ExperienceRequest
-import io.piano.android.consents.PianoConsents
-import java.util.function.Consumer
-import com.facebook.react.bridge.Arguments
-
-// importa altri listener se ti servono
-
+import io.piano.android.id.PianoIdAuthResultContract
+import io.piano.android.id.PianoIdClient
+import io.piano.android.id.models.PianoIdAuthFailureResult
+import io.piano.android.id.models.PianoIdAuthSuccessResult
+
+/**
+ * SdkPianoioModule - React Native module for the Piano.io SDK
+ *
+ * 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) { // <-- EXTEND ReactContextBaseJavaModule
-
-  private var composer: Composer? = null
-
-  // <-- ADD THIS REQUIRED METHOD
-  override fun getName(): String { // <--- MAKE THIS CHANGE
-    return NAME
-  }
-
-  @ReactMethod
-  fun initializeComposer(aid: String, promise: Promise) {
-    try {
-      val context = reactContext.currentActivity ?: reactContext.applicationContext;
-
-      Composer.init(
-        context,
-        aid,
-        Endpoint.SANDBOX, // Use Endpoint.SANDBOX instead of Composer.Endpoint.Companion
-        null
-      )
-      promise.resolve(true) // Resolve the promise on successful initialization
-    } catch (e: Exception) {
-      promise.reject("INIT_ERROR", "Errore inizializzazione Composer", e)
+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>
+
+    init {
+        // The ActivityResultLauncher must be registered in the init block or onCreate.
+        // We need to ensure we have a ComponentActivity to access the registry.
+        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)
+                            }
+                            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.
+        }
     }
-  }
-
-
-  private val tags = mutableListOf<String>()
-  private var zoneId: String? = null
-  private var referrer: String? = null
-  private val customVariables = mutableMapOf<String, String>()
-  private var userToken: String? = null
-  private var url: String? = null
-
-  @ReactMethod
-  fun addComposerTag(tag: String, promise: Promise) {
-    try {
-      if (!tags.contains(tag)) {
-        tags.add(tag)
-      }
-      promise.resolve(null)
-    } catch (e: Exception) {
-      promise.reject("TAG_ERROR", "Errore aggiunta tag", e)
+    
+    override fun getName(): String {
+        return NAME
     }
-  }
-
-  @ReactMethod
-  fun addComposerTags(tagsList: ReadableArray, promise: Promise) {
-    try {
-      for (i in 0 until tagsList.size()) {
-        val tag = tagsList.getString(i)
-        if (tag != null && !tags.contains(tag)) {
-          tags.add(tag)
+    
+    @ReactMethod
+    fun initialize(aid: String, promise: Promise) {
+        try {
+            if (isInitialized) {
+                promise.resolve(true)
+                return
+            }
+            composerImpl = ComposerPianoImpl()
+            composerImpl?.initializeComposer(reactContext, aid)
+            isInitialized = true
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("INIT_ERROR", "Failed to initialize Piano SDK", e)
         }
-      }
-      promise.resolve(null)
-    } catch (e: Exception) {
-      promise.reject("TAGS_ERROR", "Errore aggiunta tags", e)
     }
-  }
 
-  @ReactMethod
-  fun setComposerZoneId(zoneId: String, promise: Promise) {
-    try {
-      this.zoneId = zoneId
-      promise.resolve(null)
-    } catch (e: Exception) {
-      promise.reject("ZONEID_ERROR", "Errore impostazione zoneId", e)
-    }
-  }
+    // MARK: - Composer Configuration Methods
 
-  @ReactMethod
-  fun setComposerReferrer(referrer: String, promise: Promise) {
-    try {
-      this.referrer = referrer
-      promise.resolve(null)
-    } catch (e: Exception) {
-      promise.reject("REFERRER_ERROR", "Errore impostazione referrer", e)
+    @ReactMethod
+    fun addTag(tag: String, promise: Promise) {
+        try {
+            if (!validateInitialization(promise) || !validateParameter(tag, "tag", promise)) return
+            composerImpl?.addTag(tag)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("ADD_TAG_ERROR", "Error adding tag", e)
+        }
     }
-  }
 
-  @ReactMethod
-  fun setComposerCustomVariable(name: String, value: String, promise: Promise) {
-    try {
-      customVariables[name] = value
-      promise.resolve(null)
-    } catch (e: Exception) {
-      promise.reject("CUSTOMVAR_ERROR", "Errore impostazione custom variable", e)
+    @ReactMethod
+    fun addTags(tagsArray: ReadableArray, promise: Promise) {
+        try {
+            if (!validateInitialization(promise) || !validateArray(tagsArray, "tagsArray", promise)) return
+            val tags = tagsArray.toArrayList().mapNotNull { it?.toString() }
+            composerImpl?.addTags(tags)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("ADD_TAGS_ERROR", "Error adding tags", e)
+        }
     }
-  }
 
-  @ReactMethod
-  fun setComposerUserToken(token: String, promise: Promise) {
-    try {
-      userToken = token
-      promise.resolve(null)
-    } catch (e: Exception) {
-      promise.reject("TOKEN_ERROR", "Errore impostazione token", e)
+    @ReactMethod
+    fun setZoneId(zoneId: String, promise: Promise) {
+        try {
+            if (!validateInitialization(promise)) return
+            composerImpl?.setZoneId(zoneId)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("SET_ZONEID_ERROR", "Error setting Zone ID", e)
+        }
     }
-  }
 
-  @ReactMethod
-  fun setComposerUrl(url: String, promise: Promise) {
-    try {
-      this.url = url
-      promise.resolve(null)
-    } catch (e: Exception) {
-      promise.reject("URL_ERROR", "Errore impostazione URL", e)
+    @ReactMethod
+    fun setReferrer(referrer: String, promise: Promise) {
+        try {
+            if (!validateInitialization(promise)) return
+            composerImpl?.setReferrer(referrer)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("SET_REFERRER_ERROR", "Error setting referrer", e)
+        }
     }
-  }
 
-  @ReactMethod
-  fun getComposer(promise: Promise) {
-    try {
-      val context = reactContext.currentActivity ?: reactContext.applicationContext
-      composer = Composer.getInstance()
-      promise.resolve(true)
-    } catch (e: Exception) {
-      promise.reject("GET_COMPOSER_ERROR", "Errore ottenimento Composer", e)
+    @ReactMethod
+    fun setUrl(url: String, promise: Promise) {
+        try {
+            if (!validateInitialization(promise)) return
+            composerImpl?.setUrl(url)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("SET_URL_ERROR", "Error setting URL", e)
+        }
     }
-  }
-
-// Replace your old executeExperience method with this one.
 
-@ReactMethod
-fun executeExperience(promise: Promise) {
-    // 1. Get the Composer instance, rejecting the promise if it's not initialized.
-    val composer = Composer.getInstance()
-    if (composer == null) {
-        promise.reject("NOT_INITIALIZED", "Piano Composer is not initialized.")
-        return
+    @ReactMethod
+    fun setUserToken(token: String, promise: Promise) {
+        try {
+            if (!validateInitialization(promise)) return
+            composerImpl?.setUserToken(token)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("SET_TOKEN_ERROR", "Error setting user token", e)
+        }
     }
 
-    // 2. Build the request object from the stored properties.
-    // This part of your original code was correct.
-    val request = ExperienceRequest.Builder()
-        .debug(true)
-        .tags(tags)
-        .zone(zoneId)
-        .referer(referrer)
-        .customVariables(customVariables.mapValues { listOf(it.value) })
-        .url(url)
-        .userToken(userToken)
-        .build()
-
-    // 3. Create a listener to handle the asynchronous response from the Piano SDK.
-    val listener = ExecuteExperienceListener { events ->
-        // This code runs when the SDK gets a successful response.
+    @ReactMethod
+    fun addCustomVariable(key: String, value: String, promise: Promise) {
         try {
-            // We need to convert the list of Piano 'Event' objects
-            // into a WritableArray of WritableMaps that React Native can understand.
-            val eventsArray = Arguments.createArray()
-
-            for (event in events) {
-                val eventMap = Arguments.createMap()
-                eventMap.putString("eventType", event.eventType)
-                eventMap.putString("experienceId", event.experienceId)
-                // Add any other event data you need to this map.
-                // For example, for a 'showTemplate' event:
-                // if (event.eventData is ShowTemplateEventParams) {
-                //     eventMap.putString("templateUrl", (event.eventData as ShowTemplateEventParams).templateUrl)
-                // }
-                eventsArray.pushMap(eventMap)
-            }
-
-            // 4. Resolve the promise with the array of events.
-            promise.resolve(eventsArray)
-
+            if (!validateInitialization(promise)) return
+            composerImpl?.addCustomVariable(key, value)
+            promise.resolve(true)
         } catch (e: Exception) {
-            promise.reject("DATA_CONVERSION_ERROR", "Failed to convert event data.", e)
+            promise.reject("ADD_CUSTOMVAR_ERROR", "Error adding custom variable", e)
         }
     }
-
-    // 5. Create a listener for any errors.
-    val errorListener = Consumer<Exception> { e ->
-        promise.reject("EXECUTE_ERROR", "Piano SDK execution failed.", e)
+    
+    @ReactMethod
+    fun setCustomVariables(variables: ReadableMap, promise: Promise) {
+        try {
+            if (!validateInitialization(promise) || !validateMap(variables, "variables", promise)) return
+            val map = mutableMapOf<String, String>()
+            val iterator = variables.keySetIterator()
+            while (iterator.hasNextKey()) {
+                val key = iterator.nextKey()
+                val value = variables.getString(key)
+                if (value != null && value.isNotBlank()) {
+                    map[key] = value
+                }
+            }
+            if (map.isEmpty()) {
+                promise.reject("INVALID_PARAMETER", "No valid variables found in the map")
+                return
+            }
+            composerImpl?.setCustomVariables(map)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("SET_CUSTOMVARS_ERROR", "Error setting custom variables", e)
+        }
     }
 
-    // 6. Finally, execute the request with the composer, passing the request and listeners.
-    composer.getExperience(request, listener, errorListener)
-}
-
-  @ReactMethod
-  fun executeComposer(promise: Promise) {
-    try {
-      val composer = Composer.getInstance()
-      if (composer == null) {
-        promise.reject("NOT_INITIALIZED", "Piano Composer is not initialized.")
-        return
-      }
-      
-      // Execute the composer with current state
-      val request = ExperienceRequest.Builder()
-        .debug(true)
-        .tags(tags)
-        .zone(zoneId)
-        .referer(referrer)
-        .customVariables(customVariables.mapValues { listOf(it.value) })
-        .url(url)
-        .userToken(userToken)
-        .build()
-
-      val listener = ExecuteExperienceListener { events ->
-        promise.resolve(true)
-      }
+    // MARK: - Execution Method
 
-      val errorListener = Consumer<Exception> { e ->
-        promise.reject("EXECUTE_ERROR", "Piano SDK execution failed.", e)
-      }
-
-      composer.getExperience(request, listener, errorListener)
-    } catch (e: Exception) {
-      promise.reject("EXECUTE_ERROR", "Error executing composer", e)
+    @ReactMethod
+    fun executeExperience(promise: Promise) {
+        try {
+            if (!validateInitialization(promise)) return
+            composerImpl?.executeComposer(promise)
+        } catch (e: Exception) {
+            promise.reject("EXECUTION_ERROR", "Error executing experience", e)
+        }
     }
-  }
 
-  @ReactMethod
-  fun showLogin(promise: Promise) {
-    try {
-      val composer = Composer.getInstance()
-      if (composer == null) {
-        promise.reject("NOT_INITIALIZED", "Piano Composer is not initialized.")
-        return
-      }
-
-      val listener = ShowLoginListener { loginResult ->
-        promise.resolve(loginResult)
-      }
-
-      composer.showLogin(listener)
-    } catch (e: Exception) {
-      promise.reject("LOGIN_ERROR", "Error showing login", e)
+    // MARK: - Authentication Methods
+    
+    @ReactMethod
+    fun signIn(promise: Promise) {
+        if (signInPromise != null) {
+            promise.reject("IN_PROGRESS", "Another sign-in operation is already in progress.")
+            return
+        }
+        try {
+            if (!validateInitialization(promise)) return
+            this.signInPromise = promise
+            composerImpl?.tokenService?.signIn(authResultLauncher)
+        } catch (e: Exception) {
+            promise.reject("SIGNIN_ERROR", "Error during sign in", e)
+            this.signInPromise = null
+        }
     }
-  }
-
-  @ReactMethod
-  fun showTemplate(promise: Promise) {
-    try {
-      val composer = Composer.getInstance()
-      if (composer == null) {
-        promise.reject("NOT_INITIALIZED", "Piano Composer is not initialized.")
-        return
-      }
-
-      val request = ExperienceRequest.Builder()
-        .debug(true)
-        .tags(tags)
-        .zone(zoneId)
-        .referer(referrer)
-        .customVariables(customVariables.mapValues { listOf(it.value) })
-        .url(url)
-        .userToken(userToken)
-        .build()
-
-      val listener = ExecuteExperienceListener { events ->
-        promise.resolve(true)
-      }
-
-      val errorListener = Consumer<Exception> { e ->
-        promise.reject("TEMPLATE_ERROR", "Error showing template", e)
-      }
-
-      composer.getExperience(request, listener, errorListener)
-    } catch (e: Exception) {
-      promise.reject("TEMPLATE_ERROR", "Error showing template", e)
+    
+    @ReactMethod
+    fun signOut(promise: Promise) {
+        try {
+            if (!validateInitialization(promise)) return
+            composerImpl?.tokenService?.signOut { success ->
+                if (success) {
+                    promise.resolve(Arguments.createMap().apply { putBoolean("success", true) })
+                } else {
+                    promise.reject("SIGNOUT_ERROR", "Sign out failed")
+                }
+            }
+        } catch (e: Exception) {
+            promise.reject("SIGNOUT_ERROR", "Error during sign out", e)
+        }
     }
-  }
-
-  @ReactMethod
-  fun showForm(promise: Promise) {
-    try {
-      val composer = Composer.getInstance()
-      if (composer == null) {
-        promise.reject("NOT_INITIALIZED", "Piano Composer is not initialized.")
-        return
-      }
-
-      val request = ExperienceRequest.Builder()
-        .debug(true)
-        .tags(tags)
-        .zone(zoneId)
-        .referer(referrer)
-        .customVariables(customVariables.mapValues { listOf(it.value) })
-        .url(url)
-        .userToken(userToken)
-        .build()
-
-      val listener = ExecuteExperienceListener { events ->
-        promise.resolve(true)
-      }
-
-      val errorListener = Consumer<Exception> { e ->
-        promise.reject("FORM_ERROR", "Error showing form", e)
-      }
-
-      composer.getExperience(request, listener, errorListener)
-    } catch (e: Exception) {
-      promise.reject("FORM_ERROR", "Error showing form", e)
+    
+    @ReactMethod
+    fun getCurrentUser(promise: Promise) {
+        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)
+                }
+                promise.resolve(result)
+            } else {
+                val result = Arguments.createMap().apply {
+                    putBoolean("success", true)
+                    putBoolean("authenticated", false)
+                }
+                promise.resolve(result)
+            }
+        } catch (e: Exception) {
+            promise.reject("USER_ERROR", "Error getting current user", e)
+        }
     }
-  }
-
-  @ReactMethod
-  fun showRecommendations(promise: Promise) {
-    try {
-      val composer = Composer.getInstance()
-      if (composer == null) {
-        promise.reject("NOT_INITIALIZED", "Piano Composer is not initialized.")
-        return
-      }
-
-      val request = ExperienceRequest.Builder()
-        .debug(true)
-        .tags(tags)
-        .zone(zoneId)
-        .referer(referrer)
-        .customVariables(customVariables.mapValues { listOf(it.value) })
-        .url(url)
-        .userToken(userToken)
-        .build()
-
-      val listener = ExecuteExperienceListener { events ->
-        promise.resolve(true)
-      }
-
-      val errorListener = Consumer<Exception> { e ->
-        promise.reject("RECOMMENDATIONS_ERROR", "Error showing recommendations", e)
-      }
-
-      composer.getExperience(request, listener, errorListener)
-    } catch (e: Exception) {
-      promise.reject("RECOMMENDATIONS_ERROR", "Error showing recommendations", e)
+    
+    @ReactMethod
+    fun isAuthenticated(promise: Promise) {
+        try {
+            if (!validateInitialization(promise)) return
+            val isAuth = composerImpl?.tokenService?.isAuthenticated() ?: false
+            promise.resolve(Arguments.createMap().apply { putBoolean("authenticated", isAuth) })
+        } catch (e: Exception) {
+            promise.reject("AUTH_ERROR", "Error checking authentication", e)
+        }
     }
-  }
-
-  @ReactMethod
-  fun nonSite(promise: Promise) {
-    try {
-      val composer = Composer.getInstance()
-      if (composer == null) {
-        promise.reject("NOT_INITIALIZED", "Piano Composer is not initialized.")
-        return
-      }
-
-      val request = ExperienceRequest.Builder()
-        .debug(true)
-        .tags(tags)
-        .zone(zoneId)
-        .referer(referrer)
-        .customVariables(customVariables.mapValues { listOf(it.value) })
-        .url(url)
-        .userToken(userToken)
-        .build()
 
-      val listener = ExecuteExperienceListener { events ->
-        promise.resolve(true)
-      }
+    // MARK: - Helper and Cleanup Methods
 
-      val errorListener = Consumer<Exception> { e ->
-        promise.reject("NONSITE_ERROR", "Error executing nonSite", e)
-      }
-
-      composer.getExperience(request, listener, errorListener)
-    } catch (e: Exception) {
-      promise.reject("NONSITE_ERROR", "Error executing nonSite", e)
+    @ReactMethod
+    fun clearConfiguration(promise: Promise) {
+        try {
+            if (!validateInitialization(promise)) return
+            composerImpl?.clearTags()
+            composerImpl?.clearCustomVariables()
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("CLEAR_ERROR", "Error clearing configurations", e)
+        }
     }
-  }
-
-  @ReactMethod
-  fun userSegmentTrue(promise: Promise) {
-    try {
-      val composer = Composer.getInstance()
-      if (composer == null) {
-        promise.reject("NOT_INITIALIZED", "Piano Composer is not initialized.")
-        return
-      }
-
-      val request = ExperienceRequest.Builder()
-        .debug(true)
-        .tags(tags)
-        .zone(zoneId)
-        .referer(referrer)
-        .customVariables(customVariables.mapValues { listOf(it.value) })
-        .url(url)
-        .userToken(userToken)
-        .build()
-
-      val listener = ExecuteExperienceListener { events ->
-        promise.resolve(true)
-      }
-
-      val errorListener = Consumer<Exception> { e ->
-        promise.reject("USERSEGMENT_ERROR", "Error executing userSegmentTrue", e)
-      }
 
-      composer.getExperience(request, listener, errorListener)
-    } catch (e: Exception) {
-      promise.reject("USERSEGMENT_ERROR", "Error executing userSegmentTrue", e)
+    private fun validateInitialization(promise: Promise): Boolean {
+        if (!isInitialized || composerImpl == null) {
+            promise.reject("NOT_INITIALIZED", "Piano SDK not initialized. Call initialize() first.")
+            return false
+        }
+        return true
     }
-  }
-
-  @ReactMethod
-  fun userSegmentFalse(promise: Promise) {
-    try {
-      val composer = Composer.getInstance()
-      if (composer == null) {
-        promise.reject("NOT_INITIALIZED", "Piano Composer is not initialized.")
-        return
-      }
-
-      val request = ExperienceRequest.Builder()
-        .debug(true)
-        .tags(tags)
-        .zone(zoneId)
-        .referer(referrer)
-        .customVariables(customVariables.mapValues { listOf(it.value) })
-        .url(url)
-        .userToken(userToken)
-        .build()
-
-      val listener = ExecuteExperienceListener { events ->
-        promise.resolve(true)
-      }
 
-      val errorListener = Consumer<Exception> { e ->
-        promise.reject("USERSEGMENT_ERROR", "Error executing userSegmentFalse", e)
-      }
-
-      composer.getExperience(request, listener, errorListener)
-    } catch (e: Exception) {
-      promise.reject("USERSEGMENT_ERROR", "Error executing userSegmentFalse", e)
+    private fun validateParameter(value: String?, paramName: String, promise: Promise): Boolean {
+        if (value.isNullOrBlank()) {
+            promise.reject("INVALID_PARAMETER", "Parameter '$paramName' cannot be empty")
+            return false
+        }
+        return true
     }
-  }
-
-  @ReactMethod
-  fun meterActive(promise: Promise) {
-    try {
-      val composer = Composer.getInstance()
-      if (composer == null) {
-        promise.reject("NOT_INITIALIZED", "Piano Composer is not initialized.")
-        return
-      }
 
-      val request = ExperienceRequest.Builder()
-        .debug(true)
-        .tags(tags)
-        .zone(zoneId)
-        .referer(referrer)
-        .customVariables(customVariables.mapValues { listOf(it.value) })
-        .url(url)
-        .userToken(userToken)
-        .build()
-
-      val listener = ExecuteExperienceListener { events ->
-        promise.resolve(true)
-      }
-
-      val errorListener = Consumer<Exception> { e ->
-        promise.reject("METER_ERROR", "Error executing meterActive", e)
-      }
-
-      composer.getExperience(request, listener, errorListener)
-    } catch (e: Exception) {
-      promise.reject("METER_ERROR", "Error executing meterActive", e)
+    private fun validateArray(array: ReadableArray?, paramName: String, promise: Promise): Boolean {
+        if (array == null || array.size() == 0) {
+            promise.reject("INVALID_PARAMETER", "Array '$paramName' cannot be empty")
+            return false
+        }
+        return true
     }
-  }
-
-  @ReactMethod
-  fun meterExpired(promise: Promise) {
-    try {
-      val composer = Composer.getInstance()
-      if (composer == null) {
-        promise.reject("NOT_INITIALIZED", "Piano Composer is not initialized.")
-        return
-      }
-
-      val request = ExperienceRequest.Builder()
-        .debug(true)
-        .tags(tags)
-        .zone(zoneId)
-        .referer(referrer)
-        .customVariables(customVariables.mapValues { listOf(it.value) })
-        .url(url)
-        .userToken(userToken)
-        .build()
-
-      val listener = ExecuteExperienceListener { events ->
-        promise.resolve(true)
-      }
-
-      val errorListener = Consumer<Exception> { e ->
-        promise.reject("METER_ERROR", "Error executing meterExpired", e)
-      }
 
-      composer.getExperience(request, listener, errorListener)
-    } catch (e: Exception) {
-      promise.reject("METER_ERROR", "Error executing meterExpired", e)
+    private fun validateMap(map: ReadableMap?, paramName: String, promise: Promise): Boolean {
+        if (map == null) {
+            promise.reject("INVALID_PARAMETER", "Map '$paramName' cannot be empty")
+            return false
+        }
+        return true
     }
-  }
-
-  @ReactMethod
-  fun composerExecutionCompleted(promise: Promise) {
-    try {
-      val composer = Composer.getInstance()
-      if (composer == null) {
-        promise.reject("NOT_INITIALIZED", "Piano Composer is not initialized.")
-        return
-      }
-
-      val request = ExperienceRequest.Builder()
-        .debug(true)
-        .tags(tags)
-        .zone(zoneId)
-        .referer(referrer)
-        .customVariables(customVariables.mapValues { listOf(it.value) })
-        .url(url)
-        .userToken(userToken)
-        .build()
-
-      val listener = ExecuteExperienceListener { events ->
-        promise.resolve(true)
-      }
-
-      val errorListener = Consumer<Exception> { e ->
-        promise.reject("COMPLETION_ERROR", "Error executing composerExecutionCompleted", e)
-      }
-
-      composer.getExperience(request, listener, errorListener)
-    } catch (e: Exception) {
-      promise.reject("COMPLETION_ERROR", "Error executing composerExecutionCompleted", e)
+    
+    companion object {
+        const val NAME = "SdkPianoio"
     }
-  }
-
-  companion object {
-    const val NAME = "SdkPianoio"
-  }
 }