expo-accessory-setup 0.0.1 → 0.1.0

package/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["apple", "android"],
+  "apple": {
+    "modules": ["ExpoAccessorySetupModule"]
+  },
+  "android": {
+    "modules": ["expo.modules.accessorysetup.ExpoAccessorySetupModule"]
+  }
+}

package/ios/AccessorySessionController.swift

@@ -0,0 +1,290 @@
+import AccessorySetupKit
+import CoreBluetooth
+import UIKit
+
+enum AccessoryEventName: String {
+  case added = "onAccessoryAdded"
+  case removed = "onAccessoryRemoved"
+  case changed = "onAccessoryChanged"
+}
+
+/// Owns the app's single `ASAccessorySession`. All state lives on the main actor, which is also
+/// the queue the session delivers events on.
+@available(iOS 18.0, *)
+@MainActor
+final class AccessorySessionController {
+  private enum Activation {
+    case inactive
+    case activating([CheckedContinuation<Void, Error>])
+    case active
+  }
+
+  private final class PresentedPicker {
+    let continuation: CheckedContinuation<ASAccessory, Error>
+    var pickedAccessory: ASAccessory?
+    var setupError: Error?
+
+    init(_ continuation: CheckedContinuation<ASAccessory, Error>) {
+      self.continuation = continuation
+    }
+  }
+
+  private enum PickerState {
+    case idle
+    /// Reserved synchronously so concurrent calls are rejected across the awaits that follow.
+    case preparing
+    case presented(PresentedPicker)
+  }
+
+  private var session = ASAccessorySession()
+  private var activation = Activation.inactive
+  private var picker = PickerState.idle
+  private let emit: (AccessoryEventName, PairedAccessoryRecord) -> Void
+
+  init(emit: @escaping (AccessoryEventName, PairedAccessoryRecord) -> Void) {
+    self.emit = emit
+  }
+
+  /// `ASAccessorySession()` terminates the app when an `NSAccessorySetupBluetooth*` key is present
+  /// with no values, so this rejects that Info.plist before a session is created.
+  static func validateInfoPlist() throws {
+    let info = Bundle.main.infoDictionary ?? [:]
+    let keys = [
+      "NSAccessorySetupBluetoothServices", "NSAccessorySetupBluetoothNames",
+      "NSAccessorySetupBluetoothCompanyIdentifiers",
+    ]
+    for key in keys {
+      if let values = info[key] as? [Any], values.isEmpty {
+        throw AccessorySetupException(
+          .invalidOptions,
+          "Info.plist key \(key) has no values. Remove the key, or rebuild with the config plugin, which leaves out unused keys."
+        )
+      }
+    }
+  }
+
+  func invalidate() {
+    session.invalidate()
+  }
+
+  func pairedAccessories() async throws -> [PairedAccessoryRecord] {
+    try await activate()
+    return session.accessories.compactMap(PairedAccessoryRecord.init)
+  }
+
+  func removeAccessory(id: String) async throws {
+    try await activate()
+    guard
+      let accessory = session.accessories.first(where: {
+        $0.bluetoothIdentifier?.uuidString.caseInsensitiveCompare(id) == .orderedSame
+      })
+    else {
+      throw AccessorySetupException(.notFound, "No paired accessory has the id \(id).")
+    }
+    try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
+      session.removeAccessory(accessory) { error in
+        if let error {
+          continuation.resume(throwing: AccessorySetupException.from(error))
+        } else {
+          continuation.resume()
+        }
+      }
+    }
+  }
+
+  func showPicker(_ options: PickerOptions) async throws -> PairedAccessoryRecord {
+    guard case .idle = picker else {
+      throw AccessorySetupException(.alreadyInProgress, "Another accessory picker is already showing.")
+    }
+    picker = .preparing
+    defer {
+      picker = .idle
+    }
+
+    let descriptor = try Self.makeDescriptor(options)
+    let image = try await Self.loadProductImage(options.productImageUri)
+    try await activate()
+    let item = ASPickerDisplayItem(name: options.displayName, productImage: image, descriptor: descriptor)
+
+    let accessory = try await withCheckedThrowingContinuation { continuation in
+      picker = .presented(PresentedPicker(continuation))
+      session.showPicker(for: [item]) { [weak self] error in
+        guard let error else {
+          return
+        }
+        Task { @MainActor in
+          self?.finishPicker(.failure(AccessorySetupException.from(error)))
+        }
+      }
+    }
+    guard let record = PairedAccessoryRecord(accessory) else {
+      throw AccessorySetupException(.unknown, "The picked accessory has no Bluetooth identifier.")
+    }
+    return record
+  }
+
+  // MARK: - Session lifecycle
+
+  private func activate() async throws {
+    switch activation {
+    case .active:
+      return
+    case .activating:
+      try await withCheckedThrowingContinuation { continuation in
+        if case .activating(let waiters) = activation {
+          activation = .activating(waiters + [continuation])
+        } else {
+          continuation.resume()
+        }
+      }
+    case .inactive:
+      try await withCheckedThrowingContinuation { continuation in
+        activation = .activating([continuation])
+        session.activate(on: .main) { [weak self] event in
+          MainActor.assumeIsolated {
+            self?.handle(event)
+          }
+        }
+      }
+    }
+  }
+
+  private func finishActivation(_ result: Result<Void, Error>) {
+    guard case .activating(let waiters) = activation else {
+      return
+    }
+    activation = if case .success = result { .active } else { .inactive }
+    waiters.forEach { $0.resume(with: result) }
+  }
+
+  private func handle(_ event: ASAccessoryEvent) {
+    switch event.eventType {
+    case .activated:
+      finishActivation(.success(()))
+    case .invalidated:
+      let reason = event.error.map { " \($0.localizedDescription)" } ?? ""
+      let error = AccessorySetupException(.unknown, "The accessory session was invalidated.\(reason)", cause: event.error)
+      finishActivation(.failure(error))
+      finishPicker(.failure(error))
+      // An invalidated session can't be activated again.
+      session = ASAccessorySession()
+      activation = .inactive
+    case .accessoryAdded:
+      if case .presented(let presented) = picker {
+        presented.pickedAccessory = event.accessory
+      }
+      emitEvent(.added, event.accessory)
+    case .accessoryRemoved:
+      emitEvent(.removed, event.accessory)
+    case .accessoryChanged:
+      emitEvent(.changed, event.accessory)
+    case .pickerSetupFailed:
+      if case .presented(let presented) = picker {
+        presented.setupError = event.error
+      }
+    case .pickerDidDismiss:
+      // Apple delivers accessoryAdded before pickerDidDismiss, so the pick is known by now.
+      guard case .presented(let presented) = picker else {
+        return
+      }
+      if let accessory = presented.pickedAccessory {
+        finishPicker(.success(accessory))
+      } else if let error = presented.setupError {
+        finishPicker(.failure(AccessorySetupException.from(error)))
+      } else {
+        finishPicker(.failure(AccessorySetupException(.userCancelled, "The user dismissed the accessory picker.")))
+      }
+    default:
+      break
+    }
+  }
+
+  private func finishPicker(_ result: Result<ASAccessory, Error>) {
+    guard case .presented(let presented) = picker else {
+      return
+    }
+    // Back to `.preparing` until showPicker's `defer` runs; a new call must not start before then.
+    picker = .preparing
+    presented.continuation.resume(with: result)
+  }
+
+  private func emitEvent(_ name: AccessoryEventName, _ accessory: ASAccessory?) {
+    if let accessory, let record = PairedAccessoryRecord(accessory) {
+      emit(name, record)
+    }
+  }
+
+  // MARK: - Picker inputs
+
+  /// Apple terminates the app when a descriptor uses a service, name, or company identifier
+  /// missing from Info.plist, so this rejects those filters first.
+  private static func makeDescriptor(_ options: PickerOptions) throws -> ASDiscoveryDescriptor {
+    let info = Bundle.main.infoDictionary ?? [:]
+    func declared(_ key: String) -> [String] {
+      info[key] as? [String] ?? []
+    }
+    func missing(_ field: String, _ value: String, _ key: String, _ pluginOption: String) -> AccessorySetupException {
+      AccessorySetupException(
+        .invalidOptions,
+        "\(field) \(value) is not listed in \(key). Add it to the config plugin's ios.\(pluginOption) and rebuild."
+      )
+    }
+
+    let descriptor = ASDiscoveryDescriptor()
+    if let serviceUUID = options.serviceUUID {
+      let services = declared("NSAccessorySetupBluetoothServices").map(expandedUUID)
+      guard services.contains(expandedUUID(serviceUUID)) else {
+        throw missing("filter.serviceUUID", serviceUUID, "NSAccessorySetupBluetoothServices", "bluetoothServices")
+      }
+      descriptor.bluetoothServiceUUID = CBUUID(string: serviceUUID)
+    }
+    if let companyIdentifier = options.companyIdentifier {
+      let companies = declared("NSAccessorySetupBluetoothCompanyIdentifiers").compactMap(parseCompanyIdentifier)
+      guard let identifier = UInt16(exactly: companyIdentifier), companies.contains(identifier) else {
+        throw missing(
+          "filter.companyIdentifier", String(companyIdentifier), "NSAccessorySetupBluetoothCompanyIdentifiers",
+          "bluetoothCompanyIdentifiers")
+      }
+      descriptor.bluetoothCompanyIdentifier = ASBluetoothCompanyIdentifier(rawValue: identifier)
+    }
+    if let nameSubstring = options.nameSubstring {
+      guard declared("NSAccessorySetupBluetoothNames").contains(nameSubstring) else {
+        throw missing("filter.nameSubstring", nameSubstring, "NSAccessorySetupBluetoothNames", "bluetoothNames")
+      }
+      descriptor.bluetoothNameSubstring = nameSubstring
+    }
+    descriptor.bluetoothRange = options.range == "immediate" ? .immediate : .default
+    return descriptor
+  }
+
+  private static func expandedUUID(_ uuid: String) -> String {
+    let uuid = uuid.uppercased()
+    switch uuid.count {
+    case 4: return "0000\(uuid)-0000-1000-8000-00805F9B34FB"
+    case 8: return "\(uuid)-0000-1000-8000-00805F9B34FB"
+    default: return uuid
+    }
+  }
+
+  private static func parseCompanyIdentifier(_ value: String) -> UInt16? {
+    let hex = value.lowercased().hasPrefix("0x") ? String(value.dropFirst(2)) : value
+    return UInt16(hex, radix: 16)
+  }
+
+  /// Loads `file://` URIs from release bundles and `http://` URIs served by Metro in development.
+  private static func loadProductImage(_ uri: String) async throws -> UIImage {
+    guard let url = URL(string: uri) else {
+      throw AccessorySetupException(.invalidOptions, "ios.productImage URI \(uri) is not a valid URL.")
+    }
+    do {
+      let (data, _) = try await URLSession.shared.data(from: url)
+      if let image = UIImage(data: data) {
+        return image
+      }
+    } catch {
+      throw AccessorySetupException(
+        .invalidOptions, "ios.productImage could not be loaded from \(uri): \(error.localizedDescription)", cause: error)
+    }
+    throw AccessorySetupException(.invalidOptions, "ios.productImage at \(uri) is not a supported image.")
+  }
+}

