react-native-rook-sdk 4.0.0-beta.1 → 4.0.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 ROOK
+Copyright (c) 2024 Rook
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights

package/README.md

@@ -1,37 +1,5 @@
-# react-native-rook-sdk
+# Rook SDK
 
-Extract health data from health connect, apple health and samsung health to transform to a RookScore
+This SDK enables apps to extract and upload data from Health Connect, with this sdk you will be able to extract and upload data from health connect, [if you need check our app demo](https://github.com/RookeriesDevelopment/rook_demo_app_android_react_native_rook_sdk/tree/main)
 
-## Installation
-
-
-```sh
-npm install react-native-rook-sdk
-```
-
-
-## Usage
-
-
-```js
-import { multiply } from 'react-native-rook-sdk';
-
-// ...
-
-const result = multiply(3, 7);
-```
-
-
-## Contributing
-
-- [Development workflow](CONTRIBUTING.md#development-workflow)
-- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
-- [Code of conduct](CODE_OF_CONDUCT.md)
-
-## License
-
-MIT
-
----
-
-Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)
+If you need more information please refer to the [official documentation](https://docs.tryrook.io/docs/category/reactnative)

package/android/build.gradle

@@ -1,42 +1,66 @@
 buildscript {
-  ext.getExtOrDefault = {name ->
-    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['RNRookSdk_' + name]
-  }
+  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
+  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["RookSdk_kotlinVersion"]
 
   repositories {
     google()
     mavenCentral()
+    mavenLocal()
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:8.7.2"
+    classpath "com.android.tools.build:gradle:8.9.3"
     // noinspection DifferentKotlinGradleVersion
-    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
   }
 }
 
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
 
 apply plugin: "com.android.library"
 apply plugin: "kotlin-android"
+apply plugin: "kotlin-parcelize"
 
-apply plugin: "com.facebook.react"
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["RookSdk_" + name]
+}
 
 def getExtOrIntegerDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["RookSdk_" + name]).toInteger()
 }
 
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
+}
+
 android {
-  namespace "com.rooksdk"
+  if (supportsNamespace()) {
+    namespace "com.rooksdk"
+
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
+      }
+    }
+  }
 
   compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
 
   defaultConfig {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
-  }
 
-  buildFeatures {
-    buildConfig true
   }
 
   buildTypes {
@@ -53,25 +77,26 @@ android {
     sourceCompatibility JavaVersion.VERSION_1_8
     targetCompatibility JavaVersion.VERSION_1_8
   }
-
-  sourceSets {
-    main {
-      java.srcDirs += [
-        "generated/java",
-        "generated/jni"
-      ]
-    }
-  }
 }
 
 repositories {
   mavenCentral()
   google()
+  mavenLocal()
 }
 
 def kotlin_version = getExtOrDefault("kotlinVersion")
 
 dependencies {
-  implementation "com.facebook.react:react-android"
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation 'com.google.code.gson:gson:2.13.2'
+
+  implementation("io.tryrook.android:rook-sdk-samsung:4.0.0")
+  implementation 'io.tryrook.android:rook-api-sources:4.0.0'
+  implementation 'com.rookmotion.android:rook-sdk:4.0.0'
 }
+

package/android/gradle.properties

@@ -1,5 +1,5 @@
-RookSdk_kotlinVersion=2.0.21
-RookSdk_minSdkVersion=24
-RookSdk_targetSdkVersion=34
-RookSdk_compileSdkVersion=35
-RookSdk_ndkVersion=27.1.12297006
+RookSdk_kotlinVersion=2.1.21
+RookSdk_minSdkVersion=29
+RookSdk_targetSdkVersion=36
+RookSdk_compileSdkVersion=36
+RookSdk_ndkversion=21.4.7075529

package/android/src/main/AndroidManifest.xml

@@ -1,2 +1,3 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.rooksdk">
 </manifest>

