@tower-supplies/react-native-broadcast-receiver 0.6.2

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2022 Mohan
+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
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,53 @@
+# react-native-broadcast-receiver
+
+:sparkles: :rocket: Supports React-Native Bridgeless mode
+
+This package allows you to register custom intent to listen in react native applications.
+The idea here is to reduce the number app builds that are required if you change the native code in react native. With this you can inject custom intent config at runtime.
+
+
+## Installation
+
+### npm
+```sh
+npm install @tower-supplies/react-native-broadcast-receiver
+```
+
+yarn
+
+```sh
+yarn add @tower-supplies/react-native-broadcast-receiver
+```
+
+### Usage
+
+#### Listen to broadcast events with custom intent actions and extraDataKey
+
+```js
+import { BroadcastReceiver } from '@tower-supplies/react-native-broadcast-receiver';
+
+BroadcastReceiver.setIntentActionConfig([
+  { action: 'com.zzzz.yyyy.action1', datakey: '<data_key1>' },
+  { action: 'com.zzzz.yyyy.action2', datakey: '<data_key2>' },
+  { action: 'com.zzzz.yyyy.action3', datakey: '' }, // For empty dataKey an object will be returned instead of a string
+]);
+
+React.useEffect(() => {
+  const sub = BroadcastReceiver.addEventListener((d) =>
+    setScanned((x) => [...x, d.data])
+  );
+  return () => sub.remove();
+}, []);
+```
+
+## Contributing
+
+See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/android/build.gradle

