@adobe/react-native-aepmessaging 5.0.0 → 5.1.0-beta.1

package/ios/src/RCTAEPMessaging.swift

@@ -0,0 +1,283 @@
+/*
+    Copyright 2023 Adobe. All rights reserved.
+    This file is licensed to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law
+    or agreed to in writing, software distributed under the License is
+    distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS OF
+    ANY KIND, either express or implied. See the License for the specific
+    language governing permissions and limitations under the License.
+*/
+
+import AEPCore
+import AEPMessaging
+import AEPServices
+import Foundation
+import UIKit
+import UserNotifications
+import WebKit
+
+@objc(RCTAEPMessaging)
+public class RCTAEPMessaging: RCTEventEmitter, MessagingDelegate {
+    private var messageCache = [String: Message]()
+    private var latestMessage: Message? = nil
+    private let semaphore = DispatchSemaphore(value: 0)
+    private var shouldSaveMessage = false
+    private var shouldShowMessage = true
+    public static var emitter: RCTEventEmitter!
+
+    override init() {
+        super.init()
+        RCTAEPMessaging.emitter = self
+    }
+
+    @objc override public static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+
+    @objc open override func supportedEvents() -> [String] {
+        return Constants.SUPPORTED_EVENTS
+    }
+
+    @objc
+    func extensionVersion(_ resolve: RCTPromiseResolveBlock, rejecter reject: RCTPromiseRejectBlock)
+    {
+        resolve(Messaging.extensionVersion)
+    }
+
+    @objc
+    private func getCachedMessages(
+        _ resolve: RCTPromiseResolveBlock,
+        withRejecter reject: RCTPromiseRejectBlock
+    ) {
+        let cachedMessages = messageCache.values.map {
+            RCTAEPMessagingDataBridge.transformToMessage(message: $0)
+        }
+        resolve(cachedMessages)
+    }
+
+    @objc
+    func getLatestMessage(
+        _ resolve: RCTPromiseResolveBlock,
+        withRejecter reject: RCTPromiseRejectBlock
+    ) {
+        resolve(self.latestMessage != nil ? RCTAEPMessagingDataBridge.transformToMessage(message: self.latestMessage!) : nil)
+    }
+
+    @objc
+    func getPropositionsForSurfaces(
+        _ surfaces: [String],
+        withResolver resolve: @escaping RCTPromiseResolveBlock,
+        withRejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        let surfacePaths = surfaces.map { Surface(path: $0) }
+        Messaging.getPropositionsForSurfaces(surfacePaths) { propositionsDict, error in
+            guard error == nil else {
+                reject("Unable to Retrieve Propositions", nil, nil)
+                return
+            }
+            resolve(RCTAEPMessagingDataBridge.transformPropositionDict(dict: propositionsDict!))
+        }
+    }
+
+    @objc
+    func refreshInAppMessages() {
+        Messaging.refreshInAppMessages()
+    }
+
+    @objc
+    func setMessageSettings(
+        _ shouldShowMessage: Bool,
+        withShouldSaveMessage shouldSaveMessage: Bool
+    ) {
+        self.shouldShowMessage = shouldShowMessage
+        self.shouldSaveMessage = shouldSaveMessage
+        semaphore.signal()
+    }
+
+    @objc
+    func setMessagingDelegate() {
+        MobileCore.messagingDelegate = self
+    }
+
+    @objc
+    func updatePropositionsForSurfaces(
+        _ surfaces: [String],
+        withResolver resolve: @escaping RCTPromiseResolveBlock,
+        withRejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        let mapped = surfaces.map { Surface(path: $0) }
+        Messaging.updatePropositionsForSurfaces(mapped)
+        resolve(nil)
+    }
+
+    /// Message Class Methods
+    @objc
+    func clearMessage(
+        _ id: String,
+        withResolver resolve: @escaping RCTPromiseResolveBlock,
+        withRejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        let msg = messageCache[id]
+        if msg != nil {
+            messageCache.removeValue(forKey: msg!.id)
+            resolve(nil)
+        }
+        reject(Constants.CACHE_MISS, nil, nil)
+    }
+
+    @objc
+    func dismissMessage(
+        _ id: String,
+        withSuppressAutoTrack suppressAutoTrack: Bool,
+        withResolver resolve: @escaping RCTPromiseResolveBlock,
+        withRejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        let msg = messageCache[id]
+        if msg != nil {
+            msg!.dismiss(suppressAutoTrack: suppressAutoTrack)
+            resolve(nil)
+            return
+        }
+        reject(Constants.CACHE_MISS, nil, nil)
+    }
+
+    @objc
+    func handleJavascriptMessage(
+        _ id: String,
+        withName name: String,
+        withResolver resolve: @escaping RCTPromiseResolveBlock,
+        withRejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        let msg = messageCache[id]
+        if msg != nil {
+            msg!.handleJavascriptMessage(name) { content in
+                resolve(content)
+                return
+            }
+        }
+        reject(Constants.CACHE_MISS, nil, nil)
+    }
+
+    @objc
+    func setAutoTrack(
+        _ id: String,
+        withSuppressAutoTrack suppressAutoTrack: Bool,
+        withResolver resolve: @escaping RCTPromiseResolveBlock,
+        withRejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+
+        let msg = messageCache[id]
+        if msg != nil {
+            msg!.autoTrack = suppressAutoTrack
+            resolve(nil)
+            return
+        }
+        reject(Constants.CACHE_MISS, nil, nil)
+    }
+
+    @objc
+    private func showMessage(
+        _ id: String,
+        withResolver resolve: @escaping RCTPromiseResolveBlock,
+        withRejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        let msg = messageCache[id]
+        if msg != nil {
+            msg!.show()
+            resolve(nil)
+            return
+        }
+        reject(Constants.CACHE_MISS, nil, nil)
+
+    }
+
+    @objc
+    func trackMessage(
+        _ id: String,
+        withInteraction interaction: String,
+        withEventType eventType: Int,
+        withResolver resolve: @escaping RCTPromiseResolveBlock,
+        withRejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+
+        let msg = messageCache[id]
+        let eventType =
+            MessagingEdgeEventType.init(rawValue: eventType)
+            ?? MessagingEdgeEventType.inappDismiss
+        if msg != nil {
+            msg!.track(interaction, withEdgeEventType: eventType)
+            resolve(nil)
+            return
+        }
+        reject(Constants.CACHE_MISS, nil, nil)
+    }
+
+    // Messaging Delegate Methods
+    public func onDismiss(message: Showable) {
+        if let fullscreenMessage = message as? FullscreenMessage,
+            let parentMessage = fullscreenMessage.parent
+        {
+            emitNativeEvent(
+                name: Constants.ON_DISMISS_EVENT,
+                body: RCTAEPMessagingDataBridge.transformToMessage(
+                    message: parentMessage
+                )
+            )
+        }
+    }
+
+    public func onShow(message: Showable) {
+        if let fullscreenMessage = message as? FullscreenMessage,
+            let message = fullscreenMessage.parent
+        {
+            emitNativeEvent(
+                name: Constants.ON_SHOW_EVENT,
+                body: RCTAEPMessagingDataBridge.transformToMessage(message: message)
+            )
+        }
+    }
+
+    public func shouldShowMessage(message: Showable) -> Bool {
+        if let fullscreenMessage = message as? FullscreenMessage,
+            let message = fullscreenMessage.parent
+        {
+            emitNativeEvent(
+                name: Constants.SHOULD_SHOW_MESSAGE_EVENT,
+                body: RCTAEPMessagingDataBridge.transformToMessage(message: message)
+            )
+            semaphore.wait()
+            if self.shouldSaveMessage {
+                self.messageCache[message.id] = message
+            }
+
+            if self.shouldShowMessage {
+                latestMessage = message
+            }
+
+            return self.shouldShowMessage
+        }
+        return false
+    }
+
+    public func urlLoaded(_ url: URL, byMessage message: Showable) {
+        if let fullscreenMessage = message as? FullscreenMessage,
+            let parentMessage = fullscreenMessage.parent
+        {
+            emitNativeEvent(
+                name: Constants.URL_LOADED_EVENT,
+                body: [
+                    "url": url.absoluteString,
+                    "message": RCTAEPMessagingDataBridge.transformToMessage(
+                        message: parentMessage
+                    ),
+                ]
+            )
+        }
+    }
+
+    private func emitNativeEvent(name: String, body: Any) {
+        RCTAEPMessaging.emitter.sendEvent(withName: name, body: body)
+    }
+}

