expo-accessory-setup 0.0.1 → 0.1.0

package/plugin/build/options.d.ts

@@ -0,0 +1,29 @@
+export type AccessorySetupPluginProps = {
+    ios?: {
+        /** 16-bit (`"180D"`) or 128-bit service UUIDs that `showPicker` filters may use. */
+        bluetoothServices?: string[];
+        /** Advertised names or name substrings that `showPicker` filters may use. */
+        bluetoothNames?: string[];
+        /** Bluetooth SIG company identifiers (0 to 0xFFFF) that `showPicker` filters may use. */
+        bluetoothCompanyIdentifiers?: number[];
+    };
+    android?: {
+        /** Adds `REQUEST_COMPANION_RUN_IN_BACKGROUND`. */
+        runInBackground?: boolean;
+        /** Adds `REQUEST_COMPANION_USE_DATA_IN_BACKGROUND`. */
+        useDataInBackground?: boolean;
+    };
+};
+export type AccessorySetupOptions = {
+    ios: {
+        bluetoothServices: string[];
+        bluetoothNames: string[];
+        /** Four upper-case hex digits, e.g. `"004C"`. */
+        bluetoothCompanyIdentifiers: string[];
+    };
+    android: {
+        runInBackground: boolean;
+        useDataInBackground: boolean;
+    };
+};
+export declare function parseOptions(props: unknown): AccessorySetupOptions;

package/plugin/build/options.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOptions = parseOptions;
+const UUID_16 = /^[0-9A-F]{4}$/;
+const UUID_128 = /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/;
+function fail(message) {
+    throw new Error(`[expo-accessory-setup] Invalid plugin options: ${message}`);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function parseSection(value, path, keys) {
+    if (value === undefined) {
+        return {};
+    }
+    if (!isRecord(value)) {
+        fail(`${path} must be an object.`);
+    }
+    const unknownKey = Object.keys(value).find((key) => !keys.includes(key));
+    if (unknownKey !== undefined) {
+        fail(`${path}.${unknownKey} is not a known option. Known options: ${keys.join(', ')}.`);
+    }
+    return value;
+}
+function parseArray(value, path, parseItem) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        fail(`${path} must be an array.`);
+    }
+    return [...new Set(value.map((item, index) => parseItem(item, `${path}[${index}]`)))];
+}
+function parseServiceUUID(value, path) {
+    const uuid = typeof value === 'string' ? value.trim().toUpperCase() : '';
+    if (!UUID_16.test(uuid) && !UUID_128.test(uuid)) {
+        fail(`${path} must be a 16-bit ("180D") or 128-bit UUID string, got ${JSON.stringify(value)}.`);
+    }
+    return uuid;
+}
+function parseName(value, path) {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        fail(`${path} must be a non-empty string, got ${JSON.stringify(value)}.`);
+    }
+    return value;
+}
+function parseCompanyIdentifier(value, path) {
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < 0 || value > 0xffff) {
+        fail(`${path} must be an integer between 0 and 65535 (0xFFFF), got ${JSON.stringify(value)}.`);
+    }
+    return value.toString(16).toUpperCase().padStart(4, '0');
+}
+function parseBoolean(value, path) {
+    if (value === undefined) {
+        return false;
+    }
+    if (typeof value !== 'boolean') {
+        fail(`${path} must be a boolean, got ${JSON.stringify(value)}.`);
+    }
+    return value;
+}
+function parseOptions(props) {
+    const root = parseSection(props ?? {}, 'options', ['ios', 'android']);
+    const ios = parseSection(root.ios, 'ios', [
+        'bluetoothServices',
+        'bluetoothNames',
+        'bluetoothCompanyIdentifiers',
+    ]);
+    const android = parseSection(root.android, 'android', ['runInBackground', 'useDataInBackground']);
+    const options = {
+        ios: {
+            bluetoothServices: parseArray(ios.bluetoothServices, 'ios.bluetoothServices', parseServiceUUID),
+            bluetoothNames: parseArray(ios.bluetoothNames, 'ios.bluetoothNames', parseName),
+            bluetoothCompanyIdentifiers: parseArray(ios.bluetoothCompanyIdentifiers, 'ios.bluetoothCompanyIdentifiers', parseCompanyIdentifier),
+        },
+        android: {
+            runInBackground: parseBoolean(android.runInBackground, 'android.runInBackground'),
+            useDataInBackground: parseBoolean(android.useDataInBackground, 'android.useDataInBackground'),
+        },
+    };
+    if (options.ios.bluetoothServices.length === 0 &&
+        options.ios.bluetoothCompanyIdentifiers.length === 0) {
+        fail('ios.bluetoothServices or ios.bluetoothCompanyIdentifiers must list at least one value. ' +
+            'AccessorySetupKit only discovers accessories by service UUID or company identifier, ' +
+            'and the app crashes if a picker filter uses a value missing from Info.plist.');
+    }
+    return options;
+}

