@getquip/expo-nordic-dfu 0.1.0

package/example/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "expo-nordic-dfu-example",
+  "version": "1.0.0",
+  "main": "index.ts",
+  "scripts": {
+    "start": "expo start",
+    "android": "expo run:android",
+    "ios": "expo run:ios",
+    "web": "expo start --web"
+  },
+  "dependencies": {
+    "expo": "~52.0.46",
+    "react": "~18.3.1",
+    "react-native": "~0.76.9",
+    "react-native-ble-manager": "^12.1.4",
+    "react-native-paper": "^5.13.3",
+    "expo-document-picker": "~13.0.3",
+    "expo-file-system": "~18.0.12"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.25.2",
+    "@types/react": "~18.3.12",
+    "typescript": "^5.3.3"
+  },
+  "private": true,
+  "expo": {
+    "autolinking": {
+      "nativeModulesDir": ".."
+    }
+  }
+}

package/example/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "expo/tsconfig.base",
+  "compilerOptions": {
+    "strict": true,
+    "paths": {
+      "expo-nordic-dfu": ["../src/index"],
+      "expo-nordic-dfu/*": ["../src/*"]
+    }
+  }
+}

package/example/webpack.config.js

@@ -0,0 +1,20 @@
+const createConfigAsync = require('@expo/webpack-config');
+const path = require('path');
+
+module.exports = async (env, argv) => {
+  const config = await createConfigAsync(
+    {
+      ...env,
+      babel: {
+        dangerouslyAddModulePathsToTranspile: ['expo-nordic-dfu'],
+      },
+    },
+    argv
+  );
+  config.resolve.modules = [
+    path.resolve(__dirname, './node_modules'),
+    path.resolve(__dirname, '../node_modules'),
+  ];
+
+  return config;
+};

package/expo-module.config.json

@@ -0,0 +1,16 @@
+{
+  "platforms": [
+    "apple",
+    "android"
+  ],
+  "apple": {
+    "modules": [
+      "ExpoNordicDfuModule"
+    ]
+  },
+  "android": {
+    "modules": [
+      "com.getquip.nordic.ExpoNordicDfuModule"
+    ]
+  }
+}

package/ios/ExpoNordicDfu.podspec

@@ -0,0 +1,27 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name         = "ExpoNordicDfu"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.description  = package["description"]
+  s.license      = package['license']
+  s.author       = package['author']
+  s.homepage     = package["homepage"] || package["url"]
+  s.platform     = :ios, "15.1"
+  s.swift_version  = '5.4'
+  s.source       = { :git => "#{package["repository"]["url"]}.git", :tag => s.version }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+  s.dependency "iOSDFULibrary", "~> 4.15.3"
+
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+  }
+
+  s.source_files = "**/*.{h,m,mm,swift,hpp,cpp}"
+end

package/ios/ExpoNordicDfuModule.swift

