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

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.amazonaws.amplify.rtnpushnotification">
+
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <application>
+        <activity
+            android:name=".PushNotificationLaunchActivity"
+            android:launchMode="singleInstance"
+            android:exported="false" />
+
+        <service android:name=".PushNotificationHeadlessTaskService" />
+
+        <service
+            android:name=".PushNotificationFirebaseMessagingService"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="com.google.firebase.MESSAGING_EVENT" />
+            </intent-filter>
+        </service>
+    </application>
+</manifest>

package/android/src/main/kotlin/com/amazonaws/amplify/rtnpushnotification/PushNotificationAWSPinpointUtils.kt

@@ -0,0 +1,159 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package com.amazonaws.amplify.rtnpushnotification
+
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.os.Bundle
+import android.util.Log
+import com.amplifyframework.annotations.InternalAmplifyApi
+import com.amplifyframework.notifications.pushnotifications.NotificationContentProvider
+import com.amplifyframework.notifications.pushnotifications.NotificationPayload
+import com.amplifyframework.pushnotifications.pinpoint.PinpointNotificationPayload
+import com.amplifyframework.pushnotifications.pinpoint.PushNotificationsConstants
+import com.amplifyframework.pushnotifications.pinpoint.PushNotificationsUtils
+import com.amplifyframework.pushnotifications.pinpoint.permissions.PermissionRequestResult
+import com.amplifyframework.pushnotifications.pinpoint.permissions.PushNotificationPermission
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.google.firebase.messaging.RemoteMessage
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.json.Json
+import kotlin.random.Random
+
+private const val TAG = "PushNotificationAWSPinpointUtils"
+
+class PushNotificationPermission(context: Context) {
+    private val permission = PushNotificationPermission(context)
+
+    val hasRequiredPermission = permission.hasRequiredPermission
+
+    suspend fun requestPermission(): Boolean {
+        return permission.requestPermission() is PermissionRequestResult.Granted
+    }
+}
+
+@InternalAmplifyApi
+class PushNotificationUtils(context: Context) {
+    private val utils = PushNotificationsUtils(context)
+
+    fun showNotification(
+        payload: NotificationPayload
+    ) {
+        PinpointNotificationPayload.fromNotificationPayload(payload)?.let {
+            if (utils.areNotificationsEnabled() && !it.silentPush) {
+                utils.showNotification(
+                    payload.notificationId, it, PushNotificationLaunchActivity::class.java
+                )
+            }
+        }
+    }
+
+    fun isAppInForeground(): Boolean {
+        return utils.isAppInForeground()
+    }
+}
+
+@InternalAmplifyApi
+fun Bundle.getNotificationPayload(): NotificationPayload? {
+    val payload = NotificationPayload(NotificationContentProvider.FCM(RemoteMessage(this).data))
+    return PinpointNotificationPayload.fromNotificationPayload(payload)
+}
+
+@InternalAmplifyApi
+fun NotificationPayload?.getProcessedIntent(
+    context: Context,
+): Intent? {
+    // Always launch app
+    val notificationIntent: Intent? =
+        context.packageManager.getLaunchIntentForPackage(context.packageName)
+    this?.let {
+        PinpointNotificationPayload.fromNotificationPayload(it)?.action?.let { action ->
+            when {
+                // Attach action to open url
+                action[PushNotificationsConstants.URL] != null -> {
+                    notificationIntent?.action = Intent.ACTION_VIEW
+                    notificationIntent?.data = Uri.parse(action[PushNotificationsConstants.URL])
+                }
+                // Attach action to open deep link
+                action[PushNotificationsConstants.DEEPLINK] != null -> {
+                    notificationIntent?.action = Intent.ACTION_VIEW
+                    notificationIntent?.data =
+                        Uri.parse(action[PushNotificationsConstants.DEEPLINK])
+                }
+            }
+        }
+    }
+    return notificationIntent
+}
+
+@InternalAmplifyApi
+fun NotificationPayload.toWritableMap(): WritableMap {
+    val payload = PinpointNotificationPayload.fromNotificationPayload(this)
+
+    // Build actions map
+    val action = payload?.action?.let { action ->
+        Arguments.createMap().apply {
+            action[PushNotificationsConstants.OPENAPP]?.let {
+                putString(PushNotificationsConstants.OPENAPP, it)
+            }
+            action[PushNotificationsConstants.URL]?.let {
+                putString(PushNotificationsConstants.URL, it)
+            }
+            action[PushNotificationsConstants.DEEPLINK]?.let {
+                putString(PushNotificationsConstants.DEEPLINK, it)
+            }
+        }
+    }
+
+    // Build rawData map
+    val rawData = Arguments.createMap()
+    this.rawData.entries.forEach {
+        rawData.putString(it.key, it.value)
+    }
+
+    // Build and return final map
+    return Arguments.createMap().apply {
+        payload?.title?.let { putString("title", it) }
+        payload?.body?.let { putString("body", it) }
+        payload?.imageUrl?.let { putString("imageUrl", it) }
+        payload?.channelId?.let { putString("channelId", it) }
+        action?.let { putMap("action", action) }
+        putMap("rawData", rawData)
+    }
+}
+
+@InternalAmplifyApi
+private val NotificationPayload.notificationId: Int
+    get() {
+        var sourceId: String?
+        var activityId: String?
+
+        // Assign campaign attributes
+        sourceId = this.rawData[PushNotificationsConstants.PINPOINT_CAMPAIGN_CAMPAIGN_ID]
+        activityId = this.rawData[PushNotificationsConstants.PINPOINT_CAMPAIGN_CAMPAIGN_ACTIVITY_ID]
+
+        // If no campaign id, try to assign journey attributes
+        if (sourceId.isNullOrEmpty()) {
+            val journeyAttributes = this.rawData[PushNotificationsConstants.PINPOINT_PREFIX]?.let {
+                try {
+                    Json.decodeFromString<Map<String, Map<String, String>>>(it)[PushNotificationsConstants.JOURNEY]
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error parsing journey attribute", e)
+                    null
+                }
+            }
+            journeyAttributes?.let {
+                sourceId = it[PushNotificationsConstants.JOURNEY_ID]
+                activityId = it[PushNotificationsConstants.JOURNEY_ACTIVITY_ID]
+            }
+        }
+
+        // If no activity id (even if campaign was direct send), use a random id, otherwise hash
+        // attributes to prevent displaying duplicate notifications from an activity
+        return activityId?.let {
+            "$sourceId:$activityId".hashCode()
+        } ?: Random.nextInt()
+    }

