@aws-amplify/rtn-push-notification 1.0.1-push-notification-dryrun.7810

package/android/src/test/kotlin/PushNotificationModuleTest.kt

@@ -0,0 +1,201 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import android.app.Activity
+import android.content.Intent
+import android.content.SharedPreferences
+import androidx.core.app.ActivityCompat
+import com.amazonaws.amplify.rtnpushnotification.*
+import com.amplifyframework.annotations.InternalAmplifyApi
+import com.amplifyframework.notifications.pushnotifications.NotificationContentProvider
+import com.amplifyframework.notifications.pushnotifications.NotificationPayload
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.google.android.gms.tasks.OnCompleteListener
+import com.google.android.gms.tasks.Task
+import com.google.firebase.messaging.FirebaseMessaging
+import io.mockk.*
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.advanceUntilIdle
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@InternalAmplifyApi
+@ExperimentalCoroutinesApi
+@RunWith(RobolectricTestRunner::class)
+class PushNotificationModuleTest {
+    private val mockContext = mockk<ReactApplicationContext>()
+    private val mockMap = mockk<WritableMap>()
+    private val mockPromise = mockk<Promise>()
+    private val mockSharedPreferences = mockk<SharedPreferences>()
+    private val mockTask = mockk<Task<String>>()
+    private val tokenOnCompleteListenerSlot = slot<OnCompleteListener<String>>()
+    private val testPayload = NotificationPayload.Builder(
+        NotificationContentProvider.FCM(emptyMap())
+    ).build()
+    private lateinit var module: PushNotificationModule
+
+    @Before
+    fun setup() {
+        mockkConstructor(PushNotificationPermission::class)
+        mockkObject(PushNotificationEventManager)
+        mockkObject(NotificationPayload)
+        mockkStatic(ActivityCompat::class)
+        mockkStatic(Arguments::class)
+        mockkStatic(FirebaseMessaging::class)
+        mockkStatic(NotificationPayload::toWritableMap)
+        mockkStatic(PushNotificationPermission::class)
+        mockkStatic(Task::class)
+        justRun {
+            mockContext.addActivityEventListener(any())
+            mockContext.addLifecycleEventListener(any())
+            PushNotificationEventManager.sendEvent(any(), any())
+            mockMap.putString(any(), any())
+            mockPromise.resolve(any())
+        }
+        every { mockContext.currentActivity?.intent } returns Intent()
+        every { mockContext.getSharedPreferences(any(), any()) } returns mockSharedPreferences
+        every { Arguments.createMap() } returns mockMap
+        every { FirebaseMessaging.getInstance().token } returns mockTask
+        every { NotificationPayload.fromIntent(any()) } returns testPayload
+        every { any<NotificationPayload>().toWritableMap() } returns mockMap
+        every { mockTask.isSuccessful } returns true
+        every { mockTask.result } returns "foo-bar"
+        every { mockTask.addOnCompleteListener(capture(tokenOnCompleteListenerSlot)) } answers {
+            tokenOnCompleteListenerSlot.captured.onComplete(mockTask)
+            mockTask
+        }
+        every { anyConstructed<PushNotificationPermission>().hasRequiredPermission } returns false
+        every { mockSharedPreferences.getBoolean(any(), any()) } returns false
+        every { ActivityCompat.shouldShowRequestPermissionRationale(any(), any()) } returns false
+        module = PushNotificationModule(mockContext)
+    }
+
+    @Test
+    fun `returns module name`() {
+        assertEquals("AmplifyRTNPushNotification", module.name)
+    }
+
+    @Test
+    fun `returns constants for use in JS`() {
+        assertTrue(module.constants.containsKey("NativeEvent"))
+        assertTrue(module.constants.containsKey("NativeHeadlessTaskKey"))
+    }
+
+    @Test
+    fun `onNewIntent does nothing if intent does not contain payload`() {
+        every { NotificationPayload.fromIntent(any()) } returns null
+        module.onNewIntent(Intent())
+        verify(exactly = 0) { PushNotificationEventManager.sendEvent(any(), any()) }
+    }
+
+    @Test
+    fun `onNewIntent sends notification opened event if intent contains payload`() {
+        module.onNewIntent(Intent())
+        verify {
+            PushNotificationEventManager.sendEvent(
+                PushNotificationEventType.NOTIFICATION_OPENED, mockMap
+            )
+        }
+    }
+
+    @Test
+    fun `only first onHostResume call is app launch`() {
+        module.onHostResume()
+        module.onHostResume()
+        verify(exactly = 1) {
+            PushNotificationEventManager.sendEvent(
+                PushNotificationEventType.TOKEN_RECEIVED, mockMap
+            )
+            PushNotificationEventManager.sendEvent(
+                PushNotificationEventType.LAUNCH_NOTIFICATION_OPENED, mockMap
+            )
+        }
+    }
+
+    @Test
+    fun `launch notification is set by app launch and consumed by getLaunchNotification call`() {
+        module.onHostResume()
+        module.getLaunchNotification(mockPromise)
+        module.getLaunchNotification(mockPromise)
+        verify(exactly = 1) {
+            mockPromise.resolve(mockMap)
+            mockPromise.resolve(null)
+        }
+    }
+
+    @Test
+    fun `launch notification is wiped by subsequent app launches`() {
+        module.onHostResume()
+        module.onHostResume()
+        module.getLaunchNotification(mockPromise)
+        verify { mockPromise.resolve(null) }
+    }
+
+    @Test
+    fun `returns ShouldRequest permission status`() {
+        module.getPermissionStatus(mockPromise)
+        verify { mockPromise.resolve(PushNotificationPermissionStatus.ShouldRequest.name) }
+    }
+
+    @Test
+    fun `returns ShouldExplainThenRequest permission status`() {
+        every { ActivityCompat.shouldShowRequestPermissionRationale(any(), any()) } returns true
+        module.getPermissionStatus(mockPromise)
+        verify { mockPromise.resolve(PushNotificationPermissionStatus.ShouldExplainThenRequest.name) }
+    }
+
+    @Test
+    fun `returns Granted permission status`() {
+        every { anyConstructed<PushNotificationPermission>().hasRequiredPermission } returns true
+        module.getPermissionStatus(mockPromise)
+        verify { mockPromise.resolve(PushNotificationPermissionStatus.Granted.name) }
+    }
+
+    @Test
+    fun `returns Denied permission status`() {
+        every { mockSharedPreferences.getBoolean(any(), any()) } returns true
+        module.getPermissionStatus(mockPromise)
+        verify { mockPromise.resolve(PushNotificationPermissionStatus.Denied.name) }
+    }
+
+    @Test
+    fun `requests permission`() = runTest {
+        val dispatcher = StandardTestDispatcher(testScheduler)
+        coEvery { anyConstructed<PushNotificationPermission>().requestPermission() } returns true
+        PushNotificationModule(mockContext, dispatcher).requestPermissions(mockk(), mockPromise)
+        advanceUntilIdle()
+        verify { mockPromise.resolve(true) }
+    }
+
+    @Test
+    fun `requests permission sets previously denied flag`() = runTest {
+        val dispatcher = StandardTestDispatcher(testScheduler)
+        val mockSharedPreferencesEditor = mockk<SharedPreferences.Editor>()
+        justRun { mockSharedPreferencesEditor.apply() }
+        every { ActivityCompat.shouldShowRequestPermissionRationale(any(), any()) } returns true
+        every { mockSharedPreferences.edit() } returns mockSharedPreferencesEditor
+        every {
+            mockSharedPreferencesEditor.putBoolean(
+                any(), any()
+            )
+        } returns mockSharedPreferencesEditor
+        coEvery { anyConstructed<PushNotificationPermission>().requestPermission() } returns false
+        PushNotificationModule(mockContext, dispatcher).requestPermissions(mockk(), mockPromise)
+        advanceUntilIdle()
+        verify {
+            mockPromise.resolve(false)
+            mockSharedPreferencesEditor.putBoolean("wasPermissionPreviouslyDenied", true)
+        }
+    }
+}