package/plugin/src/index.ts

@@ -0,0 +1,122 @@
+import {
+  AndroidConfig,
+  createRunOncePlugin,
+  withAndroidManifest,
+  withInfoPlist,
+  type ConfigPlugin,
+  type InfoPlist,
+} from '@expo/config-plugins';
+
+import {
+  parseOptions,
+  type AccessorySetupOptions,
+  type AccessorySetupPluginProps,
+} from './options';
+
+const pkg = require('../../package.json');
+
+export type { AccessorySetupPluginProps } from './options';
+
+type AndroidManifest = AndroidConfig.Manifest.AndroidManifest;
+
+export function setAccessorySetupInfoPlist(
+  infoPlist: InfoPlist,
+  { ios }: AccessorySetupOptions
+): InfoPlist {
+  const supports = Array.isArray(infoPlist.NSAccessorySetupKitSupports)
+    ? (infoPlist.NSAccessorySetupKitSupports as string[])
+    : [];
+  const result: InfoPlist = {
+    ...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: AndroidManifest, name: string) {
+  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' } });
+  }
+}
+
+// Expo's manifest types leave out android:maxSdkVersion, which the manifest XML accepts.
+type UsesPermission = { $: { 'android:name': string; 'android:maxSdkVersion'?: string } };
+
+function ensureLegacyPermission(manifest: AndroidManifest, name: string) {
+  manifest.manifest['uses-permission'] ??= [];
+  const permissions: UsesPermission[] = 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' } });
+  }
+}
+
+export function setAccessorySetupManifest(
+  manifest: AndroidManifest,
+  { android }: AccessorySetupOptions
+): AndroidManifest {
+  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');
+  AndroidConfig.Permissions.ensurePermission(manifest, 'android.permission.BLUETOOTH_CONNECT');
+
+  if (android.runInBackground) {
+    AndroidConfig.Permissions.ensurePermission(
+      manifest,
+      'android.permission.REQUEST_COMPANION_RUN_IN_BACKGROUND'
+    );
+  }
+  if (android.useDataInBackground) {
+    AndroidConfig.Permissions.ensurePermission(
+      manifest,
+      'android.permission.REQUEST_COMPANION_USE_DATA_IN_BACKGROUND'
+    );
+  }
+  return manifest;
+}
+
+const withAccessorySetup: ConfigPlugin<AccessorySetupPluginProps | void> = (config, props) => {
+  const options = parseOptions(props);
+
+  config = withInfoPlist(config, (config) => {
+    config.modResults = setAccessorySetupInfoPlist(config.modResults, options);
+    return config;
+  });
+
+  return withAndroidManifest(config, (config) => {
+    config.modResults = setAccessorySetupManifest(config.modResults, options);
+    return config;
+  });
+};
+
+export default createRunOncePlugin(withAccessorySetup, pkg.name, pkg.version);

package/plugin/src/options.ts

