@fishjam-cloud/react-native-client 0.29.0 → 0.30.0-rc.1

package/README.md

@@ -10,6 +10,85 @@ npm install @fishjam-cloud/react-native-client
 yarn add @fishjam-cloud/react-native-client
 ```
 
+## Android VoIP setup
+
+Incoming calls on Android are delivered over Firebase Cloud Messaging, so Firebase is
+only pulled into your build when you opt in. iOS uses PushKit/APNs and needs none of this.
+
+### Expo
+
+Enable VoIP in the config plugin and point Expo at your `google-services.json`:
+
+```json
+{
+  "expo": {
+    "android": { "googleServicesFile": "./google-services.json" },
+    "plugins": [["@fishjam-cloud/react-native-client", { "android": { "enableVoIP": true } }]]
+  }
+}
+```
+
+Prebuild does the rest. [`android.googleServicesFile`](https://docs.expo.dev/versions/latest/config/app/#googleservicesfile)
+makes Expo add the `com.google.gms:google-services` classpath, apply the Gradle plugin, and copy
+the file into `android/app/`. Omitting it while `enableVoIP` is on is a prebuild error.
+
+### Call timeouts
+
+The plugin can set native timeouts in seconds. An unanswered incoming call defaults
+to 45 seconds, an unconnected outgoing call defaults to 60 seconds, and the
+answer-fulfillment handshake defaults to 10 seconds:
+
+```json
+{
+  "expo": {
+    "plugins": [
+      [
+        "@fishjam-cloud/react-native-client",
+        {
+          "android": { "enableVoIP": true },
+          "voip": {
+            "incomingCallTimeout": 45,
+            "outgoingCallTimeout": 60,
+            "fulfillAnswerCallTimeout": 10
+          }
+        }
+      ]
+    ]
+  }
+}
+```
+
+All timeout properties are optional and must be positive finite numbers. Omit a
+property to use its native default.
+
+### Bare React Native
+
+Config plugins do not run, and the [`google-services` Gradle plugin](https://developers.google.com/android/guides/google-services-plugin)
+must be applied to the **application** module — a library cannot do it for you. Follow the
+[Firebase Android setup guide](https://firebase.google.com/docs/android/setup) to add
+`google-services.json` and apply the plugin.
+
+You must also declare by hand what the config plugin would otherwise inject into
+`AndroidManifest.xml` — the `MANAGE_OWN_CALLS`, `POST_NOTIFICATIONS`,
+`USE_FULL_SCREEN_INTENT` and `VIBRATE` permissions, the `IncomingCallActivity`,
+the `EndCallNotificationReceiver`, and the `PushNotificationService` with its
+`com.google.firebase.MESSAGING_EVENT` intent filter. See `plugin/src/withFishjamVoIPAndroid.ts`
+for the exact entries.
+
+Set timeout metadata manually when using bare React Native:
+
+```xml
+<application>
+  <meta-data android:name="VoIPIncomingCallTimeout" android:value="45" />
+  <meta-data android:name="VoIPOutgoingCallTimeout" android:value="60" />
+  <meta-data android:name="VoIPFulfillAnswerTimeout" android:value="10" />
+</application>
+```
+
+For iOS, add the same timeout values as numeric `Info.plist` keys:
+`VoIPIncomingCallTimeout`, `VoIPOutgoingCallTimeout`, and
+`VoIPFulfillAnswerTimeout`.
+
 ## Local Development with WebRTC Fork
 
 This package depends on `@fishjam-cloud/react-native-webrtc`, a fork of `react-native-webrtc`. The fork lives in [its own GitHub repo](https://github.com/fishjam-cloud/fishjam-react-native-webrtc) and is included in this monorepo as a git submodule at `packages/react-native-webrtc/`, wired up as a yarn workspace. No manual linking is required.

package/dist/index.d.ts

@@ -7,7 +7,13 @@ import './webrtc-polyfill';
 import React from 'react';
 import { type FishjamProviderProps as ReactClientFishjamProviderProps } from '@fishjam-cloud/react-client';
 export { RTCView, RTCPIPView, type RTCVideoViewProps, type RTCPIPViewProps } from './overrides/RTCView';
-export { ScreenCapturePickerView, startPIP, stopPIP, AudioDeviceType, useAudioOutput, pushAudioSamples, } from '@fishjam-cloud/react-native-webrtc';
+export { ScreenCapturePickerView, startPIP, stopPIP, AudioDeviceType, useAudioOutput, pushAudioSamples, useVoIPEvents, useTelecom, useTelecomEvent, fulfillIncomingCallConnected, failIncomingCallConnected, getPendingAnswerRequestId, reportOutgoingCallConnected, setCallHeld, setCallMuted, isCallHeld, } from '@fishjam-cloud/react-native-webrtc';
+export type { VoIPEventHandlers, VoIPCallIntent, VoIPIncomingPayload } from '@fishjam-cloud/react-native-webrtc';
+export { VoIPProvider } from './voip/VoIPProvider';
+export type { VoIPProviderProps } from './voip/VoIPProvider';
+export { useVoIP } from './voip/VoIPContext';
+export type { CurrentCall, VoIPCallStatus, VoIPContextValue } from './voip/VoIPContext';
+export type { CallEndedReason, TelecomConfig, TelecomEvent, TelecomEventType, UseTelecomResult, } from '@fishjam-cloud/react-native-webrtc';
 export type { CallKitAction, CallKitConfig, CustomAudioSink, CustomAudioTrack, MediaStream, MediaStreamTrack, AudioDevice, AudioOutputChangedInfo, UseAudioOutputResult, } from '@fishjam-cloud/react-native-webrtc';
 export { useForegroundService, type ForegroundServiceConfig } from './useForegroundService';
 export { useCameraPermissions, useMicrophonePermissions, type PermissionStatus } from './hooks/usePermissions';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,mBAAmB,CAAC;AAC3B,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAEL,KAAK,oBAAoB,IAAI,+BAA+B,EAC7D,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACxG,OAAO,EACL,uBAAuB,EACvB,QAAQ,EACR,OAAO,EACP,eAAe,EACf,cAAc,EACd,gBAAgB,GACjB,MAAM,oCAAoC,CAAC;AAE5C,YAAY,EACV,aAAa,EACb,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,WAAW,EACX,sBAAsB,EACtB,oBAAoB,GACrB,MAAM,oCAAoC,CAAC;AAE5C,OAAO,EAAE,oBAAoB,EAAE,KAAK,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAC5F,OAAO,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,KAAK,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/G,OAAO,EACL,oBAAoB,EACpB,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,GAChC,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EACL,yBAAyB,EACzB,aAAa,EACb,cAAc,EACd,UAAU,EACV,qBAAqB,EACrB,MAAM,EACN,OAAO,GACR,MAAM,6BAA6B,CAAC;AAErC,OAAO,EACL,SAAS,EACT,oBAAoB,EACpB,aAAa,EACb,cAAc,EACd,eAAe,EACf,qBAAqB,EACrB,mBAAmB,EACnB,QAAQ,EACR,UAAU,EACV,eAAe,EACf,iBAAiB,GAClB,MAAM,mBAAmB,CAAC;AAE3B,YAAY,EACV,cAAc,EACd,qBAAqB,EACrB,2BAA2B,EAC3B,yBAAyB,EACzB,eAAe,EACf,mBAAmB,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,0BAA0B,EAC1B,KAAK,EACL,WAAW,EACX,YAAY,EACZ,uBAAuB,EACvB,cAAc,EACd,WAAW,EACX,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,sBAAsB,GACvB,MAAM,mBAAmB,CAAC;AAE3B,YAAY,EACV,0BAA0B,EAC1B,cAAc,EACd,mBAAmB,EACnB,QAAQ,EACR,eAAe,EACf,eAAe,EACf,KAAK,EACL,WAAW,EACX,UAAU,EACV,uBAAuB,EACvB,MAAM,EACN,UAAU,EACV,yBAAyB,EACzB,wBAAwB,EACxB,YAAY,EACZ,OAAO,EACP,eAAe,EACf,eAAe,EACf,oBAAoB,EACpB,YAAY,EACZ,kBAAkB,EAClB,QAAQ,EACR,eAAe,EACf,kBAAkB,EAClB,uBAAuB,EACvB,eAAe,EACf,mBAAmB,GACpB,MAAM,6BAA6B,CAAC;AAGrC,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,+BAA+B,EAAE,mBAAmB,GAAG,eAAe,CAAC,CAAC;AAChH,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,mEAO1D"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -13,7 +13,9 @@ import React from 'react';
 import { FishjamProvider as ReactClientFishjamProvider, } from '@fishjam-cloud/react-client';
 import { FishjamClient } from '@fishjam-cloud/ts-client';
 export { RTCView, RTCPIPView } from './overrides/RTCView';
-export { ScreenCapturePickerView, startPIP, stopPIP, AudioDeviceType, useAudioOutput, pushAudioSamples, } from '@fishjam-cloud/react-native-webrtc';
+export { ScreenCapturePickerView, startPIP, stopPIP, AudioDeviceType, useAudioOutput, pushAudioSamples, useVoIPEvents, useTelecom, useTelecomEvent, fulfillIncomingCallConnected, failIncomingCallConnected, getPendingAnswerRequestId, reportOutgoingCallConnected, setCallHeld, setCallMuted, isCallHeld, } from '@fishjam-cloud/react-native-webrtc';
+export { VoIPProvider } from './voip/VoIPProvider';
+export { useVoIP } from './voip/VoIPContext';
 export { useForegroundService } from './useForegroundService';
 export { useCameraPermissions, useMicrophonePermissions } from './hooks/usePermissions';
 export { useCustomAudioSource, } from './hooks/useCustomAudioSource';

package/dist/overrides/hooks.d.ts

@@ -19,8 +19,10 @@ export declare function usePeers<P = Record<string, unknown>, S = Record<string,
 };
 export declare function useCallKit(): {
     startCallKitSession: (config: CallKitConfig) => Promise<void>;
-    endCallKitSession: () => Promise<void>;
+    endCallKitSession: (reason?: import("@fishjam-cloud/react-native-webrtc").CallEndedReason) => Promise<void>;
     getCallKitSessionStatus: () => Promise<boolean>;
+    setCallHeld: (onHold: boolean) => Promise<void>;
+    isHeld: () => boolean;
 };
 export declare function useCallKitService(config: CallKitConfig): void;
 export declare function useCallKitEvent<T extends keyof CallKitAction>(action: T, callback: (event: CallKitAction[T]) => void): void;

package/dist/overrides/hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/overrides/hooks.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,WAAW,IAAI,aAAa,EAAE,MAAM,oCAAoC,CAAC;AASrH,OAAO,KAAK,EAEV,uBAAuB,EACvB,cAAc,EACd,WAAW,EAGX,eAAe,EACf,2BAA2B,EAC3B,yBAAyB,EACzB,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,SAAS,CAAC;AAEjB,wBAAgB,SAAS,IAAI,eAAe,CAc3C;AAED,wBAAgB,aAAa,IAAI,mBAAmB,CAcnD;AAED,wBAAgB,cAAc,IAAI,oBAAoB,CAgBrD;AAED,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,QAAQ,EAAE,CAAC;YAIhC,aAAa,GAAG,SAAS;eACnB,CAAC,SAAS,EAAE,aAAa,GAAG,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC;EAEpF;AAED,wBAAgB,qBAAqB,IAAI,2BAA2B,CAYnE;AAED,wBAAgB,mBAAmB,IAAI,yBAAyB,CAM/D;AAED,wBAAgB,oBAAoB;uBAGO,CACrC,GAAG,IAAI,EAAE,UAAU,wJAAyB,KACzC,OAAO,CAAC,uBAAuB,CAAC;EAExC;AAED,wBAAgB,QAAQ,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC9B;IAC/C,SAAS,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC;IACvC,WAAW,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,WAAW,CAAC,EAAE,CAAC;IACjD,KAAK,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,WAAW,CAAC,EAAE,CAAC;CAC5C,CACF;AAED,wBAAgB,UAAU;;;;EAGzB;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,aAAa,QAEtD;AAED,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,aAAa,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,IAAI,QAEpH"}
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/overrides/hooks.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,WAAW,IAAI,aAAa,EAAE,MAAM,oCAAoC,CAAC;AASrH,OAAO,KAAK,EAEV,uBAAuB,EACvB,cAAc,EACd,WAAW,EAGX,eAAe,EACf,2BAA2B,EAC3B,yBAAyB,EACzB,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,SAAS,CAAC;AAEjB,wBAAgB,SAAS,IAAI,eAAe,CAc3C;AAED,wBAAgB,aAAa,IAAI,mBAAmB,CAcnD;AAED,wBAAgB,cAAc,IAAI,oBAAoB,CAgBrD;AAED,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,QAAQ,EAAE,CAAC;YAIhC,aAAa,GAAG,SAAS;eACnB,CAAC,SAAS,EAAE,aAAa,GAAG,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC;EAEpF;AAED,wBAAgB,qBAAqB,IAAI,2BAA2B,CAYnE;AAED,wBAAgB,mBAAmB,IAAI,yBAAyB,CAM/D;AAED,wBAAgB,oBAAoB;uBAGO,CACrC,GAAG,IAAI,EAAE,UAAU,wJAAyB,KACzC,OAAO,CAAC,uBAAuB,CAAC;EAExC;AAED,wBAAgB,QAAQ,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC9B;IAC/C,SAAS,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC;IACvC,WAAW,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,WAAW,CAAC,EAAE,CAAC;IACjD,KAAK,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,WAAW,CAAC,EAAE,CAAC;CAC5C,CACF;AAED,wBAAgB,UAAU;;8BAhImB,CAAC;;;;EAmI7C;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,aAAa,QAEtD;AAED,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,aAAa,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,IAAI,QAEpH"}

package/dist/voip/VoIPContext.d.ts

@@ -0,0 +1,99 @@
+import type { CallEndedReason, VoIPCallIntent } from '@fishjam-cloud/react-native-webrtc';
+/**
+ * Lifecycle state of the current VoIP call.
+ *
+ * - `available` — no call in progress
+ * - `incoming` — a call is ringing, awaiting the user's answer
+ * - `connecting` — the call was started/answered; **your app should be joining its room now**
+ * - `active` — your app reported the media connected and the call is in progress
+ */
+export type VoIPCallStatus = 'available' | 'incoming' | 'connecting' | 'active';
+/**
+ * Details of the call currently being handled.
+ */
+export type CurrentCall = {
+    /**
+     * Fishjam room the call takes place in. For outgoing calls it is the name passed to
+     * `startCall`; for incoming ones it comes from the VoIP push payload.
+     */
+    roomName: string;
+    /** Name shown in the CallKit UI (the remote party). */
+    displayName: string;
+    /**
+     * Stable id of the remote party — use a durable user id, not a display name (which
+     * may not be unique), since this is what Recents hands back for redialing.
+     */
+    handle: string;
+    /** Whether the call is a video call. */
+    isVideo: boolean;
+    /** Timestamp (ms) when the call became `active`, or `null` if not yet connected. */
+    startedAt: number | null;
+    /** `true` when this device initiated the call, `false` when receiving it. */
+    isOutgoing: boolean;
+};
+/**
+ * Value returned from {@link useVoIP}.
+ */
+export type VoIPContextValue = {
+    /** Current call lifecycle status. */
+    callStatus: VoIPCallStatus;
+    /** This device's VoIP push token, or `null` until APNs has issued one. */
+    voipToken: string | null;
+    /** The call currently being handled, or `null` when `callStatus` is `available`. */
+    currentCall: CurrentCall | null;
+    /**
+     * Why the most recently handled call ended. `null` until a call has ended at
+     * least once. Surfaced so a consumer can react to `missed`/`rejected`/etc., e.g.
+     * showing a "missed call" notification.
+     */
+    lastEndedReason: CallEndedReason | null;
+    /**
+     * Whether the native CallKit/Core-Telecom session is currently held. Reported only —
+     * apply it to your own tracks.
+     */
+    isOnHold: boolean;
+    /** Whether the system call UI has the call muted. Reported only, as with {@link VoIPContextValue.isOnHold}. */
+    isMuted: boolean;
+    /**
+     * A redial requested from the iOS **Recents** list, or `null` when there is none.
+     * It carries only the handle to call, never a room, so mint a room name yourself.
+     * Held until {@link VoIPContextValue.clearCallIntent}, so one arriving before your
+     * app has restored its session is not lost.
+     */
+    pendingCallIntent: VoIPCallIntent | null;
+    /** Discards {@link VoIPContextValue.pendingCallIntent} once you have acted on it. */
+    clearCallIntent: () => void;
+    /**
+     * Reports an outgoing call to `to` in `roomName` to CallKit/Core-Telecom and moves
+     * to `connecting`. Run your own signaling (ringing the callee) *before* calling this.
+     * It does **not** join the room — react to `callStatus` becoming `connecting` for that.
+     */
+    startCall: (to: string, roomName: string) => Promise<void>;
+    /**
+     * Report that the room join succeeded and media is flowing. Fulfills CallKit's answer
+     * action (or reports the outgoing call as connected) and moves the call to `active`.
+     *
+     * An answered incoming call must be fulfilled within `VoIPFulfillAnswerTimeout`
+     * (10s by default) or the native side ends it and `onEnded` fires.
+     */
+    reportConnected: () => Promise<void>;
+    /** Tell the SDK your room join failed. Ends the call with reason `failed`. */
+    reportConnectFailed: () => Promise<void>;
+    /**
+     * Ends or rejects the current call. Dismisses CallKit/Telecom and resets state back
+     * to `available`; leaving the room is up to you. `reason` (defaults to `local`) is
+     * surfaced to the system call UI/log and to `lastEndedReason`.
+     */
+    endCall: (reason?: CallEndedReason) => Promise<void>;
+    /** Requests that the native CallKit/Core-Telecom session be held or resumed. */
+    setCallHeld: (onHold: boolean) => Promise<void>;
+};
+export declare const VoIPContext: import("react").Context<VoIPContextValue | null>;
+/**
+ * Returns the current {@link VoIPContextValue}.
+ *
+ * Must be used inside a `VoIPProvider`. Without it the VoIP call machine is not
+ * mounted and this hook throws.
+ */
+export declare function useVoIP(): VoIPContextValue;
+//# sourceMappingURL=VoIPContext.d.ts.map

package/dist/voip/VoIPContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VoIPContext.d.ts","sourceRoot":"","sources":["../../src/voip/VoIPContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAG1F;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,UAAU,GAAG,YAAY,GAAG,QAAQ,CAAC;AAEhF;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB,uDAAuD;IACvD,WAAW,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IACf,wCAAwC;IACxC,OAAO,EAAE,OAAO,CAAC;IACjB,oFAAoF;IACpF,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,6EAA6E;IAC7E,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,qCAAqC;IACrC,UAAU,EAAE,cAAc,CAAC;IAC3B,0EAA0E;IAC1E,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,oFAAoF;IACpF,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IAChC;;;;OAIG;IACH,eAAe,EAAE,eAAe,GAAG,IAAI,CAAC;IACxC;;;OAGG;IACH,QAAQ,EAAE,OAAO,CAAC;IAClB,+GAA+G;IAC/G,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;OAKG;IACH,iBAAiB,EAAE,cAAc,GAAG,IAAI,CAAC;IACzC,qFAAqF;IACrF,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B;;;;OAIG;IACH,SAAS,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3D;;;;;;OAMG;IACH,eAAe,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACrC,8EAA8E;IAC9E,mBAAmB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC;;;;OAIG;IACH,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,eAAe,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,gFAAgF;IAChF,WAAW,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACjD,CAAC;AAEF,eAAO,MAAM,WAAW,kDAA+C,CAAC;AAExE;;;;;GAKG;AACH,wBAAgB,OAAO,IAAI,gBAAgB,CAQ1C"}

package/dist/voip/VoIPContext.js

@@ -0,0 +1,15 @@
+import { createContext, useContext } from 'react';
+export const VoIPContext = createContext(null);
+/**
+ * Returns the current {@link VoIPContextValue}.
+ *
+ * Must be used inside a `VoIPProvider`. Without it the VoIP call machine is not
+ * mounted and this hook throws.
+ */
+export function useVoIP() {
+    const ctx = useContext(VoIPContext);
+    if (!ctx) {
+        throw new Error('useVoIP must be used inside a VoIPProvider — wrap your app in `<VoIPProvider>` to enable VoIP calls.');
+    }
+    return ctx;
+}

package/dist/voip/VoIPProvider.d.ts

@@ -0,0 +1,26 @@
+import { type VoIPIncomingPayload } from '@fishjam-cloud/react-native-webrtc';
+import { type PropsWithChildren } from 'react';
+/**
+ * Props of {@link VoIPProvider} — the configuration of the VoIP call machine.
+ */
+export type VoIPProviderProps = PropsWithChildren & {
+    /**
+     * A waiting or overflow incoming call was declined from native UI. Does not
+     * change local call state - use for signaling (e.g. `call-rejected` to the caller).
+     */
+    onWaitingCallDeclined?: (payload: VoIPIncomingPayload) => void;
+    /**
+     * Whether outgoing calls are video calls — reflected in the CallKit session.
+     * Make sure the underlying room type is set accordingly. Defaults to `false` (audio-only).
+     */
+    isVideo?: boolean;
+};
+/**
+ * Tracks the current VoIP call state, driven by the native CallKit / Core-Telecom
+ * events from {@link useVoIPEvents}, and exposes it through {@link useVoIP}.
+ *
+ * Joining rooms, peer tokens and media are the consumer's — react to `callStatus` and
+ * report back with `reportConnected` / `reportConnectFailed`.
+ */
+export declare function VoIPProvider({ onWaitingCallDeclined, isVideo, children }: VoIPProviderProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=VoIPProvider.d.ts.map

package/dist/voip/VoIPProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VoIPProvider.d.ts","sourceRoot":"","sources":["../../src/voip/VoIPProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,EASL,KAAK,mBAAmB,EACzB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,KAAK,iBAAiB,EAA0C,MAAM,OAAO,CAAC;AAMvF;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,iBAAiB,GAAG;IAClD;;;OAGG;IACH,qBAAqB,CAAC,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,IAAI,CAAC;IAC/D;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,EAAE,qBAAqB,EAAE,OAAe,EAAE,QAAQ,EAAE,EAAE,iBAAiB,2CAiTnG"}

package/dist/voip/VoIPProvider.js

@@ -0,0 +1,268 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { failIncomingCallConnected, fulfillIncomingCallConnected, reportOutgoingCallConnected, setCallHeld as setVoIPCallHeld, useTelecom, useVoIPEvents, } from '@fishjam-cloud/react-native-webrtc';
+import { useCallback, useMemo, useRef, useState } from 'react';
+import { Platform } from 'react-native';
+import { useCallKit } from '../overrides/hooks';
+import { VoIPContext } from './VoIPContext';
+/**
+ * Tracks the current VoIP call state, driven by the native CallKit / Core-Telecom
+ * events from {@link useVoIPEvents}, and exposes it through {@link useVoIP}.
+ *
+ * Joining rooms, peer tokens and media are the consumer's — react to `callStatus` and
+ * report back with `reportConnected` / `reportConnectFailed`.
+ */
+export function VoIPProvider({ onWaitingCallDeclined, isVideo = false, children }) {
+    const [voipToken, setVoIPToken] = useState(null);
+    const [callStatus, setCallStatus] = useState('available');
+    const [currentCall, setCurrentCall] = useState(null);
+    const [lastEndedReason, setLastEndedReason] = useState(null);
+    const [isOnHold, setIsOnHold] = useState(false);
+    const [isMuted, setIsMuted] = useState(false);
+    const [pendingCallIntent, setPendingCallIntent] = useState(null);
+    const currentCallRef = useRef(null);
+    const pendingAnswerRequestIdRef = useRef(null);
+    const activationInFlightRef = useRef(false);
+    const isCallOnHoldRef = useRef(false);
+    /** Serializes native call events so End & Accept cannot interleave their transitions. */
+    const callTransitionRef = useRef(Promise.resolve());
+    /**
+     * Set when the accept (`onAnswered`) is processed before the promoted waiting
+     * call's `onIncoming` payload, so `onIncoming` can replay the answer.
+     */
+    const pendingWaitingAnswerRef = useRef(null);
+    const enqueueCallTransition = useCallback((op) => {
+        const run = callTransitionRef.current.then(op);
+        callTransitionRef.current = run.catch(() => { });
+        return run;
+    }, []);
+    const { startCallKitSession, endCallKitSession } = useCallKit();
+    const { startCall: startTelecomSession, endCall: endTelecomSession } = useTelecom();
+    const startNativeCallSession = useCallback((to) => Platform.OS === 'ios'
+        ? startCallKitSession({ displayName: to, handle: to, isVideo })
+        : startTelecomSession({ displayName: to, handle: to, isVideo }), [startCallKitSession, startTelecomSession, isVideo]);
+    const endNativeCallSession = useCallback((reason) => (Platform.OS === 'ios' ? endCallKitSession(reason) : endTelecomSession(reason)), [endCallKitSession, endTelecomSession]);
+    const setCallHeld = useCallback(async (onHold) => {
+        if (!currentCallRef.current) {
+            return;
+        }
+        await setVoIPCallHeld(onHold);
+    }, []);
+    const resetCallState = useCallback((reason = 'local', endedRoomName) => {
+        const roomName = endedRoomName ?? currentCallRef.current?.roomName;
+        if (!roomName || currentCallRef.current?.roomName !== roomName) {
+            return;
+        }
+        currentCallRef.current = null;
+        pendingAnswerRequestIdRef.current = null;
+        pendingWaitingAnswerRef.current = null;
+        isCallOnHoldRef.current = false;
+        setIsOnHold(false);
+        setIsMuted(false);
+        setCurrentCall(null);
+        setCallStatus('available');
+        setLastEndedReason(reason);
+    }, []);
+    const endCall = useCallback(async (reason = 'local', options) => {
+        const endedCall = currentCallRef.current;
+        if (!endedCall)
+            return;
+        resetCallState(reason, endedCall.roomName);
+        // Native already ended the CallKit session before `onEnded` fired — calling
+        // endNativeCallSession again during call-waiting swap would end the new call.
+        if (!options?.fromNative) {
+            await endNativeCallSession(reason);
+        }
+    }, [endNativeCallSession, resetCallState]);
+    const startCall = useCallback(async (to, roomName) => {
+        const call = {
+            roomName,
+            displayName: to,
+            handle: to,
+            isVideo,
+            startedAt: null,
+            isOutgoing: true,
+        };
+        currentCallRef.current = call;
+        setCurrentCall(call);
+        setCallStatus('connecting');
+        setLastEndedReason(null);
+        try {
+            await startNativeCallSession(to);
+        }
+        catch (err) {
+            console.error('Failed to start call:', err);
+            await endCall('failed');
+        }
+    }, [startNativeCallSession, isVideo, endCall]);
+    const reportConnected = useCallback(async () => {
+        const call = currentCallRef.current;
+        if (!call || call.startedAt != null || activationInFlightRef.current) {
+            return;
+        }
+        activationInFlightRef.current = true;
+        try {
+            const requestId = pendingAnswerRequestIdRef.current;
+            if (requestId) {
+                pendingAnswerRequestIdRef.current = null;
+                const connected = await fulfillIncomingCallConnected(requestId);
+                if (!connected) {
+                    if (currentCallRef.current === call) {
+                        await endCall('failed');
+                    }
+                    return;
+                }
+            }
+            else if (call.isOutgoing) {
+                await reportOutgoingCallConnected();
+            }
+            // The call may have ended while we were talking to the native side.
+            const activeCall = currentCallRef.current;
+            if (!activeCall || activeCall.roomName !== call.roomName)
+                return;
+            const connectedCall = { ...activeCall, startedAt: Date.now() };
+            currentCallRef.current = connectedCall;
+            setCurrentCall(connectedCall);
+            setCallStatus('active');
+        }
+        catch (err) {
+            console.error('Failed to activate call:', err);
+            if (currentCallRef.current === call) {
+                await endCall('failed');
+            }
+        }
+        finally {
+            activationInFlightRef.current = false;
+        }
+    }, [endCall]);
+    const reportConnectFailed = useCallback(async () => {
+        const call = currentCallRef.current;
+        if (!call)
+            return;
+        const requestId = pendingAnswerRequestIdRef.current;
+        if (!requestId) {
+            await endCall('failed');
+            return;
+        }
+        pendingAnswerRequestIdRef.current = null;
+        try {
+            await failIncomingCallConnected(requestId);
+        }
+        finally {
+            resetCallState('failed', call.roomName);
+        }
+    }, [endCall, resetCallState]);
+    const clearCallIntent = useCallback(() => setPendingCallIntent(null), []);
+    useVoIPEvents({
+        onRegistered: useCallback((token) => {
+            setVoIPToken(token);
+        }, []),
+        // Native only delivers `onIncoming` for a *first* call, or for a waiting call
+        // the moment the user picks "End & Accept" — never while a waiting call merely
+        // rings (that stays entirely inside CallKit/Telecom). So a payload arriving
+        // while we're already in a call means an accepted waiting call is taking over:
+        // native has already ended the old one, and we just swap `currentCall` over.
+        // Leaving the old room and joining the new one falls out of the consumer
+        // reacting to `currentCall.roomName` changing.
+        onIncoming: useCallback((payload) => {
+            enqueueCallTransition(async () => {
+                const call = {
+                    roomName: payload.roomName,
+                    displayName: payload.displayName,
+                    handle: payload.handle,
+                    isVideo: payload.isVideo,
+                    startedAt: null,
+                    isOutgoing: false,
+                };
+                currentCallRef.current = call;
+                pendingAnswerRequestIdRef.current = null;
+                isCallOnHoldRef.current = false;
+                setCurrentCall(call);
+                setCallStatus('incoming');
+                setLastEndedReason(null);
+                setIsOnHold(false);
+                setIsMuted(false);
+                // The user already accepted this call before its payload arrived — apply
+                // the answer we stashed then.
+                const pendingAnswer = pendingWaitingAnswerRef.current;
+                if (pendingAnswer) {
+                    pendingWaitingAnswerRef.current = null;
+                    pendingAnswerRequestIdRef.current = pendingAnswer;
+                    setCallStatus('connecting');
+                }
+            });
+        }, [enqueueCallTransition]),
+        onAnswered: useCallback((requestId) => {
+            enqueueCallTransition(async () => {
+                if (pendingAnswerRequestIdRef.current) {
+                    return;
+                }
+                // No ringing call to answer yet: either the accepted waiting call's
+                // `onIncoming` hasn't arrived, or `call` is still the old (already
+                // `active`) call that native is ending. Stash so `onIncoming` replays it.
+                const call = currentCallRef.current;
+                if (!call || call.startedAt != null) {
+                    pendingWaitingAnswerRef.current = requestId;
+                    return;
+                }
+                pendingAnswerRequestIdRef.current = requestId;
+                setCallStatus('connecting');
+            });
+        }, [enqueueCallTransition]),
+        onEnded: useCallback((reason) => {
+            enqueueCallTransition(async () => {
+                await endCall(reason ?? 'remote', { fromNative: true });
+            });
+        }, [endCall, enqueueCallTransition]),
+        onHeldChanged: useCallback((onHold) => {
+            if (!currentCallRef.current?.startedAt || isCallOnHoldRef.current === onHold) {
+                return;
+            }
+            isCallOnHoldRef.current = onHold;
+            setIsOnHold(onHold);
+        }, []),
+        onMuteChanged: useCallback((muted) => {
+            if (!currentCallRef.current?.startedAt) {
+                return;
+            }
+            setIsMuted(muted);
+        }, []),
+        onCallIntent: useCallback((intent) => {
+            if (currentCallRef.current) {
+                console.warn('Ignoring call intent while another call is active');
+                return;
+            }
+            setPendingCallIntent(intent);
+        }, []),
+        onWaitingCallDeclined,
+    });
+    const voipValue = useMemo(() => ({
+        voipToken,
+        callStatus,
+        currentCall,
+        lastEndedReason,
+        isOnHold,
+        isMuted,
+        pendingCallIntent,
+        clearCallIntent,
+        startCall,
+        reportConnected,
+        reportConnectFailed,
+        endCall,
+        setCallHeld,
+    }), [
+        voipToken,
+        callStatus,
+        currentCall,
+        lastEndedReason,
+        isOnHold,
+        isMuted,
+        pendingCallIntent,
+        clearCallIntent,
+        startCall,
+        reportConnected,
+        reportConnectFailed,
+        endCall,
+        setCallHeld,
+    ]);
+    return _jsx(VoIPContext.Provider, { value: voipValue, children: children });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fishjam-cloud/react-native-client",
-  "version": "0.29.0",
+  "version": "0.30.0-rc.1",
   "description": "React Native client library for Fishjam",
   "license": "Apache-2.0",
   "author": "Fishjam Team",
@@ -42,15 +42,15 @@
     ]
   },
   "peerDependencies": {
-    "@fishjam-cloud/react-native-webrtc": "0.29.0",
+    "@fishjam-cloud/react-native-webrtc": "0.30.0-rc.0",
     "expo": "*",
     "react": "*",
     "react-native": "*",
     "react-native-get-random-values": "1.11.0"
   },
   "dependencies": {
-    "@fishjam-cloud/react-client": "0.29.0",
-    "@fishjam-cloud/react-native-webrtc": "0.29.0",
+    "@fishjam-cloud/react-client": "0.30.0-rc.1",
+    "@fishjam-cloud/react-native-webrtc": "0.30.0-rc.0",
     "fast-text-encoding": "1.0.6",
     "react-native-get-random-values": "1.11.0",
     "react-native-url-polyfill": "3.0.0"

package/plugin/build/types.d.ts

@@ -3,6 +3,21 @@ export type FishjamPluginOptions = {
         enableForegroundService?: boolean;
         enableScreensharing?: boolean;
         supportsPictureInPicture?: boolean;
+        enableVoIP?: boolean;
+        /**
+         * Register the SDK's FCM messaging service (default `true`). Set to `false`
+         * when the app ships its own dispatcher service that calls
+         * `PushNotificationService.handleVoIPMessage` / `handleNewToken`.
+         */
+        voipMessagingService?: boolean;
+        /**
+         * Messaging service that non-VoIP FCM messages and token callbacks are
+         * relayed to. Pass a supported library name (`'expo-notifications'`,
+         * `'@react-native-firebase/messaging'`) or a fully-qualified service class
+         * name. Omit to disable relaying — without it, other push libraries won't
+         * receive messages while VoIP is enabled.
+         */
+        voipFallbackMessagingService?: string;
     };
     ios?: {
         enableScreensharing?: boolean;
@@ -14,4 +29,10 @@ export type FishjamPluginOptions = {
         iphoneDeploymentTarget?: string;
         enableVoIPBackgroundMode?: boolean;
     };
+    voip?: {
+        incomingCallTimeout?: number;
+        outgoingCallTimeout?: number;
+        fulfillAnswerCallTimeout?: number;
+        notificationIcon?: string;
+    };
 } | undefined;

package/plugin/build/withFishjamAndroid.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.withFishjamAndroid = void 0;
 const config_plugins_1 = require("@expo/config-plugins");
 const Manifest_1 = require("@expo/config-plugins/build/android/Manifest");
+const withFishjamVoIPAndroid_1 = require("./withFishjamVoIPAndroid");
+const needsForegroundService = (props) => Boolean(props?.android?.enableForegroundService || props?.android?.enableVoIP);
 const withFishjamPictureInPicture = (config, props) => (0, config_plugins_1.withAndroidManifest)(config, (configuration) => {
     const activity = config_plugins_1.AndroidConfig.Manifest.getMainActivityOrThrow(configuration.modResults);
     if (props?.android?.supportsPictureInPicture) {
@@ -14,7 +16,7 @@ const withFishjamPictureInPicture = (config, props) => (0, config_plugins_1.with
     return configuration;
 });
 const withFishjamForegroundService = (config, props) => (0, config_plugins_1.withAndroidManifest)(config, async (configuration) => {
-    if (!props?.android?.enableForegroundService) {
+    if (!needsForegroundService(props)) {
         return configuration;
     }
     const mainApplication = (0, Manifest_1.getMainApplicationOrThrow)(configuration.modResults);
@@ -39,7 +41,7 @@ const withFishjamForegroundService = (config, props) => (0, config_plugins_1.wit
     return configuration;
 });
 const withFishjamForegroundServicePermission = (config, props) => (0, config_plugins_1.withAndroidManifest)(config, (configuration) => {
-    if (!props?.android?.enableForegroundService) {
+    if (!needsForegroundService(props)) {
         return configuration;
     }
     const mainApplication = configuration.modResults;
@@ -71,6 +73,7 @@ const withFishjamForegroundServicePermission = (config, props) => (0, config_plu
 const withFishjamAndroid = (config, props) => {
     config = withFishjamForegroundServicePermission(config, props);
     config = withFishjamForegroundService(config, props);
+    config = (0, withFishjamVoIPAndroid_1.withFishjamVoIPAndroid)(config, props);
     config = withFishjamPictureInPicture(config, props);
     return config;
 };

package/plugin/build/withFishjamIos.js

@@ -258,6 +258,59 @@ const withFishjamVoIPBackgroundMode = (config, props) => (0, config_plugins_1.wi
     }
     return configuration;
 });
+const withFishjamVoIPTimeouts = (config, props) => (0, config_plugins_1.withInfoPlist)(config, (configuration) => {
+    const timeouts = [
+        ['VoIPIncomingCallTimeout', 'incomingCallTimeout'],
+        ['VoIPOutgoingCallTimeout', 'outgoingCallTimeout'],
+        ['VoIPFulfillAnswerTimeout', 'fulfillAnswerCallTimeout'],
+    ];
+    timeouts.forEach(([key, option]) => {
+        const seconds = props?.voip?.[option];
+        if (seconds === undefined) {
+            return;
+        }
+        if (!Number.isFinite(seconds) || seconds <= 0) {
+            throw new Error(`Fishjam VoIP ${option} must be a positive finite number of seconds.`);
+        }
+        configuration.modResults[key] = Math.floor(seconds);
+    });
+    return configuration;
+});
+const withFishjamExpoVoip = (config, props) => {
+    if (!props?.voip) {
+        return config;
+    }
+    return (0, config_plugins_1.withInfoPlist)(config, (configuration) => {
+        try {
+            require.resolve('@fishjam-cloud/ios-expo-voip/package.json', {
+                paths: [configuration.modRequest.projectRoot],
+            });
+        }
+        catch {
+            throw new Error('Fishjam VoIP options are enabled but @fishjam-cloud/ios-expo-voip is not installed. ' +
+                'Run: npx expo install @fishjam-cloud/ios-expo-voip');
+        }
+        configuration.modResults['FishjamVoIPEnabled'] = true;
+        return configuration;
+    });
+};
+const withFishjamVoIPRecentsAndIntents = (config, props) => {
+    if (!props?.voip) {
+        return config;
+    }
+    return (0, config_plugins_1.withInfoPlist)(config, (configuration) => {
+        const activityTypes = new Set(Array.isArray(configuration.modResults.NSUserActivityTypes)
+            ? configuration.modResults.NSUserActivityTypes
+            : []);
+        // The audio/video variants are deprecated in favour of INStartCallIntent, but Recents
+        // redial still delivers them, so all three must be declared.
+        activityTypes.add('INStartCallIntent');
+        activityTypes.add('INStartAudioCallIntent');
+        activityTypes.add('INStartVideoCallIntent');
+        configuration.modResults.NSUserActivityTypes = Array.from(activityTypes);
+        return configuration;
+    });
+};
 const withFishjamPictureInPicture = (config, props) => (0, config_plugins_1.withInfoPlist)(config, (configuration) => {
     if (props?.ios?.supportsPictureInPicture) {
         const backgroundModes = new Set(configuration.modResults.UIBackgroundModes ?? []);
@@ -278,6 +331,9 @@ const withFishjamIos = (config, props) => {
     });
     config = withFishjamPictureInPicture(config, props);
     config = withFishjamVoIPBackgroundMode(config, props);
+    config = withFishjamVoIPTimeouts(config, props);
+    config = withFishjamExpoVoip(config, props);
+    config = withFishjamVoIPRecentsAndIntents(config, props);
     return config;
 };
 exports.withFishjamIos = withFishjamIos;

package/plugin/build/withFishjamVoIPAndroid.d.ts

@@ -0,0 +1,3 @@
+import type { ConfigPlugin } from '@expo/config-plugins';
+import type { FishjamPluginOptions } from './types';
+export declare const withFishjamVoIPAndroid: ConfigPlugin<FishjamPluginOptions>;

package/plugin/build/withFishjamVoIPAndroid.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withFishjamVoIPAndroid = void 0;
+const config_plugins_1 = require("@expo/config-plugins");
+const Manifest_1 = require("@expo/config-plugins/build/android/Manifest");
+/**
+ * Manifest entries required by the Android Telecom (VoIP calling) integration.
+ * Opt in with `android.enableVoIP`.
+ *
+ * - MANAGE_OWN_CALLS: required to register calls with Telecom via
+ *   androidx.core.telecom CallsManager.
+ * - POST_NOTIFICATIONS: the incoming/ongoing CallStyle notifications.
+ * - USE_FULL_SCREEN_INTENT: the incoming-call ring screen over the lock screen.
+ * - VIBRATE: the looping ring vibration driven while an incoming call rings.
+ */
+const VOIP_PERMISSIONS = [
+    'android.permission.MANAGE_OWN_CALLS',
+    'android.permission.POST_NOTIFICATIONS',
+    'android.permission.USE_FULL_SCREEN_INTENT',
+    'android.permission.VIBRATE',
+];
+const INCOMING_CALL_ACTIVITY = {
+    $: {
+        'android:name': 'com.oney.WebRTCModule.voip.IncomingCallActivity',
+        'android:exported': 'false',
+        'android:showWhenLocked': 'true',
+        'android:turnScreenOn': 'true',
+        'android:launchMode': 'singleInstance',
+        'android:excludeFromRecents': 'true',
+        'android:taskAffinity': '',
+        'android:theme': '@android:style/Theme.Black.NoTitleBar.Fullscreen',
+    },
+};
+const END_CALL_RECEIVER = {
+    $: {
+        'android:name': 'com.oney.WebRTCModule.voip.EndCallNotificationReceiver',
+        'android:exported': 'false',
+    },
+};
+const MESSAGING_SERVICE = {
+    '$': {
+        'android:name': 'com.oney.WebRTCModule.voip.PushNotificationService',
+        'android:exported': 'false',
+    },
+    'intent-filter': [
+        {
+            $: { 'android:priority': '1' },
+            action: [{ $: { 'android:name': 'com.google.firebase.MESSAGING_EVENT' } }],
+        },
+    ],
+};
+const INSTALLATION_ID_META = {
+    $: {
+        'android:name': 'firebase_messaging_installation_id_enabled',
+        'android:value': 'true',
+    },
+};
+const FALLBACK_META_NAME = 'VoIPFallbackMessagingService';
+/**
+ * Library names accepted by `android.voipFallbackMessagingService`, mapped to
+ * their FCM service class. These services come from **library** manifests, so on
+ * top of configuring the relay we re-declare them with tools:node="replace" and
+ * no intent-filter: the library's MESSAGING_EVENT filter is dropped (FCM routing
+ * stays deterministic) while the manifest entry keeps R8 from stripping the
+ * reflectively-loaded class in minified builds.
+ */
+const KNOWN_FALLBACK_SERVICES = {
+    'expo-notifications': 'expo.modules.notifications.service.ExpoFirebaseMessagingService',
+    '@react-native-firebase/messaging': 'io.invertase.firebase.messaging.ReactNativeFirebaseMessagingService',
+};
+const VOIP_TIMEOUTS = [
+    ['VoIPIncomingCallTimeout', 'incomingCallTimeout'],
+    ['VoIPOutgoingCallTimeout', 'outgoingCallTimeout'],
+    ['VoIPFulfillAnswerTimeout', 'fulfillAnswerCallTimeout'],
+];
+const NOTIFICATION_ICON_META_NAME = 'VoIPNotificationIcon';
+// The CallStyle notification's small icon defaults to the app's launcher icon.
+const DEFAULT_NOTIFICATION_ICON = '@mipmap/ic_launcher';
+function validateTimeout(name, seconds) {
+    if (!Number.isFinite(seconds) || seconds <= 0) {
+        throw new Error(`Fishjam VoIP ${name} must be a positive finite number of seconds.`);
+    }
+}
+function resolveFallbackMessagingService(props) {
+    const option = props?.android?.voipFallbackMessagingService;
+    if (!option) {
+        return null;
+    }
+    const known = KNOWN_FALLBACK_SERVICES[option];
+    if (known) {
+        return { className: known, knownLibrary: true };
+    }
+    if (option.includes('.')) {
+        return { className: option, knownLibrary: false };
+    }
+    throw new Error(`Fishjam VoIP: unknown voipFallbackMessagingService '${option}'. ` +
+        `Use one of ${Object.keys(KNOWN_FALLBACK_SERVICES).join(', ')} ` +
+        `or a fully-qualified FirebaseMessagingService class name.`);
+}
+/** Applies every VoIP manifest change. */
+function applyVoIPManifest(androidManifest, props, fallbackService) {
+    const manifest = androidManifest.manifest;
+    if (!manifest['uses-permission']) {
+        manifest['uses-permission'] = [];
+    }
+    const permissions = manifest['uses-permission'];
+    VOIP_PERMISSIONS.forEach((permissionName) => {
+        const hasPermission = permissions.some((perm) => perm.$?.['android:name'] === permissionName);
+        if (!hasPermission) {
+            permissions.push({ $: { 'android:name': permissionName } });
+        }
+    });
+    const mainApplication = (0, Manifest_1.getMainApplicationOrThrow)(androidManifest);
+    mainApplication.activity = mainApplication.activity || [];
+    const activityName = INCOMING_CALL_ACTIVITY.$['android:name'];
+    const existingActivityIndex = mainApplication.activity.findIndex((activity) => activity.$['android:name'] === activityName);
+    if (existingActivityIndex !== -1) {
+        mainApplication.activity[existingActivityIndex] = INCOMING_CALL_ACTIVITY;
+    }
+    else {
+        mainApplication.activity.push(INCOMING_CALL_ACTIVITY);
+    }
+    mainApplication.receiver = mainApplication.receiver || [];
+    const receiverName = END_CALL_RECEIVER.$['android:name'];
+    const existingReceiverIndex = mainApplication.receiver.findIndex((receiver) => receiver.$['android:name'] === receiverName);
+    if (existingReceiverIndex !== -1) {
+        mainApplication.receiver[existingReceiverIndex] = END_CALL_RECEIVER;
+    }
+    else {
+        mainApplication.receiver.push(END_CALL_RECEIVER);
+    }
+    mainApplication.service = mainApplication.service || [];
+    if (props?.android?.voipMessagingService !== false) {
+        // Cast: ManifestIntentFilter's typing omits android:priority, which is valid XML.
+        upsertService(mainApplication.service, MESSAGING_SERVICE);
+        if (fallbackService?.knownLibrary) {
+            manifest.$['xmlns:tools'] = manifest.$['xmlns:tools'] ?? 'http://schemas.android.com/tools';
+            upsertService(mainApplication.service, {
+                $: {
+                    'android:name': fallbackService.className,
+                    'tools:node': 'replace',
+                },
+            });
+        }
+    }
+    const metadataEntries = mainApplication['meta-data'] || [];
+    mainApplication['meta-data'] = metadataEntries;
+    const upsertMeta = (entry) => {
+        const existingIndex = metadataEntries.findIndex((meta) => meta.$['android:name'] === entry.$['android:name']);
+        if (existingIndex !== -1) {
+            metadataEntries[existingIndex] = entry;
+        }
+        else {
+            metadataEntries.push(entry);
+        }
+    };
+    upsertMeta(INSTALLATION_ID_META);
+    if (props?.android?.voipMessagingService !== false && fallbackService) {
+        upsertMeta({
+            $: {
+                'android:name': FALLBACK_META_NAME,
+                'android:value': fallbackService.className,
+            },
+        });
+    }
+    VOIP_TIMEOUTS.forEach(([key, option]) => {
+        const seconds = props?.voip?.[option];
+        if (seconds === undefined) {
+            return;
+        }
+        validateTimeout(option, seconds);
+        upsertMeta({
+            $: {
+                'android:name': key,
+                'android:value': String(Math.floor(seconds)),
+            },
+        });
+    });
+    // CallStyle notification small icon; defaults to the app's launcher icon.
+    upsertMeta({
+        $: {
+            'android:name': NOTIFICATION_ICON_META_NAME,
+            'android:resource': props?.voip?.notificationIcon ?? DEFAULT_NOTIFICATION_ICON,
+        },
+    });
+    return androidManifest;
+}
+function upsertService(services, entry) {
+    const existingIndex = services.findIndex((service) => service.$?.['android:name'] === entry.$?.['android:name']);
+    if (existingIndex !== -1) {
+        services[existingIndex] = entry;
+    }
+    else {
+        services.push(entry);
+    }
+}
+const withFishjamVoIPAndroid = (config, props) => {
+    if (!props?.android?.enableVoIP) {
+        return config;
+    }
+    const fallbackService = resolveFallbackMessagingService(props);
+    return (0, config_plugins_1.withAndroidManifest)(config, (configuration) => {
+        applyVoIPManifest(configuration.modResults, props, fallbackService);
+        return configuration;
+    });
+};
+exports.withFishjamVoIPAndroid = withFishjamVoIPAndroid;