package/ios/AccessorySetupException.swift

@@ -0,0 +1,50 @@
+import AccessorySetupKit
+import ExpoModulesCore
+
+enum AccessorySetupErrorCode: String {
+  case unsupported = "UNSUPPORTED"
+  case userCancelled = "USER_CANCELLED"
+  case permissionDenied = "PERMISSION_DENIED"
+  case alreadyInProgress = "ALREADY_IN_PROGRESS"
+  case notFound = "NOT_FOUND"
+  case discoveryTimeout = "DISCOVERY_TIMEOUT"
+  case invalidOptions = "INVALID_OPTIONS"
+  case unknown = "UNKNOWN"
+}
+
+final class AccessorySetupException: Exception, @unchecked Sendable {
+  private let errorCode: AccessorySetupErrorCode
+  private let detail: String
+
+  init(_ code: AccessorySetupErrorCode, _ message: String, cause: Error? = nil) {
+    self.errorCode = code
+    self.detail = message
+    super.init()
+    self.cause = cause
+  }
+
+  override var code: String {
+    errorCode.rawValue
+  }
+
+  override var reason: String {
+    detail
+  }
+
+  @available(iOS 18.0, *)
+  static func from(_ error: Error) -> AccessorySetupException {
+    if let error = error as? AccessorySetupException {
+      return error
+    }
+    let code: AccessorySetupErrorCode =
+      switch (error as? ASError)?.code {
+      case .userCancelled: .userCancelled
+      case .pickerAlreadyActive: .alreadyInProgress
+      case .pickerRestricted, .userRestricted: .permissionDenied
+      case .discoveryTimeout: .discoveryTimeout
+      case .invalidRequest: .invalidOptions
+      default: .unknown
+      }
+    return AccessorySetupException(code, error.localizedDescription, cause: error)
+  }
+}