@@ -0,0 +1,142 @@
+export type AccessorySetupPluginProps = {
+  ios?: {
+    /** 16-bit (`"180D"`) or 128-bit service UUIDs that `showPicker` filters may use. */
+    bluetoothServices?: string[];
+    /** Advertised names or name substrings that `showPicker` filters may use. */
+    bluetoothNames?: string[];
+    /** Bluetooth SIG company identifiers (0 to 0xFFFF) that `showPicker` filters may use. */
+    bluetoothCompanyIdentifiers?: number[];
+  };
+  android?: {
+    /** Adds `REQUEST_COMPANION_RUN_IN_BACKGROUND`. */
+    runInBackground?: boolean;
+    /** Adds `REQUEST_COMPANION_USE_DATA_IN_BACKGROUND`. */
+    useDataInBackground?: boolean;
+  };
+};
+
+export type AccessorySetupOptions = {
+  ios: {
+    bluetoothServices: string[];
+    bluetoothNames: string[];
+    /** Four upper-case hex digits, e.g. `"004C"`. */
+    bluetoothCompanyIdentifiers: string[];
+  };
+  android: {
+    runInBackground: boolean;
+    useDataInBackground: boolean;
+  };
+};
+
+const UUID_16 = /^[0-9A-F]{4}$/;
+const UUID_128 = /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/;
+
+function fail(message: string): never {
+  throw new Error(`[expo-accessory-setup] Invalid plugin options: ${message}`);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function parseSection(value: unknown, path: string, keys: string[]): Record<string, unknown> {
+  if (value === undefined) {
+    return {};
+  }
+  if (!isRecord(value)) {
+    fail(`${path} must be an object.`);
+  }
+  const unknownKey = Object.keys(value).find((key) => !keys.includes(key));
+  if (unknownKey !== undefined) {
+    fail(`${path}.${unknownKey} is not a known option. Known options: ${keys.join(', ')}.`);
+  }
+  return value;
+}
+
+function parseArray<T>(
+  value: unknown,
+  path: string,
+  parseItem: (item: unknown, path: string) => T
+) {
+  if (value === undefined) {
+    return [];
+  }
+  if (!Array.isArray(value)) {
+    fail(`${path} must be an array.`);
+  }
+  return [...new Set(value.map((item, index) => parseItem(item, `${path}[${index}]`)))];
+}
+
+function parseServiceUUID(value: unknown, path: string): string {
+  const uuid = typeof value === 'string' ? value.trim().toUpperCase() : '';
+  if (!UUID_16.test(uuid) && !UUID_128.test(uuid)) {
+    fail(`${path} must be a 16-bit ("180D") or 128-bit UUID string, got ${JSON.stringify(value)}.`);
+  }
+  return uuid;
+}
+
+function parseName(value: unknown, path: string): string {
+  if (typeof value !== 'string' || value.trim().length === 0) {
+    fail(`${path} must be a non-empty string, got ${JSON.stringify(value)}.`);
+  }
+  return value;
+}
+
+function parseCompanyIdentifier(value: unknown, path: string): string {
+  if (typeof value !== 'number' || !Number.isInteger(value) || value < 0 || value > 0xffff) {
+    fail(`${path} must be an integer between 0 and 65535 (0xFFFF), got ${JSON.stringify(value)}.`);
+  }
+  return value.toString(16).toUpperCase().padStart(4, '0');
+}
+
+function parseBoolean(value: unknown, path: string): boolean {
+  if (value === undefined) {
+    return false;
+  }
+  if (typeof value !== 'boolean') {
+    fail(`${path} must be a boolean, got ${JSON.stringify(value)}.`);
+  }
+  return value;
+}
+
+export function parseOptions(props: unknown): AccessorySetupOptions {
+  const root = parseSection(props ?? {}, 'options', ['ios', 'android']);
+  const ios = parseSection(root.ios, 'ios', [
+    'bluetoothServices',
+    'bluetoothNames',
+    'bluetoothCompanyIdentifiers',
+  ]);
+  const android = parseSection(root.android, 'android', ['runInBackground', 'useDataInBackground']);
+
+  const options: AccessorySetupOptions = {
+    ios: {
+      bluetoothServices: parseArray(
+        ios.bluetoothServices,
+        'ios.bluetoothServices',
+        parseServiceUUID
+      ),
+      bluetoothNames: parseArray(ios.bluetoothNames, 'ios.bluetoothNames', parseName),
+      bluetoothCompanyIdentifiers: parseArray(
+        ios.bluetoothCompanyIdentifiers,
+        'ios.bluetoothCompanyIdentifiers',
+        parseCompanyIdentifier
+      ),
+    },
+    android: {
+      runInBackground: parseBoolean(android.runInBackground, 'android.runInBackground'),
+      useDataInBackground: parseBoolean(android.useDataInBackground, 'android.useDataInBackground'),
+    },
+  };
+
+  if (
+    options.ios.bluetoothServices.length === 0 &&
+    options.ios.bluetoothCompanyIdentifiers.length === 0
+  ) {
+    fail(
+      'ios.bluetoothServices or ios.bluetoothCompanyIdentifiers must list at least one value. ' +
+        'AccessorySetupKit only discovers accessories by service UUID or company identifier, ' +
+        'and the app crashes if a picker filter uses a value missing from Info.plist.'
+    );
+  }
+  return options;
+}

package/plugin/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "lib": ["es2022"],
+    "types": ["node"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "noUnusedLocals": true,
+    "noImplicitReturns": true,
+    "rootDir": "./src",
+    "outDir": "./build"
+  },
+  "include": ["./src"]
+}

package/src/ExpoAccessorySetup.types.ts