package/ios/AmplifyPushNotification.h

@@ -0,0 +1,17 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef AmplifyPushNotification_h
+#define AmplifyPushNotification_h
+
+#import <Foundation/Foundation.h>
+
+@interface AmplifyPushNotification : NSObject
+
++ (void) didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken;
++ (void) didFailToRegisterForRemoteNotificationsWithError:(NSError*)error;
++ (void) didReceiveRemoteNotification:(NSDictionary *)userInfo withCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler;
+
+@end
+
+#endif

package/ios/AmplifyPushNotification.m

@@ -0,0 +1,21 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+#import "AmplifyRTNPushNotification-Swift.h"
+#import "AmplifyPushNotification.h"
+
+@implementation AmplifyPushNotification
+
++ (void) didRegisterForRemoteNotificationsWithDeviceToken:(NSData*)deviceToken {
+    [AmplifyPushNotificationAppDelegateHelper didRegisterForRemoteNotificationsWithDeviceToken:deviceToken];
+}
+
++ (void) didFailToRegisterForRemoteNotificationsWithError:(NSError*)error {
+    [AmplifyPushNotificationAppDelegateHelper didFailToRegisterForRemoteNotificationsWithError:error];
+}
+
++ (void) didReceiveRemoteNotification:(NSDictionary*)userInfo withCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {
+    [AmplifyPushNotificationAppDelegateHelper didReceiveRemoteNotificationWithUserInfo:userInfo completionHandler:completionHandler];
+}
+
+@end

