react-native-sdk-pianoio 0.3.0 → 0.3.1

package/ios/ComposerPianoImpl.swift

@@ -0,0 +1,247 @@
+//
+//  ComposerPianoImpl.swift
+//  SdkPianoio
+//
+//
+import Foundation
+import PianoComposer
+import PianoOAuth
+import React
+
+@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?
+
+  // This is a static property to hold the AID
+  public static var aid = ""
+
+  @objc public func initializeComposer(_ aid: String) {
+    ComposerPianoImpl.aid = aid
+
+    // 1. Correctly initialize the TokenService first.
+    let tokenService = TokenService()
+
+    // 2. Initialize the delegate.
+    self.delegateHelper = MyComposerDelegate()
+
+    // 3. Link the delegate back to this class so it can resolve promises.
+    self.delegateHelper?.moduleImpl = self
+
+    // 4. Initialize the composer.
+    self.composer = PianoComposer(
+      aid: ComposerPianoImpl.aid, endpoint: PianoEndpoint.productionEurope)
+
+    // 5. Set the composer's delegate property directly. This is the standard Swift way.
+    self.composer?.delegate = self.delegateHelper
+  }
+
+  @objc public func executeComposer() {
+    print("Esecuzione composer")
+    DispatchQueue.main.async {
+      if let composer = self.composer {
+        print("Calling composer.execute()")
+        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 ""
+    }
+  }
+
+  @objc public func getTags() -> [String] {
+    if let tags = composer?.tags, !tags.isEmpty {
+      return Array(tags)
+    } else {
+      return []
+    }
+  }
+
+  @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)
+      }
+    }
+  }
+
+  @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

@@ -7,236 +7,109 @@
 import Foundation
 import PianoComposer
 import PianoOAuth
