@trycourier/courier-react-native 3.2.1 → 4.0.4

package/android/src/main/java/com/courierreactnative/CourierSharedModule.kt

@@ -0,0 +1,321 @@
+package com.courierreactnative
+
+import com.courier.android.Courier
+import com.courier.android.models.CourierAgent
+import com.courier.android.models.CourierAuthenticationListener
+import com.courier.android.models.CourierInboxListener
+import com.courier.android.models.InboxMessage
+import com.courier.android.models.remove
+import com.courier.android.modules.addAuthenticationListener
+import com.courier.android.modules.addInboxListener
+import com.courier.android.modules.archiveMessage
+import com.courier.android.modules.clickMessage
+import com.courier.android.modules.fetchNextInboxPage
+import com.courier.android.modules.getToken
+import com.courier.android.modules.inboxPaginationLimit
+import com.courier.android.modules.isUserSignedIn
+import com.courier.android.modules.openMessage
+import com.courier.android.modules.readAllInboxMessages
+import com.courier.android.modules.readMessage
+import com.courier.android.modules.refreshInbox
+import com.courier.android.modules.setToken
+import com.courier.android.modules.signIn
+import com.courier.android.modules.signOut
+import com.courier.android.modules.tenantId
+import com.courier.android.modules.tokens
+import com.courier.android.modules.unreadMessage
+import com.courier.android.modules.userId
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import java.util.UUID
+
+
+class CourierSharedModule(reactContext: ReactApplicationContext): ReactNativeModule(tag = "Shared Instance Error", name = "CourierSharedModule", reactContext = reactContext) {
+
+  // Listeners
+  private var authenticationListeners = mutableMapOf<String, CourierAuthenticationListener>()
+  private var inboxListeners = mutableMapOf<String, CourierInboxListener>()
+
+  init {
+
+    // User Agent is used to ensure we know the SDK
+    // the requests come from
+    Courier.USER_AGENT = CourierAgent.REACT_NATIVE_ANDROID
+
+  }
+
+  @ReactMethod
+  fun addListener(type: String?) {
+    // Keep: Required for RN built in Event Emitter Calls.
+  }
+
+  @ReactMethod
+  fun removeListeners(type: Int?) {
+    // Keep: Required for RN built in Event Emitter Calls.
+  }
+
+  // Client
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun getClient(): String? {
+    val options = Courier.shared.client?.options ?: return null
+    return options.toJson()
+  }
+
+  // Authentication
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun getUserId(): String? {
+    return Courier.shared.userId
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun getTenantId(): String? {
+    return Courier.shared.tenantId
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun getIsUserSignedIn(): String {
+    return Courier.shared.isUserSignedIn.toString()
+  }
+
+  @ReactMethod
+  fun signIn(accessToken: String, clientKey: String?, userId: String, tenantId: String?, showLogs: Boolean, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+    Courier.shared.signIn(
+      userId = userId,
+      tenantId = tenantId,
+      accessToken = accessToken,
+      clientKey = clientKey,
+      showLogs = showLogs
+    )
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun signOut(promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+    Courier.shared.signOut()
+    promise.resolve(null)
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun addAuthenticationListener(listenerId: String): String {
+
+    // Create the listener
+    val listener = Courier.shared.addAuthenticationListener { userId ->
+      reactApplicationContext.sendEvent(
+        eventName = listenerId,
+        value = userId
+      )
+    }
+
+    // Add the listener to the map
+    authenticationListeners[listenerId] = listener
+
+    return listenerId
+
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun removeAuthenticationListener(listenerId: String): String {
+
+    val listener = authenticationListeners[listenerId]
+
+    // Disable the listener
+    listener?.remove()
+
+    // Remove the id from the map
+    authenticationListeners.remove(listenerId)
+
+    return listenerId
+
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun removeAllAuthenticationListeners(): String? {
+    authenticationListeners.values.forEach { it.remove() }
+    authenticationListeners.clear()
+    return null
+  }
+
+  // Push
+
+  @ReactMethod
+  fun getAllTokens(promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+    val tokens = Courier.shared.tokens
+    val resultMap = Arguments.createMap()
+    tokens.forEach { (key, value) ->
+      resultMap.putString(key, value)
+    }
+    promise.resolve(resultMap)
+  }
+
+  @ReactMethod
+  fun getToken(provider: String, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+    val token = Courier.shared.getToken(provider)
+    promise.resolve(token)
+  }
+
+  @ReactMethod
+  fun setToken(provider: String, token: String, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+    try {
+      Courier.shared.setToken(provider, token)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+  }
+
+  // Inbox
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun getInboxPaginationLimit(): String {
+    return Courier.shared.inboxPaginationLimit.toString()
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun setInboxPaginationLimit(limit: Double): String {
+    Courier.shared.inboxPaginationLimit = limit.toInt()
+    return Courier.shared.inboxPaginationLimit.toString()
+  }
+
+  @ReactMethod
+  fun openMessage(messageId: String, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+    try {
+      Courier.shared.openMessage(messageId)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+  }
+
+  @ReactMethod
+  fun archiveMessage(messageId: String, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+    try {
+      Courier.shared.archiveMessage(messageId)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+  }
+
+  @ReactMethod
+  fun clickMessage(messageId: String, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+    try {
+      Courier.shared.clickMessage(messageId)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+  }
+
+  @ReactMethod
+  fun readMessage(messageId: String, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+    try {
+      Courier.shared.readMessage(messageId)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+  }
+
+  @ReactMethod
+  fun unreadMessage(messageId: String, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+    try {
+      Courier.shared.unreadMessage(messageId)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+  }
+
+  @ReactMethod
+  fun readAllInboxMessages(promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+    try {
+      Courier.shared.readAllInboxMessages()
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun addInboxListener(loadingId: String, errorId: String, messagesId: String): String {
+
+    val listener = Courier.shared.addInboxListener(
+      onInitialLoad = {
+
+        reactApplicationContext.sendEvent(
+          eventName = loadingId,
+          value = null
+        )
+
+      },
+      onError = { e ->
+
+        reactApplicationContext.sendEvent(
+          eventName = errorId,
+          value = e.message ?: "Courier Inbox Error"
+        )
+
+      },
+      onMessagesChanged = { messages: List<InboxMessage>, unreadMessageCount: Int, totalMessageCount: Int, canPaginate: Boolean ->
+
+        val json = Arguments.createMap()
+        json.putArray("messages", messages.toList().map { it.toJson() }.toWritableArray())
+        json.putInt("unreadMessageCount", unreadMessageCount)
+        json.putInt("totalMessageCount", totalMessageCount)
+        json.putBoolean("canPaginate", canPaginate)
+
+        reactApplicationContext.sendEvent(
+          eventName = messagesId,
+          value = json
+        )
+
+      }
+    )
+
+    // Add listener
+    val id = UUID.randomUUID().toString()
+    inboxListeners[id] = listener
+
+    return id
+
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun removeInboxListener(listenerId: String): String {
+    val listener = inboxListeners[listenerId]
+    listener?.remove()
+    inboxListeners.remove(listenerId)
+    return listenerId
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun removeAllInboxListeners(): String? {
+    inboxListeners.values.forEach { it.remove() }
+    inboxListeners.clear()
+    return null
+  }
+
+  @ReactMethod
+  fun refreshInbox(promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+    Courier.shared.refreshInbox()
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun fetchNextPageOfMessages(promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+    try {
+      val messages = Courier.shared.fetchNextInboxPage()
+      promise.resolve(messages.map { it.toJson() }.toWritableArray())
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+  }
+
+}

package/android/src/main/java/com/courierreactnative/CourierSystemModule.kt

@@ -0,0 +1,91 @@
+package com.courierreactnative
+
+import android.content.Intent
+import android.provider.Settings
+import com.courier.android.Courier
+import com.courier.android.modules.isPushPermissionGranted
+import com.courier.android.modules.requestNotificationPermission
+import com.courier.android.utils.error
+import com.courier.android.utils.pushNotification
+import com.courier.android.utils.trackPushNotificationClick
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.google.firebase.messaging.RemoteMessage
+import org.json.JSONObject
+
+class CourierSystemModule(reactContext: ReactApplicationContext): ReactNativeModule(tag = "System Error", name = "CourierSystemModule", reactContext = reactContext) {
+
+  @ReactMethod
+  fun addListener(type: String?) {
+    // Keep: Required for RN built in Event Emitter Calls.
+  }
+
+  @ReactMethod
+  fun removeListeners(type: Int?) {
+    // Keep: Required for RN built in Event Emitter Calls.
+  }
+
+  @ReactMethod
+  fun registerPushNotificationClickedOnKilledState() {
+    reactActivity?.let { activity ->
+      checkIntentForPushNotificationClick(activity.intent)
+    }
+  }
+
+  private fun checkIntentForPushNotificationClick(intent: Intent?) {
+    intent?.trackPushNotificationClick { message ->
+      postPushNotificationClicked(message)
+    }
+  }
+
+  private fun postPushNotificationClicked(message: RemoteMessage) {
+    reactApplicationContext.sendEvent(
+      eventName = CourierEvents.Push.CLICKED_EVENT,
+      value = JSONObject(message.pushNotification).toString()
+    )
+  }
+
+  @ReactMethod
+  fun requestNotificationPermission(promise: Promise) {
+
+    reactActivity?.let { activity ->
+      Courier.shared.requestNotificationPermission(activity)
+    }
+
+    promise.resolve("unknown")
+
+  }
+
+  @ReactMethod
+  fun getNotificationPermissionStatus(promise: Promise) {
+
+    reactActivity?.let { context ->
+
+      val isGranted = Courier.shared.isPushPermissionGranted(context)
+      val status = if (isGranted) "authorized" else "denied"
+      promise.resolve(status)
+      return
+
+    }
+
+    promise.resolve("unknown")
+
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun openSettingsForApp(): String? {
+    // TODO: Move this to the native package in the future
+    val context = reactApplicationContext
+    try {
+      val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
+      intent.data = android.net.Uri.parse("package:" + context.packageName)
+      intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+      context.startActivity(intent)
+    } catch (e: Exception) {
+      Courier.shared.client?.error(e.toString())
+    }
+    return null
+  }
+
+}

package/android/src/main/java/com/courierreactnative/ReactNativeModule.kt

@@ -0,0 +1,36 @@
+package com.courierreactnative
+
+import com.courier.android.Courier
+import com.courier.android.models.CourierAgent
+import com.facebook.react.ReactActivity
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+
+abstract class ReactNativeModule(val tag: String, private val name: String, reactContext: ReactApplicationContext): ReactContextBaseJavaModule(reactContext)  {
+
+  override fun getName() = name
+
+  val reactActivity: ReactActivity? get() = currentActivity as? ReactActivity
+
+  init {
+
+    // User Agent is used to ensure we know the SDK
+    // the requests come from
+    Courier.USER_AGENT = CourierAgent.REACT_NATIVE_ANDROID
+
+  }
+
+  internal fun Promise.rejectMissingContext() {
+    reject("Missing Context", tag, null)
+  }
+
+  internal fun Promise.rejectMissingClient() {
+    reject("Missing Client", tag, null)
+  }
+
+  internal fun Promise.apiError(throwable: Throwable) {
+    reject(throwable.message, tag, throwable)
+  }
+
+}

package/android/src/main/java/com/courierreactnative/{Extensions.kt → Utils.kt}

@@ -16,6 +16,7 @@ import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.WritableArray
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.google.gson.GsonBuilder
 
 internal fun ReactContext.sendEvent(eventName: String, value: Any?) {
   getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java).emit(eventName, value)
@@ -108,12 +109,7 @@ internal fun InboxMessage.toWritableMap(): WritableMap {
   map.putBoolean("archived", isArchived)
 
   val trackingIds = Arguments.createMap()
-  trackingIds.putString("archiveTrackingId", archiveTrackingId)
-  trackingIds.putString("openTrackingId", openTrackingId)
   trackingIds.putString("clickTrackingId", clickTrackingId)
-  trackingIds.putString("deliverTrackingId", deliverTrackingId)
-  trackingIds.putString("unreadTrackingId", unreadTrackingId)
-  trackingIds.putString("readTrackingId", readTrackingId)
 
   map.putMap("trackingIds", trackingIds)
 
@@ -218,3 +214,7 @@ internal fun ReadableMap.toInfoViewStyle(context: Context): CourierStyles.InfoVi
   )
 
 }
+
+internal fun Any.toJson(): String {
+  return GsonBuilder().setPrettyPrinting().create().toJson(this)
+}

package/courier-react-native.podspec

@@ -17,7 +17,7 @@ Pod::Spec.new do |s|
   s.source_files = "ios/**/*.{h,m,mm,swift}"
   
   # Courier Core Dependency
-  s.dependency "Courier_iOS", "3.5.0"
+  s.dependency "Courier_iOS", "4.3.2"
 
   # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
   # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.