@voltkit-rtc/react-native 0.0.0-stage → 0.1.0

package/plugin/build/android.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withVoltkitAndroid = exports.META_SCREEN_SHARE = exports.META_HW_AEC = exports.META_AUDIO_MODE = exports.CALL_SERVICE_CLASS = void 0;
+exports.blockedPermissions = blockedPermissions;
+exports.planAndroid = planAndroid;
+exports.setVoltkitManifest = setVoltkitManifest;
+/**
+ * What the plugin writes into the app's AndroidManifest.xml (plan §5.5). The names are the ones the SDK's native side
+ * reads (android/src/main/java/com/voltkit/rtc/reactnative/):
+ *
+ *     <uses-permission android:name="android.permission.CAMERA" />                      unless android.camera is false
+ *     <uses-permission android:name="android.permission.RECORD_AUDIO" />
+ *     <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+ *     <uses-permission android:name="android.permission.INTERNET" />
+ *     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+ *     <!-- with the call service (android.callService, default on) -->
+ *     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+ *     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MICROPHONE" />
+ *     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK" />
+ *     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+ *     <!-- for the permissions above, so Google Play does not read them as hardware the app cannot do without -->
+ *     <uses-feature android:name="android.hardware.camera" android:required="false" />            with CAMERA
+ *     <uses-feature android:name="android.hardware.camera.autofocus" android:required="false" />
+ *     <uses-feature android:name="android.hardware.camera.front" android:required="false" />
+ *     <uses-feature android:name="android.hardware.microphone" android:required="false" />        with RECORD_AUDIO
+ *     <application>
+ *       <meta-data android:name="in.voltkit.rtc.AUDIO_MODE" android:value="communication" />   RtcConfig.kt
+ *       <meta-data android:name="in.voltkit.rtc.HW_AEC" android:value="true" />
+ *       <meta-data android:name="in.voltkit.rtc.SCREEN_SHARE" android:value="false" />
+ *       <service android:name="com.voltkit.rtc.reactnative.VoltkitCallService" android:exported="false"
+ *                android:foregroundServiceType="microphone|mediaPlayback" />                    VoltkitCallService.kt
+ *     </application>
+ *
+ * android.callServiceCamera adds the camera type and FOREGROUND_SERVICE_CAMERA; android.screenShare adds
+ * FOREGROUND_SERVICE_MEDIA_PROJECTION, SCREEN_SHARE=true and the mediaProjection type, and, without the call service,
+ * still FOREGROUND_SERVICE and POST_NOTIFICATIONS: react-native-webrtc's screen-capture service is a foreground service
+ * with a notification of its own. The call service's types are what it MAY take: CallServiceTypes.kt picks from them
+ * at run time (microphone when RECORD_AUDIO is granted, otherwise mediaPlayback; camera only with pauseCamera false;
+ * mediaProjection only while a screen share is live). POST_NOTIFICATIONS goes with any foreground service: from
+ * Android 13 its notification shows only once the user allows notifications (the service runs either way).
+ *
+ * The uses-feature entries: Google Play reads CAMERA as "needs a camera with autofocus" and RECORD_AUDIO as "needs a
+ * microphone" unless the manifest says otherwise, and hides the app from devices without them (tablets, TVs,
+ * Chromebooks, some car and kiosk devices): a voice-only app, or a listener, would vanish from them for a camera it
+ * never opens. The plugin marks each feature of the permissions it adds as not required (the front camera too, which
+ * calls use); a missing camera or microphone is reported at run time (media-unavailable). The app's own <uses-feature>
+ * entries, by android:name, are never changed, so an app that does require a camera keeps its android:required="true".
+ *
+ * The SDK's own library manifest has only INTERNET, ACCESS_NETWORK_STATE, MODIFY_AUDIO_SETTINGS and its init provider,
+ * so an app that turns the call service off takes on no foreground service at all.
+ *
+ * Never written, whatever the options: a Bluetooth permission (call audio routing needs none, as in the Android SDK),
+ * SYSTEM_ALERT_WINDOW (which the community react-native-webrtc plugin adds), VIBRATE or storage. Expo's template adds
+ * SYSTEM_ALERT_WINDOW, VIBRATE and the storage permissions to every app; they are not the plugin's, so it leaves them as
+ * they are, and the app drops them with "android.blockedPermissions" (PLAN_UPDATES 10; the docs show the list).
+ *
+ * The app's blocks win over the plugin: a permission in android.blockedPermissions (or already in the manifest with
+ * tools:node="remove") is never asked for again, and a call-service type that a block leaves unusable is not declared,
+ * with its FOREGROUND_SERVICE_* permission, e.g. a listen-only app that blocks RECORD_AUDIO gets a mediaPlayback-only
+ * service. Screen sharing goes the same way (SCREEN_SHARE=false, no mediaProjection type, a warning) when a block
+ * leaves react-native-webrtc's screen-capture service unable to run, i.e. FOREGROUND_SERVICE or, on Android 14 and
+ * later, FOREGROUND_SERVICE_MEDIA_PROJECTION: with SCREEN_SHARE=true the first share would crash the app (a
+ * SecurityException in that service's startForeground), where the SDK now raises screen-share-service-required.
+ * Expo's own blockedPermissions plugin runs before app plugins' manifest mods, so both orders are handled.
+ *
+ * GOOGLE PLAY. An app that targets Android 14 (API 34) or later and whose manifest declares foreground service types
+ * must declare each type in Play Console before it can publish (Monitor and improve > App content > Foreground service
+ * permissions; https://support.google.com/googleplay/android-developer/answer/13392821): for each type, the feature it
+ * serves, what happens to the user if the task is deferred or interrupted, and a link to a short video of a user
+ * starting it. With the defaults that is two types:
+ *   - microphone: "Keeps the user's call audio going when they switch apps or turn the screen off during a call they
+ *     started"; the video starts a call, goes to the home screen and keeps talking.
+ *   - mediaPlayback: "Keeps a call audible for a listener who leaves the app"; the video joins as a listener, goes to
+ *     the home screen and keeps listening.
+ * camera (android.callServiceCamera) and mediaProjection (android.screenShare; react-native-webrtc's
+ * MediaProjectionService declares it too) are declared the same way. android.callService: false declares no
+ * foreground service and needs no declaration, at the price of calls that drop about 6 s after the app leaves the screen
+ * (Android cuts a background app's network without one; Android 17 also blocks its background audio).
+ */
+const config_plugins_1 = require("expo/config-plugins");
+const options_1 = require("./options");
+/** The SDK's call service (VoltkitCallService.kt); not exported: only the app itself starts it. */
+exports.CALL_SERVICE_CLASS = 'com.voltkit.rtc.reactnative.VoltkitCallService';
+/** The meta-data the SDK's init provider reads once when the app starts (RtcConfig.kt). */
+exports.META_AUDIO_MODE = 'in.voltkit.rtc.AUDIO_MODE';
+exports.META_HW_AEC = 'in.voltkit.rtc.HW_AEC';
+exports.META_SCREEN_SHARE = 'in.voltkit.rtc.SCREEN_SHARE';
+const permission = (name) => `android.permission.${name}`;
+const CAMERA = permission('CAMERA');
+const RECORD_AUDIO = permission('RECORD_AUDIO');
+const FOREGROUND_SERVICE = permission('FOREGROUND_SERVICE');
+const FOREGROUND_SERVICE_MEDIA_PROJECTION = permission('FOREGROUND_SERVICE_MEDIA_PROJECTION');
+const POST_NOTIFICATIONS = permission('POST_NOTIFICATIONS');
+const CALL_PERMISSIONS = ['RECORD_AUDIO', 'MODIFY_AUDIO_SETTINGS', 'INTERNET', 'ACCESS_NETWORK_STATE'].map(permission);
+/**
+ * The device features Google Play reads from a permission as required unless the manifest says otherwise
+ * (developer.android.com/guide/topics/manifest/uses-feature-element, "Permissions that imply feature requirements"),
+ * plus the front camera, which calls use.
+ */
+const FEATURES = [
+    {
+        permission: CAMERA,
+        features: ['android.hardware.camera', 'android.hardware.camera.autofocus', 'android.hardware.camera.front'],
+    },
+    { permission: RECORD_AUDIO, features: ['android.hardware.microphone'] },
+];
+const SERVICE_TYPES = {
+    microphone: { permission: permission('FOREGROUND_SERVICE_MICROPHONE'), needs: [RECORD_AUDIO] },
+    mediaPlayback: { permission: permission('FOREGROUND_SERVICE_MEDIA_PLAYBACK'), needs: [] },
+    camera: { permission: permission('FOREGROUND_SERVICE_CAMERA'), needs: [CAMERA] },
+    mediaProjection: { permission: FOREGROUND_SERVICE_MEDIA_PROJECTION, needs: [] },
+};
+/** The permissions the app blocks: android.blockedPermissions, and entries with tools:node="remove" already there. */
+function blockedPermissions(manifest, configBlocked = []) {
+    const blocked = new Set(configBlocked.map((name) => config_plugins_1.AndroidConfig.Permissions.ensurePermissionNameFormat(name)));
+    for (const entry of manifest.manifest['uses-permission'] ?? []) {
+        if (entry.$?.['tools:node'] === 'remove')
+            blocked.add(entry.$['android:name']);
+    }
+    return blocked;
+}
+function planAndroid(options, blocked) {
+    const usable = (...names) => names.every((name) => !blocked.has(name));
+    // react-native-webrtc's screen-capture service is a foreground service of type mediaProjection: without these it
+    // would crash the app at the first share (a SecurityException in its startForeground), so sharing stays off.
+    let screenShare = options.screenShare;
+    let screenShareDropped = null;
+    if (options.screenShare) {
+        const blocks = [FOREGROUND_SERVICE, FOREGROUND_SERVICE_MEDIA_PROJECTION].filter((name) => blocked.has(name));
+        if (blocks.length > 0) {
+            screenShare = false;
+            screenShareDropped = `android.blockedPermissions blocks ${blocks.join(' and ')}`;
+        }
+    }
+    let serviceTypes = [];
+    let serviceDropped = null;
+    if (options.callService) {
+        const wanted = ['microphone', 'mediaPlayback'];
+        if (options.callServiceCamera)
+            wanted.push('camera');
+        if (screenShare)
+            wanted.push('mediaProjection');
+        serviceTypes = wanted.filter((type) => usable(SERVICE_TYPES[type].permission, ...SERVICE_TYPES[type].needs));
+        if (!usable(FOREGROUND_SERVICE)) {
+            serviceDropped = `android.blockedPermissions blocks ${FOREGROUND_SERVICE}`;
+        }
+        else if (!serviceTypes.includes('microphone') && !serviceTypes.includes('mediaPlayback')) {
+            // CallServiceTypes.kt runs the service as microphone or mediaPlayback; camera or mediaProjection alone is no call.
+            const blocks = [RECORD_AUDIO, SERVICE_TYPES.microphone.permission, SERVICE_TYPES.mediaPlayback.permission].filter((name) => blocked.has(name));
+            serviceDropped = `android.blockedPermissions blocks ${blocks.join(', ')}, which leaves it neither the microphone nor the mediaPlayback type`;
+        }
+        if (serviceDropped)
+            serviceTypes = [];
+    }
+    // A foreground service of the app's: the call service, or react-native-webrtc's screen-capture service.
+    const foregroundService = serviceTypes.length > 0 || screenShare;
+    const wanted = [];
+    if (options.camera)
+        wanted.push(CAMERA);
+    wanted.push(...CALL_PERMISSIONS);
+    if (foregroundService)
+        wanted.push(FOREGROUND_SERVICE);
+    for (const type of serviceTypes)
+        wanted.push(SERVICE_TYPES[type].permission);
+    // react-native-webrtc's own screen-capture service needs it too, with or without the call service.
+    if (screenShare)
+        wanted.push(FOREGROUND_SERVICE_MEDIA_PROJECTION);
+    // Every foreground service has a notification, which Android 13 and later show only once the user allows them.
+    if (foregroundService)
+        wanted.push(POST_NOTIFICATIONS);
+    const permissions = [...new Set(wanted)].filter((name) => usable(name));
+    const features = FEATURES.flatMap((entry) => (permissions.includes(entry.permission) ? entry.features : []));
+    return { permissions, features, serviceTypes, serviceDropped, screenShare, screenShareDropped };
+}
+/**
+ * Marks these device features as not required, leaving the app's own <uses-feature> entries (by android:name) as they
+ * are. A manifest without any gets the list right before <application>, which the manifest must keep as its last
+ * child: xml2js writes the children in key order, and Expo's ensurePermissions appends a manifest's first
+ * <uses-permission> after <application>, so the rebuilt order ends with <application> whatever came before.
+ */
+function setUsesFeatures(manifest, names) {
+    const root = manifest.manifest;
+    const existing = root['uses-feature'];
+    const declared = new Set((existing ?? []).map((entry) => entry.$?.['android:name']));
+    const added = names
+        .filter((name) => !declared.has(name))
+        .map((name) => ({ $: { 'android:name': name, 'android:required': 'false' } }));
+    if (added.length === 0)
+        return;
+    if (existing) {
+        existing.push(...added);
+        return;
+    }
+    const ordered = {};
+    for (const [key, value] of Object.entries(root)) {
+        if (key !== 'application')
+            ordered[key] = value;
+    }
+    ordered['uses-feature'] = added;
+    if ('application' in root)
+        ordered.application = root.application;
+    manifest.manifest = ordered;
+}
+/** Declares the call service with these types, in place (an earlier prebuild's entry is updated), or takes it out. */
+function setCallService(application, types) {
+    const services = application.service ?? [];
+    const isCallService = (service) => service.$?.['android:name'] === exports.CALL_SERVICE_CLASS;
+    if (types.length === 0) {
+        const others = services.filter((service) => !isCallService(service));
+        if (others.length > 0)
+            application.service = others;
+        else
+            delete application.service;
+        return;
+    }
+    const attributes = {
+        'android:name': exports.CALL_SERVICE_CLASS,
+        'android:exported': 'false',
+        'android:foregroundServiceType': types.join('|'),
+    };
+    let written = false;
+    const next = [];
+    for (const service of services) {
+        if (!isCallService(service))
+            next.push(service);
+        else if (!written) {
+            next.push({ ...service, $: { ...service.$, ...attributes } });
+            written = true;
+        }
+    }
+    if (!written)
+        next.push({ $: attributes });
+    application.service = next;
+}
+/**
+ * Writes the permissions, the device features, the meta-data and the call service for these options into the manifest.
+ * Running it again on its own output changes nothing; after an option changes, the meta-data and the service are
+ * updated in place.
+ */
+function setVoltkitManifest(manifest, options, configBlocked = []) {
+    const plan = planAndroid(options, blockedPermissions(manifest, configBlocked));
+    // ensurePermissions skips a name already listed, including a tools:node="remove" block.
+    config_plugins_1.AndroidConfig.Permissions.ensurePermissions(manifest, plan.permissions);
+    setUsesFeatures(manifest, plan.features);
+    const application = config_plugins_1.AndroidConfig.Manifest.getMainApplicationOrThrow(manifest);
+    config_plugins_1.AndroidConfig.Manifest.addMetaDataItemToMainApplication(application, exports.META_AUDIO_MODE, options.audioMode);
+    config_plugins_1.AndroidConfig.Manifest.addMetaDataItemToMainApplication(application, exports.META_HW_AEC, String(options.hardwareEchoCancellation));
+    config_plugins_1.AndroidConfig.Manifest.addMetaDataItemToMainApplication(application, exports.META_SCREEN_SHARE, String(plan.screenShare));
+    setCallService(application, plan.serviceTypes);
+    if (plan.serviceDropped) {
+        config_plugins_1.WarningAggregator.addWarningAndroid(`${options_1.PLUGIN_NAME} android.callService`, `VoltkitCallService is not declared: ${plan.serviceDropped}. Calls will drop a few seconds after the app leaves ` +
+            'the screen; unblock those permissions, or set android.callService to false to silence this.');
+    }
+    if (plan.screenShareDropped) {
+        config_plugins_1.WarningAggregator.addWarningAndroid(`${options_1.PLUGIN_NAME} android.screenShare`, `screen sharing is off (${exports.META_SCREEN_SHARE}=false): ${plan.screenShareDropped}, which react-native-webrtc's ` +
+            'screen-capture service needs; with it on, the first share would crash the app. Unblock those permissions, or ' +
+            'set android.screenShare to false to silence this.');
+    }
+    return manifest;
+}
+const withVoltkitAndroid = (config, options) => (0, config_plugins_1.withAndroidManifest)(config, (modConfig) => {
+    modConfig.modResults = setVoltkitManifest(modConfig.modResults, options, modConfig.android?.blockedPermissions ?? []);
+    return modConfig;
+});
+exports.withVoltkitAndroid = withVoltkitAndroid;