package/android/src/main/kotlin/com/amazonaws/amplify/rtnpushnotification/PushNotificationEventManager.kt

@@ -0,0 +1,49 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package com.amazonaws.amplify.rtnpushnotification
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+enum class PushNotificationEventType(val value: String) {
+    FOREGROUND_MESSAGE_RECEIVED("ForegroundMessageReceived"),
+    LAUNCH_NOTIFICATION_OPENED("LaunchNotificationOpened"),
+    NOTIFICATION_OPENED("NotificationOpened"),
+    TOKEN_RECEIVED("TokenReceived")
+}
+
+class PushNotificationEvent(val type: PushNotificationEventType, val params: WritableMap?)
+
+object PushNotificationEventManager {
+    private lateinit var reactContext: ReactApplicationContext
+    private var isInitialized: Boolean = false
+    private val eventQueue: MutableList<PushNotificationEvent> = mutableListOf()
+
+    fun init(reactContext: ReactApplicationContext) {
+        this.reactContext = reactContext
+        isInitialized = true
+        flushEventQueue()
+    }
+
+    fun sendEvent(type: PushNotificationEventType, params: WritableMap?) {
+        if (!isInitialized) {
+            eventQueue.add(PushNotificationEvent(type, params))
+        } else {
+            sendJSEvent(type, params)
+        }
+    }
+
+    private fun sendJSEvent(type: PushNotificationEventType, params: WritableMap?) {
+        reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            ?.emit(type.value, params)
+    }
+
+    private fun flushEventQueue() {
+        eventQueue.forEach {
+            sendJSEvent(it.type, it.params)
+        }
+        eventQueue.clear()
+    }
+}

package/android/src/main/kotlin/com/amazonaws/amplify/rtnpushnotification/PushNotificationFirebaseMessagingService.kt