package/ios/src/RCTAEPMessagingConstants.swift

@@ -0,0 +1,22 @@
+/*
+    Copyright 2023 Adobe. All rights reserved.
+    This file is licensed to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law
+    or agreed to in writing, software distributed under the License is
+    distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS OF
+    ANY KIND, either express or implied. See the License for the specific
+    language governing permissions and limitations under the License.
+*/
+
+class Constants {
+    static let CACHE_MISS = "No message found in cache. Please ensure you have cached the message"
+    static let ON_DISMISS_EVENT = "onDismiss"
+    static let ON_SHOW_EVENT = "onShow"
+    static let SHOULD_SHOW_MESSAGE_EVENT = "shouldShowMessage"
+    static let URL_LOADED_EVENT = "urlLoaded"
+    static let SUPPORTED_EVENTS = [
+        ON_DISMISS_EVENT, ON_SHOW_EVENT, SHOULD_SHOW_MESSAGE_EVENT, URL_LOADED_EVENT,
+    ]
+}

package/ios/src/RCTAEPMessagingDataBridge.swift

@@ -0,0 +1,41 @@
+/*
+    Copyright 2023 Adobe. All rights reserved.
+    This file is licensed to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law
+    or agreed to in writing, software distributed under the License is
+    distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS OF
+    ANY KIND, either express or implied. See the License for the specific
+    language governing permissions and limitations under the License.
+*/
+
+import AEPMessaging
+
+public class RCTAEPMessagingDataBridge: NSObject {
+    static func transformToMessage(message: Message) -> [String: Any] {
+        return [
+            "id": message.id, "autoTrack": message.autoTrack,
+        ]
+    }
+
+    static func transformPropositionDict(dict: [Surface: [MessagingProposition]]) -> [String: [Any]]
+    {
+        let bundleID = "mobileapp://" + Bundle.main.bundleIdentifier! + "/"
+        return dict.reduce(into: [:]) { result, element in
+            result[element.key.uri.replacingOccurrences(of: bundleID, with: "")] = element.value
+                .map({ self.transformToProposition(proposition: $0) })
+        }
+    }
+
+    static func transformToProposition(proposition: MessagingProposition) -> [String: Any] {
+        return [
+            "scope": proposition.scope, "uniqueId": proposition.uniqueId,
+            "items": proposition.items.map({ item in
+                [
+                    "content": item.content, "schema": item.schema, "uniqueId": item.uniqueId,
+                ]
+            }),
+        ]
+    }
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@adobe/react-native-aepmessaging",
-  "version": "5.0.0",
+  "version": "5.1.0-beta.1",
   "description": "Adobe Experience Platform support for React Native apps.",
   "homepage": "https://developer.adobe.com/client-sdks/documentation/",
   "license": "Apache-2.0",
-  "main": "./ts/index.ts",
+  "main": "./src/index.ts",
   "scripts": {
     "cleanup": "rm -rf node_modules",
     "tsc": "tsc"
@@ -38,5 +38,5 @@
   "installConfig": {
     "hoistingLimits": "dependencies"
   },
-  "gitHead": "7c28b79c996a51d9d5048b0bfd60a5df4cbc8cc8"
+  "gitHead": "fdc4078e6278822c955f095dec2f133056c00713"
 }

package/src/Messaging.ts

@@ -0,0 +1,147 @@
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import { NativeModules, NativeEventEmitter, NativeModule } from 'react-native';
+import Message from './models/Message';
+import { MessagingDelegate } from './models/MessagingDelegate';
+import { MessagingProposition } from './models/MessagingProposition';
+
+export interface NativeMessagingModule {
+  extensionVersion: () => Promise<string>;
+  getCachedMessages: () => Message[];
+  getLatestMessage: () => Message;
+  getPropositionsForSurfaces: (
+    surfaces: string[]
+  ) => Record<string, MessagingProposition[]>;
+  refreshInAppMessages: () => void;
+  setMessagingDelegate: (delegate?: MessagingDelegate) => void;
+  setMessageSettings: (
+    shouldShowMessage: boolean,
+    shouldSaveMessage: boolean
+  ) => void;
+  updatePropositionsForSurfaces: (surfaces: string[]) => void;
+}
+
+const RCTAEPMessaging: NativeModule & NativeMessagingModule =
+  NativeModules.AEPMessaging;
+
+declare var messagingDelegate: MessagingDelegate;
+var messagingDelegate: MessagingDelegate;
+
+class Messaging {
+  /**
+   * Returns the version of the AEPMessaging extension
+   * @returns {string} Promise a promise that resolves with the extension version
+   */
+  static extensionVersion(): Promise<string> {
+    return Promise.resolve(RCTAEPMessaging.extensionVersion());
+  }
+
+  /**
+   * Initiates a network call to retrieve remote In-App Message definitions.
+   */
+  static refreshInAppMessages() {
+    RCTAEPMessaging.refreshInAppMessages();
+  }
+
+  /**
+   * Retrieves the list of messages which have been cached using the `shouldSaveMessage`
+   * method of the messaging delegate.
+   * Note: Messages should be cached before trying to use any of the methods on the message class
+   * @returns An array of messages that have been cached
+   */
+  static async getCachedMessages(): Promise<Message[]> {
+    const messages = await RCTAEPMessaging.getCachedMessages();
+    return messages.map(msg => new Message(msg));
+  }
+
+  /**
+   * Retrieves the last message that has been shown in the UI
+   * @returns The latest message to have been displayed
+   */
+  static async getLatestMessage(): Promise<Message> {
+    const message = await RCTAEPMessaging.getLatestMessage();
+    return message ? new Message(message) : undefined;
+  }
+
+  /**
+   * Retrieves the previously fetched (and cached) feeds content from the SDK for the provided surfaces.
+   * If the feeds content for one or more surfaces isn't previously cached in the SDK, it will not be retrieved from Adobe Journey Optimizer via the Experience Edge network.
+   * @param surfaces A list of surfaces to fetch
+   * @returns A record of surface names with their corresponding propositions
+   */
+  static async getPropositionsForSurfaces(
+    surfaces: string[]
+  ): Promise<Record<string, MessagingProposition[]>> {
+    return await RCTAEPMessaging.getPropositionsForSurfaces(surfaces);
+  }
+
+  /**
+   * Function to set the UI Message delegate to listen the Message lifecycle events.
+   * @returns A function to unsubscribe from all event listeners
+   */
+  static setMessagingDelegate(delegate: MessagingDelegate): () => void {
+    messagingDelegate = delegate;
+
+    const eventEmitter = new NativeEventEmitter(RCTAEPMessaging);
+
+    eventEmitter.addListener('onShow', (message) =>
+      messagingDelegate?.onShow?.(message)
+    );
+
+    eventEmitter.addListener('onDismiss', (message) => {
+      messagingDelegate?.onDismiss?.(message);
+    });
+
+    eventEmitter.addListener('shouldShowMessage', (message) => {
+      const shouldShowMessage =
+        messagingDelegate?.shouldShowMessage?.(message) ?? true;
+      const shouldSaveMessage =
+        messagingDelegate?.shouldSaveMessage?.(message) ?? false;
+      RCTAEPMessaging.setMessageSettings(shouldShowMessage, shouldSaveMessage);
+    });
+
+    eventEmitter.addListener('urlLoaded', (event) =>
+      messagingDelegate?.urlLoaded?.(event.url, event.message)
+    );
+
+    RCTAEPMessaging.setMessagingDelegate();
+
+    return () => {
+      eventEmitter.removeAllListeners('onDismiss');
+      eventEmitter.removeAllListeners('onShow');
+      eventEmitter.removeAllListeners('shouldShowMessage');
+      eventEmitter.removeAllListeners('urlLoaded');
+    };
+  }
+
+  /**
+   * Sets global settings for messages being shown and cached
+   * Note: This method is also used by MessagingDelegate.shouldShowMessage,
+   * which allows finer-grained control over setting these settings
+   * @param shouldShowMessage Whether or not a message should be displayed
+   * @param shouldSaveMessage Whether or not a message should be cached
+   */
+  static setMessageSettings(shouldShowMessage: boolean, shouldSaveMessage: boolean) {
+    RCTAEPMessaging.setMessageSettings(shouldShowMessage, shouldSaveMessage);
+  }
+
+  /**
+   * Dispatches an event to fetch propositions for the provided surfaces from remote.
+   * @param surfaces A list of surface names to update
+   */
+  static updatePropositionsForSurfaces(surfaces: string[]) {
+    RCTAEPMessaging.updatePropositionsForSurfaces(surfaces);
+  }
+}
+
+export default Messaging;

package/{ts → src}/index.ts

@@ -1,5 +1,5 @@
 /*
-Copyright 2022 Adobe. All rights reserved.
+Copyright 2023 Adobe. All rights reserved.
 This file is licensed to you under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License. You may obtain a copy
 of the License at http://www.apache.org/licenses/LICENSE-2.0

package/src/models/Message.ts

@@ -0,0 +1,84 @@
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import { NativeModules } from 'react-native';
+const RCTAEPMessaging = NativeModules.AEPMessaging;
+
+class Message {
+  id: string;
+  autoTrack: boolean;
+
+  constructor({id, autoTrack = false}: {id: string; autoTrack: boolean}) {
+    this.id = id;
+    this.autoTrack = autoTrack;
+  }
+
+  /**
+   * 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) {
+    this.autoTrack = autoTrack;
+    RCTAEPMessaging.setAutoTrack(this.id, autoTrack);
+  }
+
+  /**
+   * 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() {
+    RCTAEPMessaging.show(this.id);
+  }
+
+  /**
+   * 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) {
+    RCTAEPMessaging.dismiss(this.id, suppressAutoTrack ? true : false);
+  }
+
+  /**
+   * 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) {
+    RCTAEPMessaging.track(this.id, interaction, eventType);
+  }
+
+  /**
+   * 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> {
+    return Promise.resolve(
+      RCTAEPMessaging.handleJavascriptMessage(this.id, name)
+    );
+  }
+
+  /**
+   * Clears the cached reference to the Message object.
+   * This function must be called if Message was saved by calling "MessagingDelegate.shouldSaveMessage" but no longer needed.
+   * Failure to call this function leads to memory leaks.
+   */
+  clear() {
+    RCTAEPMessaging.clear(this.id);
+  }
+}
+
+export default Message;