package/ios/AccessorySetupRecords.swift

@@ -0,0 +1,32 @@
+import AccessorySetupKit
+import ExpoModulesCore
+
+struct PickerOptions: Record {
+  @Field var serviceUUID: String?
+  @Field var companyIdentifier: Int?
+  @Field var nameSubstring: String?
+  @Field var displayName: String = ""
+  @Field var productImageUri: String = ""
+  @Field var range: String = "default"
+}
+
+struct PairedAccessoryRecord: Record {
+  @Field var id: String = ""
+  @Field var bleIdentifier: String = ""
+  @Field var displayName: String = ""
+  @Field var platform: String = "ios"
+}
+
+@available(iOS 18.0, *)
+extension PairedAccessoryRecord {
+  /// `nil` for accessories without a Bluetooth identity (Wi-Fi only), which this module doesn't expose.
+  init?(_ accessory: ASAccessory) {
+    guard let identifier = accessory.bluetoothIdentifier?.uuidString else {
+      return nil
+    }
+    self.init()
+    id = identifier
+    bleIdentifier = identifier
+    displayName = accessory.displayName
+  }
+}

package/ios/ExpoAccessorySetup.podspec

@@ -0,0 +1,31 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'ExpoAccessorySetup'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platforms      = {
+    :ios => '16.4'
+  }
+  s.source         = { git: package['repository'] }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  # AccessorySetupKit only exists on iOS 18+. Weak linking lets the app launch on older versions,
+  # where isSupported() returns false.
+  s.weak_frameworks = 'AccessorySetupKit'
+
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+  }
+
+  s.source_files = "**/*.{h,m,mm,swift,hpp,cpp}"
+end