@@ -0,0 +1,74 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package com.amazonaws.amplify.rtnpushnotification
+
+import android.content.Intent
+import android.os.Bundle
+import android.util.Log
+import com.amplifyframework.annotations.InternalAmplifyApi
+import com.amplifyframework.notifications.pushnotifications.NotificationPayload
+import com.facebook.react.HeadlessJsTaskService
+import com.facebook.react.bridge.Arguments
+import com.google.firebase.messaging.FirebaseMessagingService
+
+@InternalAmplifyApi
+private val TAG = PushNotificationFirebaseMessagingService::class.java.simpleName
+
+@InternalAmplifyApi
+class PushNotificationFirebaseMessagingService : FirebaseMessagingService() {
+
+    private lateinit var utils: PushNotificationUtils
+
+    override fun onCreate() {
+        super.onCreate()
+        utils = PushNotificationUtils(baseContext)
+    }
+
+    override fun onNewToken(token: String) {
+        super.onNewToken(token)
+        val params = Arguments.createMap()
+        params.putString("token", token)
+        Log.d(TAG, "Send device token event")
+        PushNotificationEventManager.sendEvent(PushNotificationEventType.TOKEN_RECEIVED, params)
+    }
+
+    override fun handleIntent(intent: Intent) {
+        val extras = intent.extras ?: Bundle()
+        extras.getNotificationPayload()?.let {
+            // message contains push notification payload, show notification
+            onMessageReceived(it)
+        } ?: run {
+            Log.d(TAG, "Ignore intents that don't contain push notification payload")
+            super.handleIntent(intent)
+        }
+    }
+
+    private fun onMessageReceived(payload: NotificationPayload) {
+        if (utils.isAppInForeground()) {
+            Log.d(TAG, "Send foreground message received event")
+            PushNotificationEventManager.sendEvent(
+                PushNotificationEventType.FOREGROUND_MESSAGE_RECEIVED, payload.toWritableMap()
+            )
+        } else {
+            Log.d(
+                TAG, "App is in background, try to create notification and start headless service"
+            )
+
+            utils.showNotification(payload)
+
+            try {
+                val serviceIntent =
+                    Intent(baseContext, PushNotificationHeadlessTaskService::class.java)
+                serviceIntent.putExtra("amplifyNotificationPayload", payload)
+                if (baseContext.startService(serviceIntent) != null) {
+                    HeadlessJsTaskService.acquireWakeLockNow(baseContext)
+                }
+            } catch (exception: Exception) {
+                Log.e(
+                    TAG, "Something went wrong while starting headless task: ${exception.message}"
+                )
+            }
+        }
+    }
+}

package/android/src/main/kotlin/com/amazonaws/amplify/rtnpushnotification/PushNotificationHeadlessTaskService.kt

@@ -0,0 +1,28 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package com.amazonaws.amplify.rtnpushnotification
+
+import android.content.Intent
+import com.amplifyframework.annotations.InternalAmplifyApi
+import com.amplifyframework.notifications.pushnotifications.NotificationPayload
+import com.facebook.react.HeadlessJsTaskService
+import com.facebook.react.jstasks.HeadlessJsTaskConfig
+
+class PushNotificationHeadlessTaskService : HeadlessJsTaskService() {
+
+    private val defaultTimeout: Long = 10000 // 10 seconds
+
+    @InternalAmplifyApi
+    override fun getTaskConfig(intent: Intent): HeadlessJsTaskConfig? {
+        return NotificationPayload.fromIntent(intent)?.let {
+            HeadlessJsTaskConfig(
+                HEADLESS_TASK_KEY, it.toWritableMap(), defaultTimeout, true
+            )
+        }
+    }
+
+    companion object {
+        const val HEADLESS_TASK_KEY = "PushNotificationHeadlessTaskKey"
+    }
+}

package/android/src/main/kotlin/com/amazonaws/amplify/rtnpushnotification/PushNotificationLaunchActivity.kt

@@ -0,0 +1,27 @@
+package com.amazonaws.amplify.rtnpushnotification
+
+import android.app.Activity
+import android.content.ActivityNotFoundException
+import android.os.Bundle
+import android.util.Log
+import com.amplifyframework.annotations.InternalAmplifyApi
+import com.amplifyframework.notifications.pushnotifications.NotificationPayload
+
+private val TAG = PushNotificationLaunchActivity::class.java.simpleName
+
+class PushNotificationLaunchActivity : Activity() {
+    @Override
+    @InternalAmplifyApi
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        val payload = NotificationPayload.fromIntent(intent)
+        val notificationIntent = payload.getProcessedIntent(applicationContext)
+        notificationIntent?.putExtras(intent)
+        try {
+            startActivity(notificationIntent)
+        } catch (e: ActivityNotFoundException) {
+            Log.e(TAG, "Unable to launch intent.", e)
+        }
+        finish()
+    }
+}

