@bota.dev/react-native-app-sdk 2.0.0-beta.0

package/lib/typescript/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/utils/logger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAEjD,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;AAEpD,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,WAAW,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,MAAM,UAAU,GAAG,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;AAUtD,cAAM,MAAM;IACV,OAAO,CAAC,KAAK,CAAoB;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,OAAO,CAA2B;IAE1C,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAI/B,QAAQ,IAAI,QAAQ;IAIpB,UAAU,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,GAAG,IAAI;IAI5C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI/D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI9D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI9D,KAAK,CACH,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,KAAK,EACb,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,IAAI;IAUP,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY;IAI9B,OAAO,CAAC,KAAK;IAcb,OAAO,CAAC,MAAM;CAQf;AAED,cAAM,YAAY;IAEd,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBADR,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM;IAGnC,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI/D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI9D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI9D,KAAK,CACH,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,KAAK,EACb,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,IAAI;CAGR;AAED,eAAO,MAAM,MAAM,QAAe,CAAC;AAEnC,YAAY,EAAE,YAAY,EAAE,CAAC"}

package/package.json

@@ -0,0 +1,100 @@
+{
+  "name": "@bota.dev/react-native-app-sdk",
+  "version": "2.0.0-beta.0",
+  "description": "React Native facade for the Bota App SDK",
+  "packageManager": "npm@12.0.2",
+  "main": "lib/commonjs/index.js",
+  "module": "lib/module/index.js",
+  "types": "lib/typescript/index.d.ts",
+  "react-native": "src/index.ts",
+  "source": "src/index.ts",
+  "files": [
+    "BotaDeviceSDK.podspec",
+    "LICENSE",
+    "README.md",
+    "android/",
+    "generated/",
+    "ios/",
+    "lib/",
+    "scripts/bota_device_sdk_spm_workaround.rb",
+    "src/"
+  ],
+  "scripts": {
+    "build": "bob build",
+    "clean": "rm -rf lib generated/build",
+    "codegen": "node scripts/verify-codegen.mjs --write",
+    "codegen:check": "node scripts/verify-codegen.mjs",
+    "license-check": "node ../../scripts/check-licenses.mjs",
+    "pretest": "npm run build",
+    "test": "node --test test/*.test.mjs",
+    "test:apple:integration": "../../tools/react-native/test-apple-adapter.sh",
+    "test:apple:lifecycle": "../../tools/apple/build-xcframework.sh && swift test -Xswiftc -strict-concurrency=complete -Xswiftc -warnings-as-errors",
+    "test:apple:remote-resolution": "../../tools/react-native/test-apple-adapter.sh remote",
+    "test:apple:spm-workaround": "ruby test/apple-spm-workaround.test.rb",
+    "typecheck": "tsc --noEmit",
+    "verify": "node ../../tools/react-native/verify-package.mjs --workspace-root ../.. --package-root . && npm run codegen:check && npm run typecheck && npm test && npm run license-check"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bota-dev/app-sdk.git",
+    "directory": "frameworks/react-native"
+  },
+  "homepage": "https://docs.bota.dev",
+  "bugs": {
+    "url": "https://github.com/bota-dev/app-sdk/issues"
+  },
+  "author": "Bota",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "peerDependencies": {
+    "react": ">=19.2.3",
+    "react-native": ">=0.86.3 <1.0"
+  },
+  "devDependencies": {
+    "@types/react": "19.2.17",
+    "react": "19.2.3",
+    "react-native": "0.86.3",
+    "react-native-builder-bob": "0.43.0",
+    "typescript": "6.0.3"
+  },
+  "codegenConfig": {
+    "name": "BotaDeviceSDKSpec",
+    "type": "modules",
+    "jsSrcsDir": "./src/specs",
+    "android": {
+      "javaPackageName": "dev.bota.sdk.reactnative"
+    }
+  },
+  "bota": {
+    "nativeModuleName": "BotaDeviceSDK",
+    "reactNativeFloor": "0.86.3",
+    "android": {
+      "compileSdkVersion": 36,
+      "coroutinesVersion": "1.10.2",
+      "kotlinVersion": "2.1.20",
+      "mavenCoordinate": "dev.bota:bota-app-sdk",
+      "minSdkVersion": 26,
+      "namespace": "dev.bota.sdk.reactnative"
+    },
+    "apple": {
+      "podName": "BotaDeviceSDK",
+      "moduleName": "BotaDeviceSDK",
+      "deploymentTarget": "15.1",
+      "swiftVersion": "6.0",
+      "cocoapodsVersion": "1.13.0",
+      "packageUrl": "https://github.com/bota-dev/app-sdk.git",
+      "packageRequirement": "exactVersion",
+      "packageProduct": "BotaAppSDK",
+      "localPackagePathEnvironment": "BOTA_APPLE_SDK_PACKAGE_PATH"
+    }
+  },
+  "dependencies": {
+    "buffer": "6.0.3",
+    "eventemitter3": "5.0.1"
+  }
+}

