@adobe/react-native-aepmessaging 1.0.0-beta.2 → 1.0.0

package/android/src/main/java/com/adobe/marketing/mobile/reactnative/messaging/RCTAEPMessagingModule.java

@@ -10,28 +10,244 @@
  */
 package com.adobe.marketing.mobile.reactnative.messaging;
 
+import com.adobe.marketing.mobile.AdobeCallback;
+import com.adobe.marketing.mobile.LoggingMode;
+
+import static com.adobe.marketing.mobile.LoggingMode.DEBUG;
+import static com.adobe.marketing.mobile.LoggingMode.VERBOSE;
+
+import android.util.Log;
+
+import com.adobe.marketing.mobile.Message;
 import com.adobe.marketing.mobile.Messaging;
+import com.adobe.marketing.mobile.MessagingEdgeEventType;
+import com.adobe.marketing.mobile.MobileCore;
+import com.adobe.marketing.mobile.services.MessagingDelegate;
+import com.adobe.marketing.mobile.services.ui.FullscreenMessage;
+import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+
+public final class RCTAEPMessagingModule extends ReactContextBaseJavaModule implements MessagingDelegate {
+
+    private static final String TAG = "RCTAEPMessagingModule";
+    private final Map<String, Message> messageCache;
+    private final ReactApplicationContext reactContext;
+    private boolean shouldSaveMessage;
+    private boolean shouldShowMessage;
+    private CountDownLatch latch = new CountDownLatch(1);
+
+    public RCTAEPMessagingModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+        this.messageCache = new HashMap<>();
+        this.shouldShowMessage = false;
+        this.shouldSaveMessage = false;
+    }
+
+    @Override
+    public String getName() {
+        return "AEPMessaging";
+    }
+
+    // Required for rn built in EventEmitter Calls.
+    @ReactMethod
+    public void addListener(String eventName) {}
+
+    @ReactMethod
+    public void removeListeners(Integer count) {}
+
+    @ReactMethod
+    public void extensionVersion(final Promise promise) {
+        MobileCore.log(VERBOSE, TAG, "extensionVersion is called");
+        promise.resolve(Messaging.extensionVersion());
+    }
+
+    @ReactMethod
+    public void refreshInAppMessages() {
+        MobileCore.log(VERBOSE, TAG, "refreshInAppMessages is called");
+        Messaging.refreshInAppMessages();
+    }
+
+    @ReactMethod
+    public void setMessagingDelegate() {
+        MobileCore.log(VERBOSE, TAG, "setMessagingDelegate is called");
+        MobileCore.setMessagingDelegate(this);
+    }
+
+    @ReactMethod
+    public void show(final String messageId) {
+        if (messageId != null && messageCache.get(messageId) != null) {
+            MobileCore.log(VERBOSE, TAG, String.format("show is called with message id: %s", messageId));
+            messageCache.get(messageId).show();
+        }
+    }
+
+    @ReactMethod
+    public void dismiss(final String messageId, final boolean suppressAutoTrack) {
+        if (messageId != null && messageCache.get(messageId) != null) {
+            MobileCore.log(VERBOSE, TAG, String.format("dismiss is called with message id: %s and suppressAutoTrack: %b", messageId, suppressAutoTrack));
+            messageCache.get(messageId).dismiss(suppressAutoTrack);
+        }
+    }
+
+    @ReactMethod
+    public void track(final String messageId, final String interaction, final int eventType) {
+        if (messageId != null && messageCache.get(messageId) != null) {
+            MobileCore.log(VERBOSE, TAG, String.format("track is called with message id: %s, interaction: %s and eventType: %d", messageId, interaction, eventType));
+            MessagingEdgeEventType edgeEventType = null;
+            switch (eventType) {
+                case 0:
+                    edgeEventType = MessagingEdgeEventType.IN_APP_DISMISS;
+                    break;
+                case 1:
+                    edgeEventType = MessagingEdgeEventType.IN_APP_INTERACT;
+                    break;
+                case 2:
+                    edgeEventType = MessagingEdgeEventType.IN_APP_TRIGGER;
+                    break;
+                case 3:
+                    edgeEventType = MessagingEdgeEventType.IN_APP_DISPLAY;
+                    break;
+                case 4:
+                    edgeEventType = MessagingEdgeEventType.PUSH_APPLICATION_OPENED;
+                    break;
+                case 5:
+                    edgeEventType = MessagingEdgeEventType.PUSH_CUSTOM_ACTION;
+                    break;
+                default:
+                    break;
+            }
+            if (edgeEventType != null) {
+                messageCache.get(messageId).track(interaction, edgeEventType);
+            } else {
+                MobileCore.log(DEBUG, TAG, String.format("Unable to track interaction (%s) because edgeEventType (%d) is invalid ", interaction, eventType));
+            }
+        }
+    }
+
+    @ReactMethod
+    public void handleJavascriptMessage(final String messageId, final String messageName, final Promise promise) {
+        if (messageId != null && messageCache.get(messageId) != null) {
+            MobileCore.log(VERBOSE, TAG, String.format("handleJavascriptMessage is called with message id: %s and messageName: %s", messageId, messageName));
+            messageCache.get(messageId).handleJavascriptMessage(messageName, new AdobeCallback<String>() {
+                @Override
+                public void call(final String s) {
+                    if (s != null) {
+                        promise.resolve(s);
+                    } else {
+                        promise.reject("error", "error in handling javascriptMessage " + messageName);
+                    }
+                }
+            });
+        }
+    }
+
+    @ReactMethod
+    public void clear(final String messageId) {
+        if (messageId != null) {
+            MobileCore.log(VERBOSE, TAG, String.format("clear is called with message id: %s", messageId));
+            messageCache.remove(messageId);
+        }
+    }
+
+    @ReactMethod
+    public void setAutoTrack(final String messageId, final boolean autoTrack) {
+        if (messageId != null && messageCache.get(messageId) != null) {
+            MobileCore.log(VERBOSE, TAG, String.format("setAutoTrack is called with message id: %s and autoTrack: %b", messageId, autoTrack));
+            messageCache.get(messageId).setAutoTrack(autoTrack);
+        }
+    }
 
