react-native-sdk-pianoio 0.2.1 → 0.2.3

package/ios/ComposerPiano.swift

@@ -9,24 +9,33 @@ import PianoComposer
 import PianoOAuth
 import PianoConsents
 import PianoTemplate
+import React
+
+import SwiftUI
+
 
 @objcMembers public class ComposerPianoImpl: NSObject {
-    
   private var composer: PianoComposer?;
+  private var delegateHelper : MyComposerDelegate?;
+  public static var aid = "";
   
   @objc public func initializeComposer(_ aid: String) -> PianoComposer? {
-    print("ASSING AID");
-    composer = PianoComposer(aid: aid);
+    ComposerPianoImpl.aid = aid;
+    let tokenService = TokenService();
+    delegateHelper = MyComposerDelegate(tokenService: tokenService);
+    composer = PianoComposer(aid: ComposerPianoImpl.aid, endpoint: PianoEndpoint.sandbox);
+    composer = delegateHelper?.setComposerAndDelegate(composer!);
     return composer;
   }
   
   @objc public func addTag(_ tag: String) -> PianoComposer? {
-    print("ASSIGN TAG");
     return composer?.tag(tag);
   }
+  @objc public func addTagToComposer(_ composer: PianoComposer, tag: String) {
+    composer.tag(tag);
+  }
   
   @objc public func addTags(_ tags: [String]) -> PianoComposer? {
-    print("ASSIGN TAGS");
     return composer?.tags(tags);
   }
   
@@ -44,19 +53,96 @@ import PianoTemplate
   
   @objc public func setCustomVariable(_ name: String, value: String) -> PianoComposer? {
     return composer?.customVariable(name: name, value: value);
-      
   }
   
   @objc public func setUserToken(_ token: String) -> PianoComposer? {
     return composer?.userToken(token);
   }
   
-  @objc public func executeComposer() -> PianoComposer? {
+  /*@objc public func executeComposer() -> PianoComposer? {
     return composer?.execute();
+  }*/
+  @objc public func executeComposer() {
+      DispatchQueue.main.async {
+        guard let rootVC = UIApplication.shared.connectedScenes
+                   .compactMap({ $0 as? UIWindowScene })
+                   .first(where: { $0.activationState == .foregroundActive })?.windows
+                   .first(where: { $0.isKeyWindow })?.rootViewController else {
+                   return
+               }
+               
+          self.composer?.execute()
+      }
+  }
+  
+  
+  
+  // Delegate handler
+  @objc public func executeExperience() {
+    let eventDict: [String: Any] = [
+        "eventType": "login"
+    ];
+
+    let xpEvent = XpEvent(dict: eventDict);
+    
+    if(composer != nil && composer!.delegate != nil ) {
+      delegateHelper?.executeExperience(composer: composer!, event: xpEvent, params: nil);
+    }
   }
+  
+  @objc public func showLogin() {
+    let eventDict: [String: Any] = [
+        "eventType": "login"
+    ];
+
+    let xpEvent = XpEvent(dict: eventDict);
+    
+    if(composer != nil && composer!.delegate != nil ) {
+      delegateHelper?.myShowLogin(composer: composer!, event: xpEvent, params: nil);
+    }
+  }
+  
+  @objc public func showTemplate() {
+      DispatchQueue.main.async {
+          guard let rootVC = UIApplication.shared
+                  .connectedScenes
+                  .compactMap({ $0 as? UIWindowScene })
+                  .flatMap({ $0.windows })
+                  .first(where: { $0.isKeyWindow })?
+                  .rootViewController else {
+              print("⚠️ rootViewController non trovato")
+              return
+          }
+
+          let tokenService = self.delegateHelper!.tokenService
+          let view = ShowTemplateView(tokenService: tokenService)
+          let hostingController = UIHostingController(rootView: view)
+          hostingController.modalPresentationStyle = .fullScreen
+
+          rootVC.present(hostingController, animated: true, completion: nil)
+      }
+  }
+  
+  @objc public func showForm() {
+    let eventDict: [String: Any] = [
+        "eventType": "form"
+    ];
+
+    let xpEvent = XpEvent(dict: eventDict);
     
+    if(composer != nil && composer!.delegate != nil ) {
+      delegateHelper?.myShowForm(composer: composer!, event: xpEvent, params: nil);
+    }
+  }
+  
+
+  
+  public func findViewBySelector(selector: String) -> UIView? {
+    return nil;
+  }
+
   
-  // metodi di aiuto :)
+  // method to get values and helpers
   @objc public func getAid() -> String {
     if(composer != nil){
       return composer?.aid ?? "";
@@ -74,7 +160,6 @@ import PianoTemplate
   }
   
   @objc public func getComposer() -> PianoComposer? {
-    print("GET COMPOSER");
     return composer;
   }
   
@@ -93,5 +178,35 @@ import PianoTemplate
   @objc public func getUserToken() -> String {
       return composer?.userToken ?? ""
   }
+  
+  @objc public func addTagsToComposer(_ composer: PianoComposer, tags: [String]) {
+      composer.tags(tags)
+  }
+
+  @objc public func setCustomVariable(_ composer: PianoComposer, name: String, value: String) {
+      composer.customVariable(name: name, value: value)
+  }
+
+  @objc public func setReferrer(_ composer: PianoComposer, referrer: String) {
+      composer.referrer(referrer)
+  }
+
+  @objc public func setUrl(_ composer: PianoComposer, url: String) {
+      composer.url(url)
+  }
+
+  @objc public func setUserToken(_ composer: PianoComposer, token: String) {
+      composer.userToken(token)
+  }
+
+  @objc public func setZoneId(_ composer: PianoComposer, zoneId: String) {
+      composer.zoneId(zoneId)
+  }
+
+  @objc public func executeComposer(_ composer: PianoComposer) {
+      DispatchQueue.main.async {
+          composer.execute()
+      }
+  }
 
 }

package/ios/MyComposerDelegate.swift

@@ -0,0 +1,204 @@
+//
+//  MyComposerDelegate.swift
+//  Pods
+//
+//  Created by Alessia Sarak on 23.04.2025.
+//
+
+import Foundation
+import PianoComposer
+import PianoOAuth
+import PianoCommon
+import PianoTemplate
+
+import SwiftUI
+import WebKit
+
+public class MyComposerDelegate: ComposerService, PianoShowTemplateDelegate {
+  
+  var view: WKWebView?
+  
+  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)
+      }
+    }
+  }
+
+
+  
+  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 findViewBySelector(selector: String) -> UIView? {
+    return nil;
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+struct WebView : UIViewRepresentable {
+
+    let webView: WKWebView
+
+    @Binding var height: CGFloat
+
+    class Coordinator: NSObject, WKNavigationDelegate {
+
+        var parent: WebView
+
+        init(_ parent: WebView) {
+            self.parent = parent
+        }
+
+        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
+                }
+            })
+        }
+    }
+
+    func makeCoordinator() -> Coordinator {
+        Coordinator(self)
+    }
+
+    func makeUIView(context: Context) -> WKWebView {
+        webView.scrollView.bounces = false
+        webView.navigationDelegate = context.coordinator
+
+        return webView
+    }
+
+    func updateUIView(_ uiView: WKWebView, context: Context) {}
+}
+
+fileprivate class ShowTemplateService: ComposerService, PianoShowTemplateDelegate {
+
+    @Published var webView: WKWebView? = nil
+
+    override func prepare(composer: PianoComposer) {
+        webView = nil
+        _ = composer.tag("templates")
+    }
+
+    func showTemplate(composer: PianoComposer, event: XpEvent, params: ShowTemplateEventParams?) {
+        if let p = params {
+            if p.displayMode == .inline {
+                webView = WKWebView()
+            }
+
+            let controller = PianoShowTemplateController(p)
+            controller.delegate = self
+            controller.show()
+        }
+    }
+
+    func findViewBySelector(selector: String) -> UIView? {
+        selector == "template" ? webView : nil
+    }
+}
+
+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")
+      }
+    }
+}