package/src/models/MessagingDelegate.ts

@@ -0,0 +1,47 @@
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import Message from './Message';
+
+export interface MessagingDelegate {
+  /**
+   * Invoked when the any message is displayed
+   * @param {Message} message: Message that is being displayed.
+   */
+  onShow?(message: Message): void;
+
+  /**
+   * Invoked when any message is dismissed
+   * @param {Message} message: Message that is being dismissed
+   */
+  onDismiss?(message: Message): void;
+
+  /**
+   * Used to determine whether a message should be cached, so it can be used later. Return true if the message should be cached.
+   * Note: Message must be cached in order to call any of the functions of the message object
+   */
+  shouldSaveMessage?(message: Message): boolean;
+
+  /**
+   * Used to find whether messages should be shown or not
+   * @param {Message} message: Message that is about to get displayed
+   * @returns {boolean}: true if the message should be shown else false
+   */
+  shouldShowMessage?(message: Message): boolean;
+
+  /**
+   * Called when message loads a URL
+   * @param {string} url: the URL being loaded by the message
+   * @param {Message} message: the Message loading a URL
+   */
+  urlLoaded?(url: string, message: Message): void;
+}

package/{ts → src}/models/MessagingEdgeEventType.ts

@@ -1,5 +1,5 @@
 /*
-Copyright 2022 Adobe. All rights reserved.
+Copyright 2023 Adobe. All rights reserved.
 This file is licensed to you under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License. You may obtain a copy
 of the License at http://www.apache.org/licenses/LICENSE-2.0