package/scripts/bota_device_sdk_spm_workaround.rb

@@ -0,0 +1,53 @@
+module BotaDeviceSDKSPMWorkaround
+  POD_NAME = "BotaDeviceSDK"
+  STATIC_LIBRARY_PRODUCT_TYPE = "com.apple.product-type.library.static"
+  SHARED_PRODUCTS_DIRECTORY = "${PODS_CONFIGURATION_BUILD_DIR}"
+
+  module PostInstallPatch
+    def apply_on_post_install(installer)
+      super
+      BotaDeviceSDKSPMWorkaround.apply(installer)
+    end
+  end
+
+  def self.install!(manager)
+    singleton = manager.singleton_class
+    singleton.prepend(PostInstallPatch) unless singleton.ancestors.include?(PostInstallPatch)
+  end
+
+  def self.apply(installer)
+    target = installer.pods_project.targets.find { |candidate| candidate.name == POD_NAME }
+    return unless target&.product_type == STATIC_LIBRARY_PRODUCT_TYPE
+
+    target.build_configurations.each do |configuration|
+      target.build_settings(configuration.name)["CONFIGURATION_BUILD_DIR"] =
+        SHARED_PRODUCTS_DIRECTORY
+    end
+
+    rewrite_aggregate_modulemap_references(installer)
+  end
+
+  def self.rewrite_aggregate_modulemap_references(installer)
+    nested = "${PODS_CONFIGURATION_BUILD_DIR}/#{POD_NAME}/#{POD_NAME}.modulemap"
+    flattened = "${PODS_CONFIGURATION_BUILD_DIR}/#{POD_NAME}.modulemap"
+
+    installer.aggregate_targets.each do |aggregate_target|
+      aggregate_target.xcconfigs.each do |configuration_name, config_file|
+        changed = false
+        %w[OTHER_CFLAGS OTHER_SWIFT_FLAGS].each do |key|
+          value = config_file.attributes[key]
+          next unless value
+
+          updated = value.gsub(nested, flattened)
+          next if updated == value
+
+          config_file.attributes[key] = updated
+          changed = true
+        end
+        config_file.save_as(aggregate_target.xcconfig_path(configuration_name)) if changed
+      end
+    end
+  end
+
+  private_class_method :rewrite_aggregate_modulemap_references
+end

package/src/BotaClient.ts