-public class RCTAEPMessagingModule extends ReactContextBaseJavaModule {
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    public void shouldShowMessage(final boolean shouldShowMessage, final boolean shouldSaveMessage) {
+        MobileCore.log(VERBOSE, TAG, String.format("shouldShowMessage is called with message id: %b and shouldSaveMessage: %b", shouldShowMessage, shouldSaveMessage));
+        this.shouldShowMessage = shouldShowMessage;
+        this.shouldSaveMessage = shouldSaveMessage;
+        latch.countDown();
+    }
 
-  private final ReactApplicationContext reactContext;
+    //Messaging Delegate functions
+    @Override
+    public void onShow(final FullscreenMessage fullscreenMessage) {
+        MobileCore.log(VERBOSE, TAG, "onShow is called");
+        final Message message = (Message) fullscreenMessage.getParent();
+        if (message != null) {
+            Map<String, String> data = new HashMap<>();
+            data.put("id", message.getId());
+            data.put("autoTrack", String.valueOf(message.getAutoTrack()));
+            emitEvent("onShow", data);
+        }
+    }
 
-  public RCTAEPMessagingModule(ReactApplicationContext reactContext) {
-    super(reactContext);
-    this.reactContext = reactContext;
-  }
+    @Override
+    public void onDismiss(final FullscreenMessage fullscreenMessage) {
+        MobileCore.log(VERBOSE, TAG, "onDismiss is called");
+        final Message message = (Message) fullscreenMessage.getParent();
+        if (message != null) {
+            Map<String, String> data = new HashMap<>();
+            data.put("id", message.getId());
+            data.put("autoTrack", String.valueOf(message.getAutoTrack()));
+            emitEvent("onDismiss", data);
+        }
+    }
 
-  @Override
-  public String getName() {
-    return "AEPMessaging";
-  }
+   @Override
+   public boolean shouldShowMessage(final FullscreenMessage fullscreenMessage) {
+       MobileCore.log(VERBOSE, TAG, "shouldShowMessage is called");
+       final Message message = (Message) fullscreenMessage.getParent();
+       if (message != null) {
+           Map<String, String> data = new HashMap<>();
+           data.put("id", message.getId());
+           data.put("autoTrack", String.valueOf(message.getAutoTrack()));
+           emitEvent("shouldShowMessage", data);
+           //Latch stops the thread until the shouldShowMessage value is received from the JS side on thread dedicated to run JS code. The function called from JS that resumes the thread is "shouldShowMessage".
+           MobileCore.log(VERBOSE, TAG, "shouldShowMessage: Thread is locked.");
+           try {
+               latch.await();
+           } catch (final InterruptedException e) {
+               MobileCore.log(LoggingMode.ERROR, TAG, String.format("CountDownLatch await Interrupted: (%s)", e.getLocalizedMessage()));
+           }
+           MobileCore.log(VERBOSE, TAG, "shouldShowMessage: Thread is resumed.");
+           if (shouldSaveMessage) {
+               messageCache.put(message.getId(), message);
+           }
+       }
+       return shouldShowMessage;
+     }
+     
+     @Override
+     public void urlLoaded(String url, FullscreenMessage fullscreenMessage) {
+        MobileCore.log(VERBOSE, TAG, String.format("overrideUrlLoad is called with url: (%s)", url));
+        final Message message = (Message) fullscreenMessage.getParent();
+        if (message != null) {
+            Map<String, String> data = new HashMap<>();
+            data.put("id", message.getId());
+            data.put("autoTrack", String.valueOf(message.getAutoTrack()));
+            data.put("url", url);
+            emitEvent("urlLoaded", data);
+        }
+     }
 
-  @ReactMethod
-  public void extensionVersion(final Promise promise) {
-    promise.resolve(Messaging.extensionVersion());
-  }
+    /**
+     * Emits an event along with data to be handled by the Javascript
+     *
+     * @param name event name
+     * @param data data sent along with event
+     */
+    private void emitEvent(final String name, final Map<String, String> data) {
+        WritableMap eventData = Arguments.createMap();
+        for (final Map.Entry<String, String> entry : data.entrySet()) {
+            eventData.putString(entry.getKey(), entry.getValue());
+        }
+        reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class).emit(name, eventData);
+    }
 }