@@ -0,0 +1,69 @@
+export type AccessoryPlatform = 'ios' | 'android';
+
+export type PairedAccessory = {
+  /**
+   * Stable identifier for `removeAccessory()` and for matching events.
+   * Equal to `bleIdentifier` for Bluetooth accessories.
+   */
+  id: string;
+  /**
+   * Pass this to react-native-ble-plx (`connectToDevice`, `devices`, ...).
+   * iOS: the CoreBluetooth peripheral UUID. Android: the MAC address, upper case.
+   */
+  bleIdentifier: string;
+  displayName: string;
+  platform: AccessoryPlatform;
+};
+
+export type AccessoryFilter = {
+  /**
+   * 16-bit (`"180D"`), 32-bit, or 128-bit Bluetooth service UUID.
+   * Must also be listed in the config plugin's `ios.bluetoothServices`.
+   */
+  serviceUUID?: string;
+  /**
+   * Bluetooth SIG company identifier, 0 to 0xFFFF.
+   * Must also be listed in the config plugin's `ios.bluetoothCompanyIdentifiers`.
+   */
+  companyIdentifier?: number;
+  /**
+   * Matches accessories whose advertised name contains this string.
+   * Must also be listed in the config plugin's `ios.bluetoothNames`.
+   */
+  nameSubstring?: string;
+};
+
+export type ImageSource = number | { uri: string };
+
+export type IosPickerOptions = {
+  /** Product name shown in the system picker. */
+  displayName: string;
+  /** Product image shown in the system picker: `require('./accessory.png')` or `{ uri }`. */
+  productImage: ImageSource;
+  /** `immediate` only discovers accessories held close to the device. Defaults to `default`. */
+  range?: 'default' | 'immediate';
+};
+
+export type AndroidPickerOptions = {
+  /** Stop scanning at the first match and show a single-device confirmation. Defaults to `true`. */
+  singleDevice?: boolean;
+  /** Java regex matched against the advertised name. Replaces `filter.nameSubstring` on Android. */
+  namePattern?: string;
+};
+
+export type ShowPickerOptions = {
+  /** Requires `serviceUUID` or `companyIdentifier`. */
+  filter: AccessoryFilter;
+  ios: IosPickerOptions;
+  android?: AndroidPickerOptions;
+};
+
+export type AccessoryEventType = 'accessoryAdded' | 'accessoryRemoved' | 'accessoryChanged';
+
+export type AccessoryEvent = {
+  accessory: PairedAccessory;
+};
+
+export type AccessorySubscription = {
+  remove(): void;
+};

package/src/ExpoAccessorySetupModule.ts

@@ -0,0 +1,20 @@
+import { NativeModule, requireOptionalNativeModule } from 'expo';
+
+import type { PairedAccessory } from './ExpoAccessorySetup.types';
+import type { NativePickerOptions } from './pickerOptions';
+
+export type ExpoAccessorySetupModuleEvents = {
+  onAccessoryAdded: (event: { accessory: PairedAccessory }) => void;
+  onAccessoryRemoved: (event: { accessory: PairedAccessory }) => void;
+  onAccessoryChanged: (event: { accessory: PairedAccessory }) => void;
+};
+
+declare class ExpoAccessorySetupModule extends NativeModule<ExpoAccessorySetupModuleEvents> {
+  isSupported(): boolean;
+  showPicker(options: NativePickerOptions): Promise<PairedAccessory>;
+  getPairedAccessories(): Promise<PairedAccessory[]>;
+  removeAccessory(id: string): Promise<void>;
+}
+
+/** `null` in Expo Go, on web, and in builds that don't include the module. */
+export default requireOptionalNativeModule<ExpoAccessorySetupModule>('ExpoAccessorySetup');

package/src/errors.ts