@@ -0,0 +1,231 @@
+import EventEmitter from 'eventemitter3';
+
+import type { BotaDeviceSDKClient } from './client';
+import { getCompatibilityClient } from './compatibility/runtime';
+import { DeviceManager } from './managers/DeviceManager';
+import { OTAManager } from './managers/OTAManager';
+import { RecordingManager } from './managers/RecordingManager';
+import type {
+  BluetoothState,
+  BotaClientEvents,
+  BotaConfig,
+  LogLevel,
+  SdkState,
+} from './models/Status';
+import { BluetoothError, SdkError } from './utils/errors';
+import { logger, type LogHandler } from './utils/logger';
+
+const log = logger.tag('BotaClient');
+
+const normalizeConfig = (config: BotaConfig): Required<BotaConfig> => ({
+  environment: config.environment ?? 'production',
+  backgroundSyncEnabled: config.backgroundSyncEnabled ?? true,
+  wifiOnlyUpload: config.wifiOnlyUpload ?? false,
+  logLevel: config.logLevel ?? 'warn',
+  debug: config.debug ?? false,
+});
+
+class BotaClientImpl extends EventEmitter<BotaClientEvents> {
+  private _config: BotaConfig | null = null;
+  private _state: SdkState = 'uninitialized';
+  private _bluetoothState: BluetoothState = 'unknown';
+  private _client: BotaDeviceSDKClient | null = null;
+  private _deviceManager: DeviceManager | null = null;
+  private _recordingManager: RecordingManager | null = null;
+  private _otaManager: OTAManager | null = null;
+  private _nativeOwned = false;
+  private _operation: Promise<void> = Promise.resolve();
+  private _configurePromise: Promise<void> | null = null;
+  private _destroyPromise: Promise<void> | null = null;
+
+  get state(): SdkState {
+    return this._state;
+  }
+
+  get bluetoothState(): BluetoothState {
+    return this._bluetoothState;
+  }
+
+  get isBluetoothReady(): boolean {
+    return this._bluetoothState === 'poweredOn';
+  }
+
+  get isInitialized(): boolean {
+    return this._state === 'ready';
+  }
+
+  get config(): BotaConfig | null {
+    return this._config;
+  }
+
+  get devices(): DeviceManager {
+    if (!this._deviceManager) throw SdkError.notInitialized();
+    return this._deviceManager;
+  }
+
+  get recordings(): RecordingManager {
+    if (!this._recordingManager) throw SdkError.notInitialized();
+    return this._recordingManager;
+  }
+
+  get ota(): OTAManager {
+    if (!this._otaManager) throw SdkError.notInitialized();
+    return this._otaManager;
+  }
+
+  configure(config: BotaConfig = {}): Promise<void> {
+    if (this._configurePromise && !this._destroyPromise) {
+      return this._configurePromise;
+    }
+    const normalized = normalizeConfig(config);
+    const operation = this.enqueue(() => this.performConfigure(normalized));
+    this._configurePromise = operation;
+    void operation
+      .finally(() => {
+        if (this._configurePromise === operation) this._configurePromise = null;
+      })
+      .catch(() => undefined);
+    return operation;
+  }
+
+  async waitForBluetooth(timeoutMs: number = 10000): Promise<void> {
+    if (!this._client || !this._nativeOwned) throw SdkError.notInitialized();
+    if (this._bluetoothState === 'poweredOn') return;
+    if (this._bluetoothState === 'unsupported') {
+      throw BluetoothError.unavailable();
+    }
+
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      await new Promise<void>((resolve) => setTimeout(() => resolve(), 50));
+      const capabilities = await this._client.getCapabilities();
+      const state: BluetoothState = capabilities.bluetooth
+        ? 'poweredOn'
+        : 'unsupported';
+      this.setBluetoothState(state);
+      if (state === 'poweredOn') return;
+      if (state === 'unsupported') {
+        throw BluetoothError.unavailable();
+      }
+    }
+    throw SdkError.timeout('Bluetooth ready');
+  }
+
+  setLogLevel(level: LogLevel): void {
+    logger.setLevel(level);
+    if (this._config) this._config.logLevel = level;
+  }
+
+  setLogHandler(handler: LogHandler | null): void {
+    logger.setHandler(handler);
+  }
+
+  destroy(): Promise<void> {
+    if (this._destroyPromise) return this._destroyPromise;
+    const operation = this.enqueue(async () => {
+      await this.releaseOwnerGraph();
+      this.removeAllListeners();
+    });
+    this._destroyPromise = operation;
+    void operation
+      .finally(() => {
+        if (this._destroyPromise === operation) this._destroyPromise = null;
+      })
+      .catch(() => undefined);
+    return operation;
+  }
+
+  private enqueue(operation: () => Promise<void>): Promise<void> {
+    const queued = this._operation.catch(() => undefined).then(operation);
+    this._operation = queued.catch(() => undefined);
+    return queued;
+  }
+
+  private async performConfigure(config: Required<BotaConfig>): Promise<void> {
+    if (this._state !== 'uninitialized' || this._nativeOwned) {
+      log.warn('SDK already configured, reconfiguring');
+      await this.releaseOwnerGraph();
+    }
+
+    this._config = config;
+    logger.setLevel(config.logLevel);
+    this.setState('initializing');
+    const client = getCompatibilityClient();
+    this._client = client;
+    this._nativeOwned = true;
+
+    let deviceManager: DeviceManager | null = null;
+    let recordingManager: RecordingManager | null = null;
+    let otaManager: OTAManager | null = null;
+    try {
+      await client.configure({ logLevel: config.logLevel });
+      const nativeState = await client.getState();
+      if (nativeState !== 'ready') {
+        throw SdkError.invalidState('ready', nativeState);
+      }
+      const capabilities = await client.getCapabilities();
+      this.setBluetoothState(
+        capabilities.bluetooth ? 'poweredOn' : 'unsupported'
+      );
+
+      deviceManager = new DeviceManager();
+      await deviceManager.initialize();
+      recordingManager = new RecordingManager();
+      await recordingManager.initialize();
+      otaManager = new OTAManager(deviceManager);
+
+      this._deviceManager = deviceManager;
+      this._recordingManager = recordingManager;
+      this._otaManager = otaManager;
+      this.setState(nativeState);
+      log.info('SDK configured successfully', {
+        environment: config.environment,
+        bluetoothState: this._bluetoothState,
+      });
+    } catch (error) {
+      deviceManager?.destroy();
+      recordingManager?.destroy();
+      otaManager?.destroy();
+      await client.destroy().catch(() => undefined);
+      this._nativeOwned = false;
+      this._client = null;
+      this.setState('error');
+      const failure = error instanceof Error ? error : new Error(String(error));
+      log.error('Failed to configure SDK', failure);
+      this.emit('error', failure);
+      throw error;
+    }
+  }
+
+  private async releaseOwnerGraph(): Promise<void> {
+    this._deviceManager?.destroy();
+    this._recordingManager?.destroy();
+    this._otaManager?.destroy();
+    this._deviceManager = null;
+    this._recordingManager = null;
+    this._otaManager = null;
+
+    const client = this._client;
+    this._client = null;
+    if (client && this._nativeOwned) await client.destroy();
+    this._nativeOwned = false;
+    this._config = null;
+    this.setState('uninitialized');
+  }
+
+  private setState(state: SdkState): void {
+    if (state === this._state) return;
+    this._state = state;
+    this.emit('stateChanged', state);
+  }
+
+  private setBluetoothState(state: BluetoothState): void {
+    if (state === this._bluetoothState) return;
+    this._bluetoothState = state;
+    this.emit('bluetoothStateChanged', state);
+  }
+}
+
+export const BotaClient = new BotaClientImpl();
+
+export type { BluetoothState, BotaConfig, SdkState };