package/ios/src/RCTAEPMessaging.h

@@ -9,9 +9,12 @@
  governing permissions and limitations under the License.
  */
 
- #import <React/RCTBridgeModule.h>
- #import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+#import <Foundation/Foundation.h>
+#import <React/RCTEventEmitter.h>
+#import <React/RCTBridgeModule.h>
+@import AEPServices;
 
-@interface RCTAEPMessaging : NSObject <RCTBridgeModule>
+@interface RCTAEPMessaging : RCTEventEmitter <RCTBridgeModule, AEPMessagingDelegate>
 
 @end

package/ios/src/RCTAEPMessaging.m

@@ -8,11 +8,34 @@
  OF ANY KIND, either express or implied. See the License for the specific language
  governing permissions and limitations under the License.
  */
-
 #import "RCTAEPMessaging.h"
 @import AEPMessaging;
+@import AEPCore;
+
+static NSString* const TAG = @"RCTAEPMessaging";
+
+@implementation RCTAEPMessaging {
+    NSMutableDictionary<NSString*, AEPMessage*> * cachedMessages;
+    dispatch_semaphore_t semaphore;
+    bool shouldShowMessage;
+    bool hasListeners;
+    bool shouldSaveMessage;
+}
 
-@implementation RCTAEPMessaging
+- (instancetype) init {
+    self = [super init];
+    cachedMessages = [NSMutableDictionary dictionary];
+    semaphore = dispatch_semaphore_create(0);
+    hasListeners = false;
+    shouldShowMessage = true;
+    shouldSaveMessage = false;
+    return self;
+}
+
++ (BOOL)requiresMainQueueSetup
+{
+    return NO;
+}
 
 RCT_EXPORT_MODULE(AEPMessaging);
 
@@ -24,5 +47,150 @@ RCT_EXPORT_MODULE(AEPMessaging);
 RCT_EXPORT_METHOD(extensionVersion: (RCTPromiseResolveBlock) resolve rejecter:(RCTPromiseRejectBlock) reject) {
     resolve([AEPMobileMessaging extensionVersion]);
 }
