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

package/RCTAEPMessaging.podspec

@@ -18,5 +18,5 @@ Pod::Spec.new do |s|
   s.requires_arc = true
 
   s.dependency "React"
-  s.dependency "AEPMessaging", "~>1.0"
+  s.dependency "AEPMessaging", "~>1.1.0-beta2"
 end

package/README.md

@@ -1,7 +1,7 @@
 
 # React Native Adobe Experience Platform Messaging Extension
 
-[![npm version](https://badge.fury.io/js/%40adobe%2Freact-native-aepmessaging.svg)](https://www.npmjs.com/package/@adobe/react-native-aepmessaging) 
+[![npm version](https://badge.fury.io/js/%40adobe%2Freact-native-aepmessaging.svg)](https://www.npmjs.com/package/@adobe/react-native-aepmessaging)
 [![npm downloads](https://img.shields.io/npm/dm/@adobe/react-native-aepmessaging)](https://www.npmjs.com/package/@adobe/react-native-aepmessaging)
 
 `@adobe/react-native-aepmessaging` is a wrapper around the iOS and Android [Adobe Journey Optimizer Messaging](https://aep-sdks.gitbook.io/docs/using-mobile-extensions/adobe-journey-optimizer) to allow for integration with React Native applications.
@@ -15,18 +15,46 @@ The messaging extension has the following peer dependenices, which must be insta
 
 ## Installation
 
-See [Requirements and Installation](https://github.com/adobe/aepsdk-react-native#requirements) instructions on the main page 
+See [Requirements and Installation](https://github.com/adobe/aepsdk-react-native#requirements) instructions on the main page
 
-Install the `@adobe/react-native-aepmessaging` package:
+**Installation instructions for `@adobe/react-native-aepmessaging` v1.0.0-beta.2 with in-app messaging support**   
+Clone the `@adobe/react-native-aepmessaging` package from the `messaging` branch on [Github](https://github.com/adobe/aepsdk-react-native/tree/messaging). Place the Messaging package folder into app repo or directory of your choosing. Then you can install the package by running:
 
 ```bash
 cd MyReactApp
-npm install @adobe/react-native-aepmessaging
+npm install {path to messaging package}
+```
+
+## IOS Setup
+
+**Podfile setup for `@adobe/react-native-aepmessaging` v1.0.0-beta.2 with in-app messaging support**  
+The In app Message APIs depends on the AEP Messaging iOS SDK v1.1.0-beta. This version is not yet published to the Cocoapods but is available in the public [github repository](https://github.com/adobe/aepsdk-messaging-ios/tree/staging). Add the following pod dependency in your applications Podfile under the application target.
+
+```ruby
+target 'AEPSampleApp' do
+pod "AEPMessaging", :git => "https://github.com/adobe/aepsdk-messaging-ios.git", :branch => "staging"
+end
+```
+
+## Android Setup
+
+**Gradle setup for `@adobe/react-native-aepmessaging` v1.0.0-beta.2 with in-app messaging support**  
+AEPMessaging Android SDK v1.2.0-beta.2 with in-app messaging support is published to maven snapshots. In project level build.gradle file of Android project in your RN application add `maven { url "https://oss.sonatype.org/content/repositories/snapshots/" }` in `allprojects -> repositories`.
+
+
+```gradle
+repositories {
+  google()
+  mavenCentral()
+  maven { 
+    url "https://oss.sonatype.org/content/repositories/snapshots/" 
+  }
+}
 ```
 
 ## Usage
 
-### [Messaging](https://aep-sdks.gitbook.io/docs/using-mobile-extensions/adobe-journey-optimizer)
+### [Messaging](https://aep-sdks.gitbook.io/docs/beta/iam)
 
 ### Installing and registering the extension with the AEP Mobile Core
 
@@ -42,16 +70,16 @@ iOS
 @import AEPEdge;
 @import AEPEdgeIdentity;
 @import AEPMessaging;
+@import AEPOptimize;
 ...
 @implementation AppDelegate
 -(BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
-  [AEPMobileCore setLogLevel: AEPLogLevelDebug];
-  [AEPMobileCore configureWithAppId:@"yourAppID"];
-  [AEPMobileCore registerExtensions: @[AEPMobileEdge.class, AEPMobileEdgeIdentity.class, AEPMobileMessaging.class] completion:^{
+  [AEPMobileCore setLogLevel: AEPLogLevelTrace];
+  [AEPMobileCore registerExtensions: @[AEPMobileEdgeIdentity.class, AEPMobileEdge.class, AEPMobileMessaging.class, AEPMobileOptimize.class] completion:^{
+    [AEPMobileCore configureWithAppId:@"yourAppID"];
     [AEPMobileCore lifecycleStart:@{@"contextDataKey": @"contextDataVal"}];
   }
   ];
-
   return YES;
 }
 
@@ -66,9 +94,10 @@ import com.adobe.marketing.mobile.Lifecycle;
 import com.adobe.marketing.mobile.LoggingMode;
 import com.adobe.marketing.mobile.MobileCore;
 import com.adobe.marketing.mobile.Edge;
-import com.adobe.marketing.mobile.edge.identity;
+import com.adobe.marketing.mobile.edge.identity.Identity;
 import com.adobe.marketing.mobile.Messaging;
-  
+import com.adobe.marketing.mobile.optimize.Optimize;
+
 ...
 import android.app.Application;
 ...
@@ -83,6 +112,7 @@ public class MainApplication extends Application implements ReactApplication {
     try {
       Edge.registerExtension();
       Identity.registerExtension();
+      Optimize.registerExtension();
       Messaging.registerExtension();
       MobileCore.configureWithAppID("yourAppID");
       MobileCore.start(new AdobeCallback() {
@@ -101,11 +131,12 @@ public class MainApplication extends Application implements ReactApplication {
 ### Importing the extension:
 
 ```javascript
-import {AEPMessaging} from '@adobe/react-native-aepmessaging';
+import { Messaging, MessagingDelegate, MessagingEdgeEventType, Message } from '@adobe/react-native-aepmessaging';
 ```
 
 ## API reference
 ### extensionVersion
+Returns the version of the AEPMessaging extension
 
 **Syntax**
 ```javascript
@@ -117,18 +148,251 @@ extensionVersion(): Promise<string>;
 Messaging.extensionVersion().then(version => console.log("AdobeExperienceSDK: Messaging version: " + version));
 ```
 
-## Configure Adobe Journey Optimizer 
+## Configure Adobe Journey Optimizer
 To configure Adobe Journey optimizer Messaging in Launch follow steps in [Configure Adobe Journey optimizer](https://aep-sdks.gitbook.io/docs/using-mobile-extensions/adobe-journey-optimizer#setup-adobe-journey-optimizer-extension)
 
 ## Push Notification Setup
-Handling push notifications must be done in native (Android/iOS) code for the React Native app. To configure push notification in the native project, follow the instructions provided by their respective platforms: 
+Handling push notifications must be done in native (Android/iOS) code for the React Native app. To configure push notification in the native project, follow the instructions provided by their respective platforms:
 - [Apple - iOS push notification setup](https://developer.apple.com/documentation/usernotifications/registering_your_app_with_apns)  
 - [Google - Android push notification setup](https://firebase.google.com/docs/cloud-messaging/android/client)
 
-## Messaging SDK API usage
-Messaging SDK APIs must be called from the native Android/iOS project of React Native app.  
+## Push Messaging APIs usage
+Push messaging APIs in the SDK must be called from the native Android/iOS project of React Native app.  
 
 ###### [iOS API usage](https://github.com/adobe/aepsdk-messaging-ios/blob/main/Documentation/APIUsage.md)  
 
 ##### [Android API usage](https://github.com/adobe/aepsdk-messaging-android/blob/main/Documentation/APIUsage.md)
 In Android, [MessagingPushPayload](https://github.com/adobe/aepsdk-messaging-android/blob/main/Documentation/push/MessagingPushPayload.md#messagingpushpayload-usage) can be used for getting the notification attributes like title, body, and action. These are useful for push notification creation.
+
+## In-app messages API reference
+### refreshInAppMessages
+Initiates a network call to retrieve remote in-app message definitions.
+
+**Syntax**
+```javascript
+refreshInAppMessages()
+```
+
+**Example**
+```javascript
+Messaging.refreshInAppMessages();
+```
+
+### setMessagingDelegate
+Sets the MessagingDelegate in AEPCore to listen the Message lifecycle events.
+
+**Syntax**
+```javascript
+setMessagingDelegate(delegate: MessagingDelegate);
+```
+
+**Example**
+```javascript
+const messagingDelegate = {
+
+    onShow(message: Message) {
+       // Action after message is displayed.
+    },
+
+    onDismiss(message: Message) {
+       // Action after message is dismissed.
+    },
+
+    shouldShowMessage(message: Message) {                  
+        return true; //Return true to show the Message else return false
+    },
+
+    urlLoaded(url: string, message: Message) {
+       // Action after message loads an URL
+    }
+  };
+
+  Messaging.setMessagingDelegate(messagingDelegate);
+```
+
+### saveMessage
+Natively caches the provided Message object in-memory. Cached Message object can be later use to show message or perform other actions on the Message object. This function should be called from **shouldShowMessage** of MessagingDelegate.
+
+**Syntax**
+```javascript
+saveMessage(message: Message);
+```
+
+**Example**
+```javascript
+Messaging.saveMessage(message);
+```
+
+## Handling In App Messages using Message Object
+The Message Object passed to the Messaging delegate contains the following functions to handle a message
+
+### show
+Signals to the UIServices that the message should be shown.
+
+**Syntax**
+```javascript
+show();
+```
+
+**Example**
+```javascript
+var message: Message;
+message.show();
+```
+
+### dismiss
+Signals to the UIServices that the message should be dismissed.
+
+**Syntax**
+```javascript
+dismiss(suppressAutoTrack: ?boolean = false);
+```
+
+**Example**
+```javascript
+var message: Message;
+message.dismiss(true);
+```
+
+### track
+Generates an Edge Event for the provided interaction and eventType.
+
+**Syntax**
+```javascript
+track(interaction: ?string, eventType: MessagingEdgeEventType);
+```
+
+**Example**
+```javascript
+var message: Message;
+message.track("sample text", MessagingEdgeEventType.IN_APP_DISMISS);
+```
+
+### handleJavascriptMessage
+Adds a handler for Javascript messages sent from the message's webview.
+
+**Syntax**
+```javascript
+handleJavascriptMessage(name: string) : Promise<?any>;
+```
+
+**Example**
+```javascript
+var message: Message;
+message.handleJavascriptMessage("test").then((data) => {
+
+});
+```
+
+### setAutoTrack
+Enables/Disables the autotracking for the Message events.
+
+**Syntax**
+```javascript
+setAutoTrack(autoTrack: boolean);
+```
+
+**Example**
+```javascript
+var message: Message;
+message.setAutoTrack(true);
+```
+
+### clear
+Clears the reference to the in-memory cached Message object. This function must be called if a Message was saved by calling "Messaging.saveMessage" but no longer needed. Failure to call this function leads to memory leaks.
+
+
+**Syntax**
+```javascript
+clear();
+```
+
+**Example**
+```javascript
+var message: Message;
+message.clear();
+```
+
+## Programatically control the display of in-app messages
+App developers can now create a type MessagingDelegate in order to be alerted when specific events occur during the lifecycle of an in-app message.
+
+Definition of type MessagingDelegate is:
+```javascript
+type MessagingDelegate = {    
+
+    onShow(message: Message): void;
+
+    onDismiss(message: Message): void;
+
+    shouldShowMessage(message: Message): boolean;
+
+    urlLoaded(url: string, message: Message): void;
+};
+```
+Objects of type MessagingDelegate can be created as shown below:
+```javascript
+const messagingDelegate = {
+
+    onShow(message: Message) {
+       // Action after message is displayed.
+    },
+
+    onDismiss(message: Message) {
+       // Action after message is dismissed.
+    },
+
+    shouldShowMessage(message: Message) {                  
+        return true; //Return true to show the Message else return false
+    },
+
+    urlLoaded(url: string, message: Message) {
+       // Action after message loads an URL
+    }
+  };
+```
+
+### Controlling when the message should be shown to the end user.
+If a MessagingDelegate has been set, the delegate's shouldShowMessage method will be called prior to displaying an in-app message for which the end user has qualified. The developer is responsible for returning true if the message should be shown, or false if the message should be suppressed.
+
+Below is an example of when the developer may choose to suppress an in-app message due to the status of some other workflow within the app:
+```javascript
+function shouldShowMessage(message: Message): boolean {
+    if(someOtherWorkflowStatus == "inProgress") {
+        return false
+    }
+
+    return true
+}
+```
+
+Another option for the developer is to store a reference to the Message object, and call the show() function on it at a later time. App developer also have to call _Messaging.saveMessage(message)_ from _shouldShowMessage_ of MessagingDelegate for caching the Message on the native side of the RN AEPMessaging package.
+Continuing with the above example, the developer has stored the message that was triggered initially, and chooses to show it upon completion of the other workflow:
+
+```javascript
+var cachedMessage: Message;
+
+function otherWorkflowFinished() {
+    anotherWorkflowStatus = "complete";
+    cachedMessage.show();
+}
+
+function shouldShowMessage(message: Message): boolean {
+    if(anotherWorkflowStatus === "inProgress") {                
+        // store the current message for later use
+        Messaging.saveMessage(message);
+        cachedMessage = message;
+        return false
+    }
+
+    return true
+}
+```
+
+**Important:** If the cached message is no longer needed after being used, free up the references to the Message object by calling _message.clearMessage()_ to prevent memory leaks. In above example after displaying the in app message using cached message object if it is no longer needed then it should be cleared as shown below.
+```javascript
+function otherWorkflowFinished() {
+  anotherWorkflowStatus = "complete";
+  currentMessage.show();
+  currentMessage.clearMessage();
+}
+```

package/android/build.gradle

@@ -2,6 +2,7 @@ buildscript {
     repositories {
         google()
         mavenCentral()
+        maven { url "https://oss.sonatype.org/content/repositories/snapshots/" }
     }
 
     dependencies {
@@ -29,9 +30,11 @@ android {
 repositories {
     google()
     mavenCentral()
+    maven { url "https://oss.sonatype.org/content/repositories/snapshots/" }
 }
 
 dependencies {
+    api "com.adobe.marketing.mobile:optimize:1.+"
+    api "com.adobe.marketing.mobile:messaging:1.3.0-beta-3-SNAPSHOT"
     implementation "com.facebook.react:react-native:+"
-    api "com.adobe.marketing.mobile:messaging:1.+"
 }

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

@@ -10,28 +10,252 @@
  */
 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.ServiceProvider;
+import com.adobe.marketing.mobile.services.ui.FullscreenMessage;
+import com.adobe.marketing.mobile.services.ui.FullscreenMessageDelegate;
+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 FullscreenMessageDelegate {
+
+    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");
+        ServiceProvider.getInstance().setMessageDelegate(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).autoTrack = autoTrack;
+        }
+    }
+
+    @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();
+    }
+
+    //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.id);
+            data.put("autoTrack", String.valueOf(message.autoTrack));
+            emitEvent("onShow", data);
+        }
+    }
 
-public class RCTAEPMessagingModule extends ReactContextBaseJavaModule {
+    @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.id);
+            data.put("autoTrack", String.valueOf(message.autoTrack));
+            emitEvent("onDismiss", data);
+        }
+    }
 
-  private final ReactApplicationContext reactContext;
+    @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.id);
+            data.put("autoTrack", String.valueOf(message.autoTrack));
+            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.id, message);
+            }
+        }
+        return shouldShowMessage;
+    }
 
-  public RCTAEPMessagingModule(ReactApplicationContext reactContext) {
-    super(reactContext);
-    this.reactContext = reactContext;
-  }
+    @Override
+    public boolean overrideUrlLoad(FullscreenMessage fullscreenMessage, String s) {
+        MobileCore.log(VERBOSE, TAG, String.format("overrideUrlLoad is called with url: (%s)", s));
+        final Message message = (Message) fullscreenMessage.getParent();
+        if (message != null) {
+            Map<String, String> data = new HashMap<>();
+            data.put("id", message.id);
+            data.put("autoTrack", String.valueOf(message.autoTrack));
+            data.put("url", s);
+            emitEvent("shouldShowMessage", data);
+            emitEvent("urlLoaded", data);
+        }
+        return true;
+    }
 
-  @Override
-  public String getName() {
-    return "AEPMessaging";
-  }
+    @Override
+    public void onShowFailure() {
+        MobileCore.log(VERBOSE, TAG, "onShowFailure is called.");
+    }
 
-  @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