@trycourier/courier-react-native 2.0.0-beta4 → 2.0.0-beta6

package/android/build.gradle

@@ -101,7 +101,7 @@ dependencies {
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 
   // Courier Core SDK
-  api 'com.github.trycourier:courier-android:2.0.2'
+  api 'com.github.trycourier:courier-android:2.0.32'
 
 }
 

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

@@ -0,0 +1,28 @@
+package com.courierreactnative
+
+internal class CourierEvents {
+
+  companion object {
+    const val COURIER_ERROR_TAG = "Courier Android SDK Error"
+  }
+
+  object Log {
+    const val DEBUG_LOG = "courierDebugEvent"
+  }
+
+  object Auth {
+    const val USER_CHANGED = "courierAuthUserChanged"
+  }
+
+  object Push {
+    const val CLICKED_EVENT = "pushNotificationClicked"
+    const val DELIVERED_EVENT = "pushNotificationDelivered"
+  }
+
+  object Inbox {
+    const val INITIAL_LOADING = "inboxInitialLoad"
+    const val ERROR = "inboxError"
+    const val MESSAGES_CHANGED = "inboxMessagesChanged"
+  }
+
+}

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

@@ -3,6 +3,9 @@ package com.courierreactnative
 import android.content.Intent
 import android.os.Bundle
 import com.courier.android.Courier
+import com.courier.android.utils.getLastDeliveredMessage
+import com.courier.android.utils.pushNotification
+import com.courier.android.utils.trackPushNotificationClick
 //import com.courier.android.pushNotification
 //import com.courier.android.trackPushNotificationClick
 import com.facebook.react.ReactActivity
@@ -12,11 +15,6 @@ import org.json.JSONObject
 
 open class CourierReactNativeActivity : ReactActivity() {
 
-  companion object {
-    private const val PUSH_CLICKED_EVENT = "pushNotificationClicked"
-    private const val PUSH_DELIVERED_EVENT = "pushNotificationDelivered"
-  }
-
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
 
@@ -28,16 +26,10 @@ open class CourierReactNativeActivity : ReactActivity() {
     checkIntentForPushNotificationClick(intent)
 
     // Handle delivered messages on the main thread
-//    Courier.getLastDeliveredMessage { message ->
-//      postPushNotificationDelivered(message)
-//    }
-
-  }
-
-  private fun sendEvent(eventName: String, params: String) {
-    reactInstanceManager.currentReactContext?.let { reactContext ->
-      reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)?.emit(eventName, params)
+    Courier.shared.getLastDeliveredMessage { message ->
+      postPushNotificationDelivered(message)
     }
+
   }
 
   override fun onNewIntent(intent: Intent?) {
@@ -46,17 +38,23 @@ open class CourierReactNativeActivity : ReactActivity() {
   }
 
   private fun checkIntentForPushNotificationClick(intent: Intent?) {
-//    intent?.trackPushNotificationClick { message ->
-//      postPushNotificationClicked(message)
-//    }
+    intent?.trackPushNotificationClick { message ->
+      postPushNotificationClicked(message)
+    }
   }
 
   private fun postPushNotificationDelivered(message: RemoteMessage) {
-//    sendEvent(PUSH_DELIVERED_EVENT, JSONObject(message.pushNotification).toString())
+    reactInstanceManager.currentReactContext?.sendEvent(
+      eventName = CourierEvents.Push.DELIVERED_EVENT,
+      value = JSONObject(message.pushNotification).toString()
+    )
   }
 
   private fun postPushNotificationClicked(message: RemoteMessage) {
-//    sendEvent(PUSH_CLICKED_EVENT, JSONObject(message.pushNotification).toString())
+    reactInstanceManager.currentReactContext?.sendEvent(
+      eventName = CourierEvents.Push.CLICKED_EVENT,
+      value = JSONObject(message.pushNotification).toString()
+    )
   }
 
 }

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

@@ -1,52 +1,99 @@
 package com.courierreactnative
 
 import android.content.Intent
-import com.courier.android.*
-import com.courier.android.models.CourierAgent
-import com.courier.android.models.CourierProvider
+import com.courier.android.Courier
+import com.courier.android.models.*
 import com.courier.android.modules.*
 import com.courier.android.utils.pushNotification
 import com.courier.android.utils.trackPushNotificationClick
 import com.facebook.react.ReactActivity
 import com.facebook.react.bridge.*
-import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.google.firebase.messaging.RemoteMessage
 import org.json.JSONObject
+import java.util.*
 
 
 class CourierReactNativeModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
 
   override fun getName() = "CourierReactNativeModule"
+  private val reactActivity: ReactActivity? get() = currentActivity as? ReactActivity
 
-  companion object {
-    private const val COURIER_ERROR_TAG = "Courier Android SDK Error"
-    private const val COURIER_PUSH_NOTIFICATION_DEBUG_LOG_EVENT = "courierDebugEvent"
-    private const val COURIER_PUSH_NOTIFICATION_CLICKED_EVENT = "pushNotificationClicked"
-  }
+  private val authListeners = mutableMapOf<String, CourierAuthenticationListener>()
+  private val 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
 
-//    Courier.shared.logListener = { data ->
-//      sendEvent(reactContext, COURIER_PUSH_NOTIFICATION_DEBUG_LOG_EVENT, data)
-//    }
+    // Attach the log listener
+    Courier.shared.logListener = { data ->
+      reactContext.sendEvent(CourierEvents.Log.DEBUG_LOG, data)
+    }
 
   }
 
