react-native-rook-sdk 0.6.2 → 1.0.0-rc.0

package/android/src/main/java/com/rooksdk/RookSdkModule.kt

@@ -1,5 +1,7 @@
 package com.rooksdk
 
+import android.content.IntentFilter
+import androidx.core.content.ContextCompat
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
@@ -11,47 +13,72 @@ import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.rookmotion.rook.sdk.RookConfigurationManager
 import com.rookmotion.rook.sdk.RookDataSources
 import com.rookmotion.rook.sdk.RookEventManager
-import com.rookmotion.rook.sdk.RookHealthPermissionsManager
 import com.rookmotion.rook.sdk.RookHelpers
+import com.rookmotion.rook.sdk.RookPermissionsManager
 import com.rookmotion.rook.sdk.RookStepsManager
-import com.rookmotion.rook.sdk.RookStepsPermissions
 import com.rookmotion.rook.sdk.RookSummaryManager
 import com.rookmotion.rook.sdk.RookYesterdaySyncManager
-import com.rookmotion.rook.sdk.RookYesterdaySyncPermissions
+import com.rookmotion.rook.sdk.domain.enums.DataSourceType
+import com.rookmotion.rook.sdk.domain.enums.HealthConnectAvailability
 import com.rookmotion.rook.sdk.domain.environment.RookAndroidClass
 import com.rookmotion.rook.sdk.domain.environment.RookEnvironment
 import com.rookmotion.rook.sdk.domain.model.RookConfiguration
 import com.rookmotion.rook.sdk.domain.enums.HealthDataType
-import com.rookmotion.rook.sdk.domain.enums.SyncInstruction
+import com.rookmotion.rook.sdk.domain.enums.RequestPermissionsStatus
 import com.rookmotion.rook.sdk.domain.enums.SyncStatus
 import com.rookmotion.rook.sdk.domain.model.DataSource
 import com.rookmotion.rook.sdk.domain.model.SyncStatusWithData