package/ios/SdkPianoio.h

@@ -1,6 +1,4 @@
+#import <React/RCTBridgeModule.h>
 
-#import "generated/RNSdkPianoioSpec/RNSdkPianoioSpec.h"
-
-@interface SdkPianoio : NSObject <NativeSdkPianoioSpec>
-
+@interface SdkPianoio : NSObject <RCTBridgeModule>
 @end

package/ios/SdkPianoio.mm

@@ -1,40 +1,41 @@
 #import "SdkPianoio.h"
 #import "SdkPianoio-Swift.h"
+#import <React/RCTBridgeModule.h>
 
 @implementation SdkPianoio {
   ComposerPianoImpl *moduleImpl;
 }
 
-- (instancetype) init {
+RCT_EXPORT_MODULE(SdkPianoio)
+
+
+- (instancetype)init {
   self = [super init];
-  if(self){
+  if (self) {
     moduleImpl = [ComposerPianoImpl new];
   }
   return self;
 }
 
-RCT_EXPORT_MODULE()
-
-- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params
+RCT_EXPORT_METHOD(initializeComposer:(NSString *)aid
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
 {
-    return std::make_shared<facebook::react::NativeSdkPianoioSpecJSI>(params);
-}
-
-// initialize composer with one parameter
-- (void) initializeComposer:(nonnull NSString *)aid
-                                         resolve:(nonnull RCTPromiseResolveBlock)resolve
-                                          reject:(nonnull RCTPromiseRejectBlock)reject {
+  if (!moduleImpl) {
+      moduleImpl = [ComposerPianoImpl new];
+  }
+  
   PianoComposer *composer = [moduleImpl initializeComposer:aid];
   if (composer) {
     resolve(composer);
   } else {
-    reject(@"composer_error", @"Impossibile aggiungere il tag", nil);
+    reject(@"composer_error", @"Impossibile inizializzare il composer", nil);
   }
 }
 
-// get composer
-- (void) getComposer:(nonnull RCTPromiseResolveBlock)resolve
-             reject:(nonnull RCTPromiseRejectBlock)reject {
+RCT_EXPORT_METHOD(getComposer:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
   PianoComposer *composer = [moduleImpl getComposer];
   if (composer) {
     NSMutableDictionary *response = [NSMutableDictionary new];
@@ -44,16 +45,15 @@ RCT_EXPORT_MODULE()
     [response setObject:[moduleImpl getReferrer] forKey:@"referrer"];
     [response setObject:[moduleImpl getUrl] forKey:@"url"];
     [response setObject:[moduleImpl getUserToken] forKey:@"userToken"];
-    
     resolve(response);
   } else {
-    reject(@"composer_error", @"Impossibile aggiungere il tag", nil);
+    reject(@"composer_error", @"Impossibile ottenere il composer", nil);
   }
 }
 
-- (void)addComposerTag:(nonnull NSString *)tag
-               resolve:(nonnull RCTPromiseResolveBlock)resolve
-                reject:(nonnull RCTPromiseRejectBlock)reject
+RCT_EXPORT_METHOD(addComposerTag:(NSString *)tag
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
 {
   PianoComposer *composer = [moduleImpl addTag:tag];
   if (composer) {
@@ -63,9 +63,9 @@ RCT_EXPORT_MODULE()
   }
 }
 
-- (void)addComposerTags:(nonnull NSArray *)tags
-                resolve:(nonnull RCTPromiseResolveBlock)resolve
-                 reject:(nonnull RCTPromiseRejectBlock)reject
+RCT_EXPORT_METHOD(addComposerTags:(NSArray *)tags
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
 {
   PianoComposer *composer = [moduleImpl addTags:tags];
   if (composer) {
@@ -75,21 +75,17 @@ RCT_EXPORT_MODULE()
   }
 }
 
-- (void)executeComposer:(nonnull RCTPromiseResolveBlock)resolve
-                 reject:(nonnull RCTPromiseRejectBlock)reject
+RCT_EXPORT_METHOD(executeComposer:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
 {
-  PianoComposer *composer = [moduleImpl executeComposer];
-  if (composer) {
-    resolve(nil);
-  } else {
-    reject(@"composer_error", @"Impossibile eseguire il composer", nil);
-  }
+  [moduleImpl executeComposer];
+  resolve(nil);
 }
 
-- (void)setComposerCustomVariable:(nonnull NSString *)name
-                            value:(nonnull NSString *)value
-                          resolve:(nonnull RCTPromiseResolveBlock)resolve
-                           reject:(nonnull RCTPromiseRejectBlock)reject
+RCT_EXPORT_METHOD(setComposerCustomVariable:(NSString *)name
+                  value:(NSString *)value
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
 {
   PianoComposer *composer = [moduleImpl setCustomVariable:name value:value];
   if (composer) {
@@ -99,9 +95,9 @@ RCT_EXPORT_MODULE()
   }
 }
 
-- (void)setComposerReferrer:(nonnull NSString *)referrer
-                    resolve:(nonnull RCTPromiseResolveBlock)resolve
-                     reject:(nonnull RCTPromiseRejectBlock)reject
+RCT_EXPORT_METHOD(setComposerReferrer:(NSString *)referrer
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
 {
   PianoComposer *composer = [moduleImpl setReferrer:referrer];
   if (composer) {
@@ -111,9 +107,9 @@ RCT_EXPORT_MODULE()
   }
 }
 
-- (void)setComposerUrl:(nonnull NSString *)url
-               resolve:(nonnull RCTPromiseResolveBlock)resolve
-                reject:(nonnull RCTPromiseRejectBlock)reject
+RCT_EXPORT_METHOD(setComposerUrl:(NSString *)url
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
 {
   PianoComposer *composer = [moduleImpl setUrl:url];
   if (composer) {
@@ -123,9 +119,9 @@ RCT_EXPORT_MODULE()
   }
 }
 
-- (void)setComposerUserToken:(nonnull NSString *)token
-                     resolve:(nonnull RCTPromiseResolveBlock)resolve
-                      reject:(nonnull RCTPromiseRejectBlock)reject
+RCT_EXPORT_METHOD(setComposerUserToken:(NSString *)token
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
 {
   PianoComposer *composer = [moduleImpl setUserToken:token];
   if (composer) {
@@ -135,9 +131,9 @@ RCT_EXPORT_MODULE()
   }
 }
 
-- (void)setComposerZoneId:(nonnull NSString *)zoneId
-                  resolve:(nonnull RCTPromiseResolveBlock)resolve
-                   reject:(nonnull RCTPromiseRejectBlock)reject
+RCT_EXPORT_METHOD(setComposerZoneId:(NSString *)zoneId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
 {
   PianoComposer *composer = [moduleImpl setZoneId:zoneId];
   if (composer) {
@@ -147,6 +143,52 @@ RCT_EXPORT_MODULE()
   }
 }
 
+RCT_EXPORT_METHOD(showLogin:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  @try {
+    [moduleImpl showLogin];
+    resolve(@(YES));
+  }
+  @catch (NSException *exception) {
+    reject(@"show_login_error", @"Errore in showLogin", nil);
+  }
+}
+
+RCT_EXPORT_METHOD(showTemplate:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  @try {
+    [moduleImpl showTemplate];
+    resolve(@(YES));
+  }
+  @catch (NSException *exception) {
+    reject(@"show_template_error", @"Errore in showTemplate", nil);
+  }
+}
 
+RCT_EXPORT_METHOD(showForm:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  @try {
+    [moduleImpl showForm];
+    resolve(@(YES));
+  }
+  @catch (NSException *exception) {
+    reject(@"show_template_error", @"Errore in showForm", nil);
+  }
+}
+
+RCT_EXPORT_METHOD(experienceExecute:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  @try {
+    [moduleImpl executeExperience];
+    resolve(@(YES));
+  }
+  @catch (NSException *exception) {
+    reject(@"experience_execute_error", @"Errore in experienceExecute", nil);
+  }
+}
 
 @end