package/ios/ExpoAccessorySetupModule.swift

@@ -0,0 +1,67 @@
+import ExpoModulesCore
+
+// Sendable because its only mutable state, `sessionController`, is isolated to the main actor.
+public final class ExpoAccessorySetupModule: Module, @unchecked Sendable {
+  /// An `AccessorySessionController` on iOS 18+. Typed as `AnyObject` so the module loads on older iOS.
+  @MainActor private var sessionController: AnyObject?
+
+  public func definition() -> ModuleDefinition {
+    Name("ExpoAccessorySetup")
+
+    Events(AccessoryEventName.added.rawValue, AccessoryEventName.removed.rawValue, AccessoryEventName.changed.rawValue)
+
+    Function("isSupported") { () -> Bool in
+      if #available(iOS 18.0, *) {
+        return true
+      }
+      return false
+    }
+
+    AsyncFunction("showPicker") { (options: PickerOptions) async throws -> PairedAccessoryRecord in
+      guard #available(iOS 18.0, *) else {
+        throw Self.unsupported()
+      }
+      return try await self.controller().showPicker(options)
+    }
+
+    AsyncFunction("getPairedAccessories") { () async throws -> [PairedAccessoryRecord] in
+      guard #available(iOS 18.0, *) else {
+        throw Self.unsupported()
+      }
+      return try await self.controller().pairedAccessories()
+    }
+
+    AsyncFunction("removeAccessory") { (id: String) async throws in
+      guard #available(iOS 18.0, *) else {
+        throw Self.unsupported()
+      }
+      return try await self.controller().removeAccessory(id: id)
+    }
+
+    OnDestroy {
+      Task { @MainActor in
+        if #available(iOS 18.0, *) {
+          (self.sessionController as? AccessorySessionController)?.invalidate()
+        }
+      }
+    }
+  }
+
+  private static func unsupported() -> AccessorySetupException {
+    AccessorySetupException(.unsupported, "AccessorySetupKit requires iOS 18 or later.")
+  }
+
+  @available(iOS 18.0, *)
+  @MainActor
+  private func controller() throws -> AccessorySessionController {
+    if let controller = sessionController as? AccessorySessionController {
+      return controller
+    }
+    try AccessorySessionController.validateInfoPlist()
+    let controller = AccessorySessionController { [weak self] name, accessory in
+      self?.sendEvent(name.rawValue, ["accessory": accessory.toDictionary()])
+    }
+    sessionController = controller
+    return controller
+  }
+}

