react-native-sdk-pianoio 0.3.0 → 0.3.2

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

@@ -1,20 +1,556 @@
 package com.sdkpianoio
 
+import androidx.core.util.Consumer
 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.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
+
 @ReactModule(name = SdkPianoioModule.NAME)
-class SdkPianoioModule(reactContext: ReactApplicationContext) :
-  NativeSdkPianoioSpec(reactContext) {
+class SdkPianoioModule(private val reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) { // <-- EXTEND ReactContextBaseJavaModule
+
+  private var composer: Composer? = null
 
-  override fun getName(): String {
+  // <-- ADD THIS REQUIRED METHOD
+  override fun getName(): String { // <--- MAKE THIS CHANGE
     return NAME
   }
 
-  // Example method
-  // See https://reactnative.dev/docs/native-modules-android
-  override fun multiply(a: Double, b: Double): Double {
-    return a * b
+  @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)
+    }
+  }
+
+
+  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)
+    }
+  }
+
+  @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)
+        }
+      }
+      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)
+    }
+  }
+
+  @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 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 setComposerUserToken(token: String, promise: Promise) {
+    try {
+      userToken = token
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("TOKEN_ERROR", "Errore impostazione token", 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 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)
+    }
+  }
+
+// 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
+    }
+
+    // 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.
+        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)
+
+        } catch (e: Exception) {
+            promise.reject("DATA_CONVERSION_ERROR", "Failed to convert event data.", e)
+        }
+    }
+
+    // 5. Create a listener for any errors.
+    val errorListener = Consumer<Exception> { e ->
+        promise.reject("EXECUTE_ERROR", "Piano SDK execution failed.", 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)
+      }
+
+      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 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)
+    }
+  }
+
+  @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 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 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 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)
+      }
+
+      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 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)
+    }
+  }
+
+  @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)
+    }
+  }
+
+  @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)
+    }
+  }
+
+  @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)
+    }
+  }
+
+  @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 {

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

@@ -18,15 +18,15 @@ class SdkPianoioPackage : BaseReactPackage() {
 
   override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
     return ReactModuleInfoProvider {
-      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
-      moduleInfos[SdkPianoioModule.NAME] = ReactModuleInfo(
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap<String, ReactModuleInfo>()
+      moduleInfos.put(SdkPianoioModule.NAME, ReactModuleInfo(
         SdkPianoioModule.NAME,
         SdkPianoioModule.NAME,
         false,  // canOverrideExistingModule
         false,  // needsEagerInit
         false,  // isCxxModule
         true // isTurboModule
-      )
+      ))
       moduleInfos
     }
   }