@@ -0,0 +1,158 @@
+buildscript {
+  // 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['BroadcastReceiver_kotlinVersion']
+
+  repositories {
+      google()
+      mavenCentral()
+      gradlePluginPortal()
+  }
+
+  dependencies {
+    classpath 'com.android.tools.build:gradle:7.3.1'
+    // noinspection DifferentKotlinGradleVersion
+    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'
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: 'com.facebook.react'
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['BroadcastReceiver_' + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties['BroadcastReceiver_' + name]).toInteger()
+}
+
+android {
+  compileSdkVersion getExtOrIntegerDefault('compileSdkVersion')
+  namespace "com.broadcastreceiver"
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault('minSdkVersion')
+    targetSdkVersion getExtOrIntegerDefault('targetSdkVersion')
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+    sourceSets {
+        main {
+            if (isNewArchitectureEnabled()) {
+                java.srcDirs += ['src/newarch']
+            } else {
+                java.srcDirs += ['src/oldarch']
+            }
+        }
+    }
+  }
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable 'GradleCompatible'
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+}
+
+repositories {
+  mavenCentral()
+  google()
+
+  def found = false
+  def defaultDir = null
+  def androidSourcesName = 'React Native sources'
+
+  if (rootProject.ext.has('reactNativeAndroidRoot')) {
+    defaultDir = rootProject.ext.get('reactNativeAndroidRoot')
+  } else {
+    defaultDir = new File(
+      projectDir,
+      '/../../../node_modules/react-native/android'
+    )
+  }
+
+  if (defaultDir.exists()) {
+    maven {
+      url defaultDir.toString()
+      name androidSourcesName
+    }
+
+    logger.info(":${project.name}:reactNativeAndroidRoot ${defaultDir.canonicalPath}")
+    found = true
+  } else {
+    def parentDir = rootProject.projectDir
+
+    1.upto(5, {
+      if (found) return true
+      parentDir = parentDir.parentFile
+
+      def androidSourcesDir = new File(
+        parentDir,
+        'node_modules/react-native'
+      )
+
+      def androidPrebuiltBinaryDir = new File(
+        parentDir,
+        'node_modules/react-native/android'
+      )
+
+      if (androidPrebuiltBinaryDir.exists()) {
+        maven {
+          url androidPrebuiltBinaryDir.toString()
+          name androidSourcesName
+        }
+
+        logger.info(":${project.name}:reactNativeAndroidRoot ${androidPrebuiltBinaryDir.canonicalPath}")
+        found = true
+      } else if (androidSourcesDir.exists()) {
+        maven {
+          url androidSourcesDir.toString()
+          name androidSourcesName
+        }
+
+        logger.info(":${project.name}:reactNativeAndroidRoot ${androidSourcesDir.canonicalPath}")
+        found = true
+      }
+    })
+  }
+
+  if (!found) {
+    throw new GradleException(
+      "${project.name}: unable to locate React Native android sources. " +
+      "Ensure you have you installed React Native as a dependency in your project and try again."
+    )
+  }
+}
+
+def kotlin_version = getExtOrDefault('kotlinVersion')
+
+dependencies {
+    //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+  implementation "com.google.code.gson:gson:2.13.2"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+// From node_modules
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "BroadcastReceiver"
+    codegenJavaPackageName = "com.broadcastreceiver"
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,6 @@
+BroadcastReceiver_kotlinVersion=1.7.0
+BroadcastReceiver_minSdkVersion=21
+BroadcastReceiver_targetSdkVersion=31
+BroadcastReceiver_compileSdkVersion=33
+BroadcastReceiver_ndkversion=21.4.7075529
+android.useAndroidX=true

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,5 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:tools="http://schemas.android.com/tools"
+  package="com.broadcastreceiver">
+  <uses-permission android:name="com.google.android.c2dm.permission.RECEIVE"/>
+</manifest>

package/android/src/main/java/com/broadcastreceiver/BroadcastReceiverImpl.kt

@@ -0,0 +1,90 @@
+package com.broadcastreceiver
+
+import android.annotation.SuppressLint
+import android.content.IntentFilter
+import android.provider.Settings
+import android.util.Log
+import android.os.Build;
+import android.content.Context;
+import com.facebook.react.BuildConfig
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+
+class BroadcastReceiverImpl(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext){
+  private var broadcastReceiver = BroadcastReceiverReceiver()
+
+  init {
+    cReactContext = reactContext
+  }
+
+  override fun getName(): String {
+    return Constants.ModuleName
+  }
+
+  private fun getReactContext(): ReactApplicationContext {
+    return cReactContext
+  }
+
+  // Example method
+  // See https://reactnative.dev/docs/native-modules-android
+  fun multiply(a: Double, b: Double, promise: Promise) {
+    promise.resolve(a * b)
+  }
+
+  fun setIntentConfig(args: ReadableArray, promise: Promise) {
+    if (BuildConfig.DEBUG) {
+      Log.d(name, args.toString())
+      Log.d(name, "addActions: register receiver")
+    }
+    val argsArray = args.toArrayList().filterIsInstance<List<String>>()
+    val data = argsArray.map {
+      Pair(it[0], it[1])
+    }
+    IntentConfiguration.addToMap(data)
+    registerBroadcastReceiver()
+    promise.resolve(true)
+  }
+
+  @SuppressLint("HardwareIds")
+  fun getPhoneID(promise: Promise) {
+    try {
+      val secureId: String = Settings.Secure.getString(
+        getReactContext().contentResolver, Settings.Secure.ANDROID_ID
+      )
+      promise.resolve(Arguments.fromJavaArgs(arrayOf(secureId)))
+    } catch (e: Exception) {
+      promise.reject(RuntimeException("Could not get unique Id"))
+    }
+  }
+
+
+  companion object {
+    lateinit var cReactContext: ReactApplicationContext
+
+    fun sendEvent(eventName: String, params: WritableMap) {
+      cReactContext.emitDeviceEvent(eventName, params)
+    }
+  }
+
+  fun registerBroadcastReceiver() {
+    if (BuildConfig.DEBUG) Log.d(name, "register receiver")
+
+    val filter = IntentFilter()
+    val filterMap = IntentConfiguration.getMap()
+
+    filterMap.forEach { filter.addAction(it.key) }
+    filter.addCategory("android.intent.category.DEFAULT")
+
+    val context = getReactContext()
+    if (Build.VERSION.SDK_INT >= 34 && context.applicationInfo.targetSdkVersion >= 34) {
+      context.registerReceiver(broadcastReceiver, filter, Context.RECEIVER_EXPORTED);
+    } else {
+      context.registerReceiver(broadcastReceiver, filter);
+    }
+  }
+
+  fun unregisterBroadcastReceiver() {
+    getReactContext().unregisterReceiver(broadcastReceiver)
+  }
+}

package/android/src/main/java/com/broadcastreceiver/BroadcastReceiverPackage.kt

@@ -0,0 +1,35 @@
+package com.broadcastreceiver
+
+import com.facebook.react.TurboReactPackage
+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
+
+
+class BroadcastReceiverPackage : TurboReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == Constants.ModuleName) {
+      BroadcastReceiverModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> =
+        HashMap()
+      moduleInfos[Constants.ModuleName] = ReactModuleInfo(
+        Constants.ModuleName,
+        Constants.ModuleName,
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        true,  // hasConstants
+        false,  // isCxxModule
+        true // isTurboModule
+      )
+      moduleInfos
+    }
+  }
+}

package/android/src/main/java/com/broadcastreceiver/BroadcastReceiverReceiver.kt