@@ -0,0 +1,168 @@
+import ExpoModulesCore
+import NordicDFU
+import os
+
+public class ExpoNordicDfuModule: Module, DFUProgressDelegate, DFUServiceDelegate, LoggerDelegate {
+    private static let logger = Logger(subsystem: "com.getquip.nordic", category: "DFU")
+
+    private var controller: DFUServiceController?
+    private var currentPromise: Promise?
+    private var deviceAddress: String?
+
+    public func definition() -> ModuleDefinition {
+        Name("ExpoNordicDfuModule")
+
+        Events("DFUStateChanged", "DFUProgress")
+
+        OnStartObserving {
+          // This is called when the module starts observing events.
+          // You can start listening to events here.
+        }
+
+        OnStopObserving {
+          // This is called when the module stops observing events.
+          // You can stop listening to events here.
+        }
+
+        AsyncFunction("startIosDfu") { (
+            deviceAddress: String,
+            fileUri: String,
+            connectionTimeout: Int?,
+            disableResume: Bool?,
+            packetReceiptNotificationParameter: Int?,
+            prepareDataObjectDelay: Double?,
+            promise: Promise
+        ) in
+            guard self.controller == nil else {
+                promise.reject("dfu_in_progress", "A DFU process is already running")
+                return
+            }
+
+            self.currentPromise = promise
+            self.deviceAddress = deviceAddress
+
+            guard let uuid = UUID(uuidString: deviceAddress) else {
+                self.currentPromise?.reject("invalid_device_address", "Device address is invalid")
+                resetState()
+                return
+            }
+
+            Self.logger.info("Starting DFU on device \(uuid)")
+
+            let path = fileUri.replacingOccurrences(of: "file://", with: "")
+            let url = URL(fileURLWithPath: path)
+            let firmware = try DFUFirmware(urlToZipFile: url)
+            let initiator = DFUServiceInitiator().with(firmware: firmware)
+            initiator.logger = self
+            initiator.delegate = self
+            initiator.progressDelegate = self
+            initiator.alternativeAdvertisingNameEnabled = true
+            initiator.connectionTimeout = TimeInterval(connectionTimeout ?? 10)
+            // By default this is set to false. This property applies only to Secure DFU.
+            disableResume.map { initiator.disableResume = $0 }
+            // The number of packets of firmware data to be received by the DFU target before sending a new Packet Receipt Notification.
+            // Disabling PRNs increases upload speed but may cause failures on devices with slow flash memory.
+            packetReceiptNotificationParameter.map { initiator.packetReceiptNotificationParameter = UInt16($0) }
+            // Duration of a delay, that the service will wait before sending each data object in Secure DFU.
+            // The delay will be done after a data object is created, and before any data byte is sent.
+            // The default value is 0, which disables this feature for the second and following data objects, but the first one will be delayed by 0.4 sec.
+            // It has been found, that a delay of at least 0.3 sec reduces the risk of packet lose (the bootloader needs some time to prepare flash memory) on DFU bootloader from SDK 15, 16, and 17.
+            // The delay does not have to be longer than 0.4 sec, as according to performed tests, such such delay is sufficient.
+            // The recommended delay is from 0.3 to 0.4 second if your DFU bootloader is from SDK 15, 16 or 17. Older bootloaders do not need this delay.
+            prepareDataObjectDelay.map { initiator.dataObjectPreparationDelay = TimeInterval($0) }
+            self.controller = initiator.start(targetWithIdentifier: uuid)
+        }
+
+        AsyncFunction("abortIosDfu") { (promise: Promise) in
+            let wasAborted = self.controller?.abort()
+            if wasAborted == nil {
+                promise.reject("no_running_dfu", "There is no DFU process currently running")
+            } else if wasAborted == false {
+                promise.reject("dfu_abort_failed", "Unable to abort DFU process")
+            } else {
+                promise.resolve()
+            }
+        }
+    }
+
+    public func dfuStateDidChange(to state: NordicDFU.DFUState) {
+        guard let deviceAddress = self.deviceAddress else { return }
+
+        let stateName: String = {
+            switch state {
+            case .aborted: return "DFU_ABORTED"
+            case .completed: return "DFU_COMPLETED"
+            case .connecting: return "CONNECTING"
+            case .disconnecting: return "DEVICE_DISCONNECTING"
+            case .enablingDfuMode: return "ENABLING_DFU_MODE"
+            case .starting: return "DFU_PROCESS_STARTING"
+            case .uploading: return "DFU_UPLOADING"
+            case .validating: return "FIRMWARE_VALIDATING"
+            default: return "UNKNOWN_STATE"
+            }
+        }()
+
+        sendEvent("DFUStateChanged", [
+            "deviceAddress": deviceAddress,
+            "state": stateName
+        ])
+
+        if state == .aborted {
+            self.currentPromise?.resolve("DFU was aborted")
+            resetState()
+        }
+        if state == .completed {
+            self.currentPromise?.resolve(["deviceAddress": deviceAddress])
+            resetState()
+        }
+    }
+
+    public func dfuError(_ error: NordicDFU.DFUError, didOccurWithMessage message: String) {
+        guard let deviceAddress = self.deviceAddress else { return }
+
+        sendEvent("DFUStateChanged", [
+            "deviceAddress": deviceAddress,
+            "state": "DFU_FAILED"
+        ])
+        let combinedMessage = "Error: \(error.rawValue), Error Type: \(String(describing: error)), Message: \(message)"
+        self.currentPromise?.reject("\(error.rawValue)", combinedMessage)
+        resetState()
+    }
+
+    public func dfuProgressDidChange(
+        for part: Int,
+        outOf totalParts: Int,
+        to progress: Int,
+        currentSpeedBytesPerSecond: Double,
+        avgSpeedBytesPerSecond: Double
+    ) {
+        guard let deviceAddress = self.deviceAddress else { return }
+
+        sendEvent("DFUProgress", [
+            "deviceAddress": deviceAddress,
+            "percent": progress,
+            "speed": currentSpeedBytesPerSecond,
+            "avgSpeed": avgSpeedBytesPerSecond,
+            "currentPart": part,
+            "totalParts": totalParts,
+        ])
+    }
+
+    public func logWith(_ level: LogLevel, message: String) {
+        switch level {
+        case .debug, .verbose:
+            Self.logger.debug("\(message, privacy: .public)")
+        case .info, .application:
+            Self.logger.info("\(message, privacy: .public)")
+        case .warning:
+            Self.logger.warning("\(message, privacy: .public)")
+        case .error:
+            Self.logger.error("\(message, privacy: .public)")
+        }
+    }
+    
+    private func resetState() {
+        self.currentPromise = nil
+        self.controller = nil
+    }
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "author": "getquip",
+  "bugs": {
+    "url": "https://github.com/getquip/expo-nordic-dfu/issues"
+  },
+  "description": "Nordic DFU for Expo",
+  "devDependencies": {
+    "@types/react": "~18.3.12",
+    "expo": "~52.0.46",
+    "expo-module-scripts": "^4.0.5",
+    "prettier": "^2.8.8",
+    "react-native": "^0.76.9"
+  },
+  "expo-module": {
+    "platforms": [
+      "ios",
+      "android"
+    ]
+  },
+  "homepage": "https://github.com/getquip/expo-nordic-dfu#readme",
+  "keywords": [
+    "android",
+    "dfu",
+    "expo",
+    "expo-module",
+    "ios",
+    "nordic",
+    "react-native"
+  ],
+  "license": "MIT",
+  "main": "build/index.js",
+  "name": "@getquip/expo-nordic-dfu",
+  "peerDependencies": {
+    "expo": "^52.0.0",
+    "react": "^18.0.0",
+    "react-native": "^0.76.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "react-native": {
+    "codegenConfig": {
+      "jsSrcsDir": "src",
+      "libraryName": "ExpoNordicDfu",
+      "name": "ExpoNordicDfu",
+      "type": "modules"
+    }
+  },
+  "repository": "getquip/expo-nordic-dfu",
+  "scripts": {
+    "build": "expo-module build",
+    "clean": "expo-module clean",
+    "expo-module": "expo-module",
+    "lint": "expo-module lint",
+    "open:android": "open -a \"Android Studio\" example/android",
+    "open:ios": "xed example/ios",
+    "prepare": "expo-module prepare",
+    "prepublishOnly": "expo-module prepublishOnly",
+    "test": "expo-module test"
+  },
+  "types": "build/index.d.ts",
+  "url": "https://github.com/getquip/expo-nordic-dfu",
+  "version": "0.1.0"
+}

