bridgefy-react-native 1.0.1

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2023 Bridgefy Inc
+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,145 @@
+
+
+<p align="center">
+    <img src="https://www.gitbook.com/cdn-cgi/image/width=256,dpr=2,height=40,fit=contain,format=auto/https%3A%2F%2F3290834949-files.gitbook.io%2F~%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F5XKIMMP6VF2l9XuPV80l%252Flogo%252Fd78nQFIysoU2bbM5fYNP%252FGroup%25203367.png%3Falt%3Dmedia%26token%3Df83a642d-8a9a-411f-9ef4-d7189a4c5f0a" />
+</p>
+
+<p align="center">
+    <img src="https://3290834949-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5XKIMMP6VF2l9XuPV80l%2Fuploads%2FD0HSf0lWC4pWB4U7inIw%2Fharegit.jpg?alt=media&token=a400cf7d-3254-4afc-bed0-48f7d98205b0"/>
+</p>
+
+# Bridgefy React Native SDK
+![GitHub last commit](https://img.shields.io/github/last-commit/bridgefy/bridgefy_flutter)
+![GitHub issues](https://img.shields.io/github/issues-raw/bridgefy/bridgefy_flutter?style=plastic)
+
+The Bridgefy Software Development Kit (SDK) is a state-of-the-art, plug-and-play package that will let people use your mobile app when they don’t have access to the Internet, by using Bluetooth mesh networks.
+
+Integrate the Bridgefy SDK into your Android and iOS app to reach the 3.5 billion people that don’t always have access to an Internet connection, and watch engagement and revenue grow!
+
+**Website**. https://bridgefy.me/sdk <br>
+**Email**. contact@bridgefy.me <br>
+**witter**. https://twitter.com/bridgefy <br>
+**Facebook**. https://www.facebook.com/bridgefy <br>
+
+## Operation mode
+
+All the connections are handled seamlessly by the SDK to create a mesh network. The size of this
+network depends on the number of devices connected and the environment as a variable factor,
+allowing you to join nodes in the same network or nodes in different networks.
+
+![networking](https://images.saymedia-content.com/.image/t_share/MTkzOTUzODU0MDkyNjE3MjIx/particlesjs-examples.gif)
+
+## Platform permissions
+
+To utilize this SDK in a React Native application, you'll need to configure permissions for each
+individual platform (iOS and Android) first. You can read more about each platform's requirements
+below:
+
+* [iOS Permissions](https://github.com/bridgefy/sdk-ios#permissions)
+* [Android Permissions](https://github.com/bridgefy/sdk-android#android-permissions)
+
+## Installation
+
+Since this SDK is still in beta, you'll need to add a reference to this repository in your
+`package.json` file:
+
+```
+npm i git+https://github.com/bridgefy/bridgefy-react-native.git
+```
+
+## Usage
+
+### Initialization
+
+The `initialize` method initializes the Bridgefy SDK with the given API key and propagation profile.
+We will configure event listeners later.
+
+```typescript
+import { Bridgefy, BridgefyPropagationProfile } from 'bridgefy-react-native';
+
+const bridgefy = new Bridgefy();
+
+export default function App() {
+  React.useEffect(() => {
+    bridgefy
+      .initialize('api-key', BridgefyPropagationProfile.standard)
+      .catch((error) => {
+        console.error(error);
+      });
+  });
+```
+
+Once initialized, you can call `start` to begin using the SDK.
+
+```typescript
+bridgefy.start();
+```
+
+### Sending data
+
+The following method is used to send data using a transmission mode. This method returns a UUID to
+identify the message that was sent. You'll need to serialize your data into a `string` before
+transmission so React Native can communicate the information to the native platform.
+
+```typescript
+async function sendData() {
+  const userId = await bridgefy.currentUserId();
+  const lastMessageId = await bridgefy.send(
+    'data', // String encoded data to send.
+    {
+      type: BridgefyTransmissionModeType.broadcast,
+      uuid: userId,
+    },
+  );
+}
+```
+
+### Responding to SDK events
+
+The SDK can report events to your app through an instance of React's `NativeEventEmitter`.
+
+The following is an example subscription to a couple of events. Each message will contain
+information relevant to the event being transmitted.
+
+```typescript
+React.useEffect(() => {
+  const subscriptions: EmitterSubscription[] = [];
+  const eventEmitter = new NativeEventEmitter(
+    NativeModules.BridgefyReactNative
+  );
+  // When the Bridgefy SDK started successfully.
+  subscriptions.push(
+    eventEmitter.addListener(BridgefyEvents.bridgefyDidStart, (event) => {
+      console.log(`Bridgefy started`, event);
+    })
+  );
+  // When this device received data from another Bridgefy device.
+  subscriptions.push(
+    eventEmitter.addListener(
+      BridgefyEvents.bridgefyDidReceiveData,
+      (event) => {
+        console.log(`Bridgefy received data`, event);
+      }
+    )
+  );
+  return () => {
+    for (const sub of subscriptions) {
+      sub.remove();
+    }
+  };
+});
+```
+
+To see a full list of events, see the `BridgefyEvents` enum.
+
+## Multi-Platform Support
+
+Bridgefy's SDKs are designed to work seamlessly across different platforms, including iOS and Android. This means that users with different devices can communicate with each other as long as they have the Bridgefy-enabled applications installed.
+
+* [Bridgefy iOS](https://github.com/bridgefy/sdk-ios)
+* [Bridgefy Android](https://github.com/bridgefy/sdk-android)
+
+## Contact & Support
++ contact@bridgefy.me
+
+© 2023 Bridgefy Inc. All rights reserved

package/android/build.gradle

@@ -0,0 +1,105 @@
+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["BridgefyReactNative_kotlinVersion"]
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:7.2.1"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+rootProject.allprojects {
+  repositories {
+    maven {
+      url "http://34.82.5.94:8081/artifactory/libs-release-local"
+      allowInsecureProtocol = true
+    }
+  }
+}
+
+allprojects {
+  repositories {
+    google()
+    mavenCentral()
+  }
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+
+def appProject = rootProject.allprojects.find { it.plugins.hasPlugin('com.android.application') }
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["BridgefyReactNative_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["BridgefyReactNative_" + name]).toInteger()
+}
+
+android {
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+  }
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation (group: "me.bridgefy", name: "android-sdk", version: "1.0.1", ext: "aar") {
+    transitive = true
+  }
+  // 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 "androidx.preference:preference-ktx:1.2.0"
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "BridgefyReactNative"
+    codegenJavaPackageName = "me.bridgefy.plugin.react_native"
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+BridgefyReactNative_kotlinVersion=1.7.0
+BridgefyReactNative_minSdkVersion=21
+BridgefyReactNative_targetSdkVersion=31
+BridgefyReactNative_compileSdkVersion=31
+BridgefyReactNative_ndkversion=21.4.7075529

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,10 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:tools="http://schemas.android.com/tools"
+  package="me.bridgefy.plugin.react_native">
+  <uses-permission-sdk-23 android:name="android.permission.ACCESS_COARSE_LOCATION" android:maxSdkVersion="30" tools:node="replace" />
+  <uses-permission-sdk-23 android:name="android.permission.ACCESS_FINE_LOCATION" android:maxSdkVersion="33" tools:node="replace" />
+  <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" android:maxSdkVersion="30" />
+  <uses-permission android:name="android.permission.BLUETOOTH_SCAN" tools:node="replace" />
+  <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
+  <uses-permission android:name="android.permission.BLUETOOTH_ADVERTISE" />
+</manifest>

package/android/src/main/java/me/bridgefy/plugin/react_native/BridgefyReactNativeModule.kt

@@ -0,0 +1,323 @@
+package me.bridgefy.plugin.react_native
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import me.bridgefy.Bridgefy
+import me.bridgefy.commons.TransmissionMode
+import me.bridgefy.commons.exception.BridgefyException
+import me.bridgefy.commons.listener.BridgefyDelegate
+import me.bridgefy.commons.propagation.PropagationProfile
+import java.util.UUID
+
+class BridgefyReactNativeModule(reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  private var bridgefy: Bridgefy
+
+  init {
+    bridgefy = Bridgefy(reactContext)
+  }
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  @ReactMethod
+  fun initialize(apiKey: String,
+                 propagationProfile: String,
+                 promise: Promise) {
+    val profile = propagationProfileFromString(propagationProfile)
+    try {
+      bridgefy.init(
+        null,
+        UUID.fromString(apiKey),
+        profile!!,
+        object : BridgefyDelegate {
+          override fun onConnected(peerID: UUID) {
+            val params = Arguments.createMap().apply {
+              putString("userId", peerID.toString())
+            }
+            sendEvent(reactApplicationContext, "bridgefyDidConnect", params)
+          }
+
+          override fun onConnectedPeers(connectedPeers: List<UUID>) {
+            connectedPeers.forEach {
+              onConnected(it)
+            }
+          }
+
+          override fun onConnectedSecurely(peerID: UUID) {
+            val params = Arguments.createMap().apply {
+              putString("userId", peerID.toString())
+            }
+            sendEvent(
+              reactApplicationContext,
+              "bridgefyDidEstablishSecureConnection",
+              params
+            )
+          }
+
+          override fun onDisconnected(peerID: UUID) {
+            val params = Arguments.createMap().apply {
+              putString("userId", peerID.toString())
+            }
+            sendEvent(reactApplicationContext, "bridgefyDidDisconnect", params)
+          }
+
+          // TODO: iOS provides BridgefyError
+          override fun onFailToSend(messageID: UUID) {
+            val params = Arguments.createMap().apply {
+              putString("messageId", messageID.toString())
+            }
+            sendEvent(reactApplicationContext, "bridgefyDidFailSendingMessage", params)
+          }
+
+          override fun onFailToStart(error: BridgefyException) {
+            val params = Arguments.createMap().apply {
+              putMap("error", mapFromBridgefyException(error))
+            }
+            sendEvent(reactApplicationContext, "bridgefyDidFailToStart", params)
+          }
+
+          override fun onFailToStop(error: BridgefyException) {
+            val params = Arguments.createMap().apply {
+              putMap("error", mapFromBridgefyException(error))
+            }
+            sendEvent(reactApplicationContext, "bridgefyDidFailToStop", params)
+          }
+
+          override fun onProgressOfSend(messageID: UUID, position: Int, of: Int) {
+            val params = Arguments.createMap().apply {
+              putString("messageId", messageID.toString())
+              putInt("position", position)
+              putInt("of", of)
+            }
+            sendEvent(reactApplicationContext, "bridgefyDidSendDataProgress", params)
+          }
+
+          override fun onReceive(
+            data: ByteArray,
+            messageID: UUID,
+            transmissionMode: TransmissionMode
+          ) {
+            val params = Arguments.createMap().apply {
+              putString("data", String(data))
+              putString("messageId", messageID.toString())
+              putMap("transmissionMode", mapFromTransmissionMode(transmissionMode))
+            }
+            sendEvent(reactApplicationContext, "bridgefyDidReceiveData", params)
+          }
+
+          override fun onSend(messageID: UUID) {
+            val params = Arguments.createMap().apply {
+              putString("messageId", messageID.toString())
+            }
+            sendEvent(reactApplicationContext, "bridgefyDidSendMessage", params)
+          }
+
+          override fun onStarted(userID: UUID) {
+            val params = Arguments.createMap().apply {
+              putString("userId", userID.toString())
+            }
+            sendEvent(reactApplicationContext, "bridgefyDidStart", params)
+          }
+
+          // TODO: bridgefyDidFailToEstablishSecureConnection
+          // TODO: bridgefyDidDestroySession
+          // TODO: bridgefyDidFailToDestroySession
+
+          override fun onStopped() {
+            sendEvent(reactApplicationContext, "bridgefyDidStop", null)
+          }
+        }
+      )
+      promise.resolve(null)
+    } catch (error: BridgefyException) {
+      val map = mapFromBridgefyException(error)
+      promise.reject(map.getString("code"), map.getString("message"), error)
+    }
+  }
+
+  @ReactMethod
+  fun start(promise: Promise) {
+    bridgefy.start()
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun send(data: String, transmissionMode: ReadableMap, promise: Promise) {
+    val mode = transmissionModeFromMap(transmissionMode)!!
+    try {
+      val uuid = bridgefy.send(data.toByteArray(), mode)
+      promise.resolve(Arguments.createMap().apply {
+        putString("messageId", uuid.toString())
+      })
+    } catch (error: BridgefyException) {
+      val map = mapFromBridgefyException(error)
+      promise.reject(map.getString("code"), map.getString("message"), error)
+    }
+  }
+
+  @ReactMethod
+  fun stop(promise: Promise) {
+    bridgefy.stop()
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun connectedPeers(promise: Promise) {
+    promise.resolve(arrayOf<String>())
+    TODO("Android impl")
+  }
+
+  @ReactMethod
+  fun currentUserID(promise: Promise) {
+    val userId = bridgefy.currentBridgefyUser()
+    promise.resolve(Arguments.createMap().apply {
+      putString("userId", userId.toString())
+    })
+  }
+
+  @ReactMethod
+  fun establishSecureConnection(userId: String, promise: Promise) {
+    val uuid = UUID.fromString(userId)
+    bridgefy.establishSecureConnection(uuid)
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun licenseExpirationDate(promise: Promise) {
+    val date = bridgefy.licenseExpirationDate()
+    promise.resolve(Arguments.createMap().apply {
+      putString("licenseExpirationDate", date?.time.toString())
+    })
+  }
+
+  companion object {
+    const val NAME = "BridgefyReactNative"
+  }
+
+  private fun sendEvent(reactContext: ReactContext, eventName: String, params: WritableMap?) {
+    reactContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(eventName, params)
+  }
+
+  private fun mapFromBridgefyException(exception: BridgefyException): ReadableMap {
+    var code: String
+    var details: Int? = null
+    var message: String? = null
+    when (exception) {
+      is BridgefyException.AlreadyStartedException -> {
+        code = "alreadyStarted"
+      }
+      is BridgefyException.DeviceCapabilitiesException -> {
+        code = "deviceCapabilities"
+        message = exception.error
+      }
+      is BridgefyException.ExpiredLicenseException -> {
+        code = "expiredLicense"
+        message = exception.error
+      }
+      is BridgefyException.GenericException -> {
+        code = "genericException"
+        message = exception.message
+        details = exception.code
+      }
+      is BridgefyException.InconsistentDeviceTimeException -> {
+        code = "inconsistentDeviceTimeException"
+        message = exception.error
+      }
+      is BridgefyException.InternetConnectionRequiredException -> {
+        code = "internetConnectionRequiredException"
+        message = exception.error
+      }
+      is BridgefyException.InvalidAPIKeyFormatException -> {
+        code = "invalidAPIKey"
+        message = exception.error
+      }
+      is BridgefyException.MissingApplicationIdException -> {
+        code = "missingApplicationId"
+        message = exception.error
+      }
+      is BridgefyException.PermissionException -> {
+        code = "permissionException"
+        message = exception.error
+      }
+      is BridgefyException.RegistrationException -> {
+        code = "registrationException"
+        message = exception.error
+      }
+      is BridgefyException.SessionErrorException -> {
+        code = "sessionError"
+        message = exception.error
+      }
+      is BridgefyException.SimulatorIsNotSupportedException -> {
+        code = "simulatorIsNotSupported"
+        message = exception.error.toString()
+      }
+      is BridgefyException.SizeLimitExceededException -> {
+        code = "sizeLimitExceeded"
+        message = exception.error
+      }
+      is BridgefyException.UnknownException -> {
+        code = "unknownException"
+        message = exception.error.toString()
+      } else -> {
+        code = "unknownException"
+        message = exception.toString()
+      }
+    }
+    return Arguments.createMap().apply {
+      putString("code", code)
+      putString("message", message)
+      if (details != null) putInt("details", details) else putNull("details")
+    }
+  }
+
+  private fun propagationProfileFromString(str: String): PropagationProfile? {
+    return when (str) {
+      "highDensityNetwork" -> PropagationProfile.HighDensityEnvironment
+      "sparseNetwork" -> PropagationProfile.SparseEnvironment
+      "longReach" -> PropagationProfile.LongReach
+      "shortReach" -> PropagationProfile.ShortReach
+      "standard" -> PropagationProfile.Standard
+      else -> null
+    }
+  }
+
+  private fun mapFromTransmissionMode(mode: TransmissionMode): ReadableMap {
+    return when (mode) {
+      is TransmissionMode.Broadcast -> Arguments.createMap().apply {
+        putString("mode", "broadcast")
+        putString("uuid", mode.sender.toString())
+      }
+      is TransmissionMode.Mesh -> Arguments.createMap().apply {
+        putString("mode", "mesh")
+        putString("uuid", mode.receiver.toString())
+      }
+      is TransmissionMode.P2P -> Arguments.createMap().apply {
+        putString("mode", "p2p")
+        putString("uuid", mode.receiver.toString())
+      }
+      else -> Arguments.createMap()
+    }
+  }
+
+  private fun transmissionModeFromMap(map: ReadableMap): TransmissionMode? {
+    val uuid = UUID.fromString(map.getString("uuid"))
+    return when (map.getString("type")) {
+      "p2p" -> TransmissionMode.P2P(uuid)
+      "mesh" -> TransmissionMode.Mesh(uuid)
+      "broadcast" -> TransmissionMode.Broadcast(uuid)
+      else -> null
+    }
+  }
+}

package/android/src/main/java/me/bridgefy/plugin/react_native/BridgefyReactNativePackage.kt

@@ -0,0 +1,17 @@
+package me.bridgefy.plugin.react_native
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+
+class BridgefyReactNativePackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(BridgefyReactNativeModule(reactContext))
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}

package/bridgefy-react-native.podspec

@@ -0,0 +1,42 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
+
+Pod::Spec.new do |s|
+  s.name         = "bridgefy-react-native"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => "11.0" }
+  s.source       = { :git => "https://github.com/bridgefy/bridgefy-react-native.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+  s.vendored_frameworks = "ios/Frameworks/BridgefySDK.xcframework"
+
+  # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
+  # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.
+  if respond_to?(:install_modules_dependencies, true)
+    install_modules_dependencies(s)
+  else
+  s.dependency "React-Core"
+
+  # Don't install the dependencies when we run `pod install` in the old architecture.
+  if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
+    s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
+    s.pod_target_xcconfig    = {
+        "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
+        "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
+        "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
+    }
+    s.dependency "React-Codegen"
+    s.dependency "RCT-Folly"
+    s.dependency "RCTRequired"
+    s.dependency "RCTTypeSafety"
+    s.dependency "ReactCommon/turbomodule/core"
+   end
+  end    
+end

package/ios/BridgefyReactNative-Bridging-Header.h

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