@@ -0,0 +1,104 @@
+package com.broadcastreceiver
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.os.Parcelable
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.google.gson.Gson
+
+class BroadcastReceiverReceiver : BroadcastReceiver() {
+  override fun onReceive(context: Context?, intent: Intent?) {
+    // Check if the intent is not null
+    if (intent != null) {
+      // Get data from intent
+      val data = getDataFromIntent(intent)
+      if (data != null) {
+        val params = Arguments.createMap()
+        params.putString(Constants.Action, intent.action)
+
+        when (data) {
+          is ResultData.StringData -> {
+            // Handle the String case
+            params.putString(Constants.DataProp, data.value)
+          }
+
+          is ResultData.MapData -> {
+            // Handle the WritableMap case
+            params.putMap(Constants.DataProp, data.map)
+          }
+        }
+
+        BroadcastReceiverImpl.sendEvent(Constants.BroadcastEventName, params)
+      }
+    }
+  }
+
+  sealed class ResultData {
+    data class StringData(val value: String?) : ResultData()
+    data class MapData(val map: WritableMap) : ResultData()
+  }
+
+  private fun extraToString(intent: Intent, key: String): String {
+      val extra = intent.extras?.get(key)
+
+      if (extra is Parcelable) {
+          val parcelable = if (Build.VERSION.SDK_INT > Build.VERSION_CODES.TIRAMISU) {
+              intent.getParcelableExtra<Parcelable>(key, Parcelable::class.java)
+          } else {
+              intent.getParcelableExtra<Parcelable>(key)
+          }
+          val json = Gson().toJson(parcelable)
+          // Log.d(TAG, "Parcelable: $json")
+          return json?.trim() ?: ""
+      }
+
+      if (extra is Array<*> && extra.isArrayOf<Parcelable>()) {
+          val parcelableArray = if (Build.VERSION.SDK_INT > Build.VERSION_CODES.TIRAMISU) {
+              intent.getParcelableArrayExtra<Parcelable>(key, Parcelable::class.java)
+          } else {
+              intent.getParcelableArrayExtra(key)
+          }
+          val json = Gson().toJson(parcelableArray)
+          // Log.d(TAG, "ParcelableArray: $json")
+          return json?.trim() ?: ""
+      }
+
+      // Log.d(TAG, "Basic: $extra")
+      return extra?.toString()?.trim() ?: ""
+  }  
+
+  private fun getDataFromIntent(intent: Intent): ResultData? {
+    val action = intent.action
+    val intentFilterMap = IntentConfiguration.getMap()
+
+    Log.d(TAG, intentFilterMap.toString())
+    if (intentFilterMap.containsKey(action)) {
+      val dataKey = intentFilterMap[action]
+
+      // If a data key is given, only the corresponding string will be returned; otherwise, the entire object will be returned.
+      if (!dataKey.isNullOrEmpty() && intent.extras?.containsKey(dataKey) == true) {
+        val barcodeData = extraToString(intent, dataKey)
+        return ResultData.StringData(barcodeData)
+      } else {
+        // Create a WritableMap if there are no specific string requirements
+        val dataMap = Arguments.createMap()
+        intent.extras?.let { extras ->
+          for (key in extras.keySet()) {
+            dataMap.putString(key, extraToString(intent, key))
+          }
+        }
+        return ResultData.MapData(dataMap)
+      }
+    }
+
+    return null
+  }
+
+  companion object {
+    const val TAG = "Receiver"
+  }
+}

package/android/src/main/java/com/broadcastreceiver/Constants.kt

@@ -0,0 +1,8 @@
+package com.broadcastreceiver
+
+object Constants {
+    const val BroadcastEventName = "BROADCAST_EVENT"
+    const val ModuleName = "RNBroadcastReceiver"
+    const val DataProp = "data"
+    const val Action = "action"
+}

package/android/src/main/java/com/broadcastreceiver/IntentConfiguration.kt

@@ -0,0 +1,21 @@
+package com.broadcastreceiver
+
+object IntentConfiguration {
+    private val filterMap: MutableMap<String, String> = mutableMapOf(
+        "com.cipherlab.barcodebaseapi.PASS_DATA_2_APP" to "Decoder_Data",
+        "com.barcodeservice.broadcast.string" to "barcodedata",
+        "BROADCAST_BARCODE" to "BROADCAST_BARCODE_STRING",
+        "zebra.barcode" to "com.motorolasolutions.emdk.datawedge.data_string",
+        "com.honeywell.scantointent.intent.action.BARCODE" to "data"
+    )
+
+    fun getMap(): MutableMap<String, String> {
+        return filterMap
+    }
+
+    fun addToMap(args: List<Pair<String, String>>) {
+        args.forEach {
+            filterMap[it.first] = it.second
+        }
+    }
+}