+import com.rooksdk.broadcasts.AndroidPermissionsReceiverTransmitter
+import com.rooksdk.broadcasts.HealthConnectPermissionsReceiverTransmitter
+import com.rooksdk.utils.ReadableToWritable
+import com.rooksdk.utils.RookDateTime
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 
-class RookSdkModule(reactContext: ReactApplicationContext) :
-  ReactContextBaseJavaModule(reactContext) {
+/**
+ * The `RookSdkHealthConnectModule` class is a React Native module that interfaces
+ * with the Rook SDK for managing and syncing health data using Android's Health Connect.
+ * It provides methods for initializing the SDK, handling user configuration, syncing
+ * health data, and managing permissions.
+ *
+ * Main Responsibilities:
+ * - Initialize and configure the Rook SDK.
+ * - Manage user-related information such as user ID.
+ * - Sync health-related summaries and events (e.g., sleep, body metrics, physical activities).
+ * - Handle Health Connect permissions and check availability.
+ * - Transmit permission changes through Android and Health Connect.
+ * - Provide the ability to listen to permission changes using Android broadcast receivers.
+ * - Expose methods to JavaScript for requesting or syncing data.
+ *
+ * Key Components:
+ * - `RookConfigurationManager`: Manages configuration settings for the SDK.
+ * - `RookSummaryManager`: Handles syncing health data summaries (e.g., sleep, physical, body).
+ * - `RookEventManager`: Manages the synchronization of health-related events (e.g., physical activities, blood pressure, etc.).
+ * - `RookPermissionsManager`: Handles permission management and availability checks for Health Connect.
+ * - `RookStepsManager`: Manages steps data synchronization.
+ * - `CoroutineScope`: Used to launch asynchronous operations.
+ */
+class RookSdkModule(
+  reactContext: ReactApplicationContext,
+  private val rookConfigurationManager: RookConfigurationManager
+): ReactContextBaseJavaModule(reactContext) {
 
-  private val rookConfigurationManager = RookConfigurationManager(reactApplicationContext)
-  private val rookHealthPermissionsManager = RookHealthPermissionsManager(rookConfigurationManager)
-  private val rookSummaryManager = RookSummaryManager(rookConfigurationManager)
-  private val rookEventManager = RookEventManager(rookConfigurationManager)
   private var scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
   private var listenerCount = 0
 
-  private val rookSynManager: RookYesterdaySyncManager by lazy {
-    RookYesterdaySyncManager(reactApplicationContext)
-  }
-
   private val stepsScope: CoroutineScope by lazy {
     CoroutineScope(SupervisorJob() + Dispatchers.Main)
   }
 
-  private val rookStepsManager: RookStepsManager by lazy {
-    RookStepsManager(reactApplicationContext)
+  private val androidPermissionsReceiverTransmitter: AndroidPermissionsReceiverTransmitter by lazy {
+    AndroidPermissionsReceiverTransmitter()
+  }
+
+  private val hcPermissionsReceiverTransmitter: HealthConnectPermissionsReceiverTransmitter by lazy {
+    HealthConnectPermissionsReceiverTransmitter()
   }
 
   override fun getName(): String {
@@ -60,6 +87,25 @@ class RookSdkModule(reactContext: ReactApplicationContext) :
 
   @ReactMethod
   fun addListener(eventName: String) {
+    if (listenerCount == 0) {
+      androidPermissionsReceiverTransmitter.setReactApplicationContext(reactApplicationContext)
+      hcPermissionsReceiverTransmitter.setReactApplicationContext(reactApplicationContext)
+
+      ContextCompat.registerReceiver(
+        reactApplicationContext,
+        androidPermissionsReceiverTransmitter,
+        IntentFilter(RookPermissionsManager.ACTION_ANDROID_PERMISSIONS),
+        ContextCompat.RECEIVER_EXPORTED
+      )
+
+      ContextCompat.registerReceiver(
+        reactApplicationContext,
+        hcPermissionsReceiverTransmitter,
+        IntentFilter(RookPermissionsManager.ACTION_HEALTH_CONNECT_PERMISSIONS),
+        ContextCompat.RECEIVER_EXPORTED,
+      )
+    }
+
     listenerCount += 1
   }
 
@@ -68,115 +114,28 @@ class RookSdkModule(reactContext: ReactApplicationContext) :
     listenerCount -= count
     if (listenerCount == 0) {
       stepsScope.cancel()
-    }
-  }
-
-  private fun determineSummaryValue(summaryString: String): HealthDataType {
-    return when (summaryString) {
-      "SLEEP" -> HealthDataType.SLEEP_SUMMARY
-      "PHYSICAL" -> HealthDataType.PHYSICAL_SUMMARY
-      "BODY" -> HealthDataType.BODY_SUMMARY
-      "BLOOD_GLUCOSE_EVENT" -> HealthDataType.BLOOD_GLUCOSE_BODY_EVENT
-      "BLOOD_PRESSURE_EVENT" -> HealthDataType.BLOOD_PRESSURE_BODY_EVENT
-      "BODY_METRICS_EVENT" -> HealthDataType.BODY_METRICS_EVENT
-      "HEART_RATE_EVENT" -> HealthDataType.HEART_RATE_BODY_EVENT
-      "HYDRATION_EVENT" -> HealthDataType.HYDRATION_BODY_EVENT
-      "NUTRITION_EVENT" -> HealthDataType.NUTRITION_BODY_EVENT
-      "OXYGENATION_EVENT" -> HealthDataType.OXYGENATION_BODY_EVENT
-      "PHYSICAL_EVENT" -> HealthDataType.PHYSICAL_EVENT
-      "TEMPERATURE_EVENT" -> HealthDataType.TEMPERATURE_BODY_EVENT
-      else -> HealthDataType.SLEEP_SUMMARY
-    }
-  }
-
-  private fun dataSourcesToWritableArray(dataSources: List<DataSource>): WritableArray {
-    val array = Arguments.createArray()
-    for (dataSource in dataSources) {
-      val map = Arguments.createMap()
-      map.putString("name", dataSource.name)
-      map.putString("description", dataSource.description)
-      map.putString("image", dataSource.image)
-      map.putBoolean("connected", dataSource.connected)
-      dataSource.authorizationUrl?.let {
-        map.putString("authorizationUrl", it)
-      }
-      array.pushMap(map)
-    }
-    return array
-  }
-
-  private fun determineDoEndValue(permissionString: String): SyncInstruction {
-    return when (permissionString) {
-      "oldest" -> SyncInstruction.SYNC_OLDEST
-      "latest" -> SyncInstruction.SYNC_LATEST
-      else -> SyncInstruction.NOTHING
-    }
-  }
-
-  @ReactMethod
-  fun getUserID(promise: Promise) {
-    try {
-      promise.resolve(rookConfigurationManager.getUserID())
-    }
-    catch (e: Exception) {
-      promise.reject(e)
-    }
-  }
-
-  @ReactMethod
-  fun updateUserID(userID: String, promise: Promise) {
-    scope.launch {
-        rookConfigurationManager.updateUserID(userID)
-          .fold({
-            promise.resolve(true)
-          }, {
-            promise.reject(it)
-          })
-    }
-  }
 
-  @ReactMethod
-  fun clearUserID(promise: Promise) {
-    scope.launch {
-      rookConfigurationManager.clearUserID().fold({
-        promise.resolve(true)
-      }, {
-        promise.reject(it)
-      })
+      reactApplicationContext.unregisterReceiver(hcPermissionsReceiverTransmitter)
+      reactApplicationContext.unregisterReceiver(androidPermissionsReceiverTransmitter)
     }
   }
 
-  @ReactMethod
-  fun removeUserFromRook(promise: Promise) {
-    scope.launch {
-      val result = rookConfigurationManager.deleteUserFromRook()
-
-      result.fold({
-        promise.resolve(true)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun syncUserTimeZone(promise: Promise) {
-    scope.launch {
-      val result = rookConfigurationManager.syncUserTimeZone()
-
-      result.fold({
-        promise.resolve(true)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-
-
+  /**
+   * Initializes the Rook SDK with the specified configuration settings (environment, clientUUID, secretKey).
+   * This is required before any data synchronization or user management can occur.
+   * @param config A map containing the environment, clientUUID, secretKey, and other settings.
+   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
+   */
   @ReactMethod
   fun initRook(config: ReadableMap,promise: Promise) {
     try {
+      val clientUUID = config.getString("clientUUID")?.trim() ?: ""
+      val secretKey = config.getString("password")?.trim() ?: ""
+
+      if (clientUUID.isBlank() || secretKey.isBlank()) {
+        promise.reject("Invalid Credentials", "Invalid credentials")
+        return
+      }
 
       var environment = RookEnvironment.SANDBOX
 
@@ -188,8 +147,8 @@ class RookSdkModule(reactContext: ReactApplicationContext) :
 
       val rookConfiguration = RookConfiguration(
         environment = environment,
-        clientUUID = config.getString("clientUUID") ?: "",
-        secretKey = config.getString("password") ?: ""
+        clientUUID = clientUUID,
+        secretKey = secretKey
       )
 
       val enableLogs = config.getBoolean("enableLogs")
@@ -216,473 +175,28 @@ class RookSdkModule(reactContext: ReactApplicationContext) :
 
   }
 
-  // MARK: - Permissions
-  @ReactMethod
-  fun checkAvailability(promise: Promise) {
-
-    promise.resolve(RookHealthPermissionsManager.checkAvailability(reactApplicationContext).toString())
-
-  }
-
-  @ReactMethod
-  fun openHealthConnectSettings(promise: Promise) {
-    scope.launch {
-
-      val result = rookHealthPermissionsManager.openHealthConnectSettings()
-
-      result.fold({
-        promise.resolve(true)
-      },{
-        promise.reject(it)
-      })
-
-    }
-  }
-
-  @ReactMethod
-  fun checkPermissions(promise: Promise) {
-    scope.launch {
-      val result = rookHealthPermissionsManager.checkPermissions();
-
-      result.fold({
-        promise.resolve(it)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun requestPermissions(promise: Promise) {
-    val activity = reactApplicationContext.currentActivity
-
-    if (activity == null) {
-      promise.reject(Exception("Error trying to request permissions"))
-      return
-    }
-
-    try {
-
-      HealthConnectPermissionsActivity.launch(activity)
-      promise.resolve(true)
-
-    }
-    catch (e: Exception) {
-      promise.reject(e)
-    }
-
-  }
-
-
-  // MARK: - Sync Summaries
-  @ReactMethod
-  fun shouldSyncFor(summaryString: String, date: String,promise: Promise) {
-    scope.launch {
-      RookHelpers.shouldSyncFor(
-        healthDataType = determineSummaryValue(summaryString),
-        localDate = RookDateTime.stringToLocalDate(date)
-      ).fold({
-        promise.resolve(it)
-      },{
-        promise.reject(it)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun syncSleepSummary(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookSummaryManager.syncSleepSummary(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  // Body
+  /**
+   * Sends a broadcast message to the React Native layer.
+   * This method emits a message event to the React Native side via the
+   * `ROOK_NOTIFICATION` channel, allowing communication from the native module.
+   *
+   * @param message A ReadableMap containing the message data to send.
+   * @param promise A promise object that resolves with true if the message was sent successfully.
+   */
   @ReactMethod
-  fun syncBodySummary(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookSummaryManager.syncBodySummary(RookDateTime.stringToLocalDate(date))
+  fun sendMessageToBroadcast(message: ReadableMap, promise: Promise) {
+    if (listenerCount <= 0) return
 
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
+    val hash = ReadableToWritable.readableMapToHashMap(message)
+    val writable = ReadableToWritable.hashMapToWritableMap(hash)
 
-  // Physical
-  @ReactMethod
-  fun syncPhysicalSummary(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookSummaryManager.syncPhysicalSummary(RookDateTime.stringToLocalDate(date))
+    reactApplicationContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit("ROOK_NOTIFICATION", writable)
 
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun syncPendingSummaries(promise: Promise) {
-    scope.launch {
-      val result = rookSummaryManager.syncPendingSummaries()
-
-      result.fold({
-        promise.resolve(true)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  // MARK: - Events
-  @ReactMethod
-  fun syncPhysicalEvents(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookEventManager.syncPhysicalEvents(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun syncBloodGlucoseEvents(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookEventManager.syncBloodGlucoseEvents(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun syncBloodPressureEvents(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookEventManager.syncBloodPressureEvents(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun syncBodyMetricsEvent(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookEventManager.syncBodyMetricsEvents(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun syncBodyHeartRateEvent(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookEventManager.syncBodyHeartRateEvents(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun syncPhysicalHeartRateEvent(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookEventManager.syncPhysicalHeartRateEvents(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun syncNutritionEvents(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookEventManager.syncNutritionEvents(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun syncHydrationEvents(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookEventManager.syncHydrationEvents(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-  @ReactMethod
-  fun syncPhysicalOxygenationEvent(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookEventManager.syncPhysicalOxygenationEvents(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun syncBodyOxygenationEvent(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookEventManager.syncBodyOxygenationEvents(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun syncTemperatureEvent(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookEventManager
-        .syncTemperatureEvents(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  @ReactMethod
-  fun syncPendingEvents(promise: Promise) {
-    scope.launch {
-      val result = rookEventManager.syncPendingEvents()
-
-      result.fold({
-        promise.resolve(true)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  // MARK: - Health Connect Background
-  @ReactMethod
-  fun scheduleYesterdaySync(config: ReadableMap, promise: Promise) {
-    scope.launch {
-      try {
-        var environment = RookEnvironment.SANDBOX
-
-        if (config.getString("environment") == "production")
-          environment = RookEnvironment.PRODUCTION
-
-        val doEnd = determineDoEndValue(config.getString("doOnEnd") ?: "")
-
-        rookSynManager.scheduleYesterdaySync(
-          enableLogs = true,
-          clientUUID = config.getString("clientUUID") ?: "",
-          secretKey = config.getString(",") ?: "",
-          environment = environment,
-          doOnEnd = doEnd
-        )
-
-        promise.resolve(true)
-
-      }
-      catch (e: Exception) {
-        promise.reject(e)
-      }
-    }
-
-  }
-
-  @ReactMethod
-  fun requestAndroidBackgroundPermissions(promise: Promise) {
-    try {
-      RookYesterdaySyncPermissions.requestAndroidPermissions(reactApplicationContext)
-      promise.resolve(true)
-    }
-    catch (e: Exception) {
-      promise.reject(e)
-    }
-  }
-
-  @ReactMethod
-  fun hasAndroidBackgroundPermissions(promise: Promise) {
-    try {
-      val result = RookYesterdaySyncPermissions.hasAndroidPermissions(reactApplicationContext)
-      promise.resolve(result)
-    }
-    catch (e: Exception) {
-      promise.reject(e)
-    }
-  }
-
-  // MARK: - Steps
-  @ReactMethod
-  fun isStepsAvailable(promise: Promise) {
-    promise.resolve(RookStepsPermissions.isAvailable(reactApplicationContext))
-  }
-
-  @ReactMethod
-  fun hasStepsPermissions(promise: Promise) {
-    promise.resolve(RookStepsPermissions.hasPermissions(reactApplicationContext))
-  }
-
-  @ReactMethod
-  fun requestStepsPermissions(promise: Promise) {
-    RookStepsPermissions.requestPermissions(reactApplicationContext)
     promise.resolve(true)
   }
 
-  @ReactMethod
-  fun enableBackgroundAndroidSteps(promise: Promise) {
-    rookStepsManager.enableBackgroundAndroidSteps().fold({
-      promise.resolve(true)
-    }, {
-      promise.reject(it)
-    })
-  }
-
-  @ReactMethod
-  fun disableBackgroundAndroidSteps(promise: Promise) {
-    rookStepsManager
-      .disableBackgroundAndroidSteps()
-      .fold({
-        stepsScope.cancel()
-        promise.resolve(true)
-      }, {
-        promise.reject(it)
-      })
-  }
-
-  @ReactMethod
-  fun isBackgroundAndroidStepsActive(promise: Promise) {
-    scope.launch {
-      val response = rookStepsManager.isBackgroundAndroidStepsActive()
-      promise.resolve(response)
-    }
-  }
-
-  @ReactMethod
-  fun syncTodayAndroidStepsCount(promise: Promise) {
-    scope.launch {
-      rookStepsManager
-        .syncTodayAndroidStepsCount()
-        .fold({
-          promise.resolve(it.toString())
-        }, {
-          promise.reject(it)
-        })
-    }
-  }
-
-  @ReactMethod
-  fun syncTodayHealthConnectStepsCount(promise: Promise) {
-    scope.launch {
-      rookEventManager.syncTodayHealthConnectStepsCount().fold(
-        {
-          when (it) {
-            SyncStatusWithData.RecordsNotFound -> {
-              promise.reject("syncTodayHealthConnect", "Records Not Found")
-            }
-
-            is SyncStatusWithData.Synced -> {
-              val steps = it.data
-              promise.resolve(steps)
-            }
-          }
-        },
-        {
-          promise.reject(it)
-        }
-      )
-    }
-  }
-
-  // MARK: - Datasources
-  @ReactMethod
-  fun getAvailableDataSources(options: ReadableMap?, promise: Promise) {
-    val rookDataSources = RookDataSources(reactApplicationContext)
-    println(options)
-    var redirectURL: String? = null
-
-    if (options !== null) redirectURL = options.getString("redirectURL")
-
-    scope.launch {
-      rookDataSources.getAvailableDataSources(redirectURL).fold(
-        { dataSources ->
-          promise.resolve(dataSourcesToWritableArray(dataSources))
-        },
-        {
-          promise.reject(it)
-        },
-      )
-    }
-  }
-
-  @ReactMethod
-  fun presentDataSourceView(options: ReadableMap?, promise: Promise) {
-    val rookDataSources = RookDataSources(reactApplicationContext)
-    var redirectURL: String? = null
-
-    if (options !== null) redirectURL = options.getString("redirectURL")
-
-    rookDataSources.presentDataSourceView(redirectURL).fold({
-      promise.resolve(true)
-    }, {
-      promise.reject(it)
-    })
-  }
-
   companion object {
     const val NAME = "RookSdk"
   }