react-native-sdk-pianoio 0.3.2 → 0.3.5

package/ios/ComposerPianoImpl.swift

@@ -1,247 +1,150 @@
-//
-//  ComposerPianoImpl.swift
-//  SdkPianoio
-//
-//
 import Foundation
 import PianoComposer
 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 {
-  private var composer: PianoComposer?
-  private var delegateHelper: MyComposerDelegate?
 
-  // ✅ These will hold the promise functions from React Native
-  var promiseResolver: RCTPromiseResolveBlock?
-  var promiseRejecter: RCTPromiseRejectBlock?
+    // MARK: - Properties
+
+    private var composer: PianoComposer?
+    private var tokenService: TokenService?
+    private var delegate: MyComposerDelegate?
+
+    // Promises to communicate results of async operations back to React Native
+    var experienceResolver: RCTPromiseResolveBlock?
+    var experienceRejecter: RCTPromiseRejectBlock?
+
+    // Stored configuration properties
+    private var tags: [String] = []
+    private var zoneId: String?
+    private var referrer: String?
+    private var url: String?
+    private var customVariables: [String: String] = [:]
+
+    // MARK: - Initialization
+
+    /**
+     * Initializes the implementation class and its dependencies.
+     *
+     * @param aid The Piano Application ID.
+     */
+    public func initialize(aid: String) {
+        print("ComposerPianoImpl: Initializing with AID: \(aid)")
+
+        // 1. Initialize and store the TokenService
+        self.tokenService = TokenService()
+        self.tokenService?.initialize(aid: aid)
+        print("ComposerPianoImpl: TokenService initialized")
+
+        // 2. Initialize the Composer instance
+        self.composer = PianoComposer(aid: aid, endpoint: PianoEndpoint.production)
+        print("ComposerPianoImpl: Composer instance created for PRODUCTION")
+
+        // 3. Initialize and set up the delegate
+        self.delegate = MyComposerDelegate(impl: self)
+        self.composer?.delegate = self.delegate
+        print("ComposerPianoImpl: Delegate initialized and set")
+    }
 
-  // This is a static property to hold the AID
-  public static var aid = ""
+    // MARK: - Configuration Methods
 
-  @objc public func initializeComposer(_ aid: String) {
-    ComposerPianoImpl.aid = aid
+    public func addTag(_ tag: String) {
+        self.tags.append(tag)
+    }
 
-    // 1. Correctly initialize the TokenService first.
-    let tokenService = TokenService()
+    public func addTags(_ tags: [String]) {
+        self.tags.append(contentsOf: tags)
+    }
 
-    // 2. Initialize the delegate.
-    self.delegateHelper = MyComposerDelegate()
+    public func setZoneId(_ zoneId: String) {
+        self.zoneId = zoneId
+    }
 
-    // 3. Link the delegate back to this class so it can resolve promises.
-    self.delegateHelper?.moduleImpl = self
+    public func setReferrer(_ referrer: String) {
+        self.referrer = referrer
+    }
 
-    // 4. Initialize the composer.
-    self.composer = PianoComposer(
-      aid: ComposerPianoImpl.aid, endpoint: PianoEndpoint.productionEurope)
+    public func setUrl(_ url: String) {
+        self.url = url
+    }
+
+    public func setCustomVariable(_ name: String, value: String) {
+        self.customVariables[name] = value
+    }
 
-    // 5. Set the composer's delegate property directly. This is the standard Swift way.
-    self.composer?.delegate = self.delegateHelper
-  }
+    public func setUserToken(_ token: String) {
+        // The iOS SDK requires setting the user token on the composer instance directly
+        _ = self.composer?.userToken(token)
+    }
 
-  @objc public func executeComposer() {
-    print("Esecuzione composer")
-    DispatchQueue.main.async {
-      if let composer = self.composer {
-        print("Calling composer.execute()")
+    // MARK: - Execution Method
+
+    /**
+     * Executes the Piano experience with the current configuration.
+     *
+     * @param resolver The promise resolver from React Native.
+     * @param rejecter The promise rejecter from React Native.
+     */
+    public func executeExperience(
+        resolver: @escaping RCTPromiseResolveBlock,
+        rejecter: @escaping RCTPromiseRejectBlock
+    ) {
+        guard let composer = self.composer else {
+            rejecter("INIT_ERROR", "Composer not initialized.", nil)
+            return
+        }
+
+        print("ComposerPianoImpl: Executing experience")
+
+        // Store the promise functions to be called by the delegate later
+        self.experienceResolver = resolver
+        self.experienceRejecter = rejecter
+
+        // Configure the composer instance using the fluent interface
+        _ = composer
+            .tags(self.tags)
+            .zoneId(self.zoneId ?? "") // Safely unwrap optionals
+            .referrer(self.referrer ?? "") // Safely unwrap optionals
+            .url(self.url ?? "") // Safely unwrap optionals
+
+        for (key, value) in self.customVariables {
+            _ = composer.customVariable(name: key, value: value)
+        }
+
+        // Execute the experience. The result will be handled by the delegate.
         composer.execute()
-      } else {
-        print("⚠️ Composer è nil")
-        self.promiseRejecter?(
-          "composer_nil", "Piano Composer is not initialized.", nil)
-      }
     }
-  }
-
-  @objc public func executeExperience(
-    resolver: @escaping RCTPromiseResolveBlock,
-    rejecter: @escaping RCTPromiseRejectBlock
-  ) {
-    self.promiseResolver = resolver
-    self.promiseRejecter = rejecter
-
-    self.executeComposer()
-  }
-
-  public func findViewBySelector(selector: String) -> UIView? {
-    return nil
-  }
-
-  // --- Configuration methods ---
-
-  @objc public func addTag(_ tag: String) {
-    _ = composer?.tag(tag)
-  }
-
-  @objc public func addTags(_ tags: [String]) {
-    _ = composer?.tags(tags)
-  }
-
-  @objc public func setZoneId(_ zoneId: String) {
-    _ = composer?.zoneId(zoneId)
-  }
-
-  @objc public func setReferrer(_ referrer: String) {
-    _ = composer?.referrer(referrer)
-  }
-
-  @objc public func setUrl(_ url: String) {
-    _ = composer?.url(url)
-  }
-
-  @objc public func setCustomVariable(_ name: String, value: String) {
-    _ = composer?.customVariable(name: name, value: value)
-  }
-
-  @objc public func setUserToken(_ token: String) {
-    _ = composer?.userToken(token)
-  }
-
-  // method to get values and helpers
-  @objc public func getAid() -> String {
-    if composer != nil {
-      return composer?.aid ?? ""
-    } else {
-      return ""
+    
+    // MARK: - State Methods (Getters)
+    
+    public func getTags() -> [String] {
+        return self.tags
     }
-  }
-
-  @objc public func getTags() -> [String] {
-    if let tags = composer?.tags, !tags.isEmpty {
-      return Array(tags)
-    } else {
-      return []
+    
+    public func getZoneId() -> String {
+        return self.zoneId ?? ""
     }
-  }
-
-  @objc public func getComposer() -> PianoComposer? {
-    return composer
-  }
-
-  @objc public func getZoneId() -> String {
-    return composer?.zoneId ?? ""
-  }
-
-  @objc public func getReferrer() -> String {
-    return composer?.referrer ?? ""
-  }
-
-  @objc public func getUrl() -> String {
-    return composer?.url ?? ""
-  }
-
-  @objc public func getUserToken() -> String {
-    return composer?.userToken ?? ""
-  }
-
-  // MARK: - Additional Methods for React Native Bridge
-
-  @objc public func executeComposerWithResolver(
-    resolver: @escaping RCTPromiseResolveBlock,
-    rejecter: @escaping RCTPromiseRejectBlock
-  ) {
-    self.promiseResolver = resolver
-    self.promiseRejecter = rejecter
-    self.executeComposer()
-  }
-
-  @objc public func showLoginWithResolver(
-    resolver: @escaping RCTPromiseResolveBlock,
-    rejecter: @escaping RCTPromiseRejectBlock
-  ) {
-    self.promiseResolver = resolver
-    self.promiseRejecter = rejecter
     
-    DispatchQueue.main.async {
-      if let composer = self.composer {
-        // This would need to be implemented based on Piano SDK's login functionality
-        print("Show login triggered")
-        resolver(true)
-      } else {
-        rejecter("composer_nil", "Piano Composer is not initialized.", nil)
-      }
+    public func getReferrer() -> String {
+        return self.referrer ?? ""
+    }
+    
+    public func getUrl() -> String {
+        return self.url ?? ""
+    }
+    
+    public func getUserToken() -> String {
+        // User token is write-only to the composer instance, so we return the stored value if needed.
+        return self.composer?.userToken ?? ""
     }
-  }
-
-  @objc public func showTemplateWithResolver(
-    resolver: @escaping RCTPromiseResolveBlock,
-    rejecter: @escaping RCTPromiseRejectBlock
-  ) {
-    self.promiseResolver = resolver
-    self.promiseRejecter = rejecter
-    self.executeComposer()
-  }
-
-  @objc public func showFormWithResolver(
-    resolver: @escaping RCTPromiseResolveBlock,
-    rejecter: @escaping RCTPromiseRejectBlock
-  ) {
-    self.promiseResolver = resolver
-    self.promiseRejecter = rejecter
-    self.executeComposer()
-  }
-
-  @objc public func showRecommendationsWithResolver(
-    resolver: @escaping RCTPromiseResolveBlock,
-    rejecter: @escaping RCTPromiseRejectBlock
-  ) {
-    self.promiseResolver = resolver
-    self.promiseRejecter = rejecter
-    self.executeComposer()
-  }
-
-  @objc public func nonSiteWithResolver(
-    resolver: @escaping RCTPromiseResolveBlock,
-    rejecter: @escaping RCTPromiseRejectBlock
-  ) {
-    self.promiseResolver = resolver
-    self.promiseRejecter = rejecter
-    self.executeComposer()
-  }
-
-  @objc public func userSegmentTrueWithResolver(
-    resolver: @escaping RCTPromiseResolveBlock,
-    rejecter: @escaping RCTPromiseRejectBlock
-  ) {
-    self.promiseResolver = resolver
-    self.promiseRejecter = rejecter
-    self.executeComposer()
-  }
-
-  @objc public func userSegmentFalseWithResolver(
-    resolver: @escaping RCTPromiseResolveBlock,
-    rejecter: @escaping RCTPromiseRejectBlock
-  ) {
-    self.promiseResolver = resolver
-    self.promiseRejecter = rejecter
-    self.executeComposer()
-  }
-
-  @objc public func meterActiveWithResolver(
-    resolver: @escaping RCTPromiseResolveBlock,
-    rejecter: @escaping RCTPromiseRejectBlock
-  ) {
-    self.promiseResolver = resolver
-    self.promiseRejecter = rejecter
-    self.executeComposer()
-  }
-
-  @objc public func meterExpiredWithResolver(
-    resolver: @escaping RCTPromiseResolveBlock,
-    rejecter: @escaping RCTPromiseRejectBlock
-  ) {
-    self.promiseResolver = resolver
-    self.promiseRejecter = rejecter
-    self.executeComposer()
-  }
-
-  @objc public func composerExecutionCompletedWithResolver(
-    resolver: @escaping RCTPromiseResolveBlock,
-    rejecter: @escaping RCTPromiseRejectBlock
-  ) {
-    self.promiseResolver = resolver
-    self.promiseRejecter = rejecter
-    self.executeComposer()
-  }
-
 }

package/ios/MyComposerDelegate.swift

@@ -1,115 +1,148 @@
-//
-//  MyComposerDelegate.swift
-//  Pods
-//
-//
-
 import Foundation
 import PianoComposer
-import PianoOAuth
-
-// import PianoTemplate
+import React
 
+/**
+ * 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 {
 
-  // ✅ STEP 1: Add a weak reference back to the main implementation class.
-  // This lets us access the stored promiseResolver and promiseRejecter.
-  weak var moduleImpl: ComposerPianoImpl?
-
-  // ✅ STEP 2: This is a generic helper function to resolve the promise.
-  // We'll call this from all the different delegate methods.
-  private func resolvePromise(with eventData: [String: Any]) {
-    guard self.moduleImpl?.promiseResolver != nil else { return }
-
-    self.moduleImpl?.promiseResolver?(eventData)
-    self.clearPromiseHandlers()
-  }
-
-  private func rejectPromise(with error: Error) {
-    guard self.moduleImpl?.promiseRejecter != nil else { return }
-
-    let errorCode = "execution_failed"
-    let errorMessage = error.localizedDescription
-    self.moduleImpl?.promiseRejecter?(errorCode, errorMessage, error)
-    self.clearPromiseHandlers()
-  }
-
-  private func clearPromiseHandlers() {
-    self.moduleImpl?.promiseResolver = nil
-    self.moduleImpl?.promiseRejecter = nil
-  }
-
-  // ✅ STEP 3: Implement the real delegate methods.
-  // The Piano SDK will call these automatically.
-
-  public func executeExperience(
-    composer: PianoComposer, event: XpEvent
-  ) {
-    print("✅ Delegate received: executeExperience")
-
-    // Correct: Access the experienceId from the public 'eventExecutionContext' object
-    let experienceId = event.eventExecutionContext?.experienceId ?? ""
-
-    let eventData: [String: Any] = [
-      "eventType": event.eventType,
-      "experienceId": experienceId,
-    ]
-
-    resolvePromise(with: eventData)
-  }
-
-  public func showTemplate(
-    composer: PianoComposer, event: XpEvent, params: ShowTemplateEventParams?
-  ) {
-    print("✅ Delegate received: showTemplate")
-
-    // Correct: Access the experienceId from the public 'eventExecutionContext' object
-    let experienceId = event.eventExecutionContext?.experienceId ?? ""
-
-    let eventData: [String: Any] = [
-      "eventType": event.eventType,
-      "experienceId": experienceId,
-      "templateUrl": params?.templateUrl ?? "",
-      "displayMode": params?.displayMode.rawValue ?? "",
-    ]
-
-    resolvePromise(with: eventData)
-  }
-
-  public func meterExpired(
-    composer: PianoComposer, event: XpEvent, params: PageViewMeterEventParams?
-  ) {
-    print("✅ Delegate received: meterExpired")
-
-    // Correct: Access the experienceId from the public 'eventExecutionContext' object
-    let experienceId = event.eventExecutionContext?.experienceId ?? ""
-
-    let eventData: [String: Any] = [
-      "eventType": event.eventType,
-      "experienceId": experienceId,
-      "meterName": params?.meterName ?? "",
-    ]
-
-    resolvePromise(with: eventData)
-  }
-
-  public func composerExecutionFailed(_ composer: PianoComposer, error: Error) {
-    print("❌ Delegate received: composerExecutionFailed")
-    rejectPromise(with: error)
-  }
-
-  public func composerExecutionCompleted(composer: PianoComposer) {
-    print("✅ Delegate received: composerExecutionCompleted")
-    resolvePromise(with: ["eventType": "composerExecutionCompleted"])
-  }
-
-  public func experienceExecutionFailed(composer: PianoComposer, event: XpEvent, params: FailureEventParams?) {
-    print("❌ Delegate received: experienceExecutionFailed")
-    let error = NSError(domain: "PianoSDK", code: -1, userInfo: [NSLocalizedDescriptionKey: "Experience execution failed"])
-    rejectPromise(with: error)
-  }
-
-  public func findViewBySelector(selector: String) -> UIView? {
-    return nil
-  }
+    // 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"
+        let errorMessage = error.localizedDescription
+        rejecter(errorCode, errorMessage, error)
+        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
+    }
+
+    // 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 ?? ""
+        ]
+        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
+        ]
+        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 ?? ""
+        ]
+        resolvePromise(with: eventData)
+    }
+
+    /**
+     * Called when the user segment is true.
+     */
+    public func userSegmentTrue(composer: PianoComposer, event: XpEvent) {
+        print("MyComposerDelegate: Received userSegmentTrue event")
+        resolvePromise(with: ["eventType": "userSegmentTrue"])
+    }
+
+    /**
+     * Called when the user segment is false.
+     */
+    public func userSegmentFalse(composer: PianoComposer, event: XpEvent) {
+        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"])
+    }
+
+    /**
+     * Called when an error occurs during the experience execution.
+     */
+    public func experienceExecutionFailed(composer: PianoComposer, event: XpEvent, params: FailureEventParams?) {
+        print("MyComposerDelegate: Received experienceExecutionFailed event")
+        let error = NSError(
+            domain: "PianoSDK",
+            code: -1,
+            userInfo: [NSLocalizedDescriptionKey: "Experience execution failed by the server."]
+        )
+        rejectPromise(with: error)
+    }
 }
+