Upgrade iadvize to latest

packages/nativescript-iadvize/common.ts

@@ -11,7 +11,7 @@ export interface ChatConfiguration {
 }
 
 export class IAdvizeCommon extends Observable {
-  private static chatbotActivated$: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);
+  private static chatbotActivated$ = new BehaviorSubject<boolean>(false);
 
   constructor() {
     super();

packages/nativescript-iadvize/index.android.ts

@@ -30,23 +30,26 @@ export class IAdvize extends IAdvizeCommon {
     return instance;
   }
 
-  public activate(projectId: number, userId: string, legalUrl: string | undefined = undefined, onSuccess: () => void, onFailure: () => void) {
-    IAdvize.initate();
-
-    let gdprOption;
-    if (legalUrl) {
-      const uri = new java.net.URI(legalUrl);
-      const gdprEnabledOption = new com.iadvize.conversation.sdk.model.gdpr.GDPREnabledOption.LegalUrl(uri);
-      gdprOption = new com.iadvize.conversation.sdk.model.gdpr.GDPROption.Enabled(gdprEnabledOption);
-    } else {
-      gdprOption = com.iadvize.conversation.sdk.model.gdpr.GDPROption.Disabled.class.getDeclaredField('INSTANCE').get(null);
+  private buildGdprOption(legalUrl: string | undefined) {
+    if (!legalUrl) {
+      return com.iadvize.conversation.sdk.feature.gdpr.GDPROption.Disabled.class.getDeclaredField('INSTANCE').get(null);
     }
 
+    const uri = new java.net.URI(legalUrl);
+    const gdprEnabledOption = new com.iadvize.conversation.sdk.feature.gdpr.GDPREnabledOption.LegalUrl(uri);
+    return new com.iadvize.conversation.sdk.feature.gdpr.GDPROption.Enabled(gdprEnabledOption);
+  }
+
+  public activate(projectId: number, userId: string, legalUrl: string | undefined = undefined, onSuccess: () => void, onFailure: () => void) {
+    IAdvize.initiate();
+
+    const gdprOption = this.buildGdprOption(legalUrl);
+
     com.iadvize.conversation.sdk.IAdvizeSDK.activate(
       projectId,
-      new com.iadvize.conversation.sdk.model.auth.AuthenticationOption.Simple(userId),
+      new com.iadvize.conversation.sdk.feature.authentication.AuthenticationOption.Simple(userId),
       gdprOption,
-      new com.iadvize.conversation.sdk.model.SDKCallback({
+      new com.iadvize.conversation.sdk.IAdvizeSDK.Callback({
         onSuccess(): void {
           console.log('iAdvize[Android] activated');
           onSuccess();
@@ -59,28 +62,46 @@ export class IAdvize extends IAdvizeCommon {
     );
   }
 
+  private buildTargetingRule(targetingRuleUUID: string) {
+    const conversationChannel = com.iadvize.conversation.sdk.feature.conversation.ConversationChannel.class.getDeclaredField('CHAT').get(null);
+    const uuid = java.util.UUID.fromString(targetingRuleUUID);
+    return new com.iadvize.conversation.sdk.feature.targeting.TargetingRule(uuid, conversationChannel);
+  }
+
   public activateTargetingRule(targetingRuleUUID: string) {
     if (!IAdvizeSDK()) {
       return;
     }
 
     const listeners = IAdvizeSDK().getTargetingController().getListeners();
     listeners.add(
-      new com.iadvize.conversation.sdk.controller.targeting.TargetingListener({
+      new com.iadvize.conversation.sdk.feature.targeting.TargetingListener({
         onActiveTargetingRuleAvailabilityUpdated(param0: boolean): void {
           console.log('iAdvize[Android] Targeting rule available - ' + param0);
           IAdvize.activateChatbot();
         },
       })
     );
 
-    IAdvizeSDK().getTargetingController().activateTargetingRule(java.util.UUID.fromString(targetingRuleUUID));
+    const language = com.iadvize.conversation.sdk.type.Language.class.getDeclaredField('nl').get(null);
+
+    IAdvizeSDK().getTargetingController().setLanguage(new com.iadvize.conversation.sdk.feature.targeting.LanguageOption.Custom(language));
+    IAdvizeSDK().getTargetingController().activateTargetingRule(this.buildTargetingRule(targetingRuleUUID));
 
     IAdvize.activateChatbot();
   }
 
   public logout() {
-    com.iadvize.conversation.sdk.IAdvizeSDK.logout();
+    com.iadvize.conversation.sdk.IAdvizeSDK.logout(
+      new com.iadvize.conversation.sdk.IAdvizeSDK.Callback({
+        onSuccess(): void {
+          console.log('iAdvize[Android] logout success');
+        },
+        onFailure(error): void {
+          console.error('iAdvize[Android] logout failed' + error.getLocalizedMessage());
+        },
+      })
+    );
     IAdvize.deactivateChatbot();
   }
 
@@ -93,10 +114,10 @@ export class IAdvize extends IAdvizeCommon {
     const navigationBarMainColor = new Color(configuration.navigationBarMainColor).android;
     const avatar = ImageSource.fromFileOrResourceSync('res://' + configuration.incomingMessageAvatar).android;
 
-    const chatboxConfiguration = new com.iadvize.conversation.sdk.model.configuration.ChatboxConfiguration(mainColor);
+    const chatboxConfiguration = new com.iadvize.conversation.sdk.feature.chatbox.ChatboxConfiguration(mainColor);
     chatboxConfiguration.setToolbarBackgroundColor(java.lang.Integer.valueOf(navigationBarBackgroundColor));
     chatboxConfiguration.setToolbarMainColor(java.lang.Integer.valueOf(navigationBarMainColor));
-    chatboxConfiguration.setIncomingMessageAvatar(new com.iadvize.conversation.sdk.model.conversation.IncomingMessageAvatar.Image(new android.graphics.drawable.BitmapDrawable(Application.android.context.getResources(), avatar)));
+    chatboxConfiguration.setIncomingMessageAvatar(new com.iadvize.conversation.sdk.feature.conversation.IncomingMessageAvatar.Image(new android.graphics.drawable.BitmapDrawable(Utils.android.getApplicationContext().getResources(), avatar)));
     chatboxConfiguration.setAutomaticMessage(configuration.automaticMessage);
     chatboxConfiguration.setToolbarTitle(configuration.navigationBarTitle);
     chatboxConfiguration.setFontPath(configuration.font);
@@ -110,9 +131,9 @@ export class IAdvize extends IAdvizeCommon {
     }
     const listeners = IAdvizeSDK().getConversationController().getListeners();
     listeners.add(
-      new com.iadvize.conversation.sdk.controller.conversation.ConversationListener({
-        onOngoingConversationStatusChanged(param0: boolean): void {
-          ongoingConversationStatusDidChange(param0);
+      new com.iadvize.conversation.sdk.feature.conversation.ConversationListener({
+        onOngoingConversationUpdated(param0: com.iadvize.conversation.sdk.feature.conversation.OngoingConversation): void {
+          ongoingConversationStatusDidChange(!!param0);
         },
         onNewMessageReceived(_param0: string): void {
           newMessageReceived(_param0);
@@ -128,18 +149,21 @@ export class IAdvize extends IAdvizeCommon {
     if (!IAdvizeSDK()) {
       return;
     }
-    IAdvizeSDK().getChatboxController().setUseDefaultChatButton(false);
+    const disabledOption = com.iadvize.conversation.sdk.feature.defaultfloatingbutton.DefaultFloatingButtonOption.Disabled.class.getDeclaredField('INSTANCE').get(null);
+    IAdvizeSDK().getDefaultFloatingButtonController().setupDefaultFloatingButton(disabledOption);
   }
 
   public presentChat() {
     if (!IAdvizeSDK()) {
       return;
     }
-    IAdvizeSDK().getChatboxController().presentChatboxActivity(Application.android.foregroundActivity);
+    IAdvizeSDK()
+      .getChatboxController()
+      .presentChatbox(Application.android.foregroundActivity || Application.android.startActivity);
   }
 
   public dismissChat() {
-    const isChatActivity = Application.android.foregroundActivity instanceof com.iadvize.conversation.sdk.view.ChatboxActivity;
+    const isChatActivity = Application.android.foregroundActivity instanceof com.iadvize.conversation.sdk.feature.chatbox.ChatboxActivity;
     if (isChatActivity) {
       Application.android.foregroundActivity.finish();
     }
@@ -163,7 +187,25 @@ export class IAdvize extends IAdvizeCommon {
     return IAdvize.getChatbotActivated().asObservable();
   }
 
-  private static initate() {
+  public setLogLevel(logLevel: number) {
+    com.iadvize.conversation.sdk.IAdvizeSDK.setLogLevel(this.logLevelFrom(logLevel));
+  }
+
+  private logLevelFrom(logLevel: number): com.iadvize.conversation.sdk.feature.logger.Logger.Level {
+    switch (logLevel) {
+      case 0:
+        return com.iadvize.conversation.sdk.feature.logger.Logger.Level.VERBOSE;
+      case 1:
+        return com.iadvize.conversation.sdk.feature.logger.Logger.Level.INFO;
+      case 3:
+        return com.iadvize.conversation.sdk.feature.logger.Logger.Level.ERROR;
+      case 2:
+      default:
+        return com.iadvize.conversation.sdk.feature.logger.Logger.Level.WARNING;
+    }
+  }
+
+  private static initiate() {
     if (didInit) {
       return;
     }

packages/nativescript-iadvize/index.ios.ts

@@ -1,11 +1,11 @@
-import { Application, Color, ImageSource } from '@nativescript/core';
+import { Color, ImageSource } from '@nativescript/core';
 import { ChatConfiguration, IAdvizeCommon } from './common';
 import { Observable } from 'rxjs';
 
 export class IAdvize extends IAdvizeCommon {
   private static instance: IAdvize = new IAdvize();
-  private delegate: ConversationControllerDelegate;
-  private targetingRuleDelegate: TargetingControllerDelegate;
+  private delegate: ConversationControllerDelegateImpl;
+  private targetingRuleDelegate: TargetingControllerDelegateImpl;
 
   constructor() {
     super();
@@ -19,17 +19,19 @@ export class IAdvize extends IAdvizeCommon {
     return IAdvize.instance;
   }
 
-  public activate(projectId: number, userId: string, legalUrl: string | undefined = undefined, onSuccess: () => void, onFailure: () => void) {
-    let gdprOption;
-
-    if (legalUrl) {
-      const url = NSURL.URLWithString(legalUrl);
-      const gdprEnabledOption = new GDPREnabledOption({ legalInformationURL: url });
-      gdprOption = new GDPROption({ gdprEnabledOption: gdprEnabledOption });
-    } else {
-      gdprOption = GDPROption.disabled();
+  private buildGdprOption(legalUrl: string | undefined) {
+    if (!legalUrl) {
+      return GDPROption.disabled();
     }
 
+    const url = NSURL.URLWithString(legalUrl);
+    const gdprEnabledOption = new GDPREnabledOption({ legalInformationURL: url });
+    return new GDPROption({ gdprEnabledOption: gdprEnabledOption });
+  }
+
+  public activate(projectId: number, userId: string, legalUrl: string | undefined = undefined, onSuccess: () => void, onFailure: () => void) {
+    const gdprOption = this.buildGdprOption(legalUrl);
+
     IAdvizeSDK.shared.activateWithProjectIdAuthenticationOptionGdprOptionCompletion(projectId, new AuthenticationOption({ simple: userId }), gdprOption, (success: boolean) => {
       if (success) {
         console.log('iAdvize[iOS] activated');
@@ -41,14 +43,21 @@ export class IAdvize extends IAdvizeCommon {
     });
   }
 
+  private buildTargetingRule(targetingRuleUUID: string) {
+    const uuid = new NSUUID({ UUIDString: targetingRuleUUID });
+    const conversationChannel = ConversationChannel.alloc().init();
+    return TargetingRule.alloc().initWithIdObjcConversationChannel(uuid, conversationChannel);
+  }
+
   public activateTargetingRule(targetingRuleUUID: string) {
     this.targetingRuleDelegate = TargetingControllerDelegateImpl.initWithCallbacks((isActiveTargetingRuleAvailable: boolean) => {
       console.log('iAdvize[iOS] Targeting rule available - ' + isActiveTargetingRuleAvailable);
       IAdvize.activateChatbot();
     });
+
     IAdvizeSDK.shared.targetingController.delegate = this.targetingRuleDelegate;
-    IAdvizeSDK.shared.targetingController.activateTargetingRuleWithTargetingRuleId(new NSUUID({ UUIDString: targetingRuleUUID }));
     IAdvizeSDK.shared.targetingController.setLanguage(SDKLanguageOption.customWithValue(GraphQLLanguage.Nl));
+    IAdvizeSDK.shared.targetingController.activateTargetingRuleWithTargetingRule(this.buildTargetingRule(targetingRuleUUID));
   }
 
   public logout() {
@@ -62,15 +71,21 @@ export class IAdvize extends IAdvizeCommon {
     const mainColor = new Color(configuration.mainColor).ios;
     const navigationBarBackgroundColor = new Color(configuration.navigationBarBackgroundColor).ios;
     const navigationBarMainColor = new Color(configuration.navigationBarMainColor).ios;
-    const avatar = ImageSource.fromFileOrResourceSync('res://' + configuration.incomingMessageAvatar).ios;
+    const resImage = ImageSource.fromFileOrResourceSync('res://' + configuration.incomingMessageAvatar);
+    let avatar;
+    if (resImage) {
+      avatar = resImage.ios;
+    }
 
     const chatboxConfiguration = new ChatboxConfiguration();
 
     chatboxConfiguration.mainColor = mainColor;
     chatboxConfiguration.navigationBarBackgroundColor = navigationBarBackgroundColor;
     chatboxConfiguration.navigationBarMainColor = navigationBarMainColor;
     chatboxConfiguration.automaticMessage = configuration.automaticMessage;
-    chatboxConfiguration.incomingMessageAvatar = new IncomingMessageAvatar({ image: avatar });
+    if (avatar) {
+      chatboxConfiguration.incomingMessageAvatar = new IncomingMessageAvatar({ image: avatar });
+    }
     chatboxConfiguration.navigationBarTitle = configuration.navigationBarTitle;
     chatboxConfiguration.font = UIFont.fontWithNameSize(configuration.font, 12);
 
@@ -85,28 +100,46 @@ export class IAdvize extends IAdvizeCommon {
   }
 
   public hideDefaultChatButton() {
-    IAdvizeSDK.shared.chatboxController.useDefaultChatButton = false;
+    IAdvizeSDK.shared.chatboxController.useDefaultFloatingButton = false;
   }
 
   public presentChat() {
-    IAdvizeSDK.shared.conversationController.presentChatboxWithAnimatedPresentingViewControllerCompletion(true, Application.ios.window.rootController, () => {});
+    IAdvizeSDK.shared.chatboxController.presentChatboxWithAnimatedPresentingViewControllerCompletion(true, getRootViewController(), () => {});
   }
 
   public dismissChat() {
-    IAdvizeSDK.shared.conversationController.dismissChatboxWithAnimatedCompletion(false, () => {});
+    IAdvizeSDK.shared.chatboxController.dismissChatboxWithAnimatedCompletion(false, () => {});
   }
 
   public registerPushToken(token: string, isProd: boolean) {
     IAdvizeSDK.shared.notificationController.registerPushTokenApplicationMode(token, isProd ? GraphQLApplicationMode.Prod : GraphQLApplicationMode.Dev);
   }
 
   public isChatPresented() {
-    return IAdvizeSDK.shared.conversationController.isChatboxPresented();
+    return IAdvizeSDK.shared.chatboxController.isChatboxPresented();
   }
 
   public chatbotActivatedState(): Observable<boolean> {
     return IAdvize.getChatbotActivated().asObservable();
   }
+
+  public setLogLevel(logLevel: number) {
+    IAdvizeSDK.shared.setLogLevel(this.logLevelFrom(logLevel));
+  }
+
+  private logLevelFrom(logLevel: number): LoggerLogLevel {
+    switch (logLevel) {
+      case 0:
+        return LoggerLogLevel.Verbose;
+      case 1:
+        return LoggerLogLevel.Info;
+      case 3:
+        return LoggerLogLevel.Error;
+      case 2:
+      default:
+        return LoggerLogLevel.Warning;
+    }
+  }
 }
 
 @NativeClass()
@@ -117,7 +150,7 @@ class ConversationControllerDelegateImpl extends NSObject implements Conversatio
   private newMessageReceived: (content: string) => void;
 
   static initWithCallbacks(openURLCallback: (url: string) => boolean, ongoingConversationStatusDidChange: (hasOngoingConversation: boolean) => void, newMessageReceived: (content: string) => void): ConversationControllerDelegateImpl {
-    let delegate = <ConversationControllerDelegateImpl>super.new();
+    const delegate = <ConversationControllerDelegateImpl>super.new();
     delegate.openURLCallback = openURLCallback;
     delegate.ongoingConversationStatusDidChange = ongoingConversationStatusDidChange;
     delegate.newMessageReceived = newMessageReceived;
@@ -135,6 +168,8 @@ class ConversationControllerDelegateImpl extends NSObject implements Conversatio
   ongoingConversationStatusDidChangeWithHasOngoingConversation(hasOngoingConversation: boolean): void {
     this.ongoingConversationStatusDidChange(hasOngoingConversation);
   }
+
+  ongoingConversationUpdatedWithOngoingConversation(ongoingConversation: OngoingConversation): void {}
 }
 
 @NativeClass()
@@ -143,7 +178,7 @@ class TargetingControllerDelegateImpl extends NSObject implements TargetingContr
   private isActiveTargetingRuleAvailableCallback: (isActiveTargetingRuleAvailable: boolean) => void;
 
   static initWithCallbacks(isActiveTargetingRuleAvailableCallback: (isActiveTargetingRuleAvailable: boolean) => void): TargetingControllerDelegateImpl {
-    let delegate = <TargetingControllerDelegateImpl>super.new();
+    const delegate = <TargetingControllerDelegateImpl>super.new();
     delegate.isActiveTargetingRuleAvailableCallback = isActiveTargetingRuleAvailableCallback;
     return delegate;
   }
@@ -152,3 +187,13 @@ class TargetingControllerDelegateImpl extends NSObject implements TargetingContr
     this.isActiveTargetingRuleAvailableCallback(isActiveTargetingRuleAvailable);
   }
 }
+
+function getRootViewController(): UIViewController {
+  const app = UIApplication.sharedApplication;
+  const win = app.keyWindow || (app.windows && app.windows.count > 0 && app.windows.objectAtIndex(0));
+  let vc = win.rootViewController;
+  while (vc && vc.presentedViewController) {
+    vc = vc.presentedViewController;
+  }
+  return vc;
+}

packages/nativescript-iadvize/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@essent/nativescript-iadvize",
-  "version": "2.4.0",
+  "version": "2.9.0",
   "description": "iAdvize plugin for NativeScript.",
   "main": "index",
   "typings": "index.d.ts",

packages/nativescript-iadvize/platforms/android/include.gradle

@@ -11,5 +11,5 @@ dependencies {
     exclude group: 'xpp3', module: 'xpp3'
   }
 
-  implementation("com.iadvize:iadvize-sdk:2.4.3")
+  implementation("com.iadvize:iadvize-sdk:2.9.1")
 }

packages/nativescript-iadvize/platforms/ios/Podfile

@@ -1,4 +1,4 @@
-pod 'iAdvize', '2.4.0'
+pod 'iAdvize', '2.11.0'
 
 post_install do |installer|
     installer.pods_project.targets.each do |target|

packages/nativescript-iadvize/typings/android-declarations.d.ts

@@ -0,0 +1,9 @@
+declare module androidNative {
+  export class Array<T> {
+    constructor();
+    length: number;
+    [index: number]: T;
+  }
+}
+
+import globalAndroid = android;