package/src/ExpoNordicDfu.types.ts

@@ -0,0 +1,38 @@
+export type ExpoSettingsModuleEvents = {
+  DFUStateChanged: (params: DFUStateChangedPayload) => void;
+  DFUProgress: (params: DFUProgressPayload) => void;
+};
+
+export type DFUStateChangedPayload = {
+  state: string;
+  deviceAddress: string;
+};
+
+export type DFUProgressPayload = {
+  deviceAddress: string;
+  percent: number;
+  speed: number;
+  avgSpeed: number;
+  currentPart: number;
+  totalParts: number;
+}
+
+export type StartDFUParams = {
+  deviceAddress: string;
+  fileUri: string;
+  packetReceiptNotificationParameter?: number;
+  prepareDataObjectDelay?: number;
+  android?: {
+    deviceName?: string;
+    keepBond?: boolean;
+    numberOfRetries?: number;
+    // See android/src/main/java/com/getquip/nordic/ExpoNordicDfuModule.kt
+    // rebootTime?: number;
+    // restoreBond?: boolean;
+  }
+  ios?: {
+    connectionTimeout?: number,
+    disableResume?: boolean,
+  }
+}
+

package/src/ExpoNordicDfuModule.ts

@@ -0,0 +1,73 @@
+import { NativeModule, requireNativeModule } from 'expo';
+import { ExpoSettingsModuleEvents, StartDFUParams } from './ExpoNordicDfu.types';
+import { Platform } from 'react-native';
+
+declare class ExpoNordicDfuModule extends NativeModule<ExpoSettingsModuleEvents> {
+  startAndroidDfu(
+    deviceAddress: string,
+    fileUri: string,
+    deviceName?: string,
+    keepBond?: boolean,
+    numberOfRetries?: number,
+    packetReceiptNotificationParameter?: number,
+    prepareDataObjectDelay?: number,
+    rebootTime?: number,
+    restoreBond?: boolean,
+  ): Promise<void>;
+  abortAndroidDfu(): Promise<void>;
+  startIosDfu(
+    deviceAddress: string,
+    fileUri: string,
+    connectionTimeout?: number,
+    disableResume?: boolean,
+    packetReceiptNotificationParameter?: number,
+    prepareDataObjectDelay?: number,
+  ): Promise<void>;
+  abortIosDfu(): Promise<void>;
+}
+
+const DfuModule = requireNativeModule<ExpoNordicDfuModule>('ExpoNordicDfuModule');
+
+class CrossplatformWrapper {
+  constructor(private dfuModule: ExpoNordicDfuModule) {}
+
+  get module() {
+    return this.dfuModule;
+  }
+
+  async startDfu(params: StartDFUParams): Promise<void> {
+    if (Platform.OS === 'ios') {
+      return await this.dfuModule.startIosDfu(
+        params.deviceAddress,
+        params.fileUri,
+        params.ios?.connectionTimeout,
+        params.ios?.disableResume,
+        params.packetReceiptNotificationParameter,
+        params.prepareDataObjectDelay,
+      );
+    } else {
+      return await this.dfuModule.startAndroidDfu(
+        params.deviceAddress,
+        params.fileUri,
+        params.android?.deviceName,
+        params.android?.keepBond,
+        params.android?.numberOfRetries,
+        params.packetReceiptNotificationParameter,
+        params.prepareDataObjectDelay,
+        // See android/src/main/java/com/getquip/nordic/ExpoNordicDfuModule.kt
+        // params.android?.rebootTime,
+        // params.android?.restoreBond,
+      );
+    }
+  }
+
+  async abortDfu(): Promise<void> {
+    if (Platform.OS === 'ios') {
+      return await this.dfuModule.abortIosDfu();
+    } else {
+      return await this.dfuModule.abortAndroidDfu();
+    }
+  }
+};
+
+export default new CrossplatformWrapper(DfuModule);

package/src/index.ts

@@ -0,0 +1,5 @@
+// Reexport the native module. On web, it will be resolved to ExpoNordicDfuModule.web.ts
+// and on native platforms to ExpoNordicDfuModule.ts
+export { default } from './ExpoNordicDfuModule';
+// export { default as ExpoNordicDfuView } from './ExpoNordicDfuView';
+export * from  './ExpoNordicDfu.types';

package/tsconfig.json

@@ -0,0 +1,9 @@
+// @generated by expo-module-scripts
+{
+  "extends": "expo-module-scripts/tsconfig.base",
+  "compilerOptions": {
+    "outDir": "./build"
+  },
+  "include": ["./src"],
+  "exclude": ["**/__mocks__/*", "**/__tests__/*", "**/__rsc_tests__/*"]
+}