package/mocks/ExpoAccessorySetup.ts

@@ -0,0 +1,13 @@
+export function isSupported(): boolean {
+  return true;
+}
+
+export async function showPicker(): Promise<never> {
+  throw Object.assign(new Error('User cancelled'), { code: 'USER_CANCELLED' });
+}
+
+export async function getPairedAccessories(): Promise<never[]> {
+  return [];
+}
+
+export async function removeAccessory(): Promise<void> {}

package/package.json

@@ -1,8 +1,67 @@
 {
   "name": "expo-accessory-setup",
-  "version": "0.0.1",
-  "description": "Placeholder. Expo module for native accessory pairing (AccessorySetupKit on iOS, CompanionDeviceManager on Android). Under development; not usable yet.",
+  "version": "0.1.0",
+  "description": "System accessory pairing for Expo: AccessorySetupKit on iOS, CompanionDeviceManager on Android",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "node internal/module_scripts/build.js",
+    "clean": "node internal/module_scripts/clean.js",
+    "lint": "eslint src/ plugin/src/ plugin/__tests__/ mocks/",
+    "test": "node internal/module_scripts/test.js",
+    "prepare": "node internal/module_scripts/prepare.js",
+    "open:ios": "node internal/module_scripts/open-ios.js",
+    "open:android": "node internal/module_scripts/open-android.js"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "expo-accessory-setup",
+    "accessorysetupkit",
+    "companion-device-manager",
+    "bluetooth",
+    "ble"
+  ],
+  "repository": "https://github.com/nguyenphutrong/expo-accessory-setup",
+  "bugs": {
+    "url": "https://github.com/nguyenphutrong/expo-accessory-setup/issues"
+  },
+  "author": "Trong Nguyen <nguyenphutrong.dev@gmail.com> (https://github.com/nguyenphutrong)",
   "license": "MIT",
-  "keywords": ["expo", "react-native", "accessorysetupkit", "companion-device-manager", "bluetooth", "ble"],
-  "files": ["README.md"]
+  "homepage": "https://github.com/nguyenphutrong/expo-accessory-setup#readme",
+  "dependencies": {},
+  "devDependencies": {
+    "@babel/core": "^7.26.0",
+    "@expo/config-plugins": "~58.0.9",
+    "@react-native/jest-preset": "0.88.0",
+    "@types/jest": "^29.2.1",
+    "@types/node": "^22",
+    "@types/react": "~19.3.0",
+    "babel-preset-expo": "~58.0.17",
+    "eslint": "~9.39.4",
+    "eslint-config-universe": "^15.0.3",
+    "expo": "~58.0.14",
+    "jest": "^29.7.0",
+    "jest-expo": "~58.0.11",
+    "prettier": "^3.0.0",
+    "react-native": "0.88.0",
+    "typescript": "^5.9.2"
+  },
+  "jest": {
+    "projects": [
+      {
+        "displayName": "module",
+        "preset": "jest-expo",
+        "roots": [
+          "<rootDir>/src"
+        ]
+      },
+      "<rootDir>/plugin/jest.config.js"
+    ]
+  },
+  "peerDependencies": {
+    "expo": "*",
+    "react": "*",
+    "react-native": "*"
+  }
 }

package/plugin/build/index.d.ts

@@ -0,0 +1,8 @@
+import { AndroidConfig, type ConfigPlugin, type InfoPlist } from '@expo/config-plugins';
+import { type AccessorySetupOptions, type AccessorySetupPluginProps } from './options';
+export type { AccessorySetupPluginProps } from './options';
+type AndroidManifest = AndroidConfig.Manifest.AndroidManifest;
+export declare function setAccessorySetupInfoPlist(infoPlist: InfoPlist, { ios }: AccessorySetupOptions): InfoPlist;
+export declare function setAccessorySetupManifest(manifest: AndroidManifest, { android }: AccessorySetupOptions): AndroidManifest;
+declare const _default: ConfigPlugin<void | AccessorySetupPluginProps>;
+export default _default;