-import PianoCommon
-import PianoTemplate
-
-import SwiftUI
-import WebKit
-
-public class MyComposerDelegate: ComposerService, PianoShowTemplateDelegate {
-  
-  var view: WKWebView?
-  
-  func experienceExecute(composer: PianoComposer, event: XpEvent, params: ExperienceExecuteEventParams?) {
-    print("Evento ricevuto: \(event)")
-    print(event.eventType)
-  }
-  
-  func showTemplate(params: ShowTemplateEventParams) {
-      if params.displayMode == .inline {
-          let request = URLRequest(url: URL(string: params.templateUrl)!)
-          view?.load(request)
-      }
-  }
-  
-  public func setComposerAndDelegate(_ myComposer: PianoComposer) -> PianoComposer? {
-    myComposer.delegate = self;
-    return myComposer;
-  }
-  
-  public func myShowLogin(composer: PianoComposer, event: XpEvent, params: [AnyHashable: Any]?) {
-    DispatchQueue.main.async {
-      PianoID.shared.aid = composer.aid;
-      PianoID.shared.endpoint = composer.endpoint;
-      PianoID.shared.signUpEnabled = true;
-      
-      PianoID.shared.signIn();
-    };
-  }
-  
-  public func myShowForm(composer: PianoComposer, event: XpEvent, params: [AnyHashable: Any]?) {
-    DispatchQueue.main.async {
-      PianoID.shared.formInfo(accessToken: PianoIDToken.description()) { formInfo, error in
-        if let error = error {
-          print("Errore nel recuperare il form: \(error.localizedDescription)")
-          return
-        }
-
-        guard let formInfo = formInfo else {
-          print("FormInfo non disponibile.")
-          return
-        }
-
-        composer.delegate?.showForm?(composer: composer, event: event, params: nil)
-      }
-    }
-  }
 
+// import PianoTemplate
 
-  
-  public func myShowTemplate(composer: PianoComposer, event: XpEvent, params: ShowTemplateEventParams?) {
-      if let p = params {
-              let webView = WKWebView()
-              let request = URLRequest(url: URL(string: p.templateUrl)!)
-              webView.load(request)
-
-              // Aggiungi webView alla vista principale
-              let controller = PianoShowTemplateController(p)
-              controller.delegate = self
-              controller.show()
-      
-        self.execute();
-      }
-  }
-  
-  public func executeExperience(composer: PianoComposer, event: XpEvent, params: ExperienceExecuteEventParams?) {
-    composer.delegate?.experienceExecute?(composer: composer, event: event, params: params)
-    
-  }
-  
-  public func composerExecutionCompleted(composer: PianoComposer, event: XpEvent, params: ExperienceExecuteEventParams?) {
-    composer.delegate?.composerExecutionCompleted?(composer: composer)
-    
-  }
+@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?
 
-  
-  public func findViewBySelector(selector: String) -> UIView? {
-    return nil;
-  }
-  
-  public func showRecommendations(composer: PianoComposer, event: XpEvent, params: ShowRecommendationsEventParams?) {
-       DispatchQueue.main.async {
-           composer.delegate?.showRecommendations?(composer: composer, event: event, params: params)
-       }
-   }
-
-   public func nonSite(composer: PianoComposer, event: XpEvent) {
-       DispatchQueue.main.async {
-           composer.delegate?.nonSite?(composer: composer, event: event)
-       }
-   }
-
-   public func userSegmentTrue(composer: PianoComposer, event: XpEvent) {
-       DispatchQueue.main.async {
-           composer.delegate?.userSegmentTrue?(composer: composer, event: event)
-       }
-   }
-
-   public func userSegmentFalse(composer: PianoComposer, event: XpEvent) {
-       DispatchQueue.main.async {
-           composer.delegate?.userSegmentFalse?(composer: composer, event: event)
-       }
-   }
-
-   public func meterActive(composer: PianoComposer, event: XpEvent, params: PageViewMeterEventParams?) {
-       DispatchQueue.main.async {
-           composer.delegate?.meterActive?(composer: composer, event: event, params: params)
-       }
-   }
-
-   public func meterExpired(composer: PianoComposer, event: XpEvent, params: PageViewMeterEventParams?) {
-       DispatchQueue.main.async {
-           composer.delegate?.meterExpired?(composer: composer, event: event, params: params)
-       }
-   }
-  
-  public func composerDidCompleteExecution(_ composer: PianoComposer, result: PianoComposerEdgeResult?) {
-      print("✅ Composer execution finished.")
-
-      // Qui puoi notificare JS, inviare un evento, ecc.
-      // Ad esempio: invia una notifica o chiama una callback
-  }
+  // ✅ 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 }
 
-  public func composerExecutionFailed(_ composer: PianoComposer, error: Error) {
-      print("❌ Composer execution failed with error: \(error.localizedDescription)")
+    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()
+  }
 
-struct WebView : UIViewRepresentable {
+  private func clearPromiseHandlers() {
+    self.moduleImpl?.promiseResolver = nil
+    self.moduleImpl?.promiseRejecter = nil
+  }
 
-    let webView: WKWebView
+  // ✅ STEP 3: Implement the real delegate methods.
+  // The Piano SDK will call these automatically.
 
-    @Binding var height: CGFloat
+  public func executeExperience(
+    composer: PianoComposer, event: XpEvent
+  ) {
+    print("✅ Delegate received: executeExperience")
 
-    class Coordinator: NSObject, WKNavigationDelegate {
+    // Correct: Access the experienceId from the public 'eventExecutionContext' object
+    let experienceId = event.eventExecutionContext?.experienceId ?? ""
 
-        var parent: WebView
+    let eventData: [String: Any] = [
+      "eventType": event.eventType,
+      "experienceId": experienceId,
+    ]
 
-        init(_ parent: WebView) {
-            self.parent = parent
-        }
+    resolvePromise(with: eventData)
+  }
 
-        func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
-            webView.evaluateJavaScript("document.documentElement.scrollHeight", completionHandler: { (height, error) in
-                DispatchQueue.main.async {
-                    self.parent.height = height as! CGFloat
-                }
-            })
-        }
-    }
+  public func showTemplate(
+    composer: PianoComposer, event: XpEvent, params: ShowTemplateEventParams?
+  ) {
+    print("✅ Delegate received: showTemplate")
 
-    func makeCoordinator() -> Coordinator {
-        Coordinator(self)
-    }
+    // Correct: Access the experienceId from the public 'eventExecutionContext' object
+    let experienceId = event.eventExecutionContext?.experienceId ?? ""
 
-    func makeUIView(context: Context) -> WKWebView {
-        webView.scrollView.bounces = false
-        webView.navigationDelegate = context.coordinator
+    let eventData: [String: Any] = [
+      "eventType": event.eventType,
+      "experienceId": experienceId,
+      "templateUrl": params?.templateUrl ?? "",
+      "displayMode": params?.displayMode.rawValue ?? "",
+    ]
 
-        return webView
-    }
+    resolvePromise(with: eventData)
+  }
 
-    func updateUIView(_ uiView: WKWebView, context: Context) {}
-}
+  public func meterExpired(
+    composer: PianoComposer, event: XpEvent, params: PageViewMeterEventParams?
+  ) {
+    print("✅ Delegate received: meterExpired")
 
-fileprivate class ShowTemplateService: ComposerService, PianoShowTemplateDelegate {
+    // Correct: Access the experienceId from the public 'eventExecutionContext' object
+    let experienceId = event.eventExecutionContext?.experienceId ?? ""
 
-    @Published var webView: WKWebView? = nil
+    let eventData: [String: Any] = [
+      "eventType": event.eventType,
+      "experienceId": experienceId,
+      "meterName": params?.meterName ?? "",
+    ]
 
-    override func prepare(composer: PianoComposer) {
-        webView = nil
-        _ = composer.tag("templates")
-    }
+    resolvePromise(with: eventData)
+  }
 
-    func showTemplate(composer: PianoComposer, event: XpEvent, params: ShowTemplateEventParams?) {
-        if let p = params {
-            if p.displayMode == .inline {
-                webView = WKWebView()
-            }
+  public func composerExecutionFailed(_ composer: PianoComposer, error: Error) {
+    print("❌ Delegate received: composerExecutionFailed")
+    rejectPromise(with: error)
+  }
 
-            let controller = PianoShowTemplateController(p)
-            controller.delegate = self
-            controller.show()
-        }
-    }
+  public func composerExecutionCompleted(composer: PianoComposer) {
+    print("✅ Delegate received: composerExecutionCompleted")
+    resolvePromise(with: ["eventType": "composerExecutionCompleted"])
+  }
 
-    func findViewBySelector(selector: String) -> UIView? {
-        selector == "template" ? webView : nil
-    }
-}
+  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)
+  }
 
-struct ShowTemplateView: View {
-
-    @ObservedObject private var service: ShowTemplateService
-
-    @State private var height: CGFloat = .zero
-
-    init(tokenService: TokenService) {
-        service = ShowTemplateService(tokenService: tokenService)
-    }
-
-    var body: some View {
-      if #available(iOS 14.0, *) {
-        VStack(spacing: 20) {
-          if !service.loading {
-            Button("Execute") {
-              service.execute()
-            }
-            
-            if let wv = service.webView {
-              WebView(webView: wv, height: $height)
-                .frame(height: height > 320 ? 320 : height)
-            }
-          } else {
-            
-          }
-        }.navigationTitle("Show template")
-      }
-    }
+  public func findViewBySelector(selector: String) -> UIView? {
+    return nil
+  }
 }