package/src/ble/constants.ts

@@ -0,0 +1,3 @@
+export const DEVICE_LOG_FLAG_BACKLOG = 0x01;
+export const DEVICE_LOG_FLAG_DROPPED = 0x02;
+export const BLE_ERROR_STORAGE_KEY_UNAVAILABLE = 0x14;

package/src/ble/deviceLogs.ts

@@ -0,0 +1,61 @@
+import { Buffer } from 'buffer';
+
+import {
+  DEVICE_LOG_FLAG_BACKLOG,
+  DEVICE_LOG_FLAG_DROPPED,
+} from './constants';
+import type { DeviceLogEvent } from '../models/Device';
+
+export type { DeviceLogEvent } from '../models/Device';
+
+const PACKET_HEADER_SIZE = 3;
+
+export class DeviceLogDecoder {
+  private lineBuffer = Buffer.alloc(0);
+  private expectedSequence: number | null = null;
+
+  push(packet: Buffer): DeviceLogEvent[] {
+    if (packet.length < PACKET_HEADER_SIZE) {
+      return [];
+    }
+
+    const sequence = packet.readUInt16LE(0);
+    const flags = packet[2];
+    const hasSequenceGap = this.expectedSequence !== null
+      && sequence !== this.expectedSequence;
+    const hasDroppedBytes = (flags & DEVICE_LOG_FLAG_DROPPED) !== 0;
+    const events: DeviceLogEvent[] = [];
+
+    if (hasSequenceGap || hasDroppedBytes) {
+      this.lineBuffer = Buffer.alloc(0);
+    }
+
+    this.expectedSequence = (sequence + 1) & 0xffff;
+    this.lineBuffer = Buffer.concat([this.lineBuffer, packet.subarray(PACKET_HEADER_SIZE)]);
+
+    const isBacklog = (flags & DEVICE_LOG_FLAG_BACKLOG) !== 0;
+    let newlineIndex = this.lineBuffer.indexOf(0x0a);
+    while (newlineIndex !== -1) {
+      let line = this.lineBuffer.subarray(0, newlineIndex);
+      if (line.length > 0 && line[line.length - 1] === 0x0d) {
+        line = line.subarray(0, line.length - 1);
+      }
+      events.push({
+        level: 'debug',
+        message: Buffer.from(line).toString('utf8'),
+        isBacklog,
+      });
+      this.lineBuffer = Buffer.from(
+        this.lineBuffer.subarray(newlineIndex + 1)
+      );
+      newlineIndex = this.lineBuffer.indexOf(0x0a);
+    }
+
+    return events;
+  }
+
+  reset(): void {
+    this.lineBuffer = Buffer.alloc(0);
+    this.expectedSequence = null;
+  }
+}

package/src/cache/DeviceStateCache.ts

@@ -0,0 +1,20 @@
+import type { WiFiStatusInfo } from '../models/Device';
+
+export interface CachedDeviceState {
+  wifiStatus?: WiFiStatusInfo;
+  updatedAt: number;
+}
+
+export interface DeviceStatePatch {
+  wifiStatus?: Partial<WiFiStatusInfo> | null;
+}
+
+export interface DeviceStateCacheEvents {
+  stateChanged: (
+    serialNumber: string,
+    patch: DeviceStatePatch,
+    state: CachedDeviceState
+  ) => void;
+  cleared: (serialNumber: string) => void;
+  clearedAll: () => void;
+}