package/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,36 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <queries>
+    <package android:name="com.google.android.apps.healthdata"/>
+  </queries>
+
+  <uses-permission android:name="android.permission.ACTIVITY_RECOGNITION"/>
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_HEALTH"/>
+  <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
+  <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
+
+  <uses-permission android:name="android.permission.health.READ_SLEEP"/>
+  <uses-permission android:name="android.permission.health.READ_STEPS"/>
+  <uses-permission android:name="android.permission.health.READ_DISTANCE"/>
+  <uses-permission android:name="android.permission.health.READ_FLOORS_CLIMBED"/>
+  <uses-permission android:name="android.permission.health.READ_ELEVATION_GAINED"/>
+  <uses-permission android:name="android.permission.health.READ_OXYGEN_SATURATION"/>
+  <uses-permission android:name="android.permission.health.READ_VO2_MAX"/>
+  <uses-permission android:name="android.permission.health.READ_TOTAL_CALORIES_BURNED"/>
+  <uses-permission android:name="android.permission.health.READ_ACTIVE_CALORIES_BURNED"/>
+  <uses-permission android:name="android.permission.health.READ_HEART_RATE"/>
+  <uses-permission android:name="android.permission.health.READ_RESTING_HEART_RATE"/>
+  <uses-permission android:name="android.permission.health.READ_HEART_RATE_VARIABILITY"/>
+  <uses-permission android:name="android.permission.health.READ_EXERCISE"/>
+  <uses-permission android:name="android.permission.health.READ_SPEED"/>
+  <uses-permission android:name="android.permission.health.READ_WEIGHT"/>
+  <uses-permission android:name="android.permission.health.READ_HEIGHT"/>
+  <uses-permission android:name="android.permission.health.READ_BLOOD_GLUCOSE"/>
+  <uses-permission android:name="android.permission.health.READ_BLOOD_PRESSURE"/>
+  <uses-permission android:name="android.permission.health.READ_HYDRATION"/>
+  <uses-permission android:name="android.permission.health.READ_BODY_TEMPERATURE"/>
+  <uses-permission android:name="android.permission.health.READ_RESPIRATORY_RATE"/>
+  <uses-permission android:name="android.permission.health.READ_NUTRITION"/>
+  <uses-permission android:name="android.permission.health.READ_MENSTRUATION"/>
+  <uses-permission android:name="android.permission.health.READ_POWER"/>
+</manifest>

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

@@ -1,28 +1,280 @@
 package com.rooksdk
 
+import android.content.IntentFilter
+import android.util.Log
+import androidx.core.content.ContextCompat
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.rookmotion.rook.sdk.RookConfigurationManager
+import com.rookmotion.rook.sdk.RookPermissionsManager
+import com.rookmotion.rook.sdk.domain.analytics.HCRookAnalytics
+import com.rookmotion.rook.sdk.domain.analytics.HCRookFramework
+import com.rookmotion.rook.sdk.domain.environment.RookEnvironment
+import com.rookmotion.rook.sdk.domain.exception.HCException
+import com.rookmotion.rook.sdk.domain.model.RookConfiguration
+import com.rooksdk.broadcasts.AndroidPermissionsReceiverTransmitter
+import com.rooksdk.broadcasts.HealthConnectPermissionsReceiverTransmitter
+import com.rooksdk.broadcasts.SamsungHealthPermissionsReceiverTransmitter
+import com.rooksdk.utils.ReadableToWritable
+import com.rooksdk.utils.SamsungAvailability
+import io.tryrook.api.sources.RookApiSources
+import io.tryrook.api.sources.domain.environment.ApiEnvironment
+import io.tryrook.api.sources.domain.model.ApiConfiguration
+import io.tryrook.sdk.samsung.RookSamsung
+import io.tryrook.sdk.samsung.domain.analytics.SHRookAnalytics
+import io.tryrook.sdk.samsung.domain.analytics.SHRookFramework
+import io.tryrook.sdk.samsung.domain.enums.SamsungHealthAvailability
+import io.tryrook.sdk.samsung.domain.enums.SamsungHealthPermission
+import io.tryrook.sdk.samsung.domain.environment.SHEnvironment
+import io.tryrook.sdk.samsung.domain.exception.SHException
+import io.tryrook.sdk.samsung.domain.model.SHConfiguration
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
 
