bridgefy-react-native 1.1.7 → 1.1.9

package/src/index.tsx

@@ -1,230 +1,178 @@
-import { NativeModules, Platform } from 'react-native';
-import type {
-  BridgefyService,
-  IInitializeIn,
-  IStartIn,
-} from './infraestructure';
-
-const LINKING_ERROR =
-  "The package 'bridgefy-react-native' doesn't seem to be linked. Make sure: \n\n" +
-  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
-  '- You rebuilt the app after installing the package\n' +
-  '- You are not using Expo Go\n';
-
-const BridgefyReactNative = NativeModules.BridgefyReactNative
-  ? NativeModules.BridgefyReactNative
-  : new Proxy(
-      {},
-      {
-        get() {
-          throw new Error(LINKING_ERROR);
-        },
-      }
-    );
-
-/** Profile that defines a series of properties and rules for the propagation of messages. */
-export enum BridgefyPropagationProfile {
-  standard = 'standard',
-  highDensityNetwork = 'highDensityNetwork',
-  sparseNetwork = 'sparseNetwork',
-  longReach = 'longReach',
-  shortReach = 'shortReach',
-}
+import { NativeEventEmitter, NativeModules } from 'react-native';
+import BridgefyReactNative, {
+  BridgefyPropagationProfile,
+  BridgefyTransmissionModeType,
+  BridgefyEvents,
+  BridgefyErrorCode,
+  BridgefyOperationMode,
+  type BridgefyInitConfig,
+  type BridgefyTransmissionMode,
+  type BridgefyError,
+  type BridgefyMessageData,
+  type BridgefyStartEvent,
+  type BridgefyConnectEvent,
+  type BridgefyDisconnectEvent,
+  type BridgefySendMessageEvent,
+  type BridgefyReceiveDataEvent,
+  type BridgefySecureConnectionEvent,
+  type BridgefyLicenseInfo,
+  type BridgefyUpdatedConnectedEvent,
+  type BridgefyDidSendDataProgress,
+  type BridgefyOperationModeConfig,
+  type BridgefyOperationModeStatus,
+} from './NativeBridgefy';
 
-/** The mode used to propagate a message through nearby devices. */
-export enum BridgefyTransmissionModeType {
-  /** Deliver a message to a specific recipient only if there's an active connection with it. */
-  p2p = 'p2p',
-  /** Deliver a message to a specific recipient using nearby devices to propagate it. */
-  mesh = 'mesh',
-  /** Propagate a message readable by every device that receives it. */
-  broadcast = 'broadcast',
-}
+/**
+ * index.ts
+ *
+ * Main export file for Bridgefy React Native TurboModule
+ * Provides a clean JavaScript/TypeScript wrapper around the native TurboModule
+ */
 