package/ios/AmplifyPushNotificationAppDelegateHelper.swift

@@ -0,0 +1,31 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import Foundation
+
+@objc(AmplifyPushNotificationAppDelegateHelper)
+public class AmplifyPushNotificationAppDelegateHelper: NSObject {
+    @objc
+    static public func didRegisterForRemoteNotificationsWithDeviceToken(_ deviceToken: Data) {
+        AmplifyRTNPushNotificationManager
+            .shared
+            .didRegisterForRemoteNotificationsWithDeviceToken(deviceToken: deviceToken)
+    }
+
+    @objc
+    static public func didFailToRegisterForRemoteNotificationsWithError(_ error: Error) {
+        AmplifyRTNPushNotificationManager
+            .shared
+            .didFailToRegisterForRemoteNotificationsWithError(error: error)
+    }
+
+    @objc
+    static public func didReceiveRemoteNotification(
+        userInfo: [AnyHashable: Any],
+        completionHandler: @escaping (UIBackgroundFetchResult) -> Void
+    ) {
+        AmplifyRTNPushNotificationManager
+            .shared
+            .didReceiveRemoteNotification(userInfo: userInfo, completionHandler: completionHandler)
+    }
+}

package/ios/AmplifyRTNEventManager.swift

@@ -0,0 +1,73 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import Foundation
+
+enum NativeEvent {
+    case tokenReceived
+    case notificationOpened
+    case launchNotificationOpened
+    case backgroundMessageReceived
+    case foregroundMessageReceived
+
+    var key: String {
+        switch(self) {
+        case .tokenReceived:
+            return "TOKEN_RECEIVED"
+        case .notificationOpened:
+            return "NOTIFICATION_OPENED"
+        case .launchNotificationOpened:
+            return "LAUNCH_NOTIFICATION_OPENED"
+        case .backgroundMessageReceived:
+            return "BACKGROUND_MESSAGE_RECEIVED"
+        case .foregroundMessageReceived:
+            return "FOREGROUND_MESSAGE_RECEIVED"
+        }
+    }
+
+    var name: String {
+        switch(self) {
+        case .tokenReceived:
+            return "TokenReceived"
+        case .notificationOpened:
+            return "NotificationOpened"
+        case .launchNotificationOpened:
+            return "LaunchNotificationOpened"
+        case .foregroundMessageReceived:
+            return "ForegroundMessageReceived"
+        case .backgroundMessageReceived:
+            return "BackgroundMessageReceived"
+        }
+    }
+}
+
+struct AmplifyRTNEvent {
+    var type: NativeEvent
+    var payload: Any
+}
+
+class AmplifyRTNEventManager {
+    static let shared = AmplifyRTNEventManager()
+
+    private var eventQueue: [AmplifyRTNEvent] = []
+    private var sendEvent: ((AmplifyRTNEvent) -> Void)?
+
+    func setSendEvent(sendEvent: @escaping (AmplifyRTNEvent) -> Void) {
+        self.sendEvent = sendEvent
+        flushQueuedEvents();
+    }
+
+    func sendEventToJS(_ event: AmplifyRTNEvent) {
+        if let sendEvent = self.sendEvent {
+            sendEvent(event)
+        } else {
+            eventQueue.append(event)
+        }
+    }
+
+    private func flushQueuedEvents() {
+        while (!eventQueue.isEmpty) {
+            sendEventToJS(eventQueue.removeFirst())
+        }
+    }
+}

package/ios/AmplifyRTNPushNotification-Bridging-Header.h

@@ -0,0 +1,7 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+#import <React/RCTEventEmitter.h>
+#import <React/RCTRootView.h>

package/ios/AmplifyRTNPushNotification.m