-@ReactModule(name = RookSdkModule.NAME)
-class RookSdkModule(reactContext: ReactApplicationContext) :
-  NativeRookSdkSpec(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,
+  private val rookSamsung: RookSamsung,
+  private val rookApiSources: RookApiSources,
+): ReactContextBaseJavaModule(reactContext) {
+
+  private var scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+  private var listenerCount = 0
+
+  private val stepsScope: CoroutineScope by lazy {
+    CoroutineScope(SupervisorJob() + Dispatchers.Main)
+  }
+
+  private val androidPermissionsReceiverTransmitter: AndroidPermissionsReceiverTransmitter by lazy {
+    AndroidPermissionsReceiverTransmitter()
+  }
+
+  private val hcPermissionsReceiverTransmitter: HealthConnectPermissionsReceiverTransmitter by lazy {
+    HealthConnectPermissionsReceiverTransmitter()
+  }
+
+  private val shHealthPermissionsReceiverTransmitter: SamsungHealthPermissionsReceiverTransmitter by lazy {
+    SamsungHealthPermissionsReceiverTransmitter()
+  }
 
   override fun getName(): String {
     return NAME
   }
 
-  // Example method
-  // See https://reactnative.dev/docs/native-modules-android
-  override fun multiply(a: Double, b: Double): Double {
-    return a * b
+  @ReactMethod
+  fun addListener(eventName: String) {
+    if (listenerCount == 0) {
+      androidPermissionsReceiverTransmitter.setReactApplicationContext(reactApplicationContext)
+      hcPermissionsReceiverTransmitter.setReactApplicationContext(reactApplicationContext)
+      shHealthPermissionsReceiverTransmitter.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,
+      )
+
+      ContextCompat.registerReceiver(
+        reactApplicationContext,
+        shHealthPermissionsReceiverTransmitter,
+        IntentFilter(SamsungHealthPermission.ACTION_SAMSUNG_HEALTH_PERMISSIONS),
+        ContextCompat.RECEIVER_EXPORTED
+      )
+    }
+
+    listenerCount += 1
+  }
+
+  @ReactMethod
+  fun removeListeners(count: Int) {
+    listenerCount -= count
+    if (listenerCount == 0) {
+      stepsScope.cancel()
+
+      reactApplicationContext.unregisterReceiver(hcPermissionsReceiverTransmitter)
+      reactApplicationContext.unregisterReceiver(androidPermissionsReceiverTransmitter)
+    }
   }
 
-  override fun simplePromise(promise: Promise?) {
-    TODO("Not yet implemented")
+  /**
+   * 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 secret = config.getString("secret")?.trim() ?: ""
+      val packageName = config.getString("packageName")?.trim()
+
+      if (clientUUID.isBlank() || secret.isBlank()) {
+        promise.reject("3", "Requested operation needs an authorization level that your clientUUID doesn't have.")
+        return
+      }
+
+      var environment = RookEnvironment.SANDBOX
+      var shEnv = SHEnvironment.SANDBOX
+      var apiEnv = ApiEnvironment.SANDBOX
+
+      if (config.getString("environment") == "production") {
+        environment = RookEnvironment.PRODUCTION
+        shEnv = SHEnvironment.SANDBOX
+        apiEnv = ApiEnvironment.PRODUCTION
+      }
+
+      val rookConfiguration = RookConfiguration(
+        environment = environment,
+        clientUUID = clientUUID,
+        packageName = packageName,
+        secret = secret
+      )
+
+      val shConfig = SHConfiguration(
+        environment = shEnv,
+        clientUUID = clientUUID,
+        packageName = packageName,
+        secret = secret
+      )
+
+      val apiConfig = ApiConfiguration(
+        environment = apiEnv,
+        clientUUID = clientUUID,
+        packageName = packageName,
+        secret = secret
+      )
+
+      val enableLogs = config.getBoolean("enableLogs")
+      if(enableLogs) {
+        rookConfigurationManager.enableLocalLogs()
+        rookSamsung.enableLocalLogs()
+        rookApiSources.enableLocalLogs()
+      }
+
+      rookConfigurationManager.setConfiguration(rookConfiguration)
+
+      HCRookAnalytics.setFramework(HCRookFramework.REACT_NATIVE)
+      SHRookAnalytics.setFramework(SHRookFramework.REACT_NATIVE)
+
+      scope.launch {
+        try {
+          val result = rookConfigurationManager.initRook()
+          rookApiSources.initRook(apiConfig)
+
+          result.getOrThrow()
+
+          val availableResult = SamsungAvailability.getSamsungHealthAvailabilityOrDefault(rookSamsung)
+
+          if (availableResult == SamsungHealthAvailability.INSTALLED) {
+            rookSamsung.initRook(shConfig)
+            tryToSetSamsungUserId()
+          }
+
+          promise.resolve(true)
+        } catch (e: Throwable) {
+          when (e) {
+            is HCException -> {
+              promise.reject(e.code.toString(), e.message, e)
+            }
+            is SHException -> {
+              promise.reject(e.code.toString(), e.message, e)
+            }
+            else -> {
+              promise.reject("1001", e.message, e)
+            }
+          }
+        }
+      }
+    }
+    catch (e: Exception) {
+      when (e) {
+        is HCException -> {
+          promise.reject(e.code.toString(), e.message, e)
+        }
+        is SHException -> {
+          promise.reject(e.code.toString(), e.message, e)
+        }
+        else -> {
+          promise.reject("1001", e.message, e)
+        }
+      }
+    }
+
+  }
+
+  private fun tryToSetSamsungUserId() {
+    scope.launch {
+      val result = rookConfigurationManager.getUserID()
+
+      if (result != null) {
+        val user =  rookSamsung.updateUserID(result)
+        user.getOrNull()
+      }
+    }
+  }
+
+  /**
+   * 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 sendMessageToBroadcast(message: ReadableMap, promise: Promise) {
+    if (listenerCount <= 0) return
+
+    val hash = ReadableToWritable.readableMapToHashMap(message)
+    val writable = ReadableToWritable.hashMapToWritableMap(hash)
+
+    reactApplicationContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit("ROOK_NOTIFICATION", writable)
+
+    promise.resolve(true)
   }
 
   companion object {
-    const val NAME = "RNRookSdk"
+    const val NAME = "RookSdk"
   }
 }

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

@@ -1,33 +1,49 @@
 package com.rooksdk
 
-import com.facebook.react.BaseReactPackage
+import com.facebook.react.ReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.module.model.ReactModuleInfo
-import com.facebook.react.module.model.ReactModuleInfoProvider
-import java.util.HashMap
-
-class RookSdkPackage : BaseReactPackage() {
-  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
-    return if (name == RookSdkModule.NAME) {
-      RookSdkModule(reactContext)
-    } else {
-      null
-    }
-  }
+import com.facebook.react.uimanager.ViewManager
+import com.rookmotion.rook.sdk.RookConfigurationManager
+import com.rooksdk.modules.RookBackgroundSyncModule
+import com.rooksdk.modules.RookConfigurationModule
+import com.rooksdk.modules.RookLocalData
+import com.rooksdk.modules.RookPermissionsModule
+import com.rooksdk.modules.RookSourcesModule
+import com.rooksdk.modules.RookStepsModule
+import com.rooksdk.modules.RookSyncModule
+import io.tryrook.api.sources.RookApiSources
+import io.tryrook.sdk.samsung.RookSamsung
+
+
+class RookSdkPackage : ReactPackage {
+  private var rookConfigurationManager: RookConfigurationManager? = null
+  private var rookSamsung: RookSamsung? = null
+  private var rookApiSources: RookApiSources? = null
+
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    if (rookConfigurationManager == null)
+      rookConfigurationManager = RookConfigurationManager(reactContext)
+
+    if (rookSamsung == null)
+      rookSamsung = RookSamsung(reactContext)
+
+    if (rookApiSources == null)
+      rookApiSources = RookApiSources(reactContext)
+
+    return listOf(
+      RookSdkModule(reactContext, rookConfigurationManager!!, rookSamsung!!, rookApiSources!!),
+      RookPermissionsModule(reactContext, rookSamsung!!),
+      RookConfigurationModule(reactContext, rookConfigurationManager!!, rookSamsung!!),
+      RookSyncModule(reactContext, rookSamsung!!),
+      RookBackgroundSyncModule(reactContext),
+      RookStepsModule(reactContext),
+      RookLocalData(reactContext, rookSamsung!!),
+      RookSourcesModule(reactContext),
+    )
+}
 
-  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
-    return ReactModuleInfoProvider {
-      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
-      moduleInfos[RookSdkModule.NAME] = ReactModuleInfo(
-        RookSdkModule.NAME,
-        RookSdkModule.NAME,
-        canOverrideExistingModule = false,  // canOverrideExistingModule
-        needsEagerInit = false,  // needsEagerInit
-        isCxxModule = false,  // isCxxModule
-        isTurboModule = true // isTurboModule
-      )
-      moduleInfos
-    }
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
   }
 }

package/android/src/main/java/com/rooksdk/broadcasts/AndroidPermissionsReceiverTransmitter.kt

@@ -0,0 +1,65 @@
+package com.rooksdk.broadcasts
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.rookmotion.rook.sdk.RookPermissionsManager
+
+/**
+ * AndroidPermissionsReceiverTransmitter is a custom BroadcastReceiver used to listen for updates
+ * on Android permission changes and transmit them back to the React Native layer.
+ * It listens for a broadcast containing permission status, then emits a corresponding event to JavaScript.
+ */
+class AndroidPermissionsReceiverTransmitter: BroadcastReceiver() {
+  private var reactApplicationContext: ReactApplicationContext? = null
+
+ /**
+   * This method is called when a broadcast is received.
+   * It checks whether the broadcast includes the permission status and emits an event to the React Native
+   * JavaScript layer with the results.
+   *
+   * @param context The context in which the receiver is running.
+   * @param intent The intent containing permission-related data.
+   */
+ override fun onReceive(context: Context?, intent: Intent?) {
+   val permissionsGranted = intent?.getBooleanExtra(
+     /* name = */ RookPermissionsManager.EXTRA_ANDROID_PERMISSIONS_GRANTED,
+     /* defaultValue = */ false
+   ) ?: false
+
+   val dialogDisplayed = intent?.getBooleanExtra(
+     RookPermissionsManager.EXTRA_ANDROID_PERMISSIONS_DIALOG_DISPLAYED,
+     false
+   ) ?: false
+
+   reactApplicationContext?.also { reactContext ->
+     val events = listOf(
+       "ROOK_BACKGROUND_ANDROID_PERMISSIONS" to permissionsGranted,
+       "ROOK_BACKGROUND_ANDROID_PERMISSIONS_DIALOG_DISPLAYED" to dialogDisplayed
+     )
+
+     val emitter = reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+
+     events.forEach { (type, value) ->
+       Arguments.createMap().apply {
+         putString("type", type)
+         putBoolean("value", value)
+         emitter.emit("ROOK_NOTIFICATION", this)
+       }
+     }
+   }
+ }
+
+  /**
+   * Sets the ReactApplicationContext to be used for emitting events to the React Native side.
+   *
+   * @param context The ReactApplicationContext provided by React Native.
+   */
+  fun setReactApplicationContext(context: ReactApplicationContext) {
+    this.reactApplicationContext = context
+  }
+
+}