-export interface BridgefyTransmissionMode {
-  type: BridgefyTransmissionModeType;
-  uuid: string;
-}
-
-/** Describes errors in the Bridgefy error domain. */
-export enum BridgefyErrorType {
-  /** The Bridgefy SDK cannot run in the simulator */
-  simulatorIsNotSupported = 'simulatorIsNotSupported',
-  /** The Bridgefy SDK is already running */
-  alreadyStarted = 'alreadyStarted',
-  /** The provided API key is not valid */
-  invalidAPIKey = 'invalidAPIKey',
-  /** The license is expired */
-  expiredLicense = 'expiredLicense',
-  /** An error occurred while creating the session */
-  sessionError = 'sessionError',
-  /** (iOS) The Bridgefy SDK hasn't been started */
-  notStarted = 'notStarted',
-  /** (iOS) A Bridgefy SDK instance already exists */
-  alreadyInstantiated = 'alreadyInstantiated',
-  /** (iOS) The Bridgefy SDK is performing the start process */
-  startInProgress = 'startInProgress',
-  /** (iOS) The Bridgefy SDK service is not started */
-  serviceNotStarted = 'serviceNotStarted',
-  /** (iOS) Cannot get app's bundle id */
-  missingBundleID = 'missingBundleID',
-  /** (iOS) An internet connection is required to validate the license */
-  internetConnectionRequired = 'internetConnectionRequired',
-  /** (iOS) The device's time has been modified */
-  inconsistentDeviceTime = 'inconsistentDeviceTime',
-  /** (iOS) The user does not allow the use of BLE */
-  BLEUsageNotGranted = 'BLEUsageNotGranted',
-  /** (iOS) The use of BLE in this device is restricted */
-  BLEUsageRestricted = 'BLEUsageRestricted',
-  /** (iOS) The BLE antenna has been turned off */
-  BLEPoweredOff = 'BLEPoweredOff',
-  /** (iOS) The usage of BLE is not supported in the device */
-  BLEUnsupported = 'BLEUnsupported',
-  /** (iOS) BLE usage failed with an unknown error */
-  BLEUnknownError = 'BLEUnknownError',
-  /** (iOS) Inconsistent connection */
-  inconsistentConnection = 'inconsistentConnection',
-  /** (iOS) Connection is already secure */
-  connectionIsAlreadySecure = 'connectionIsAlreadySecure',
-  /** (iOS) Cannot create secure connection */
-  cannotCreateSecureConnection = 'cannotCreateSecureConnection',
-  /** (iOS) The length of the data exceed the maximum limit */
-  dataLengthExceeded = 'dataLengthExceeded',
-  /** (iOS) The data to send is empty */
-  dataValueIsEmpty = 'dataValueIsEmpty',
-  /** (iOS) The requested peer is not connected */
-  peerIsNotConnected = 'peerIsNotConnected',
-  /** (iOS) An internal error occurred */
-  internalError = 'internalError',
-  /** (iOS) An error occurred while validating the license */
-  licenseError = 'licenseError',
-  /** (iOS) An error occurred while storing data */
-  storageError = 'storageError',
-  /** (iOS) An error occurred while encoding the message */
-  encodingError = 'encodingError',
-  /** (iOS) An error occurred while encrypting the message */
-  encryptionError = 'encryptionError',
-  /** (Android) Missing application ID */
-  missingApplicationId = 'missingApplicationId',
-  /** (Android) Permission exception */
-  permissionException = 'permissionException',
-  /** (Android) Registration exception */
-  registrationException = 'registrationException',
-  /** (Android) Size limit exceeded */
-  sizeLimitExceeded = 'sizeLimitExceeded',
-  /** (Android) Device capabilities error */
-  deviceCapabilities = 'deviceCapabilities',
-  /** (Android) Generic exception */
-  genericException = 'genericException',
-  /** (Android) Inconsistent device time */
-  inconsistentDeviceTimeException = 'inconsistentDeviceTimeException',
-  /** (Android) Internet connection required */
-  internetConnectionRequiredException = 'internetConnectionRequiredException',
-  /** (Android) Unknown exception */
-  unknownException = 'unknownException',
-}
+// Export types and enums
+export {
+  BridgefyPropagationProfile,
+  BridgefyTransmissionModeType,
+  BridgefyEvents,
+  BridgefyErrorCode,
+  BridgefyOperationMode,
+  type BridgefyInitConfig,
+  type BridgefyTransmissionMode,
+  type BridgefyError,
+  type BridgefyMessageData,
+  type BridgefyStartEvent,
+  type BridgefyConnectEvent,
+  type BridgefyDisconnectEvent,
+  type BridgefySendMessageEvent,
+  type BridgefyReceiveDataEvent,
+  type BridgefySecureConnectionEvent,
+  type BridgefyLicenseInfo,
+  type BridgefyUpdatedConnectedEvent,
+  type BridgefyDidSendDataProgress,
+  type BridgefyOperationModeConfig,
+  type BridgefyOperationModeStatus,
+};
 
 /**
- * These events are available via subscriptions to the `NativeEventEmitter` using the
- * `NativeModules.BridgefyReactNative` component. See README for further instructions.
+ * Bridgefy class - JavaScript wrapper for the native TurboModule
+ * Provides event emitter capabilities and clean API
  */