@@ -0,0 +1,59 @@
+export const AccessorySetupErrorCodes = [
+  'UNSUPPORTED',
+  'USER_CANCELLED',
+  'PERMISSION_DENIED',
+  'ALREADY_IN_PROGRESS',
+  'NOT_FOUND',
+  'DISCOVERY_TIMEOUT',
+  'INVALID_OPTIONS',
+  'UNKNOWN',
+] as const;
+
+export type AccessorySetupErrorCode = (typeof AccessorySetupErrorCodes)[number];
+
+export class AccessorySetupError extends Error {
+  readonly code: AccessorySetupErrorCode;
+
+  constructor(code: AccessorySetupErrorCode, message: string, options?: { cause?: unknown }) {
+    super(message, options);
+    this.name = 'AccessorySetupError';
+    this.code = code;
+  }
+}
+
+export function isAccessorySetupError(
+  error: unknown,
+  code?: AccessorySetupErrorCode
+): error is AccessorySetupError {
+  return error instanceof AccessorySetupError && (code === undefined || error.code === code);
+}
+
+function isErrorCode(value: unknown): value is AccessorySetupErrorCode {
+  return (AccessorySetupErrorCodes as readonly unknown[]).includes(value);
+}
+
+/**
+ * Expo wraps the module's exception in a function call exception, so the module's reason is the
+ * first cause: `Calling 'x' failed (at …)\n→ Caused by: AccessorySetupException: <reason> (at File.swift:22)`.
+ * Debug iOS builds add the exception name and Swift source location, which are stripped here.
+ */
+function nativeReason(message: string): string {
+  const [, reason] = message.split('\n→ Caused by: ');
+  if (reason === undefined) {
+    return message;
+  }
+  return reason.replace(/^\w+Exception: /, '').replace(/ \(at [^()]*\)$/, '');
+}
+
+/** Native modules reject with `{ code, message }`. Anything unrecognized becomes `UNKNOWN`. */
+export function toAccessorySetupError(error: unknown): AccessorySetupError {
+  if (error instanceof AccessorySetupError) {
+    return error;
+  }
+  const { code, message } = (error ?? {}) as { code?: unknown; message?: unknown };
+  return new AccessorySetupError(
+    isErrorCode(code) ? code : 'UNKNOWN',
+    typeof message === 'string' ? nativeReason(message) : String(error),
+    { cause: error }
+  );
+}

package/src/index.ts

@@ -0,0 +1,87 @@
+import { Platform } from 'react-native';
+
+import type {
+  AccessoryEvent,
+  AccessoryEventType,
+  AccessorySubscription,
+  PairedAccessory,
+  ShowPickerOptions,
+} from './ExpoAccessorySetup.types';
+import NativeModule from './ExpoAccessorySetupModule';
+import { AccessorySetupError, toAccessorySetupError } from './errors';
+import { toNativePickerOptions } from './pickerOptions';
+
+export * from './ExpoAccessorySetup.types';
+export {
+  AccessorySetupError,
+  AccessorySetupErrorCodes,
+  isAccessorySetupError,
+  type AccessorySetupErrorCode,
+} from './errors';
+
+function requireModule() {
+  if (!NativeModule || !NativeModule.isSupported()) {
+    throw new AccessorySetupError(
+      'UNSUPPORTED',
+      NativeModule
+        ? 'Accessory setup is not supported on this device (iOS 18+ or Android with companion device setup is required).'
+        : 'The ExpoAccessorySetup native module is not available. Use a development build, not Expo Go.'
+    );
+  }
+  return NativeModule;
+}
+
+async function call<T>(body: () => Promise<T>): Promise<T> {
+  try {
+    return await body();
+  } catch (error) {
+    throw toAccessorySetupError(error);
+  }
+}
+
+/** `true` on iOS 18+ and on Android devices with the companion device setup feature. */
+export function isSupported(): boolean {
+  return NativeModule?.isSupported() ?? false;
+}
+
+/**
+ * Shows the system accessory picker and resolves with the accessory the user selected.
+ * Rejects with `USER_CANCELLED` when the user dismisses the picker and `ALREADY_IN_PROGRESS`
+ * when another picker is showing.
+ */
+export function showPicker(options: ShowPickerOptions): Promise<PairedAccessory> {
+  return call(() => {
+    const module = requireModule();
+    const platform = Platform.OS === 'ios' ? 'ios' : 'android';
+    return module.showPicker(toNativePickerOptions(options, platform));
+  });
+}
+
+export function getPairedAccessories(): Promise<PairedAccessory[]> {
+  return call(() => requireModule().getPairedAccessories());
+}
+
+/** Rejects with `NOT_FOUND` when no paired accessory has this `id`. */
+export function removeAccessory(id: string): Promise<void> {
+  return call(() => requireModule().removeAccessory(id));
+}
+
+const nativeEventNames = {
+  accessoryAdded: 'onAccessoryAdded',
+  accessoryRemoved: 'onAccessoryRemoved',
+  accessoryChanged: 'onAccessoryChanged',
+} as const satisfies Record<AccessoryEventType, string>;
+
+/**
+ * On Android, events only fire for changes made through this module. Accessories removed from
+ * system settings disappear from the next `getPairedAccessories()` result without an event.
+ */
+export function addAccessoryListener(
+  type: AccessoryEventType,
+  listener: (event: AccessoryEvent) => void
+): AccessorySubscription {
+  if (!NativeModule) {
+    return { remove() {} };
+  }
+  return NativeModule.addListener(nativeEventNames[type], listener);
+}