+
+RCT_EXPORT_METHOD(refreshInAppMessages) {
+    [AEPLog traceWithLabel:TAG message:@"refreshInAppMessages is called."];
+    [AEPMobileMessaging refreshInAppMessages];
+}
+
+RCT_EXPORT_METHOD(setMessagingDelegate) {
+    [AEPLog traceWithLabel:TAG message:@"Messaging Delegate is set."];
+    [AEPMobileCore setMessagingDelegate: self];
+}
+
+RCT_EXPORT_METHOD(show: (NSString *) messageId) {
+    [AEPLog traceWithLabel:TAG message:[NSString stringWithFormat:@"show is called with message id: %@", messageId]];
+    AEPMessage * message = [cachedMessages objectForKey:messageId];
+    if(message){
+        [message show];
+    }
+}
+
+RCT_EXPORT_METHOD(dismiss: (NSString *) messageId suppressAutoTrack: (BOOL) suppressAutoTrack) {
+    [AEPLog traceWithLabel:TAG message:[NSString stringWithFormat:@"dismiss is called with message id: %@ and suppressAutoTrack: %i", messageId, suppressAutoTrack]];
+    AEPMessage * message = [cachedMessages objectForKey:messageId];
+    if(message){
+        [message dismissSuppressingAutoTrack:suppressAutoTrack];
+    }
+}
+
+RCT_EXPORT_METHOD(track: (NSString *) messageId withInteraction: (NSString *) interaction eventType: (int) eventTypeValue) {
+    [AEPLog traceWithLabel:TAG message:[NSString stringWithFormat:@"track is called with message id: %@, withInteraction: %@ and eventType: %i", messageId, interaction, eventTypeValue]];
+    AEPMessage * message = [cachedMessages objectForKey:messageId];
+    AEPMessagingEdgeEventType messagingEdgeEventType = -1;
+
+    if(eventTypeValue == 0){
+        messagingEdgeEventType = AEPMessagingEdgeEventTypeInappDismiss;
+    } else if (eventTypeValue == 1) {
+        messagingEdgeEventType = AEPMessagingEdgeEventTypeInappInteract;
+    } else if (eventTypeValue == 2) {
+        messagingEdgeEventType = AEPMessagingEdgeEventTypeInappTrigger;
+    } else if (eventTypeValue == 3) {
+        messagingEdgeEventType = AEPMessagingEdgeEventTypeInappDisplay;
+    } else if (eventTypeValue == 4) {
+        messagingEdgeEventType = AEPMessagingEdgeEventTypePushApplicationOpened;
+    } else if (eventTypeValue == 5) {
+        messagingEdgeEventType = AEPMessagingEdgeEventTypePushCustomAction;
+    }
+
+    if(messagingEdgeEventType != -1){
+        [message trackInteraction:interaction withEdgeEventType:messagingEdgeEventType];
+    }
+}
+
+RCT_EXPORT_METHOD(handleJavascriptMessage: (NSString *) messageId
+                  messageName: (NSString *) name resolver: (RCTPromiseResolveBlock) resolve rejector:(RCTPromiseRejectBlock) reject) {
+    [AEPLog traceWithLabel:TAG message:[NSString stringWithFormat:@"handleJavascriptMessage is called with message id: %@ and messageName: %@", messageId, name]];
+    AEPMessage * message = [cachedMessages objectForKey: messageId];
+    [message handleJavascriptMessage:name withHandler:^(id result) {
+        if(result) {
+            resolve(result);
+        } else {
+            reject(@"error", @"error in handleJavaScriptMessage", nil);
+        }
+    }];
+}
+
+RCT_EXPORT_METHOD(clear: (NSString *) messageId) {
+    [AEPLog traceWithLabel:TAG message:[NSString stringWithFormat:@"clearMessage is called with message id: %@", messageId]];
+    [cachedMessages removeObjectForKey:messageId];
+}
+
+RCT_EXPORT_METHOD(setAutoTrack: (NSString *) messageId autoTrack: (BOOL) autoTrack) {
+    [AEPLog traceWithLabel:TAG message:[NSString stringWithFormat:@"setAutoTrack called for messageId: %@ and autoTrack value: %i", messageId, autoTrack]];
+    AEPMessage * messageObj = [cachedMessages objectForKey:messageId];
+    if(messageObj) {
+        messageObj.autoTrack = autoTrack;
+    }
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(shouldShowMessage: (BOOL) shouldShowMessage shouldSaveMessage: (BOOL) saveMessage) {
+    [AEPLog traceWithLabel:TAG message:[NSString stringWithFormat:@"shouldShowMessage is called with values (shouldShowMessage: %i) and (shouldSaveMessage: %i)", shouldShowMessage, shouldSaveMessage]];
+    self->shouldShowMessage = shouldShowMessage;
+    self->shouldSaveMessage = saveMessage;
+    dispatch_semaphore_signal(semaphore);
+    return nil;
+}
+
+//MARK: - AEPMessagingDelegate functions.
+- (void) onDismiss:(id<AEPShowable> _Nonnull) message {
+    AEPFullscreenMessage * fullscreenMessage = (AEPFullscreenMessage *) message;
+    AEPMessage * messageObj = (AEPMessage *) fullscreenMessage.settings.parent;
+        if(messageObj) {
+            [self emitEventWithName:@"onDismiss"  body:@{@"id":messageObj.id, @"autoTrack":messageObj.autoTrack ? @"true" : @"false"}];
+        }
+}
+
+- (void) onShow:(id<AEPShowable> _Nonnull)message {
+    AEPFullscreenMessage * fullscreenMessage = (AEPFullscreenMessage *) message;
+    AEPMessage * messageObj = (AEPMessage *) fullscreenMessage.settings.parent;
+    if(messageObj) {
+        [self emitEventWithName:@"onShow" body:@{@"id":messageObj.id, @"autoTrack":messageObj.autoTrack ? @"true" : @"false"}];
+    }
+}
+
+- (BOOL) shouldShowMessage:(id<AEPShowable> _Nonnull)message {
+    AEPFullscreenMessage * fullscreenMessage = (AEPFullscreenMessage *) message;
+    AEPMessage * messageObj = (AEPMessage *) fullscreenMessage.settings.parent;
+    if(messageObj) {
+        [self emitEventWithName:@"shouldShowMessage" body:@{@"id":messageObj.id, @"autoTrack":messageObj.autoTrack ? @"true" : @"false"}];
+    //Semaphore stops the thread until the value to be returned from this function is received from the JS side on thread dedicated to run JS code. The function called from JS that unlock the Semaphore is "shouldShowMessage".
+        [AEPLog traceWithLabel:TAG message:@"Semaphore lock initiated."];
+    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
+        [AEPLog traceWithLabel:TAG message:@"Semaphore lock removed."];
+        if(self->shouldSaveMessage) {
+            [AEPLog traceWithLabel:TAG message:[[NSString alloc] initWithFormat:@"Message is saved with id: %@", messageObj.id]];
+            [cachedMessages setObject:messageObj forKey:messageObj.id];
+        }
+    }
+    return self->shouldShowMessage;
+}
+
+- (void) urlLoaded:(NSURL *)url byMessage:(id<AEPShowable>)message {
+    AEPFullscreenMessage * fullscreenMessage = (AEPFullscreenMessage *) message;
+    AEPMessage * messageObj = (AEPMessage *) fullscreenMessage.settings.parent;
+    if(messageObj){
+        [self emitEventWithName:@"urlLoaded" body:@{@"id":messageObj.id, @"autoTrack":messageObj.autoTrack ? @"true" : @"false", @"url":url.absoluteString}];
+    }
+ }
+
+- (NSArray<NSString *> *) supportedEvents {
+    return @[@"onShow", @"onDismiss", @"shouldShowMessage",@"urlLoaded"];
+}
+
+- (void) startObserving {
+    hasListeners = true;
+}
+
+- (void) stopObserving {
+    hasListeners = false;
+}
+
+- (void) emitEventWithName: (NSString *) name body: (NSDictionary<NSString*, NSString*> *) dictionary {
+    if(hasListeners){
+        [AEPLog traceWithLabel:TAG message:[NSString stringWithFormat:@"Event emitted with name: %@", name]];
+        [self sendEventWithName:name body:dictionary];
+    }
+}
+
 @end
-  

package/js/Messaging.d.ts

@@ -1,5 +1,32 @@
-interface IMessaging {
+import Message from './models/Message';
+import { MessagingDelegate } from "./models/MessagingDelegate";
+export interface IMessaging {
     extensionVersion: () => Promise<string>;
+    refreshInAppMessages: () => void;
+    setMessagingDelegate: (delegate?: MessagingDelegate) => void;
+    shouldShowMessage: (shouldShowMessage: boolean, shouldSaveMessage: boolean) => void;
+    saveMessage: (message: Message) => void;
 }
-declare const Messaging: IMessaging;
+declare const Messaging: {
+    /**
+     * Returns the version of the AEPMessaging extension
+     * @returns {string} Promise a promise that resolves with the extension version
+     */
+    extensionVersion(): Promise<string>;
+    /**
+    * Initiates a network call to retrieve remote In-App Message definitions.
+    */
+    refreshInAppMessages(): void;
+    /**
+    * Function to set the UI Message delegate to listen the Message lifecycle events.
+    */
+    setMessagingDelegate(delegate: MessagingDelegate): void;
+    /**
+    * Cache the Message object in-memory to use later.
+    * If there is a requirement to call the Message functions like show, dismiss etc. The Message object should be saved first before calling it's functions.
+    * If the Message is saved using this API then it is responsibility of App to free it after using.
+    * To remove the Message from memory call clearMessage function of Message. Failure to call clearMessage will cause the Memory leak of Message object.
+    */
+    saveMessage(message: Message): void;
+};
 export default Messaging;

package/js/Messaging.js

@@ -11,16 +11,70 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
 const react_native_1 = require("react-native");
+const Message_1 = tslib_1.__importDefault(require("./models/Message"));
 const RCTAEPMessaging = react_native_1.NativeModules.AEPMessaging;
+var messagingDelegate;
+var savedMessageId = null;
 const Messaging = {
     /**
      * Returns the version of the AEPMessaging extension
-     * @param  {string} Promise a promise that resolves with the extension version
+     * @returns {string} Promise a promise that resolves with the extension version
      */
     extensionVersion() {
         return Promise.resolve(RCTAEPMessaging.extensionVersion());
-    }
+    },
+    /**
+    * Initiates a network call to retrieve remote In-App Message definitions.
+    */
+    refreshInAppMessages() {
+        RCTAEPMessaging.refreshInAppMessages();
+    },
+    /**
+    * Function to set the UI Message delegate to listen the Message lifecycle events.
+    */
+    setMessagingDelegate(delegate) {
+        messagingDelegate = delegate;
+        RCTAEPMessaging.setMessagingDelegate();
+        const eventEmitter = new react_native_1.NativeEventEmitter(RCTAEPMessaging);
+        eventEmitter.addListener('onShow', (event) => {
+            if (messagingDelegate) {
+                const message = new Message_1.default(event.id, event.autoTrack === "true" ? true : false);
+                messagingDelegate.onShow(message);
+            }
+        });
+        eventEmitter.addListener('onDismiss', (event) => {
+            if (messagingDelegate) {
+                const message = new Message_1.default(event.id, event.autoTrack === "true" ? true : false);
+                messagingDelegate.onDismiss(message);
+            }
+        });
+        eventEmitter.addListener('shouldShowMessage', (event) => {
+            if (messagingDelegate) {
+                const message = new Message_1.default(event.id, event.autoTrack === "true" ? true : false);
+                const shouldShowMessage = messagingDelegate.shouldShowMessage(message);
+                RCTAEPMessaging.shouldShowMessage(shouldShowMessage, savedMessageId ? true : false);
+                savedMessageId = null;
+            }
+        });
+        eventEmitter.addListener('urlLoaded', (event) => {
+            if (messagingDelegate) {
+                const url = event.url;
+                const message = new Message_1.default(event.id, event.autoTrack === "true" ? true : false);
+                messagingDelegate.urlLoaded(url, message);
+            }
+        });
+    },
+    /**
+    * Cache the Message object in-memory to use later.
+    * If there is a requirement to call the Message functions like show, dismiss etc. The Message object should be saved first before calling it's functions.
+    * If the Message is saved using this API then it is responsibility of App to free it after using.
+    * To remove the Message from memory call clearMessage function of Message. Failure to call clearMessage will cause the Memory leak of Message object.
+    */
+    saveMessage(message) {
+        savedMessageId = message.id;
+    },
 };
 exports.default = Messaging;
 //# sourceMappingURL=Messaging.js.map

package/js/Messaging.js.map

@@ -1 +1 @@
-{"version":3,"file":"Messaging.js","sourceRoot":"","sources":["../ts/Messaging.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;EAUE;;AAEF,+CAA6C;AAM7C,MAAM,eAAe,GAAe,4BAAa,CAAC,YAAY,CAAC;AAE/D,MAAM,SAAS,GAAe;IAC5B;;;OAGG;IACH,gBAAgB;QACd,OAAO,OAAO,CAAC,OAAO,CAAC,eAAe,CAAC,gBAAgB,EAAE,CAAC,CAAC;IAC7D,CAAC;CACF,CAAC;AAEF,kBAAe,SAAS,CAAC"}
+{"version":3,"file":"Messaging.js","sourceRoot":"","sources":["../ts/Messaging.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;EAUE;;;AAEF,+CAA+E;AAC/E,uEAAuC;AAWvC,MAAM,eAAe,GAA8B,4BAAa,CAAC,YAAY,CAAC;AAK9E,IAAI,iBAAoC,CAAC;AACzC,IAAI,cAAc,GAAW,IAAI,CAAC;AAElC,MAAM,SAAS,GAAG;IAChB;;;OAGG;IACH,gBAAgB;QACd,OAAO,OAAO,CAAC,OAAO,CAAC,eAAe,CAAC,gBAAgB,EAAE,CAAC,CAAC;IAC7D,CAAC;IAED;;MAEE;IACF,oBAAoB;QAClB,eAAe,CAAC,oBAAoB,EAAE,CAAC;IACzC,CAAC;IAED;;MAEE;IACF,oBAAoB,CAAC,QAA2B;QAC9C,iBAAiB,GAAG,QAAQ,CAAC;QAC7B,eAAe,CAAC,oBAAoB,EAAE,CAAC;QACvC,MAAM,YAAY,GAAG,IAAI,iCAAkB,CAAC,eAAe,CAAC,CAAC;QAC7D,YAAY,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,EAAE;YAC3C,IAAG,iBAAiB,EAAC;gBACnB,MAAM,OAAO,GAAG,IAAI,iBAAO,CAAC,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,SAAS,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,CAAA,CAAC,CAAC,KAAK,CAAC,CAAC;gBAChF,iBAAiB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;aACnC;QACH,CAAC,CAAC,CAAC;QAEH,YAAY,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,EAAE;YAC9C,IAAG,iBAAiB,EAAC;gBACnB,MAAM,OAAO,GAAG,IAAI,iBAAO,CAAC,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,SAAS,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,CAAA,CAAC,CAAC,KAAK,CAAC,CAAC;gBAChF,iBAAiB,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;aACtC;QACH,CAAC,CAAC,CAAC;QAEH,YAAY,CAAC,WAAW,CAAC,mBAAmB,EAAE,CAAC,KAAK,EAAE,EAAE;YACtD,IAAI,iBAAiB,EAAC;gBACpB,MAAM,OAAO,GAAG,IAAI,iBAAO,CAAC,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,SAAS,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,CAAA,CAAC,CAAC,KAAK,CAAC,CAAC;gBAChF,MAAM,iBAAiB,GAAY,iBAAiB,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;gBAChF,eAAe,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;gBACpF,cAAc,GAAG,IAAI,CAAC;aACvB;QACH,CAAC,CAAC,CAAC;QAEH,YAAY,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,EAAE;YAC9C,IAAG,iBAAiB,EAAC;gBACnB,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC;gBACtB,MAAM,OAAO,GAAG,IAAI,iBAAO,CAAC,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,SAAS,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,CAAA,CAAC,CAAC,KAAK,CAAC,CAAC;gBAChF,iBAAiB,CAAC,SAAS,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;aAC3C;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;MAKE;IACF,WAAW,CAAC,OAAgB;QAC1B,cAAc,GAAG,OAAO,CAAC,EAAE,CAAC;IAC9B,CAAC;CACF,CAAC;AAEF,kBAAe,SAAS,CAAC"}

package/js/index.d.ts

@@ -1,2 +1,5 @@
 import Messaging from './Messaging';
-export { Messaging };
+import Message from './models/Message';
+import { MessagingDelegate } from './models/MessagingDelegate';
+import MessagingEdgeEventType from './models/MessagingEdgeEventType';
+export { Messaging, Message, MessagingDelegate, MessagingEdgeEventType };

package/js/index.js

@@ -11,8 +11,12 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Messaging = void 0;
+exports.MessagingEdgeEventType = exports.Message = exports.Messaging = void 0;
 const tslib_1 = require("tslib");
-const Messaging_1 = (0, tslib_1.__importDefault)(require("./Messaging"));
+const Messaging_1 = tslib_1.__importDefault(require("./Messaging"));
 exports.Messaging = Messaging_1.default;
+const Message_1 = tslib_1.__importDefault(require("./models/Message"));
+exports.Message = Message_1.default;
+const MessagingEdgeEventType_1 = tslib_1.__importDefault(require("./models/MessagingEdgeEventType"));
+exports.MessagingEdgeEventType = MessagingEdgeEventType_1.default;
 //# sourceMappingURL=index.js.map

package/js/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;EAUE;;;;AAEF,yEAAoC;AAE3B,oBAFF,mBAAS,CAEE"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;EAUE;;;;AAEF,oEAAoC;AAK3B,oBALF,mBAAS,CAKE;AAJlB,uEAAuC;AAInB,kBAJb,iBAAO,CAIa;AAF3B,qGAAqE;AAErB,iCAFzC,gCAAsB,CAEyC"}

package/js/models/Message.d.ts

@@ -0,0 +1,43 @@
+declare class Message {
+    id: string;
+    autoTrack: boolean;
+    constructor(id: string, autoTrack: boolean);
+    /**
+    * Update the value of property "autoTrack"
+    * This function works only for the Message objects that were saved by calling "Messaging.saveMessage"
+    * @param {boolean} autoTrack: New value of property autoTrack.
+     */
+    setAutoTrack(autoTrack: boolean): void;
+    /**
+    * Signals to the UIServices that the message should be shown.
+    * If autoTrack is true, calling this method will result in an "inapp.display" Edge Event being dispatched.
+    */
+    show(): void;
+    /**
+    * Signals to the UIServices that the message should be dismissed.
+    * If `autoTrack` is true, calling this method will result in an "inapp.dismiss" Edge Event being dispatched.
+    * @param {boolean?} suppressAutoTrack: if set to true, the inapp.dismiss Edge Event will not be sent regardless
+    * of the autoTrack setting.
+    */
+    dismiss(suppressAutoTrack?: boolean): void;
+    /**
+    * Generates an Edge Event for the provided interaction and eventType.
+    * @param {string?} interaction: a custom String value to be recorded in the interaction
+    * @param {MessagingEdgeEventType} eventType: the MessagingEdgeEventType to be used for the ensuing Edge Event
+     */
+    track(interaction: string, eventType: number): void;
+    /**
+    * Adds a handler for Javascript messages sent from the message's webview.
+    * The parameter passed to `handler` will contain the body of the message passed from the webview's Javascript.
+    * @param {string} name: the name of the message that should be handled by `handler`
+    * @return {Promise<any?>}: the Promise to be resolved with the body of the message passed by the Javascript message in the WebView
+    */
+    handleJavascriptMessage(name: string): Promise<any>;
+    /**
+    * Clears the reference to the Message object.
+    * This function must be called if Message was saved by calling "Messaging.saveMessage" but no longer needed.
+    * Failure to call this function leads to memory leaks.
+     */
+    clear(): void;
+}
+export default Message;