package/android/src/main/kotlin/com/amazonaws/amplify/rtnpushnotification/PushNotificationModule.kt

@@ -0,0 +1,188 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package com.amazonaws.amplify.rtnpushnotification
+
+import android.app.Activity
+import android.content.Context.MODE_PRIVATE
+import android.content.Intent
+import android.util.Log
+import androidx.core.app.ActivityCompat
+import com.amplifyframework.annotations.InternalAmplifyApi
+import com.amplifyframework.notifications.pushnotifications.NotificationPayload
+import com.facebook.react.bridge.*
+import com.google.android.gms.tasks.OnCompleteListener
+import com.google.firebase.messaging.FirebaseMessaging
+import kotlinx.coroutines.*
+
+
+private val TAG = PushNotificationModule::class.java.simpleName
+private const val PERMISSION = "android.permission.POST_NOTIFICATIONS"
+private const val PREF_FILE_KEY = "com.amazonaws.amplify.rtnpushnotification"
+private const val PREF_PREVIOUSLY_DENIED = "wasPermissionPreviouslyDenied"
+
+enum class PushNotificationPermissionStatus {
+    ShouldRequest,
+    ShouldExplainThenRequest,
+    Granted,
+    Denied,
+}
+
+class PushNotificationModule(
+    reactContext: ReactApplicationContext,
+    dispatcher: CoroutineDispatcher = Dispatchers.Main
+) : ReactContextBaseJavaModule(reactContext), ActivityEventListener, LifecycleEventListener {
+
+    private var isAppLaunch: Boolean = true
+    private var launchNotification: WritableMap? = null
+    private val sharedPreferences = reactContext.getSharedPreferences(PREF_FILE_KEY, MODE_PRIVATE)
+    private val scope = CoroutineScope(dispatcher)
+
+    init {
+        reactContext.addActivityEventListener(this)
+        reactContext.addLifecycleEventListener(this)
+    }
+
+    @ReactMethod
+    fun getLaunchNotification(promise: Promise) {
+        launchNotification?.let {
+            promise.resolve(launchNotification)
+            launchNotification = null
+        } ?: promise.resolve(null)
+    }
+
+    @ReactMethod
+    fun getPermissionStatus(promise: Promise) {
+        val permission = PushNotificationPermission(reactApplicationContext)
+        // If permission has already been granted
+        if (permission.hasRequiredPermission) {
+            return promise.resolve(PushNotificationPermissionStatus.Granted.name)
+        }
+        // If the shouldShowRequestPermissionRationale flag is true, permission must have been
+        // denied once (and only once) previously
+        if (shouldShowRequestPermissionRationale()) {
+            return promise.resolve(PushNotificationPermissionStatus.ShouldExplainThenRequest.name)
+        }
+        // If the shouldShowRequestPermissionRationale flag is false and the permission was
+        // already previously denied then user has denied permissions twice
+        if (sharedPreferences.getBoolean(PREF_PREVIOUSLY_DENIED, false)) {
+            return promise.resolve(PushNotificationPermissionStatus.Denied.name)
+        }
+        // Otherwise it's never been requested (or user could have dismissed the request without
+        // explicitly denying)
+        promise.resolve(PushNotificationPermissionStatus.ShouldRequest.name)
+    }
+
+    @ReactMethod
+    fun requestPermissions(
+        @Suppress("UNUSED_PARAMETER") permissions: ReadableMap,
+        promise: Promise
+    ) {
+        scope.launch {
+            val permission = PushNotificationPermission(reactApplicationContext)
+            if (permission.requestPermission()) {
+                promise.resolve(true)
+            } else {
+                // If permission was not granted and the shouldShowRequestPermissionRationale flag
+                // is true then user must have denied for the first time. We will set the
+                // wasPermissionPreviouslyDenied value to true only in this scenario since it's
+                // possible to dismiss the permission request without explicitly denying as well.
+                if (shouldShowRequestPermissionRationale()) {
+                    with(sharedPreferences.edit()) {
+                        putBoolean(PREF_PREVIOUSLY_DENIED, true)
+                        apply()
+                    }
+                }
+                promise.resolve(false)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun addListener(@Suppress("UNUSED_PARAMETER") eventName: String) {
+        // noop - only required for RN NativeEventEmitter
+    }
+
+    @ReactMethod
+    fun removeListeners(@Suppress("UNUSED_PARAMETER") count: Int) {
+        // noop - only required for RN NativeEventEmitter
+    }
+
+    override fun getName() = "AmplifyRTNPushNotification"
+
+    override fun getConstants(): MutableMap<String, Any> = hashMapOf(
+        "NativeEvent" to PushNotificationEventType.values()
+            .associateBy({ it.name }, { it.value }),
+        "NativeHeadlessTaskKey" to PushNotificationHeadlessTaskService.HEADLESS_TASK_KEY
+    )
+
+    override fun onActivityResult(p0: Activity?, p1: Int, p2: Int, p3: Intent?) {
+        // noop - only overridden as this class implements ActivityEventListener
+    }
+
+    /**
+     * Send notification opened app event to JS layer if the app is in a background state
+     */
+    @InternalAmplifyApi
+    override fun onNewIntent(intent: Intent) {
+        val payload = NotificationPayload.fromIntent(intent)
+        if (payload != null) {
+            PushNotificationEventManager.sendEvent(
+                PushNotificationEventType.NOTIFICATION_OPENED, payload.toWritableMap()
+            )
+        }
+    }
+
+    /**
+     * On every app resume (including launch), send the current device token to JS layer. Also
+     * store the app launching notification if app is in a quit state
+     */
+    @InternalAmplifyApi
+    override fun onHostResume() {
+        if (isAppLaunch) {
+            isAppLaunch = false
+            PushNotificationEventManager.init(reactApplicationContext)
+            val firebaseInstance = FirebaseMessaging.getInstance()
+            firebaseInstance.token.addOnCompleteListener(OnCompleteListener { task ->
+                if (!task.isSuccessful) {
+                    Log.w(TAG, "Fetching FCM registration token failed")
+                    return@OnCompleteListener
+                }
+                val params = Arguments.createMap().apply {
+                    putString("token", task.result)
+                }
+                Log.d(TAG, "Send device token event")
+                PushNotificationEventManager.sendEvent(
+                    PushNotificationEventType.TOKEN_RECEIVED,
+                    params
+                )
+            })
+            currentActivity?.intent?.let {
+                val payload = NotificationPayload.fromIntent(it)
+                if (payload != null) {
+                    launchNotification = payload.toWritableMap()
+                    // Launch notification opened event is emitted for internal use only
+                    PushNotificationEventManager.sendEvent(
+                        PushNotificationEventType.LAUNCH_NOTIFICATION_OPENED,
+                        payload.toWritableMap()
+                    )
+                }
+            }
+        } else {
+            // Wipe the launching notification as app was re-opened by some other means
+            launchNotification = null
+        }
+    }
+
+    override fun onHostPause() {
+        // noop - only overridden as this class implements LifecycleEventListener
+    }
+
+    override fun onHostDestroy() {
+        scope.cancel()
+    }
+
+    private fun shouldShowRequestPermissionRationale(): Boolean {
+        return ActivityCompat.shouldShowRequestPermissionRationale(currentActivity!!, PERMISSION)
+    }
+}

package/android/src/main/kotlin/com/amazonaws/amplify/rtnpushnotification/PushNotificationPackage.kt

@@ -0,0 +1,22 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package com.amazonaws.amplify.rtnpushnotification
+
+import android.view.View
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ReactShadowNode
+import com.facebook.react.uimanager.ViewManager
+
+class PushNotificationPackage : ReactPackage {
+
+    override fun createViewManagers(
+        reactContext: ReactApplicationContext
+    ): MutableList<ViewManager<View, ReactShadowNode<*>>> = mutableListOf()
+
+    override fun createNativeModules(
+        reactContext: ReactApplicationContext
+    ): MutableList<NativeModule> = listOf(PushNotificationModule(reactContext)).toMutableList()
+}