react-native-sdk-pianoio 0.3.2 → 0.3.4

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

@@ -0,0 +1,366 @@
+package com.sdkpianoio
+
+import android.content.Context
+import com.facebook.react.bridge.Promise
+import io.piano.android.composer.Composer
+import io.piano.android.composer.listeners.EventTypeListener
+import io.piano.android.composer.listeners.MeterListener
+import io.piano.android.composer.listeners.NonSiteListener
+import io.piano.android.composer.listeners.ShowTemplateListener
+import io.piano.android.composer.listeners.UserSegmentListener
+import io.piano.android.composer.model.CustomParameters
+import io.piano.android.composer.model.Event
+import io.piano.android.composer.model.ExperienceRequest
+import io.piano.android.composer.model.events.ShowTemplate
+
+/**
+ * ComposerPianoImpl - Main implementation class for the Piano SDK on Android
+ *
+ * This class is responsible for:
+ * - Managing the Piano SDK's Composer instance
+ * - Configuring execution parameters
+ * - Executing Piano experiences
+ * - Managing React Native callbacks and promises
+ */
+class ComposerPianoImpl {
+
+    // MARK: - Properties
+
+    /** The Piano SDK's Composer instance */
+    private var composer: Composer? = null
+
+    /** The Piano ID Token Service instance */
+    internal var tokenService: TokenService? = null
+
+    /** The Piano Application ID */
+    companion object {
+        var aid: String = ""
+    }
+
+    // MARK: - Configuration Properties
+
+    /** Configured tags for the composer */
+    private val tags = mutableListOf<String>()
+
+    /** Configured Zone ID */
+    private var zoneId: String? = null
+
+    /** Configured referrer */
+    private var referrer: String? = null
+
+    /** Configured URL */
+    private var url: String? = null
+
+    /** Configured user token */
+    private var userToken: String? = null
+
+    /** Configured custom variables */
+    private val customVariables = mutableMapOf<String, String>()
+
+    // MARK: - Initialization
+
+    /** Public class constructor Initializes the instance with default values */
+    constructor() {
+        println("ComposerPianoImpl: Constructor initialized")
+    }
+
+    /**
+     * Initializes the Composer with the provided Application ID.
+     *
+     * @param context The Android application context.
+     * @param aid The Piano Application ID.
+     */
+    fun initializeComposer(context: Context, aid: String) {
+        println("ComposerPianoImpl: Initializing composer with AID: $aid")
+
+        // Validate input parameter
+        if (aid.isBlank()) {
+            throw IllegalArgumentException("AID cannot be empty")
+        }
+
+        // Configure static AID for the whole class
+        ComposerPianoImpl.aid = aid
+        println("ComposerPianoImpl: Static AID configured: ${ComposerPianoImpl.aid}")
+
+        try {
+            // 1. Initialize the Composer SDK statically using the official API
+            Composer.init(context, aid, Composer.Endpoint.PRODUCTION)
+            println("ComposerPianoImpl: Composer SDK initialized for PRODUCTION")
+
+            // 2. Get the singleton instance and store it
+            this.composer = Composer.getInstance()
+            println("ComposerPianoImpl: Composer instance retrieved")
+
+            // 3. Initialize the TokenService and store it as a property
+            this.tokenService = TokenService()
+            this.tokenService?.initialize(aid)
+            println("ComposerPianoImpl: TokenService initialized")
+
+            println("ComposerPianoImpl: Initialization completed successfully")
+        } catch (e: Exception) {
+            println("ComposerPianoImpl: Error during initialization: ${e.message}")
+            throw e
+        }
+    }
+
+    // MARK: - Configuration Methods
+
+    /**
+     * Adds a tag to the composer
+     *
+     * @param tag The tag to be added
+     */
+    fun addTag(tag: String) {
+        if (!this.tags.contains(tag)) {
+            this.tags.add(tag)
+        }
+    }
+
+    /**
+     * Adds multiple tags to the composer
+     *
+     * @param tags The list of tags to be added
+     */
+    fun addTags(tags: List<String>) {
+        for (tag in tags) {
+            if (!this.tags.contains(tag)) {
+                this.tags.add(tag)
+            }
+        }
+    }
+
+    /**
+     * Sets the Zone ID for the composer
+     *
+     * @param zoneId The Zone ID to be configured
+     */
+    fun setZoneId(zoneId: String) {
+        this.zoneId = zoneId
+    }
+
+    /**
+     * Sets the referrer for the composer
+     *
+     * @param referrer The referrer to be configured
+     */
+    fun setReferrer(referrer: String) {
+        this.referrer = referrer
+    }
+
+    /**
+     * Sets the URL for the composer
+     *
+     * @param url The URL to be configured
+     */
+    fun setUrl(url: String) {
+        this.url = url
+    }
+
+    /**
+     * Sets the user token on the Composer instance.
+     *
+     * @param token The user's access token.
+     */
+    fun setUserToken(token: String) {
+        this.userToken = token
+        // Call the official SDK method to set the token
+        composer?.userToken(token)
+    }
+
+    /**
+     * Adds a custom variable.
+     *
+     * @param key The variable's key
+     * @param value The variable's value
+     */
+    fun addCustomVariable(key: String, value: String) {
+        this.customVariables[key] = value
+    }
+
+    // MARK: - Advanced Configuration Methods
+
+    /**
+     * Sets multiple custom variables at once.
+     *
+     * @param variables A map of custom variables.
+     */
+    fun setCustomVariables(variables: Map<String, String>) {
+        this.customVariables.clear()
+        this.customVariables.putAll(variables)
+    }
+
+    /** Removes all configured tags. */
+    fun clearTags() {
+        this.tags.clear()
+    }
+
+    /** Removes all custom variables. */
+    fun clearCustomVariables() {
+        this.customVariables.clear()
+    }
+
+    /**
+     * Removes a specific tag.
+     *
+     * @param tag The tag to be removed.
+     */
+    fun removeTag(tag: String) {
+        this.tags.remove(tag)
+    }
+
+    /**
+     * Removes a specific custom variable.
+     *
+     * @param key The key of the variable to be removed.
+     */
+    fun removeCustomVariable(key: String) {
+        this.customVariables.remove(key)
+    }
+
+    // MARK: - State Methods (Getters)
+
+    /**
+     * Gets the Application ID.
+     *
+     * @return The current Application ID.
+     */
+    fun getAid(): String {
+        return ComposerPianoImpl.aid
+    }
+
+    /**
+     * Gets the configured tags.
+     *
+     * @return A list of configured tags.
+     */
+    fun getTags(): List<String> {
+        return this.tags.toList()
+    }
+
+    /**
+     * Gets the configured Zone ID.
+     *
+     * @return The current Zone ID.
+     */
+    fun getZoneId(): String {
+        return this.zoneId ?: ""
+    }
+
+    /**
+     * Gets the configured referrer.
+     *
+     * @return The current referrer.
+     */
+    fun getReferrer(): String {
+        return referrer ?: ""
+    }
+
+    /**
+     * Gets the configured URL.
+     *
+     * @return The current URL.
+     */
+    fun getUrl(): String {
+        return url ?: ""
+    }
+
+    /**
+     * Gets the user token.
+     *
+     * @return The current user token.
+     */
+    fun getUserToken(): String {
+        return userToken ?: ""
+    }
+
+    /**
+     * Gets the composer instance.
+     *
+     * @return The Composer instance, or null if not initialized.
+     */
+    fun getComposer(): Composer? {
+        return composer
+    }
+
+    /**
+     * Gets the configured custom variables.
+     *
+     * @return A map of the custom variables.
+     */
+    fun getCustomVariables(): Map<String, String> {
+        return customVariables.toMap()
+    }
+
+    // MARK: - Execution Methods
+
+    /**
+     * Executes the composer with the current configuration.
+     *
+     * @param promise The promise that will be resolved with the execution result.
+     * @throws IllegalStateException if the composer has not been initialized.
+     */
+    fun executeComposer(promise: Promise) {
+        println("ComposerPianoImpl: 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")
+            promise.reject("INIT_ERROR", error.message, error)
+            return
+        }
+
+        try {
+            val customParams = CustomParameters()
+            this.customVariables.forEach { (key, value) -> customParams.request(key, value) }
+
+            // 2. Build the ExperienceRequest with all stored configurations
+            val request =
+                    ExperienceRequest.Builder()
+                            .tags(this.tags)
+                            .zone(this.zoneId)
+                            .referer(this.referrer)
+                            .url(this.url ?: "")
+                            .customParams(customParams)
+                            .debug(false)
+                            .build()
+            println("ComposerPianoImpl: 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
+                            },
+                            MeterListener { event ->
+                                println("MeterListener event: ${event.eventData}")
+                                promise.resolve(event.eventData.toString())
+                            },
+                            ShowTemplateListener { event: Event<ShowTemplate> ->
+                                println("ShowTemplateListener event: ${event.eventData}")
+                                promise.resolve(event.eventData.toString())
+                            },
+                            NonSiteListener { event ->
+                                println("NonSiteListener event: ${event.eventData}")
+                            }
+                    )
+
+            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}")
+                promise.reject("EXECUTION_ERROR", exception.message, exception)
+            }
+            println("ComposerPianoImpl: getExperience() called successfully")
+        } catch (e: Exception) {
+            println("ComposerPianoImpl: Error during execution setup: ${e.message}")
+            promise.reject("SETUP_ERROR", e.message, e)
+        }
+    }
+}