package/plugin/build/index.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setAccessorySetupInfoPlist = setAccessorySetupInfoPlist;
+exports.setAccessorySetupManifest = setAccessorySetupManifest;
+const config_plugins_1 = require("@expo/config-plugins");
+const options_1 = require("./options");
+const pkg = require('../../package.json');
+function setAccessorySetupInfoPlist(infoPlist, { ios }) {
+    const supports = Array.isArray(infoPlist.NSAccessorySetupKitSupports)
+        ? infoPlist.NSAccessorySetupKitSupports
+        : [];
+    const result = {
+        ...infoPlist,
+        NSAccessorySetupKitSupports: supports.includes('Bluetooth')
+            ? supports
+            : [...supports, 'Bluetooth'],
+    };
+    // ASAccessorySession terminates the app when one of these keys is present with no values,
+    // so unused keys are left out instead of written as empty arrays.
+    const keys = {
+        NSAccessorySetupBluetoothServices: ios.bluetoothServices,
+        NSAccessorySetupBluetoothNames: ios.bluetoothNames,
+        // TODO(verify): Apple documents these as "two-byte UUID" strings without a format example.
+        // Four hex digits ("004C") is the assumed format.
+        NSAccessorySetupBluetoothCompanyIdentifiers: ios.bluetoothCompanyIdentifiers,
+    };
+    for (const [key, values] of Object.entries(keys)) {
+        if (values.length > 0) {
+            result[key] = values;
+        }
+        else {
+            delete result[key];
+        }
+    }
+    return result;
+}
+const COMPANION_DEVICE_SETUP_FEATURE = 'android.software.companion_device_setup';
+function ensureUsesFeature(manifest, name) {
+    manifest.manifest['uses-feature'] ??= [];
+    const features = manifest.manifest['uses-feature'];
+    if (!features.some((feature) => feature.$['android:name'] === name)) {
+        // Not required, so the app still installs where isSupported() returns false.
+        features.push({ $: { 'android:name': name, 'android:required': 'false' } });
+    }
+}
+function ensureLegacyPermission(manifest, name) {
+    manifest.manifest['uses-permission'] ??= [];
+    const permissions = manifest.manifest['uses-permission'];
+    const existing = permissions.find((permission) => permission.$['android:name'] === name);
+    // Android 12 ignores these permissions, so the limit also applies when another plugin, such as
+    // react-native-ble-plx, declared them first.
+    if (existing) {
+        existing.$['android:maxSdkVersion'] ??= '30';
+    }
+    else {
+        permissions.push({ $: { 'android:name': name, 'android:maxSdkVersion': '30' } });
+    }
+}
+function setAccessorySetupManifest(manifest, { android }) {
+    ensureUsesFeature(manifest, COMPANION_DEVICE_SETUP_FEATURE);
+    // CompanionDeviceManager scans on the app's behalf, so no scan or location permission is
+    // needed. These cover connecting to the paired accessory afterwards (react-native-ble-plx).
+    ensureLegacyPermission(manifest, 'android.permission.BLUETOOTH');
+    ensureLegacyPermission(manifest, 'android.permission.BLUETOOTH_ADMIN');
+    config_plugins_1.AndroidConfig.Permissions.ensurePermission(manifest, 'android.permission.BLUETOOTH_CONNECT');
+    if (android.runInBackground) {
+        config_plugins_1.AndroidConfig.Permissions.ensurePermission(manifest, 'android.permission.REQUEST_COMPANION_RUN_IN_BACKGROUND');
+    }
+    if (android.useDataInBackground) {
+        config_plugins_1.AndroidConfig.Permissions.ensurePermission(manifest, 'android.permission.REQUEST_COMPANION_USE_DATA_IN_BACKGROUND');
+    }
+    return manifest;
+}
+const withAccessorySetup = (config, props) => {
+    const options = (0, options_1.parseOptions)(props);
+    config = (0, config_plugins_1.withInfoPlist)(config, (config) => {
+        config.modResults = setAccessorySetupInfoPlist(config.modResults, options);
+        return config;
+    });
+    return (0, config_plugins_1.withAndroidManifest)(config, (config) => {
+        config.modResults = setAccessorySetupManifest(config.modResults, options);
+        return config;
+    });
+};
+exports.default = (0, config_plugins_1.createRunOncePlugin)(withAccessorySetup, pkg.name, pkg.version);