@trycourier/courier-react-native 3.2.2 → 4.1.0

package/README.md

@@ -1,11 +1,9 @@
-<img width="1040" alt="banner-react-native" src="https://github.com/trycourier/courier-react-native/assets/6370613/2970316d-fdb2-4491-8578-cf4aec1bcfe6">
+<img width="1040" alt="banner-react-native" src="https://github.com/user-attachments/assets/c38f52d8-792f-4b51-a423-f1c5dd9f996b">
 
 &emsp;
 
 # Requirements & Support
 
-&emsp;
-
 <table>
     <thead>
         <tr>
@@ -199,6 +197,19 @@ These are all the available features of the SDK.
                 Allow users to update which types of notifications they would like to receive.
             </td>
         </tr>
+        <tr width="600px">
+            <td align="center">
+                5
+            </td>
+            <td align="left">
+                <a href="https://github.com/trycourier/courier-react-native/blob/master/Docs/Client.md">
+                    <code>CourierClient</code>
+                </a>
+            </td>
+            <td align="left">
+                The base level API wrapper around the Courier endpoints. Useful if you have a highly customized user experience or codebase requirements.
+            </td>
+        </tr>
     </tbody>
 </table>
 

package/android/build.gradle

@@ -100,8 +100,11 @@ dependencies {
   implementation "com.facebook.react:react-native:+"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 
+  // For converting to json
+  implementation 'com.google.code.gson:gson:2.11.0'
+
   // Courier Core SDK
-  api 'com.github.trycourier:courier-android:3.4.1'
+  api 'com.github.trycourier:courier-android:4.4.1'
   api 'androidx.recyclerview:recyclerview:1.3.2'
 
 }

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