-export enum BridgefyEvents {
-  /**
-   * This function is called when the BridgefySDK has been started.
-   */
-  bridgefyDidStart = 'bridgefyDidStart',
-  /**
-   * This function is called when an error occurred while starting the BridgefySDK.
-   */
-  bridgefyDidFailToStart = 'bridgefyDidFailToStart',
-  /**
-   * This function is called when the BridgefySDK has been stopped.
-   */
-  bridgefyDidStop = 'bridgefyDidStop',
-  /**
-   * This function is called when an error occurred while stopping the BridgefySDK.
-   */
-  bridgefyDidFailToStop = 'bridgefyDidFailToStop',
-  /**
-   * The current session was destroyed
-   */
-  bridgefyDidDestroySession = 'bridgefyDidDestroySession',
-  /**
-   * An error occurred while destroying the current session
-   */
-  bridgefyDidFailToDestroySession = 'bridgefyDidFailToDestroySession',
+export class Bridgefy {
+  private eventEmitter: NativeEventEmitter;
+
+  constructor() {
+    // Create event emitter for native events
+    const module = BridgefyReactNative || NativeModules.BridgefyReactNative;
+    this.eventEmitter = new NativeEventEmitter(module);
+  }
+
   /**
-   * This function is called to notify a new connection.
+   * Initialize the Bridgefy SDK
    */
-  bridgefyDidConnect = 'bridgefyDidConnect',
+  async initialize(
+    apiKey: string,
+    verboseLogging: boolean = false,
+    operationMode?: BridgefyOperationMode
+  ): Promise<void> {
+    const config: BridgefyInitConfig = {
+      apiKey,
+      verboseLogging,
+      operationMode,
+    };
+    return BridgefyReactNative.initialize(config);
+  }
+
   /**
-   * This function is called to notify a disconnection.
+   * Start the Bridgefy SDK
    */
-  bridgefyDidDisconnect = 'bridgefyDidDisconnect',
+  async start(
+    userId?: string,
+    propagationProfile: BridgefyPropagationProfile = BridgefyPropagationProfile.REALTIME
+  ): Promise<void> {
+    return BridgefyReactNative.start(userId, propagationProfile);
+  }
+
   /**
-   * This function is called to notify when an on-demand secure connection was established.
+   * Stop the Bridgefy SDK
    */
-  bridgefyDidEstablishSecureConnection = 'bridgefyDidEstablishSecureConnection',
+  async stop(): Promise<void> {
+    return BridgefyReactNative.stop();
+  }
+
   /**
-   * This function is called to notify when an on-demand secure connection could not be established.
+   * Destroy the current session
    */
-  bridgefyDidFailToEstablishSecureConnection = 'bridgefyDidFailToEstablishSecureConnection',
+  async destroySession(): Promise<void> {
+    return BridgefyReactNative.destroySession();
+  }
+
   /**
-   * This function is called when you confirm the sending of the message
+   * Send data through the mesh network
    */
-  bridgefyDidSendMessage = 'bridgefyDidSendMessage',
+  async send(
+    data: string,
+    transmissionMode: BridgefyTransmissionMode
+  ): Promise<string> {
+    return BridgefyReactNative.send(data, transmissionMode);
+  }
+
   /**
-   * This function is called when the message could not be sent
+   * Send broadcast message (convenience method)
    */
-  bridgefyDidFailSendingMessage = 'bridgefyDidFailSendingMessage',
+  async sendBroadcast(data: string): Promise<string> {
+    const userId = await this.currentUserId();
+    return this.send(data, {
+      type: BridgefyTransmissionModeType.BROADCAST,
+      uuid: userId,
+    });
+  }
+
   /**
-   * This function is called when a new message is received
+   * Send P2P message (convenience method)
    */
-  bridgefyDidReceiveData = 'bridgefyDidReceiveData',
+  async sendP2P(data: string, recipientId: string): Promise<string> {
+    return this.send(data, {
+      type: BridgefyTransmissionModeType.P2P,
+      uuid: recipientId,
+    });
+  }
+
   /**
-   * (Android) Called when there is progress while transmitting data.
+   * Send mesh message (convenience method)
    */
-  bridgefyDidSendDataProgress = 'bridgefyDidSendDataProgress',
-}
+  async sendMesh(data: string, recipientId: string): Promise<string> {
+    return this.send(data, {
+      type: BridgefyTransmissionModeType.MESH,
+      uuid: recipientId,
+    });
+  }
 
-/**
- * Bridgefy
- */
-export class Bridgefy implements BridgefyService {
   /**
-   * Initialize the SDK
-   * @param apiKey API key
-   * @param verboseLogging The log level.
+   * Establish secure connection with a peer
    */
-  async initialize({
-    apiKey,
-    verboseLogging = false,
-  }: IInitializeIn): Promise<void> {
-    await BridgefyReactNative.initialize(apiKey, verboseLogging);
+  async establishSecureConnection(userId: string): Promise<void> {
+    return BridgefyReactNative.establishSecureConnection(userId);
   }
 
   /**
-   * Start Bridgefy SDK operations
+   * Get current user ID
    */
-  async start(params?: IStartIn): Promise<void> {
-    const userId = params?.userId ?? null;
-    const propagationProfile =
-      params?.propagationProfile ?? BridgefyPropagationProfile.standard;
-    return await BridgefyReactNative.start(userId, propagationProfile);
+  async currentUserId(): Promise<string> {
+    return BridgefyReactNative.currentUserId();
   }
 
   /**
-   * Stop Bridgefy SDK operations
+   * Get list of connected peers
    */
-  async stop(): Promise<void> {
-    return await BridgefyReactNative.stop();
+  async connectedPeers(): Promise<string[]> {
+    return BridgefyReactNative.connectedPeers();
   }
 
   /**
-   * Destroy current session
+   * Get license expiration info
    */
-  async destroySession(): Promise<void> {
-    return BridgefyReactNative.destroySession();
+  async licenseExpirationDate(): Promise<BridgefyLicenseInfo> {
+    return BridgefyReactNative.licenseExpirationDate();
   }
 
   /**
@@ -235,60 +183,170 @@ export class Bridgefy implements BridgefyService {
   }
 
   /**
-   * Function used to send data using a ``TransmissionMode``. This method returns a UUID to identify
-   * the message sent.
-   * @param data The message data
-   * @param transmissionMode The mode used to propagate a message through nearby devices.
-   * @returns The id of the message that was sent.
+   * Check if SDK is initialized
    */
-  async send(
-    data: string,
-    transmissionMode: BridgefyTransmissionMode
-  ): Promise<string> {
-    const result = await BridgefyReactNative.send(data, transmissionMode);
-    return result.messageId;
+  async isInitialized(): Promise<boolean> {
+    return BridgefyReactNative.isInitialized();
   }
 
   /**
-   * Establishes a secure connection with the specified user
-   * @param userId The UUID of the user with whom a secure connection should be established.
+   * Check if SDK is started
    */
-  async establishSecureConnection(userId: string): Promise<void> {
-    return BridgefyReactNative.establishSecureConnection(userId);
+  async isStarted(): Promise<boolean> {
+    return BridgefyReactNative.isStarted();
+  }
+
+  async setOperationMode(
+    config: BridgefyOperationModeConfig
+  ): Promise<BridgefyOperationModeConfig> {
+    return BridgefyReactNative.setOperationMode(config);
+  }
+  async getOperationMode(): Promise<BridgefyOperationModeConfig> {
+    return BridgefyReactNative.getOperationMode();
+  }
+  async switchToBackground(): Promise<void> {
+    return BridgefyReactNative.switchToBackground();
+  }
+  async switchToForeground(): Promise<void> {
+    return BridgefyReactNative.switchToForeground();
+  }
+  async getOperationStatus(): Promise<BridgefyOperationModeStatus> {
+    return BridgefyReactNative.getOperationStatus();
   }
 
   /**
-   * Get current user Id
-   * @returns User Id
+   * Add event listener
    */
-  async currentUserId(): Promise<string> {
-    const result = await BridgefyReactNative.currentUserId();
-    return result.userId;
+  addEventListener(
+    eventName: BridgefyEvents,
+    listener: (event: any) => void
+  ): { remove: () => void } {
+    const subscription = this.eventEmitter.addListener(eventName, listener);
+    return {
+      remove: () => subscription.remove(),
+    };
   }
 
   /**
-   * Returns connected peers
-   * @returns List of connected peers
+   * Remove all listeners for an event
    */
-  async connectedPeers(): Promise<string[]> {
-    const result = await BridgefyReactNative.connectedPeers();
-    return result.connectedPeers;
+  removeAllListeners(eventName?: BridgefyEvents): void {
+    if (eventName) {
+      this.eventEmitter.removeAllListeners(eventName);
+    } else {
+      // Remove all listeners for all events
+      Object.values(BridgefyEvents).forEach((event) => {
+        this.eventEmitter.removeAllListeners(event);
+      });
+    }
   }
 
   /**
-   * Returns license expiration date
-   * @returns Expiration date
+   * Event listener helpers for common events
    */
-  async licenseExpirationDate(): Promise<Date> {
-    const result = await BridgefyReactNative.licenseExpirationDate();
-    return new Date(result.licenseExpirationDate as number);
+
+  onStart(listener: (event: BridgefyStartEvent) => void) {
+    return this.addEventListener(BridgefyEvents.BRIDGEFY_DID_START, listener);
   }
 
-  async isInitialized(): Promise<boolean> {
-    return await BridgefyReactNative.isInitialized();
+  onStop(listener: () => void) {
+    return this.addEventListener(BridgefyEvents.BRIDGEFY_DID_STOP, listener);
   }
 
-  async isStarted(): Promise<boolean> {
-    return BridgefyReactNative.isStarted();
+  onFailToStart(listener: (error: BridgefyError) => void) {
+    return this.addEventListener(
+      BridgefyEvents.BRIDGEFY_DID_FAIL_TO_START,
+      listener
+    );
+  }
+
+  onFailToStop(listener: (error: BridgefyError) => void) {
+    return this.addEventListener(
+      BridgefyEvents.BRIDGEFY_DID_FAIL_TO_STOP,
+      listener
+    );
+  }
+
+  onConnect(listener: (event: BridgefyConnectEvent) => void) {
+    return this.addEventListener(BridgefyEvents.BRIDGEFY_DID_CONNECT, listener);
+  }
+
+  onConnectedPeers(listener: (event: BridgefyUpdatedConnectedEvent) => void) {
+    return this.addEventListener(
+      BridgefyEvents.BRIDGEFY_DID_UPDATE_CONNECTED_PEERS,
+      listener
+    );
+  }
+
+  onDisconnect(listener: (event: BridgefyDisconnectEvent) => void) {
+    return this.addEventListener(
+      BridgefyEvents.BRIDGEFY_DID_DISCONNECT,
+      listener
+    );
+  }
+
+  onSendMessage(listener: (event: BridgefySendMessageEvent) => void) {
+    return this.addEventListener(
+      BridgefyEvents.BRIDGEFY_DID_SEND_MESSAGE,
+      listener
+    );
+  }
+
+  onSendDataProgress(listener: (event: BridgefyDidSendDataProgress) => void) {
+    return this.addEventListener(
+      BridgefyEvents.BRIDGEFY_DID_SEND_DATA_PROGRESS,
+      listener
+    );
+  }
+
+  onFailSendingMessage(
+    listener: (error: BridgefyError & { messageId: string }) => void
+  ) {
+    return this.addEventListener(
+      BridgefyEvents.BRIDGEFY_DID_FAIL_SENDING_MESSAGE,
+      listener
+    );
+  }
+
+  onReceiveData(listener: (event: BridgefyReceiveDataEvent) => void) {
+    return this.addEventListener(
+      BridgefyEvents.BRIDGEFY_DID_RECEIVE_DATA,
+      listener
+    );
+  }
+
+  onEstablishSecureConnection(
+    listener: (event: BridgefySecureConnectionEvent) => void
+  ) {
+    return this.addEventListener(
+      BridgefyEvents.BRIDGEFY_DID_ESTABLISH_SECURE_CONNECTION,
+      listener
+    );
+  }
+
+  onFailToEstablishSecureConnection(
+    listener: (error: BridgefyError & { userId: string }) => void
+  ) {
+    return this.addEventListener(
+      BridgefyEvents.BRIDGEFY_DID_FAIL_TO_ESTABLISH_SECURE_CONNECTION,
+      listener
+    );
+  }
+
+  onUpdateLicense(listener: () => void) {
+    return this.addEventListener(
+      BridgefyEvents.BRIDGEFY_DID_UPDATE_LICENSE,
+      listener
+    );
+  }
+
+  onFailToUpdateLicense(listener: (error: BridgefyError) => void) {
+    return this.addEventListener(
+      BridgefyEvents.BRIDGEFY_DID_FAIL_TO_UPDATE_LICENSE,
+      listener
+    );
   }
 }
+
+// Export default instance for convenience
+export default new Bridgefy();

package/ios/BridgefyReactNative.m

@@ -1,56 +0,0 @@
-#import <React/RCTBridgeModule.h>
-#import <React/RCTEventEmitter.h>
-
-@interface RCT_EXTERN_MODULE(BridgefyReactNative, RCTEventEmitter)
-
-RCT_EXTERN_METHOD(initialize:(NSString *)apiKey
-                  verboseLogging:(BOOL)verboseLogging
-                  resolve:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(start:(NSString *)userId
-                  propagationProfile:(NSString *)propagationProfile
-                  resolve:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(send:(NSString *)data
-                  transmissionMode:(NSDictionary *)transmissionMode
-                  resolve:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(stop:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(connectedPeers:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(currentUserId:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(establishSecureConnection:(NSString *)userId
-                  resolve:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(licenseExpirationDate:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(destroySession:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(updateLicense:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(isInitialized:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(isStarted:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(supportedEvents)
-
-+ (BOOL)requiresMainQueueSetup
-{
-  return NO;
-}
-
-@end