-  private val reactActivity: ReactActivity? get() = currentActivity as? ReactActivity
+  @ReactMethod
+  fun addListener(type: String?) {
+    // Keep: Required for RN built in Event Emitter Calls.
+  }
 
   @ReactMethod
-  fun setDebugMode(isDebugging: Boolean, promise: Promise) {
-    try {
-      Courier.shared.isDebugging = isDebugging
-      promise.resolve(Courier.shared.isDebugging)
-    } catch (e: Exception) {
-      promise.reject(COURIER_ERROR_TAG, e)
+  fun removeListeners(type: Int?) {
+    // Keep: Required for RN built in Event Emitter Calls.
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun setDebugMode(isDebugging: Boolean): Boolean {
+    Courier.shared.isDebugging = isDebugging
+    return Courier.shared.isDebugging
+  }
+
+  @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) {
+//    try {
+//      reactActivity?.requestNotificationPermission { isGranted ->
+////        val status = if (isGranted) NotificationPermissionStatus.AUTHORIZED else NotificationPermissionStatus.DENIED
+////        promise.resolve(status.value)
+//      }
+//    } catch (e: Exception) {
+//      promise.reject(CourierEvents.COURIER_ERROR_TAG, e)
+//    }
+  }
+
+  @ReactMethod
+  fun getNotificationPermissionStatus(promise: Promise) {
+//    try {
+//      reactActivity?.getNotificationPermissionStatus { isGranted ->
+//        val status = if (isGranted) NotificationPermissionStatus.AUTHORIZED else NotificationPermissionStatus.DENIED
+//        promise.resolve(status.value)
+//      }
+//    } catch (e: Exception) {
+//      promise.reject(COURIER_ERROR_TAG, e)
+//    }
+  }
+
   @ReactMethod
   fun signIn(accessToken: String, clientKey: String?, userId: String, promise: Promise) {
     Courier.shared.signIn(
@@ -57,160 +104,184 @@ class CourierReactNativeModule(reactContext: ReactApplicationContext) : ReactCon
         promise.resolve(null)
       },
       onFailure = { e ->
-        promise.reject(COURIER_ERROR_TAG, e)
+        promise.reject(CourierEvents.COURIER_ERROR_TAG, e)
       }
     )
   }
 
-//  @ReactMethod
-//  fun getFcmToken(promise: Promise) {
-//    Courier.shared.getFCMToken(
-//      onSuccess = { token ->
-//        promise.resolve(token)
-//      },
-//      onFailure = { e ->
-//        promise.reject(COURIER_ERROR_TAG, e)
-//      }
-//    )
-//  }
-//
-//  @ReactMethod
-//  fun setFcmToken(token: String, promise: Promise) {
-//
-//    token.let { fcmToken ->
-//
-//      Courier.shared.setFCMToken(
-//        fcmToken,
-//        onSuccess = {
-//          promise.resolve(null)
-//        },
-//        onFailure = { e ->
-//          promise.reject(COURIER_ERROR_TAG, e)
-//        }
-//      )
-//
-//    }
-//
-//  }
-//
   @ReactMethod
-  fun getUserId(promise: Promise) {
-    try {
-      val userId = Courier.shared.userId
-      promise.resolve(userId)
-    } catch (e: Exception) {
-      promise.reject(COURIER_ERROR_TAG, e)
+  fun signOut(promise: Promise) {
+    Courier.shared.signOut(
+      onSuccess = {
+        promise.resolve(null)
+      },
+      onFailure = { e ->
+        promise.reject(CourierEvents.COURIER_ERROR_TAG, e)
+      }
+    )
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun getUserId(): String? {
+    return Courier.shared.userId
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun addAuthenticationListener(): String {
+
+    val listener = Courier.shared.addAuthenticationListener { userId ->
+      reactApplicationContext.sendEvent(
+        eventName = CourierEvents.Auth.USER_CHANGED,
+        value = userId
+      )
     }
+
+    val id = UUID.randomUUID().toString()
+    authListeners[id] = listener
+
+    return id
+
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun removeAuthenticationListener(listenerId: String): String {
+
+    // Remove the listener
+    val listener = authListeners[listenerId]
+    listener?.remove()
+
+    // Remove from map
+    authListeners.remove(listenerId)
+
+    return listenerId
+
   }
 
   @ReactMethod
-  fun signOut(promise: Promise) {
-    Courier.shared.signOut(
+  fun setFcmToken(token: String, promise: Promise) {
+    Courier.shared.setFCMToken(
+      token = token,
       onSuccess = {
         promise.resolve(null)
       },
       onFailure = { e ->
-        promise.reject(COURIER_ERROR_TAG, e)
+        promise.reject(CourierEvents.COURIER_ERROR_TAG, e)
       }
     )
   }
-//
-//  @ReactMethod
-//  fun sendPush(
-//    authKey: String,
-//    userId: String,
-//    title: String,
-//    body: String,
-//    providers: ReadableArray,
-//    promise: Promise
-//  ) {
-////    Courier.shared.sendPush(
-////      authKey = authKey,
-////      userId = userId,
-////      title = title,
-////      body = body,
-////      providers = providers.toCourierProviders(),
-////      onSuccess = { messageId ->
-////        promise.resolve(messageId)
-////      },
-////      onFailure = { e ->
-////        promise.reject(COURIER_ERROR_TAG, e)
-////      }
-////    )
-//  }
-//
-//  @ReactMethod
-//  fun requestNotificationPermission(promise: Promise) {
-////    try {
-////      reactActivity?.requestNotificationPermission { isGranted ->
-////        val status = if (isGranted) NotificationPermissionStatus.AUTHORIZED else NotificationPermissionStatus.DENIED
-////        promise.resolve(status.value)
-////      }
-////    } catch (e: Exception) {
-////      promise.reject(COURIER_ERROR_TAG, e)
-////    }
-//  }
-//
-//  @ReactMethod
-//  fun getNotificationPermissionStatus(promise: Promise) {
-////    try {
-////      reactActivity?.getNotificationPermissionStatus { isGranted ->
-////        val status = if (isGranted) NotificationPermissionStatus.AUTHORIZED else NotificationPermissionStatus.DENIED
-////        promise.resolve(status.value)
-////      }
-////    } catch (e: Exception) {
-////      promise.reject(COURIER_ERROR_TAG, e)
-////    }
-//  }
-//
-//  @ReactMethod
-//  fun registerPushNotificationClickedOnKilledState() {
-//    reactActivity?.let { activity ->
-//      checkIntentForPushNotificationClick(activity.intent)
-//    }
-//  }
-//
-//  private fun checkIntentForPushNotificationClick(intent: Intent?) {
-//    intent?.trackPushNotificationClick { message ->
-//      postPushNotificationClicked(message)
-//    }
-//  }
-//
-//  private fun postPushNotificationClicked(message: RemoteMessage) {
-//    sendEvent(
-//      reactApplicationContext,
-//      COURIER_PUSH_NOTIFICATION_CLICKED_EVENT,
-//      JSONObject(message.pushNotification).toString()
-//    )
-//  }
-//
-//
-//  private fun sendEvent(reactContext: ReactContext, eventName: String, params: String) {
-//    reactContext
-//      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-//      .emit(eventName, params)
-//  }
-//
-//  @ReactMethod
-//  fun addListener(eventName: String?) {
-//    // Empty
-//  }
-//
-//  @ReactMethod
-//  fun removeListeners(count: Int?) {
-//    // Empty
-//  }
-//
-//  private fun ReadableArray.toCourierProviders(): List<CourierProvider> {
-//    val providers: MutableList<CourierProvider> = mutableListOf()
-//    for (provider in toArrayList()) {
-//      CourierProvider.values().forEach {
-//        if (it.value == provider) {
-//          providers.add(it)
-//        }
-//      }
-//    }
-//    return providers
-//  }
+
+  @ReactMethod
+  fun getFcmToken(promise: Promise) {
+    Courier.shared.getFCMToken(
+      onSuccess = { token ->
+        promise.resolve(token)
+      },
+      onFailure = { e ->
+        promise.reject(CourierEvents.COURIER_ERROR_TAG, e)
+      }
+    )
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun readMessage(messageId: String): String {
+    Courier.shared.readMessage(messageId)
+    return messageId
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun unreadMessage(messageId: String): String {
+    Courier.shared.unreadMessage(messageId)
+    return messageId
+  }
+
+  @ReactMethod
+  fun readAllInboxMessages(promise: Promise) {
+    Courier.shared.readAllInboxMessages(
+      onSuccess = {
+        promise.resolve(null)
+      },
+      onFailure = { e ->
+        promise.reject(CourierEvents.COURIER_ERROR_TAG, e)
+      }
+    )
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun addInboxListener(): String {
+
+    val listener = Courier.shared.addInboxListener(
+      onInitialLoad = {
+        reactApplicationContext.sendEvent(
+          eventName = CourierEvents.Inbox.INITIAL_LOADING,
+          value = null
+        )
+      },
+      onError = { e ->
+        reactApplicationContext.sendEvent(
+          eventName = CourierEvents.Inbox.ERROR,
+          value = e.message ?: "Courier Inbox Error"
+        )
+      },
+      onMessagesChanged = { messages: List<InboxMessage>, unreadMessageCount: Int, totalMessageCount: Int, canPaginate: Boolean ->
+
+        val json = Arguments.createMap()
+        json.putArray("messages", messages.toWritableArray())
+        json.putInt("unreadMessageCount", unreadMessageCount)
+        json.putInt("totalMessageCount", totalMessageCount)
+        json.putBoolean("canPaginate", canPaginate)
+
+        reactApplicationContext.sendEvent(
+          eventName = CourierEvents.Inbox.MESSAGES_CHANGED,
+          value = json
+        )
+
+      }
+    )
+
+    val id = UUID.randomUUID().toString()
+    inboxListeners[id] = listener
+
+    return id
+
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun removeInboxListener(listenerId: String): String {
+
+    // Remove the listener
+    val listener = inboxListeners[listenerId]
+    listener?.remove()
+
+    // Remove from map
+    inboxListeners.remove(listenerId)
+
+    return listenerId
+
+  }
+
+  @ReactMethod
+  fun refreshInbox(promise: Promise) {
+    Courier.shared.refreshInbox {
+      promise.resolve(null)
+    }
+  }
+
+  @ReactMethod
+  fun fetchNextPageOfMessages(promise: Promise) {
+    Courier.shared.fetchNextPageOfMessages(
+      onSuccess = { messages ->
+        promise.resolve(messages.toWritableArray())
+      },
+      onFailure = { e ->
+        promise.reject(CourierEvents.COURIER_ERROR_TAG, e)
+      }
+    )
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun setInboxPaginationLimit(limit: Double): String {
+    Courier.shared.inboxPaginationLimit = limit.toInt()
+    return Courier.shared.inboxPaginationLimit.toString()
+  }
 
 }

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

@@ -0,0 +1,95 @@
+package com.courierreactnative
+
+import com.courier.android.models.InboxAction
+import com.courier.android.models.InboxMessage
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+internal fun ReactContext.sendEvent(eventName: String, value: Any?) {
+  getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java).emit(eventName, value)
+}
+
+@JvmName("toWritableArrayInboxMessage")
+internal fun List<InboxMessage>.toWritableArray(): WritableArray {
+  
+  val messagesArray = Arguments.createArray()
+
+  forEach { message ->
+    messagesArray.pushMap(message.toWritableMap())
+  }
+
+  return messagesArray
+
+}
+
+internal fun InboxMessage.toWritableMap(): WritableMap {
+
+  val map = Arguments.createMap()
+  map.putString("messageId", messageId)
+  map.putString("title", title)
+  map.putString("body", body)
+  map.putString("preview", preview)
+  map.putString("created", created)
+
+  actions?.let { actionList ->
+    val actionsArray = Arguments.createArray()
+    actionList.forEach { action ->
+      actionsArray.pushMap(action.toWritableMap())
+    }
+    map.putArray("actions", actionsArray)
+  }
+
+  map.putMap("data", data.toWritableMap())
+  map.putBoolean("read", isRead)
+  map.putBoolean("opened", isOpened)
+  map.putBoolean("archived", isArchived)
+
+  return map
+
+}
+
+internal fun InboxAction.toWritableMap(): WritableMap {
+
+  val map = Arguments.createMap()
+  map.putString("content", content)
+  map.putString("href", href)
+  map.putMap("data", data.toWritableMap())
+
+  return map
+
+}
+
+internal fun Map<String, Any>?.toWritableMap(): WritableMap {
+  val map = Arguments.createMap()
+  this?.forEach { (key, value) ->
+    when (value) {
+      is String -> map.putString(key, value)
+      is Int -> map.putInt(key, value)
+      is Double -> map.putDouble(key, value)
+      is Boolean -> map.putBoolean(key, value)
+      is Map<*, *> -> map.putMap(key, (value as? Map<String, Any>).toWritableMap())
+      is List<*> -> map.putArray(key, (value as? List<Any>).toWritableArray())
+      else -> map.putNull(key)
+    }
+  }
+  return map
+}
+
+internal fun List<Any>?.toWritableArray(): WritableArray {
+  val array = Arguments.createArray()
+  this?.forEach { item ->
+    when (item) {
+      is String -> array.pushString(item)
+      is Int -> array.pushInt(item)
+      is Double -> array.pushDouble(item)
+      is Boolean -> array.pushBoolean(item)
+      is Map<*, *> -> array.pushMap((item as? Map<String, Any>).toWritableMap())
+      is List<*> -> array.pushArray((item as? List<Any>).toWritableArray())
+      else -> array.pushNull()
+    }
+  }
+  return array
+}

package/ios/CourierReactNativeModule.m

@@ -49,8 +49,9 @@ RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD(
   getApnsToken
 )
 
-RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD(
-  getFcmToken
+RCT_EXTERN_METHOD(
+  getFcmToken: (RCTPromiseResolveBlock)resolve
+  withRejecter: (RCTPromiseRejectBlock)reject
 )
 
 RCT_EXTERN_METHOD(
@@ -59,16 +60,12 @@ RCT_EXTERN_METHOD(
   withRejecter: (RCTPromiseRejectBlock)reject
 )
 
-RCT_EXTERN_METHOD(
+RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD(
   readMessage: (NSString*)messageId
-  withResolver: (RCTPromiseResolveBlock)resolve
-  withRejecter: (RCTPromiseRejectBlock)reject
 )
 
-RCT_EXTERN_METHOD(
+RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD(
   unreadMessage: (NSString*)messageId
-  withResolver: (RCTPromiseResolveBlock)resolve
-  withRejecter: (RCTPromiseRejectBlock)reject
 )
 
 RCT_EXTERN_METHOD(