@@ -0,0 +1,441 @@
+package com.courierreactnative
+
+import com.courier.android.client.CourierClient
+import com.courier.android.models.CourierDevice
+import com.courier.android.models.CourierPreferenceChannel
+import com.courier.android.models.CourierPreferenceStatus
+import com.courier.android.models.CourierTrackingEvent
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import java.util.UUID
+
+class CourierClientModule(reactContext: ReactApplicationContext): ReactNativeModule(tag = "Client Error", name = "CourierClientModule", reactContext = reactContext) {
+
+  private var clients: MutableMap<String, CourierClient> = mutableMapOf()
+
+  @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(isBlockingSynchronousMethod = true)
+  fun addClient(options: ReadableMap): String {
+
+    val userId = options.getString("userId")
+    val showLogs = if (options.hasKey("showLogs")) options.getBoolean("showLogs") else null
+
+    if (userId == null || showLogs == null) {
+      return "invalid"
+    }
+
+    val client = CourierClient(
+      jwt = options.getString("jwt"),
+      clientKey = options.getString("clientKey"),
+      userId = userId,
+      connectionId = options.getString("connectionId"),
+      tenantId = options.getString("tenantId"),
+      showLogs = showLogs
+    )
+
+    val uuid = UUID.randomUUID().toString()
+    clients[uuid] = client
+
+    return uuid
+
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun removeClient(clientId: String): String {
+    clients.remove(clientId)
+    return clientId
+  }
+
+  // Tokens
+
+  @ReactMethod
+  fun putUserToken(clientId: String, token: String, provider: String, device: ReadableMap?, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+
+    val client = clients[clientId]
+    if (client == null) {
+      promise.rejectMissingClient()
+      return@launch
+    }
+
+    if (reactActivity == null) {
+      promise.rejectMissingContext()
+      return@launch
+    }
+
+    val courierDevice = device?.let {
+      return@let CourierDevice(
+        appId = it.getString("appId"),
+        adId = it.getString("adId"),
+        deviceId = it.getString("deviceId"),
+        platform = it.getString("platform"),
+        manufacturer = it.getString("manufacturer"),
+        model = it.getString("model")
+      )
+    }
+
+    try {
+      client.tokens.putUserToken(
+        token = token,
+        provider = provider,
+        device = courierDevice ?: CourierDevice.current(reactActivity!!)
+      )
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+
+  }
+
+  @ReactMethod
+  fun deleteUserToken(clientId: String, token: String, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+
+    val client = clients[clientId]
+    if (client == null) {
+      promise.rejectMissingClient()
+      return@launch
+    }
+
+    try {
+      client.tokens.deleteUserToken(
+        token = token,
+      )
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+
+  }
+
+  // Brands
+
+  @ReactMethod
+  fun getBrand(clientId: String, brandId: String, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+
+    val client = clients[clientId]
+    if (client == null) {
+      promise.rejectMissingClient()
+      return@launch
+    }
+
+    try {
+      val brand = client.brands.getBrand(
+        brandId = brandId
+      )
+      val json = brand.toJson()
+      promise.resolve(json)
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+
+  }
+
+  // Inbox
+
+  @ReactMethod
+  fun getMessages(clientId: String, paginationLimit: Int, startCursor: String?, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+
+    val client = clients[clientId]
+    if (client == null) {
+      promise.rejectMissingClient()
+      return@launch
+    }
+
+    try {
+      val res = client.inbox.getMessages(
+        paginationLimit = paginationLimit,
+        startCursor = startCursor,
+      )
+      val json = res.toJson()
+      promise.resolve(json)
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+
+  }
+
+  @ReactMethod
+  fun getArchivedMessages(clientId: String, paginationLimit: Int, startCursor: String?, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+
+    val client = clients[clientId]
+    if (client == null) {
+      promise.rejectMissingClient()
+      return@launch
+    }
+
+    try {
+      val res = client.inbox.getArchivedMessages(
+        paginationLimit = paginationLimit,
+        startCursor = startCursor,
+      )
+      val json = res.toJson()
+      promise.resolve(json)
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+
+  }
+
+  @ReactMethod
+  fun getMessageById(clientId: String, messageId: String, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+
+    val client = clients[clientId]
+    if (client == null) {
+      promise.rejectMissingClient()
+      return@launch
+    }
+
+    try {
+      val res = client.inbox.getMessage(
+        messageId = messageId,
+      )
+      val json = res.toJson()
+      promise.resolve(json)
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+
+  }
+
+  @ReactMethod
+  fun getUnreadMessageCount(clientId: String, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+
+    val client = clients[clientId]
+    if (client == null) {
+      promise.rejectMissingClient()
+      return@launch
+    }
+
+    try {
+      val count = client.inbox.getUnreadMessageCount()
+      promise.resolve(count)
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+
+  }
+
+  @ReactMethod
+  fun openMessage(clientId: String, messageId: String, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+
+    val client = clients[clientId]
+    if (client == null) {
+      promise.rejectMissingClient()
+      return@launch
+    }
+
+    try {
+      client.inbox.open(
+        messageId = messageId,
+      )
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+
+  }
+
+  @ReactMethod
+  fun readMessage(clientId: String, messageId: String, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+
+    val client = clients[clientId]
+    if (client == null) {
+      promise.rejectMissingClient()
+      return@launch
+    }
+
+    try {
+      client.inbox.read(
+        messageId = messageId,
+      )
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+
+  }
+
+  @ReactMethod
+  fun unreadMessage(clientId: String, messageId: String, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+
+    val client = clients[clientId]
+    if (client == null) {
+      promise.rejectMissingClient()
+      return@launch
+    }
+
+    try {
+      client.inbox.unread(
+        messageId = messageId,
+      )
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+
+  }
+
+  @ReactMethod
+  fun clickMessage(clientId: String, messageId: String, trackingId: String, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+
+    val client = clients[clientId]
+    if (client == null) {
+      promise.rejectMissingClient()
+      return@launch
+    }
+
+    try {
+      client.inbox.click(
+        messageId = messageId,
+        trackingId = trackingId,
+      )
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+
+  }
+
+  @ReactMethod
+  fun archiveMessage(clientId: String, messageId: String, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+
+    val client = clients[clientId]
+    if (client == null) {
+      promise.rejectMissingClient()
+      return@launch
+    }
+
+    try {
+      client.inbox.archive(
+        messageId = messageId,
+      )
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+
+  }
+
+  @ReactMethod
+  fun readAllMessages(clientId: String, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+
+    val client = clients[clientId]
+    if (client == null) {
+      promise.rejectMissingClient()
+      return@launch
+    }
+
+    try {
+      client.inbox.readAll()
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+
+  }
+
+  // Preferences
+
+  @ReactMethod
+  fun getUserPreferences(clientId: String, paginationCursor: String?, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+
+    val client = clients[clientId]
+    if (client == null) {
+      promise.rejectMissingClient()
+      return@launch
+    }
+
+    try {
+      val res = client.preferences.getUserPreferences(
+        paginationCursor = paginationCursor
+      )
+      val json = res.toJson()
+      promise.resolve(json)
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+
+  }
+
+  @ReactMethod
+  fun getUserPreferenceTopic(clientId: String, topicId: String, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+
+    val client = clients[clientId]
+    if (client == null) {
+      promise.rejectMissingClient()
+      return@launch
+    }
+
+    try {
+      val res = client.preferences.getUserPreferenceTopic(
+        topicId = topicId
+      )
+      val json = res.toJson()
+      promise.resolve(json)
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+
+  }
+
+  @ReactMethod
+  fun putUserPreferenceTopic(clientId: String, topicId: String, status: String, hasCustomRouting: Boolean, customRouting: ReadableArray, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+
+    val client = clients[clientId]
+    if (client == null) {
+      promise.rejectMissingClient()
+      return@launch
+    }
+
+    try {
+      client.preferences.putUserPreferenceTopic(
+        topicId = topicId,
+        status = CourierPreferenceStatus.fromString(status),
+        hasCustomRouting = hasCustomRouting,
+        customRouting = customRouting.toArrayList().map { CourierPreferenceChannel.fromString(it as String) },
+      )
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+
+  }
+
+  // Tracking
+
+  @ReactMethod
+  fun postTrackingUrl(clientId: String, url: String, event: String, promise: Promise) = CoroutineScope(Dispatchers.Main).launch {
+
+    val client = clients[clientId]
+    if (client == null) {
+      promise.rejectMissingClient()
+      return@launch
+    }
+
+    try {
+      client.tracking.postTrackingUrl(
+        url = url,
+        event = CourierTrackingEvent.valueOf(event.uppercase()),
+      )
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.apiError(e)
+    }
+
+  }
+
+}

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

@@ -51,7 +51,7 @@ class CourierInboxViewManager : SimpleViewManager<CourierInbox>() {
 
     view.setOnClickMessageListener { message, index ->
       val map = Arguments.createMap()
-      map.putMap("message", message.toWritableMap())
+      map.putString("message", message.toJson())
       map.putInt("index", index)
       themedReactContext?.sendEvent(ON_CLICK_MESSAGE_AT_INDEX, map)
     }
@@ -64,7 +64,7 @@ class CourierInboxViewManager : SimpleViewManager<CourierInbox>() {
     view.setOnClickActionListener { action, message, index ->
       val map = Arguments.createMap()
       map.putMap("action", action.toWritableMap())
-      map.putMap("message", message.toWritableMap())
+      map.putString("message", message.toJson())
       map.putInt("index", index)
       themedReactContext?.sendEvent(ON_CLICK_ACTION_AT_INDEX, map)
     }

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

@@ -3,6 +3,7 @@ package com.courierreactnative
 import android.content.Intent
 import android.os.Bundle
 import com.courier.android.Courier
+import com.courier.android.models.CourierAgent
 import com.courier.android.utils.getLastDeliveredMessage
 import com.courier.android.utils.pushNotification
 import com.courier.android.utils.trackPushNotificationClick
@@ -18,6 +19,9 @@ open class CourierReactNativeActivity : ReactActivity() {
     // Used to ensure shared preferences works properly
     Courier.initialize(this)
 
+    // Update the user agent
+    Courier.agent = CourierAgent.ReactNativeAndroid(version = "4.1.0")
+
     super.onCreate(savedInstanceState)
 
     // See if there is a pending click event

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

@@ -5,15 +5,21 @@ import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ViewManager
 
-
 class CourierReactNativePackage : ReactPackage {
 
   override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-    return listOf(CourierReactNativeModule(reactContext))
+    return listOf(
+      CourierClientModule(reactContext),
+      CourierSharedModule(reactContext),
+      CourierSystemModule(reactContext),
+    )
   }
 
   override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-    return listOf(CourierInboxViewManager(), CourierPreferencesViewManager())
+    return listOf(
+      CourierInboxViewManager(),
+      CourierPreferencesViewManager(),
+    )
   }
 
 }