package/android/src/newarch/java/com/BroadcastReceiverModule.kt

@@ -0,0 +1,51 @@
+package com.broadcastreceiver
+
+import android.util.Log
+import com.facebook.react.BuildConfig
+import com.facebook.react.bridge.*
+
+class BroadcastReceiverModule(reactContext: ReactApplicationContext) :
+  NativeBroadcastReceiverSpec(reactContext), LifecycleEventListener {
+  private var implementation = BroadcastReceiverImpl(reactContext)
+  private var name = implementation.name
+
+  init {
+    reactContext.addLifecycleEventListener(
+      this
+    )
+  }
+
+  override fun getName(): String {
+    return implementation.name
+  }
+
+  // Example method
+  // See https://reactnative.dev/docs/native-modules-android
+  fun multiply(a: Double, b: Double, promise: Promise) {
+    implementation.multiply(a, b, promise)
+  }
+
+  override fun setIntentConfig(args: ReadableArray, promise: Promise) {
+    implementation.setIntentConfig(args, promise)
+  }
+
+  override fun getPhoneID(promise: Promise) {
+    implementation.getPhoneID(promise)
+  }
+
+  //region: LifecycleEventListener
+  override fun onHostResume() {
+    if (BuildConfig.DEBUG) Log.d(name, "onHostResume: register Application receivers")
+    implementation.registerBroadcastReceiver()
+  }
+
+  override fun onHostPause() {
+    if (BuildConfig.DEBUG) Log.d(name, "onHostPause: unregister receivers")
+    implementation.unregisterBroadcastReceiver()
+  }
+
+  override fun onHostDestroy() {
+    if (BuildConfig.DEBUG) Log.d(name, "onHostDestroy: Destroy host")
+  }
+  //endregion
+}

package/android/src/oldarch/java/com/BroadcastReceiverModule.kt

@@ -0,0 +1,54 @@
+package com.broadcastreceiver
+
+import android.util.Log
+import com.facebook.react.BuildConfig
+import com.facebook.react.bridge.*
+
+class BroadcastReceiverModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext), LifecycleEventListener {
+  private var implementation = BroadcastReceiverImpl(reactContext)
+  private var name = implementation.name
+
+  init {
+    reactContext.addLifecycleEventListener(
+      this
+    )
+  }
+
+  @ReactMethod
+  override fun getName(): String {
+    return implementation.name
+  }
+
+  // Example method
+  // See https://reactnative.dev/docs/native-modules-android
+  @ReactMethod
+  fun multiply(a: Double, b: Double, promise: Promise) {
+    implementation.multiply(a, b, promise)
+  }
+
+  @ReactMethod
+  fun setIntentConfig(args: ReadableArray, promise: Promise) {
+    implementation.setIntentConfig(args, promise)
+  }
+
+  @ReactMethod
+  fun getPhoneID(promise: Promise) {
+    implementation.getPhoneID(promise)
+  }
+
+  //region: LifecycleEventListener
+  override fun onHostResume() {
+    if (BuildConfig.DEBUG) Log.d(name, "onHostResume: register Application receivers")
+    implementation.registerBroadcastReceiver()
+  }
+
+  override fun onHostPause() {
+    if (BuildConfig.DEBUG) Log.d(name, "onHostPause: unregister receivers")
+    implementation.unregisterBroadcastReceiver()
+  }
+
+  override fun onHostDestroy() {
+    if (BuildConfig.DEBUG) Log.d(name, "onHostDestroy: Destroy host")
+  }
+  //endregion
+}

package/ios/BarcodeScanner-Bridging-Header.h

@@ -0,0 +1,2 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>

package/ios/BarcodeScanner.m

@@ -0,0 +1,14 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(RNBroadcastReceiver, NSObject)
+
+RCT_EXTERN_METHOD(multiply:(float)a withB:(float)b
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+@end

package/ios/BarcodeScanner.swift

@@ -0,0 +1,8 @@
+@objc(RNBroadcastReceiver)
+class RNBroadcastReceiver: NSObject {
+
+  @objc(multiply:withB:withResolver:withRejecter:)
+  func multiply(a: Float, b: Float, resolve:RCTPromiseResolveBlock,reject:RCTPromiseRejectBlock) -> Void {
+    resolve(a*b)
+  }
+}