@@ -0,0 +1,26 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+#import <React/RCTEventEmitter.h>
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(AmplifyRTNPushNotification, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(requestPermissions:(NSDictionary*)permissions
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getPermissionStatus:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getLaunchNotification:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(setBadgeCount:(int)count)
+
+RCT_EXTERN_METHOD(getBadgeCount:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(completeNotification:(NSString*)completionHandlerId)
+
+@end

package/ios/AmplifyRTNPushNotification.swift

@@ -0,0 +1,121 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import Foundation
+
+private let expectedEventNames: Set = [
+    NativeEvent.tokenReceived.name,
+    NativeEvent.backgroundMessageReceived.name,
+    NativeEvent.foregroundMessageReceived.name,
+    NativeEvent.notificationOpened.name,
+    NativeEvent.launchNotificationOpened.name
+]
+
+@objc(AmplifyRTNPushNotification)
+class AmplifyRTNPushNotification: RCTEventEmitter {
+
+    var registeredEventNames: Set<String> = []
+    var hasListeners = false
+    private let sharedNotificationManager: AmplifyRTNPushNotificationManager
+
+    // Override the bridge setter and getter to capture the launch options
+    override var bridge: RCTBridge! {
+        set(bridge) {
+            super.bridge = bridge
+
+            if let launchOptions = bridge.launchOptions {
+                sharedNotificationManager.handleLaunchOptions(launchOptions: launchOptions)
+            }
+        }
+        get {
+            return super.bridge
+        }
+    }
+
+    override init() {
+        sharedNotificationManager = AmplifyRTNPushNotificationManager.shared
+        super.init()
+    }
+
+    func notifyFlushQueuedEvents() {
+        AmplifyRTNEventManager.shared.setSendEvent(sendEvent: self.sendEventToJS)
+    }
+
+    func sendEventToJS(event: AmplifyRTNEvent) {
+        sendEvent(withName: event.type.name, body: event.payload)
+    }
+
+    override func addListener(_ eventName: String!) {
+        super.addListener(eventName)
+        registeredEventNames.insert(eventName)
+
+        if (registeredEventNames == expectedEventNames) {
+            notifyFlushQueuedEvents()
+        }
+    }
+
+    override func supportedEvents() -> [String]! {
+        return Array(expectedEventNames)
+    }
+
+    @objc
+    func requestPermissions(
+        _ permissions: [AnyHashable: Any],
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        sharedNotificationManager.requestPermissions(permissions, resolve: resolve, reject: reject)
+    }
+
+    @objc
+    func getPermissionStatus(
+        _ resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        sharedNotificationManager.getPermissionStatus(resolve, reject: reject)
+    }
+
+    @objc
+    func getLaunchNotification(
+        _ resolve: RCTPromiseResolveBlock,
+        reject: RCTPromiseRejectBlock
+    ) {
+        sharedNotificationManager.getLaunchNotification(resolve, reject: reject)
+    }
+
+    @objc
+    func setBadgeCount(_ count: Int) {
+        sharedNotificationManager.setBadgeCount(count)
+    }
+
+    @objc
+    func getBadgeCount(
+        _ resolve: @escaping RCTPromiseResolveBlock,
+        reject: RCTPromiseRejectBlock
+    ) {
+        sharedNotificationManager.getBadgeCount(resolve, reject: reject)
+    }
+
+    @objc
+    func completeNotification(_ completionHandlerId: String) {
+        sharedNotificationManager.completeNotification(completionHandlerId)
+    }
+
+    @objc
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+
+    @objc
+    override func constantsToExport() -> [AnyHashable : Any]! {
+        return [
+            "NativeEvent": [
+                NativeEvent.backgroundMessageReceived.key: NativeEvent.backgroundMessageReceived.name,
+                NativeEvent.foregroundMessageReceived.key: NativeEvent.foregroundMessageReceived.name,
+                NativeEvent.notificationOpened.key: NativeEvent.notificationOpened.name,
+                NativeEvent.launchNotificationOpened.key: NativeEvent.launchNotificationOpened.name,
+                NativeEvent.tokenReceived.key: NativeEvent.tokenReceived.name,
+            ],
+        ]
+    }
+}

package/ios/AmplifyRTNPushNotification.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "group:AmplifyPushNotification.h">
+   </FileRef>
+   <FileRef
+      location = "group:AmplifyPushNotification.m">
+   </FileRef>
+   <FileRef
+      location = "group:AmplifyPushNotificationAppDelegateHelper.swift">
+   </FileRef>
+   <FileRef
+      location = "group:AmplifyRTNEventManager.swift">
+   </FileRef>
+   <FileRef
+      location = "group:AmplifyRTNPushNotification-Bridging-Header.h">
+   </FileRef>
+   <FileRef
+      location = "group:AmplifyRTNPushNotification.m">
+   </FileRef>
+   <FileRef
+      location = "group:AmplifyRTNPushNotification.swift">
+   </FileRef>
+   <FileRef
+      location = "group:AmplifyRTNPushNotificationManager.swift">
+   </FileRef>
+</Workspace>

package/ios/AmplifyRTNPushNotification.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>