package/plugin/build/index.d.ts

@@ -0,0 +1,9 @@
+import type { ConfigPlugin } from 'expo/config-plugins';
+import type { VoltkitRtcPluginProps } from './options';
+declare const _default: ConfigPlugin<void | VoltkitRtcPluginProps | null>;
+export default _default;
+export { CALL_SERVICE_CLASS, META_AUDIO_MODE, META_HW_AEC, META_SCREEN_SHARE, blockedPermissions, planAndroid, setVoltkitManifest, withVoltkitAndroid, } from './android';
+export type { AndroidPlan } from './android';
+export { setVoltkitInfoPlist, withVoltkitIos } from './ios';
+export { DEFAULT_CAMERA_PERMISSION, DEFAULT_MICROPHONE_PERMISSION, PLUGIN_NAME, resolveOptions } from './options';
+export type { AndroidOptions, AudioMode, IosOptions, PluginOptions, VoltkitRtcAndroidProps, VoltkitRtcIosProps, VoltkitRtcPluginProps, } from './options';

package/plugin/build/index.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveOptions = exports.PLUGIN_NAME = exports.DEFAULT_MICROPHONE_PERMISSION = exports.DEFAULT_CAMERA_PERMISSION = exports.withVoltkitIos = exports.setVoltkitInfoPlist = exports.withVoltkitAndroid = exports.setVoltkitManifest = exports.planAndroid = exports.blockedPermissions = exports.META_SCREEN_SHARE = exports.META_HW_AEC = exports.META_AUDIO_MODE = exports.CALL_SERVICE_CLASS = void 0;
+/**
+ * The Expo config plugin of @voltkit-rtc/react-native (plan §5.5). An app lists it in app.json:
+ *
+ *     "plugins": [["@voltkit-rtc/react-native", { "android": { "callService": true } }]]
+ *
+ * and `npx expo prebuild` (or `npx expo run:android`) writes the permissions, the call service and the meta-data the SDK
+ * reads into AndroidManifest.xml (./android.ts), and the usage strings and background modes into Info.plist (./ios.ts):
+ * the app edits no native file. Self-sufficient: no @config-plugins/react-native-webrtc, whose table stops at Expo 56
+ * and which adds SYSTEM_ALERT_WINDOW. Options are checked when the plugin is applied (./options.ts).
+ *
+ * Expo finds it through app.plugin.js at the package root, which loads plugin/build (this file, built by
+ * `npm run build:plugin`). It runs once per app, under the package's name, even if app.json lists it twice.
+ */
+const config_plugins_1 = require("expo/config-plugins");
+const android_1 = require("./android");
+const ios_1 = require("./ios");
+const options_1 = require("./options");
+/** The package's version, for Expo's plugin history (`expo config` shows it); from src/ and build/ alike. */
+function packageVersion() {
+    try {
+        const version = require('../../package.json').version;
+        return typeof version === 'string' ? version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const withVoltkitRtc = (config, props) => {
+    const options = (0, options_1.resolveOptions)(props);
+    config = (0, android_1.withVoltkitAndroid)(config, options.android);
+    config = (0, ios_1.withVoltkitIos)(config, options.ios);
+    return config;
+};
+exports.default = (0, config_plugins_1.createRunOncePlugin)(withVoltkitRtc, options_1.PLUGIN_NAME, packageVersion());
+var android_2 = require("./android");
+Object.defineProperty(exports, "CALL_SERVICE_CLASS", { enumerable: true, get: function () { return android_2.CALL_SERVICE_CLASS; } });
+Object.defineProperty(exports, "META_AUDIO_MODE", { enumerable: true, get: function () { return android_2.META_AUDIO_MODE; } });
+Object.defineProperty(exports, "META_HW_AEC", { enumerable: true, get: function () { return android_2.META_HW_AEC; } });
+Object.defineProperty(exports, "META_SCREEN_SHARE", { enumerable: true, get: function () { return android_2.META_SCREEN_SHARE; } });
+Object.defineProperty(exports, "blockedPermissions", { enumerable: true, get: function () { return android_2.blockedPermissions; } });
+Object.defineProperty(exports, "planAndroid", { enumerable: true, get: function () { return android_2.planAndroid; } });
+Object.defineProperty(exports, "setVoltkitManifest", { enumerable: true, get: function () { return android_2.setVoltkitManifest; } });
+Object.defineProperty(exports, "withVoltkitAndroid", { enumerable: true, get: function () { return android_2.withVoltkitAndroid; } });
+var ios_2 = require("./ios");
+Object.defineProperty(exports, "setVoltkitInfoPlist", { enumerable: true, get: function () { return ios_2.setVoltkitInfoPlist; } });
+Object.defineProperty(exports, "withVoltkitIos", { enumerable: true, get: function () { return ios_2.withVoltkitIos; } });
+var options_2 = require("./options");
+Object.defineProperty(exports, "DEFAULT_CAMERA_PERMISSION", { enumerable: true, get: function () { return options_2.DEFAULT_CAMERA_PERMISSION; } });
+Object.defineProperty(exports, "DEFAULT_MICROPHONE_PERMISSION", { enumerable: true, get: function () { return options_2.DEFAULT_MICROPHONE_PERMISSION; } });
+Object.defineProperty(exports, "PLUGIN_NAME", { enumerable: true, get: function () { return options_2.PLUGIN_NAME; } });
+Object.defineProperty(exports, "resolveOptions", { enumerable: true, get: function () { return options_2.resolveOptions; } });

package/plugin/build/ios.d.ts

@@ -0,0 +1,4 @@
+import type { ConfigPlugin, InfoPlist } from 'expo/config-plugins';
+import type { IosOptions } from './options';
+export declare function setVoltkitInfoPlist(plist: InfoPlist, options: IosOptions): InfoPlist;
+export declare const withVoltkitIos: ConfigPlugin<IosOptions>;

package/plugin/build/ios.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withVoltkitIos = void 0;
+exports.setVoltkitInfoPlist = setVoltkitInfoPlist;
+/**
+ * What the plugin writes into the app's Info.plist (plan §5.5; the SDK's iOS side is a preview, JavaScript only):
+ *
+ *     NSCameraUsageDescription        cameraPermission, else the app's own text, else a short default
+ *     NSMicrophoneUsageDescription    microphonePermission, else the app's own text, else a short default
+ *     UIBackgroundModes               + "audio" (ios.backgroundAudio, default on), + "voip" (ios.voip, default off)
+ *
+ * It only adds: the app's other background modes stay, none is listed twice, and running it again changes nothing.
+ */
+const config_plugins_1 = require("expo/config-plugins");
+const options_1 = require("./options");
+function usageText(given, current, fallback) {
+    if (given !== undefined)
+        return given;
+    if (typeof current === 'string' && current.trim() !== '')
+        return current;
+    return fallback;
+}
+function setVoltkitInfoPlist(plist, options) {
+    plist.NSCameraUsageDescription = usageText(options.cameraPermission, plist.NSCameraUsageDescription, options_1.DEFAULT_CAMERA_PERMISSION);
+    plist.NSMicrophoneUsageDescription = usageText(options.microphonePermission, plist.NSMicrophoneUsageDescription, options_1.DEFAULT_MICROPHONE_PERMISSION);
+    const modes = Array.isArray(plist.UIBackgroundModes) ? [...plist.UIBackgroundModes] : [];
+    const add = (mode) => {
+        if (!modes.includes(mode))
+            modes.push(mode);
+    };
+    if (options.backgroundAudio)
+        add('audio');
+    if (options.voip)
+        add('voip');
+    if (modes.length > 0)
+        plist.UIBackgroundModes = modes;
+    return plist;
+}
+const withVoltkitIos = (config, options) => (0, config_plugins_1.withInfoPlist)(config, (modConfig) => {
+    modConfig.modResults = setVoltkitInfoPlist(modConfig.modResults, options);
+    return modConfig;
+});
+exports.withVoltkitIos = withVoltkitIos;

package/plugin/build/options.d.ts

@@ -0,0 +1,93 @@
+/**
+ * The Expo config plugin's options (plan §5.5), as an app writes them in app.json or app.config.ts:
+ *
+ *     "plugins": [
+ *       ["@voltkit-rtc/react-native", {
+ *         "cameraPermission": "Your camera is shown to the people in your call.",
+ *         "microphonePermission": "Your microphone is heard by the people in your call.",
+ *         "android": { "callService": true, "screenShare": false },
+ *         "ios": { "backgroundAudio": true }
+ *       }]
+ *     ]
+ *
+ * Every option is optional. resolveOptions checks them when the plugin is applied, before any native file is written,
+ * and fills in the defaults; an unknown name or a wrong type stops prebuild with a message that names the option, so a
+ * typo never falls back to a default without a word.
+ */
+export declare const PLUGIN_NAME = "@voltkit-rtc/react-native";
+/** How the app plays call audio (meta-data in.voltkit.rtc.AUDIO_MODE; RtcConfig.kt). */
+export type AudioMode = 'communication' | 'media';
+export interface VoltkitRtcAndroidProps {
+    /**
+     * "communication" (default): call audio, echo cancellation, the earpiece, the loudspeaker and headsets. "media", for
+     * an app whose users only ever listen: the media volume and Bluetooth's high-quality profile, no earpiece. Fixed for
+     * the life of the app's process; never "media" where anyone may speak.
+     */
+    audioMode?: AudioMode;
+    /**
+     * Declares CAMERA (default true), with the camera, its autofocus and the front camera marked as hardware the app
+     * can do without (uses-feature android:required="false", so Google Play does not hide the app from devices without
+     * them). false for an app that never publishes video.
+     */
+    camera?: boolean;
+    /**
+     * Declares the call service, VoltkitCallService, with the types microphone and mediaPlayback, and its permissions:
+     * FOREGROUND_SERVICE, FOREGROUND_SERVICE_MICROPHONE, FOREGROUND_SERVICE_MEDIA_PLAYBACK and POST_NOTIFICATIONS
+     * (default true, plan open decision 1). It keeps a call's network, microphone and sound going in the background and
+     * with the screen off. false declares no foreground service: Google Play then needs no foreground-service
+     * declaration, but a call drops a few seconds after the app leaves the screen.
+     */
+    callService?: boolean;
+    /**
+     * Adds the camera type to the call service and FOREGROUND_SERVICE_CAMERA (default false), for an app that keeps the
+     * camera on in the background (`background={{ pauseCamera: false }}` on the provider). Needs camera and callService.
+     */
+    callServiceCamera?: boolean;
+    /**
+     * Turns on react-native-webrtc's screen-capture service (meta-data in.voltkit.rtc.SCREEN_SHARE) and declares
+     * FOREGROUND_SERVICE_MEDIA_PROJECTION, plus the mediaProjection type on the call service, which takes it only while
+     * a share is live (default false). That service is a foreground service with a notification, so without the call
+     * service it still brings FOREGROUND_SERVICE and POST_NOTIFICATIONS. Stays off, with a warning, when
+     * android.blockedPermissions blocks what it needs.
+     */
+    screenShare?: boolean;
+    /** The phone's own echo canceller and noise suppressor, where it has them (meta-data in.voltkit.rtc.HW_AEC; default true). */
+    hardwareEchoCancellation?: boolean;
+}
+export interface VoltkitRtcIosProps {
+    /** Adds `audio` to UIBackgroundModes, so a call keeps its sound in the background (default true). */
+    backgroundAudio?: boolean;
+    /** Adds `voip` to UIBackgroundModes, for an app that integrates CallKit itself (default false). */
+    voip?: boolean;
+}
+export interface VoltkitRtcPluginProps {
+    /** The iOS camera prompt (NSCameraUsageDescription). Default: the app's own text, or a short one. */
+    cameraPermission?: string;
+    /** The iOS microphone prompt (NSMicrophoneUsageDescription). Default: the app's own text, or a short one. */
+    microphonePermission?: string;
+    android?: VoltkitRtcAndroidProps;
+    ios?: VoltkitRtcIosProps;
+}
+export interface AndroidOptions {
+    audioMode: AudioMode;
+    camera: boolean;
+    callService: boolean;
+    callServiceCamera: boolean;
+    screenShare: boolean;
+    hardwareEchoCancellation: boolean;
+}
+export interface IosOptions {
+    /** Absent: keep the Info.plist's own text, or write the default. */
+    cameraPermission?: string;
+    microphonePermission?: string;
+    backgroundAudio: boolean;
+    voip: boolean;
+}
+export interface PluginOptions {
+    android: AndroidOptions;
+    ios: IosOptions;
+}
+export declare const DEFAULT_CAMERA_PERMISSION = "Allow $(PRODUCT_NAME) to use your camera in calls.";
+export declare const DEFAULT_MICROPHONE_PERMISSION = "Allow $(PRODUCT_NAME) to use your microphone in calls.";
+/** The app's options, checked, with every default filled in. */
+export declare function resolveOptions(props: unknown): PluginOptions;

package/plugin/build/options.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * The Expo config plugin's options (plan §5.5), as an app writes them in app.json or app.config.ts:
+ *
+ *     "plugins": [
+ *       ["@voltkit-rtc/react-native", {
+ *         "cameraPermission": "Your camera is shown to the people in your call.",
+ *         "microphonePermission": "Your microphone is heard by the people in your call.",
+ *         "android": { "callService": true, "screenShare": false },
+ *         "ios": { "backgroundAudio": true }
+ *       }]
+ *     ]
+ *
+ * Every option is optional. resolveOptions checks them when the plugin is applied, before any native file is written,
+ * and fills in the defaults; an unknown name or a wrong type stops prebuild with a message that names the option, so a
+ * typo never falls back to a default without a word.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MICROPHONE_PERMISSION = exports.DEFAULT_CAMERA_PERMISSION = exports.PLUGIN_NAME = void 0;
+exports.resolveOptions = resolveOptions;
+exports.PLUGIN_NAME = '@voltkit-rtc/react-native';
+exports.DEFAULT_CAMERA_PERMISSION = 'Allow $(PRODUCT_NAME) to use your camera in calls.';
+exports.DEFAULT_MICROPHONE_PERMISSION = 'Allow $(PRODUCT_NAME) to use your microphone in calls.';
+const AUDIO_MODES = ['communication', 'media'];
+const ANDROID_DEFAULTS = {
+    audioMode: 'communication',
+    camera: true,
+    callService: true,
+    callServiceCamera: false,
+    screenShare: false,
+    hardwareEchoCancellation: true,
+};
+const IOS_DEFAULTS = { backgroundAudio: true, voip: false };
+const TOP_KEYS = ['cameraPermission', 'microphonePermission', 'android', 'ios'];
+const ANDROID_KEYS = Object.keys(ANDROID_DEFAULTS);
+const IOS_KEYS = Object.keys(IOS_DEFAULTS);
+/** Every option by its full name, for "did you mean" when one is in the wrong place or misspelt. */
+const FULL_NAMES = [
+    'cameraPermission',
+    'microphonePermission',
+    ...ANDROID_KEYS.map((key) => `android.${key}`),
+    ...IOS_KEYS.map((key) => `ios.${key}`),
+];
+function fail(problem) {
+    throw new Error(`${exports.PLUGIN_NAME} config plugin: ${problem}${/[.?]$/.test(problem) ? '' : '.'}`);
+}
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function show(value) {
+    if (value === undefined)
+        return 'undefined';
+    if (Array.isArray(value))
+        return 'an array';
+    if (typeof value === 'object' && value !== null)
+        return 'an object';
+    return JSON.stringify(value);
+}
+/** Refuses a name this scope does not have, pointing at the right one when it is elsewhere or differs only in case. */
+function checkKeys(props, known, scope) {
+    for (const key of Object.keys(props)) {
+        if (known.includes(key))
+            continue;
+        const name = scope ? `${scope}.${key}` : key;
+        const near = FULL_NAMES.find((full) => full.split('.').pop()?.toLowerCase() === key.toLowerCase());
+        if (near)
+            fail(`unknown option "${name}"; did you mean "${near}"?`);
+        fail(`unknown option "${name}"; the ${scope ? `${scope} options are` : 'options are'} ${known.join(', ')}`);
+    }
+}
+function bool(props, key, scope, fallback) {
+    if (!(key in props) || props[key] === undefined)
+        return fallback;
+    const value = props[key];
+    if (typeof value !== 'boolean')
+        fail(`${scope}.${key} must be true or false, not ${show(value)}`);
+    return value;
+}
+function text(props, key, what) {
+    if (!(key in props) || props[key] === undefined)
+        return undefined;
+    const value = props[key];
+    if (typeof value !== 'string' || value.trim() === '')
+        fail(`${key} must be a non-empty string (${what}), not ${show(value)}`);
+    return value;
+}
+function section(props, key) {
+    const value = props[key];
+    if (value === undefined)
+        return {};
+    if (!isObject(value))
+        fail(`${key} must be an object, like "${key}": { ... }, not ${show(value)}`);
+    return value;
+}
+/** The app's options, checked, with every default filled in. */
+function resolveOptions(props) {
+    if (props === undefined || props === null)
+        props = {};
+    if (!isObject(props)) {
+        fail(`its options must be an object, like ["${exports.PLUGIN_NAME}", { "android": { "callService": true } }], not ${show(props)}`);
+    }
+    checkKeys(props, TOP_KEYS, '');
+    const androidProps = section(props, 'android');
+    checkKeys(androidProps, ANDROID_KEYS, 'android');
+    const iosProps = section(props, 'ios');
+    checkKeys(iosProps, IOS_KEYS, 'ios');
+    let audioMode = ANDROID_DEFAULTS.audioMode;
+    if (androidProps.audioMode !== undefined) {
+        const value = androidProps.audioMode;
+        if (!AUDIO_MODES.includes(value)) {
+            fail(`android.audioMode must be ${AUDIO_MODES.map((mode) => `"${mode}"`).join(' or ')}, not ${show(value)}`);
+        }
+        audioMode = value;
+    }
+    const android = {
+        audioMode,
+        camera: bool(androidProps, 'camera', 'android', ANDROID_DEFAULTS.camera),
+        callService: bool(androidProps, 'callService', 'android', ANDROID_DEFAULTS.callService),
+        callServiceCamera: bool(androidProps, 'callServiceCamera', 'android', ANDROID_DEFAULTS.callServiceCamera),
+        screenShare: bool(androidProps, 'screenShare', 'android', ANDROID_DEFAULTS.screenShare),
+        hardwareEchoCancellation: bool(androidProps, 'hardwareEchoCancellation', 'android', ANDROID_DEFAULTS.hardwareEchoCancellation),
+    };
+    if (android.callServiceCamera && !android.callService) {
+        fail('android.callServiceCamera needs android.callService: the camera type belongs to the call service');
+    }
+    if (android.callServiceCamera && !android.camera) {
+        fail('android.callServiceCamera needs android.camera: a camera foreground service needs the CAMERA permission');
+    }
+    const ios = {
+        backgroundAudio: bool(iosProps, 'backgroundAudio', 'ios', IOS_DEFAULTS.backgroundAudio),
+        voip: bool(iosProps, 'voip', 'ios', IOS_DEFAULTS.voip),
+    };
+    const cameraPermission = text(props, 'cameraPermission', "the iOS camera prompt's text");
+    const microphonePermission = text(props, 'microphonePermission', "the iOS microphone prompt's text");
+    if (cameraPermission !== undefined)
+        ios.cameraPermission = cameraPermission;
+    if (microphonePermission !== undefined)
+        ios.microphonePermission = microphonePermission;
+    return { android, ios };
+}

package/react-native.config.js

@@ -0,0 +1,11 @@
+// How the React Native CLI and Expo autolink this package.
+// Android: the TurboModule (VoltkitRtcPackage) and the init provider in android/. The codegen spec is
+// src/specs/NativeVoltkitRtc.ts (package.json codegenConfig); the app runs codegen for it at build time.
+// iOS: JavaScript only in 0.1.0, with no podspec, so there is nothing to link.
+module.exports = {
+  dependency: {
+    platforms: {
+      ios: null,
+    },
+  },
+};