@robono/calling-react-native
v0.11.4
Published
Optional branded calling screens, sounds and native audio adapters for Robono calling.
Readme
For the supplied Messenger, use its automatic account, calling and notification connection. System incoming-call setup is included by the installer. The custom-controller examples below are for apps that intentionally keep their own calling or notification integration.
Robono mobile calling
Optional React Native screens, sounds and audio adapters for direct and group voice and video calls within your app or across Robono Bridge. Each person stays in the app they use. Supply your own accounts and navigation, and choose your branding in the Calling workspace.
Choose the pieces you want:
| Your app needs | Use |
| --- | --- |
| Its own calling interface | @robono/calling alone, or the calling HTTP API |
| Ready-made screens and controls | CallingOverlay with createCallingController |
| A screen inside its own navigation | CallingScreen with controlled state and callbacks |
| Mobile microphone and audio handling | createNativeCallAdapters from the separate /native entry point |
| System incoming calls in the supplied Messenger | Automatic /system-calling connection; see required credentials |
| Custom incoming notification routing | /expo-notifications for Expo, or /notification-router with your existing push provider |
| Background call lifetime | /runtime for Android ongoing-call service and iPhone audio interruptions |
| Entries inside an existing conversation | CallHistoryItem with your chat bubble colors |
Installing the engine never installs or opens these screens. Importing this package does not register a push handler, ask for permissions, modify navigation or start audio. Screens appear only where your app explicitly renders them. You can use your own screens with the supplied audio adapter, or the supplied screens with your own audio adapter.
Install and configure
Install the versioned calling engine and the optional mobile package from npm:
npm install @robono/[email protected] @robono/[email protected]The screens need React, React Native, React Native SVG and Safe Area Context 5. The native audio and notification adapters support the following Expo dependency families:
| Your Expo SDK | Expo Audio | Expo Crypto | Expo Notifications | WebRTC config plugin | | --- | --- | --- | --- | --- | | 54 | 1.1.1 or later 1.x | 15.0.9 or later 15.x | 0.32.17 or later 0.32.x | 13.x | | 55 | 55.x | 55.x | 55.x | 14.x | | 56 | 56.x | 56.x | 56.x | 15.x |
Keep your app's Expo version. Let Expo select its matching native dependencies:
npx expo install react-native-svg react-native-safe-area-context expo-audio expo-asset expo-crypto expo-notifications
npm install [email protected] [email protected]Install the WebRTC config plugin matching the table, for example npm install @config-plugins/react-native-webrtc@13 for Expo 54. Commit the lockfile. Do not use --force or --legacy-peer-deps to hide an incompatible version.
Add these entries to your existing Expo plugins list:
["@config-plugins/react-native-webrtc", "expo-audio", "expo-notifications", "@robono/calling-react-native/app.plugin"]The package name @robono/calling-react-native and the /app.plugin.js and /app.plugin.cjs aliases also resolve to the same plugin. Existing /app.plugin integrations need no changes. Keep your app's existing push credentials. Make one development or release build after adding native dependencies; Expo Go cannot load WebRTC. Ordinary screen and copy changes do not require a native rebuild.
These dependencies are optional peers. Apps using only the screens do not need Expo audio, notifications or WebRTC. Apps using their own calling client can keep their existing audio and notification adapters.
On iPhone, configure NSMicrophoneUsageDescription with your app's explanation and the audio background mode for ongoing calls. On Android, declare RECORD_AUDIO, MODIFY_AUDIO_SETTINGS, and INTERNET; obtain notification permission on Android 13+. For Bluetooth audio on Android 12+, declare and obtain BLUETOOTH_CONNECT through your app's permission flow. The optional native runtime supplies Android’s microphone foreground service and its ongoing-call notification. It starts only after microphone permission and an explicit call action. Ordinary calls start from the visible app; the system-calling coordinator also permits an authenticated lock-screen Answer. Locking the phone after answering keeps that service running. Tapping its notification returns to your app; End releases the call. The service does not restart a call after the app is terminated. On iPhone, the runtime observes audio interruptions and holds an established call when another call takes the microphone; the separate system-calling coordinator supplies CallKit for the standard Messenger. See incoming calls. If your app already owns call lifetime, pass your existing adapter instead of starting a second service. Screens-only applications can disable native autolinking for this package in their React Native configuration.
Unanswered calls stop after 30 seconds from call creation. The service records No answer for the caller and the history helper displays Missed call for the recipient. The client also stops ringing at the supplied deadline if a status request stalls. Answering does not restart the ringing deadline.
Network-triggered countdowns on connected calls play a recorded initial warning, a one-minute reminder, and five final beeps through the current call output. iPhone shares the existing call audio session; Android uses USAGE_VOICE_COMMUNICATION so prompts follow the call's earpiece, speaker or connected headset. Prompts never change the output, request separate audio focus, or enter the outgoing microphone stream. Android requires the updated native runtime and matching Expo Asset dependency. System interruptions can suppress local prompts while the server's deadline continues. Your backend starts the countdown with startCountdown and receives the signed calling.countdown_ended completion webhook.
Add the optional interface
The complete examples/CallingHost.tsx component accepts your authenticated session function, service origin, contact information and accepted Bridge connection. Mount it under your account provider. getSession calls your backend, which authenticates the current user and exchanges a Robono admission ticket; network API keys never belong in mobile code.
import { createHttpTransport } from '@robono/calling';
import { createCallingController, CallingOverlay } from '@robono/calling-react-native';
import { createNativeCallAdapters } from '@robono/calling-react-native/native';
import { createNativeCallRuntime } from '@robono/calling-react-native/runtime';
const runtime = createNativeCallRuntime({
notificationTitle: 'Voice call', notificationText: 'Call in progress',
channelName: 'Ongoing calls', endLabel: 'End call', onError: showCallError,
});
const adapters = createNativeCallAdapters({
runtime,
ringtone: 'robono',
restoreAudio: restoreYourNormalAudioMode,
onError: showAudioError,
});
const calling = createCallingController({
request: createHttpTransport({baseUrl: session.serviceUrl, token: session.token, eventsToken: session.eventsToken}),
...adapters,
resolveContact: id => contactsByConnectionId[id] || null,
onError: showCallError,
});
runtime.attach(calling);
await calling.listen();
// Render once at your app's root, above ordinary chat navigation:
<CallingOverlay controller={calling} labels={{call: 'Voice call'}} />
// From your contact's call action, after checking availability:
await calling.call(connectionId, {name: contact.name, avatarUri: contact.avatar});
// On logout, dispose before creating another account's controller:
try { await calling.dispose(); } finally { await runtime.dispose(); }Keep one controller per signed-in device across navigation. Dispose it on logout. Stop your app's other recorder before starting a call. restoreAudio restores the host's normal audio mode after a call, so voice messages and other playback keep their existing behavior. The supplied runtime connects native interruption callbacks to calling.interrupt(): microphone, received audio and cues are silenced, and both screens show Call on hold. The existing call remains available for up to five minutes. Android audio-focus gain and iPhone interruption-end with permission to resume trigger a fresh server check before audio returns. If automatic resumption does not occur, the local screen offers Resume call on both iPhone and Android. While checking the call it shows Resuming; if audio is still in use or the service cannot be reached, it explains the problem and allows another attempt. This checks audio availability and the current call before enabling tracks; it preserves mute and speaker preferences. Either person can end the held call. A lost transport, expired hold or revoked connection cannot be silently reopened. If you supply your own lifetime adapter, connect those same interruption and resume actions. For your own interface, use resumePending to prevent duplicate taps and resumeError to explain a failed attempt. For a controlled CallingScreen, pass onResume={() => calling.resume()} as well as the ordinary controls. Calls still being set up end silently if audio is interrupted.
The host example refreshes contact availability and respects the server's retry delay. It renews sessions before expiry while idle, waits for previous audio cleanup on account changes, and offers reconnection after access ends. It never transfers an active call to a newly admitted session. Pass expiresAt as Unix milliseconds from the session response. Keep the controller at app level so changing chat screens does not end an ongoing call.
CallingScreen accepts state and callbacks rather than owning navigation. CallingOverlay is the optional full-screen wrapper. Both allow theme and label overrides, a contact avatar, safe-area insets and a friendly error formatter. The overlay and supplied host provide safe-area measurement inside their modal, keeping controls clear of system navigation. When embedding CallingScreen directly, use your existing safe-area provider or pass insets. Labels can be translated. Answer is on the right, Decline on the left. Speaker is available while calling and connecting. The timer starts at the media connection time. End dismisses the screen; there is no separate ended-call page.
Replace sections or compose a screen
Use the same optional package for three levels of customization: the saved website design, replacement sections in the supplied screen, or a layout assembled from individual components. None requires another calling client. Apps with their own interface can continue using the headless SDK without this package.
The components prop on CallingScreen and CallingOverlay accepts Layout, Identity, Brand, Avatar, Contact, Status, Controls, AudioControls, IncomingControls and ActionButton. Omitted sections retain the default implementation. The CallingHost and ExpoCallingHost examples accept the same prop. Define replacement component functions outside your render function so they retain local state as call status changes.
import {View} from 'react-native';
import {
CallingOverlay, CallingBrand, CallingAvatar, CallingContact, CallingStatus,
type CallingScreenComponents,
} from '@robono/calling-react-native';
function AppIdentity() {
return <View style={{alignItems: 'center', gap: 16}}>
<CallingBrand />
<CallingAvatar size={72} />
<CallingContact />
<CallingStatus />
</View>;
}
const components = {Identity: AppIdentity} satisfies CallingScreenComponents;
// Reuse the existing controller and saved appearance:
<CallingOverlay controller={calling} appearance={appearance} components={components} />Each replacement is already inside CallingUIProvider. useCallingUI() returns the current state, resolved theme and labels, contact title, status/duration, errors, typography and guarded action models. A replacement may render the default component with different styles; it does not need to reimplement its behavior. Lower-level replacements still apply inside default sections. If you replace Identity entirely, you choose which identity components it includes.
| Component | Purpose |
| --- | --- |
| CallingLayout | Scrollable frame with safe-area spacing |
| CallingBrand, CallingAvatar, CallingContact | App branding, contact photo/initials, name and call description |
| CallingStatus | Connection state, duration, interruption details and errors |
| CallingIdentity | Default combination of branding, contact and status |
| CallingIncomingControls | Decline on the left and Answer on the right |
| CallingAudioControls | Mute and Speaker, including connection setup |
| CallingActionButton | One state-aware answer, decline, mute, speaker, resume, end or close action |
| CallingControls | The complete default controls for the current call phase |
For your own layout, wrap these components in one CallingUIProvider, passing the same state and callbacks used by CallingScreen. The provider hides its contents when idle. It manages presentation and the duration display only; it does not start calls, create controllers, register notifications or own audio. Keep the existing account-level host and native lifecycle integration. When composing directly from a controller, continue reporting supplied screens with controller.reportComponents?.(['screens']); this reports component adoption, not billable usage.
CallingActionButton hides irrelevant actions and disables unavailable ones. For a completely custom button, read actions[action] from useCallingUI(), respect visible, disabled, selected and busy, and call onPress. Preserve an accessible label and role. Hidden or disabled action handlers are no-ops; the controller and service still enforce call state and permissions. Keep End available during calls and Close available during loading and errors. Custom layouts should include CallingStatus or display its status and error values so interruption and connection errors remain understandable.
See examples/CustomCallingScreen.tsx for section replacement, a fully composed layout and a custom button. The components work with either standalone calling or the Bridge. Changing their arrangement does not change audio routing, sounds, authorization or server usage records. Phone-controlled notification banners remain part of the native notification integration.
Sounds and routes
The package includes original Robono WAV assets: ringing.wav, connecting.wav and ended.wav. The adapter defaults to the person's system ringtone; choose ringtone: 'robono' for the supplied melody. A quiet repeating pulse indicates connecting. A brief descending chime follows an established call ending, including when the other person hangs up. Decline and unanswered cancellation are silent on the recipient's device. Ringing stops when Answer is pressed. Each new call starts with Speaker off. A selection made during connection setup carries through connection; switching Speaker off restores the system's automatic earpiece/headset/Bluetooth choice.
The supplied assets may also be used by your own audio implementation under the SDK license. They contain no speech or third-party recordings.
Use your existing notifications
Keep the app's push registration, permission requests, privacy preferences, icon and notification handler. Robono's signed calling.incoming and calling.dismissed webhooks go to your backend. Verify them and use toCallingPushPayload from @robono/server to create the routing payload. Send it only to devices belonging to the recipient account. Set expiration to the ringing deadline.
createCallingNotificationStore(AsyncStorage) supplies account-scoped durable ordering using your existing AsyncStorage installation. Corrupt storage fails closed rather than reopening an old invitation.
For Expo, use the included examples/ExpoCallingHost.tsx above your chat navigation. It connects initial notification responses, later taps and received events to the same call layer. Supply your account, session function, contacts, durable store, and recipientAccount(data) to read the account identifier your backend attaches to each push. Only a matching signed-in account can consume that notification. The helper leaves unrelated notifications and the app’s global notification handler intact. No permission prompt or token registration happens on import.
Wrap your existing Expo handler with withCallingNotificationPresentation(existingHandler, canPresentCall) when registering it with Notifications.setNotificationHandler. canPresentCall returns true only when your signed-in call layer is ready; until then, normal alerts remain enabled. This preserves all ordinary message notifications. For another provider, call callingNotificationPresentation(data, isForeground): screen means suppress the duplicate banner and sound, notification means use your ordinary alert, dismiss means suppress a stale/cancelled invitation, and null means keep your normal handling. Background alerts are sent by your backend through your existing push provider; the mobile library does not send push notifications.
For another provider, use createCallingNotificationRouter with the same durable store, recipient check, open, refresh and dismiss callbacks. open sets the root call layer immediately; it does not wait for the calling session request.
createCallingNotificationHandler accepts your controller, an account-specific durable store and a function that dismisses your app's notification by call ID. Pass notification data to handle(data) on receipt and handle(data, {opened: true}) when tapped. It deduplicates events, retains dismissal ordering for 24 hours, rejects expired invitations, and refreshes the authenticated call before enabling Answer. Disposal prevents a late event from operating a signed-out account. A notification never answers or opens the microphone by itself.
Mount the call layer above normal navigation during startup. Once authentication is restored, pass the tapped call ID to openIncoming; its loading state stays on the same call screen until the server confirms the call. Check the initial notification response as well as subsequent taps. Clear the consumed response so restarting the app does not reopen it. Dismissal removes an incoming notification; it must not end a call that was already answered.
The host example keeps one full-screen layer visible while the session and incoming call load. Pass notificationCallId as soon as the tap is known, and use onNotificationConsumed to clear it from your router and notification provider. Closing during startup prevents the delayed lookup from reopening that notification. Render this host above any authentication-loading page; only mount it for the account that owns the notification.
When the app is open, use the screen and suppress the additional incoming notification banner and sound through your existing foreground handler. When another app is open or the phone is locked, use the receiving app's ordinary notification. A tap opens the receiving app, with unlocking when required. iOS controls banner presentation and alert delivery. An ordinary notification does not provide a custom locked-screen Answer button or guaranteed ringing. Android apps that already provide native calling notifications can keep those and forward their explicit Answer action after validating current call state.
Relationships and existing calls
The UI does not impose a network topology. The engine accepts the authorized Bridge connection ID: bridge:… for two connected networks, or app:… for a Messenger endpoint. A local chat ID is not a Bridge connection ID. Existing calls between people inside one external network can continue through that network's own engine, using CallingScreen if desired. For two users inside your own network, your backend registers their existing calling permission with setRelationship and uses the returned network:… connection. Updates carry a monotonically increasing revision so a delayed permission grant cannot undo a later block. The Bridge does not invent friendships between arbitrary users.
Verify in your app
Use the developer workspace to verify the Bridge connection, then test the chosen interface and native integration on physical iPhone and Android devices. Check two-way speech, speaker before and after connection, mute, Bluetooth, interruptions, cancellation during permission prompts, notification taps on a cold start, account switching and background operation. Verify existing messages, voice recordings and calls still work.
Calling guide · Calling API · Support
Saved branding and sounds
Screens are optional for standalone calling and Bridge integrations. In the website's Calling workspace, choose an integration, set its name and logo, select light, dark or device appearance, and customize colors, fonts, text size, layout, control shape and labels. Preview screens, audition sounds, and save. The backend helper appearance() returns {appearance, revision}; deliver these alongside the authenticated user's short-lived calling session as appearance and appearanceRevision.
const appearance = validateCallingAppearance(session.appearance);
const adapters = createNativeCallAdapters({appearance, runtime, restoreAudio, onError});
const controller = createCallingController({request, ...adapters,
appearanceRevision: session.appearanceRevision});
// Mount once at your application root:
<CallingOverlay controller={controller} appearance={appearance} />appearance.presentation controls colorMode (dark, light, system), font (system, serif, monospace), textScale (1, 1.15, 1.3), layout (standard, compact), controlShape (round, rounded), showAvatar and showCallDescription. theme stores the dark palette and lightTheme the light palette. Existing configurations that omit these additions keep the original dark layout. Device font faces differ between iOS and Android; accessibility text scaling remains enabled. Compact layout reduces the identity area, never the touch targets. Names, call status and controls remain available. These are presentation choices, not calling permissions.
The included CallingHost accepts these optional session fields. Use the same validated configuration for the screen and native adapter. Keep it stable during a call. A custom screen can use the headless engine without importing this package.
Incoming, outgoing and connecting cues repeat. Other selected cues play once; defaults keep decline and unanswered calls silent. Local audio interruptions always silence cues. The host app's notification configuration and OS govern background notification sounds; changing an in-app sound does not override that configuration. Supplied WAV assets are available from /assets/* for your notification integration.
The controller reports platform, package versions, configuration revision and optional components through the authenticated calling session. These client-declared inventory records contain no contact or message data and do not set charges. Service usage counts a same-app call once, separates cross-app directions, and records held and connected time independently.
Video calls
Video calling is optional and uses the same controller, sounds, interruption handling and conversation history as voice calling. Enable Video calling in the Experience builder. Each relationship must also allow video; show the video button only when videoAvailable is true.
Use the supplied native video renderer with the optional screens:
import {NativeCallingOverlay} from '@robono/calling-react-native/native-video';
// Call from the user's button. Incoming calls request camera access after Answer.
await controller.call(connectionId, contact, {kind: 'video'});
<NativeCallingOverlay controller={controller} appearance={appearance} />For Expo, set ['@robono/calling-react-native/app.plugin', {video: true}] in the plugins list. This adds the camera permission description on iPhone and the Android camera permission. Keep your existing microphone permissions and notification integration. Enabling a setting on the website does not grant device permissions or start recording.
NativeCallingOverlay supplies the camera view, local preview, Camera on/off and Flip camera controls. CallingVideo is available as a component when building your own layout. The headless client exposes onLocalStream and onRemoteStream for an existing interface. Camera and mute selections survive an interrupted call. Backgrounding pauses outgoing video; returning restores the user's camera choice. Audio continues under the existing call policy.
Calls are not recorded. If a customer enables a message after no answer, onUnansweredCall can navigate to the existing conversation and show the optional message recorder. The caller records a new message and explicitly sends it.
Group calls and screen sharing
Enable Group calling in the Experience builder for voice, video, or both. The backend synchronizes two to eight members with RobonoCallingBackend.setGroup. Use a separate session and createGroupCallingController from @robono/calling-react-native/groups; the direct controller continues handling direct calls. Group notifications have separate calling.group_incoming and calling.group_dismissed event types. Set group: true on their notification router. Controllers recheck current permissions and never admit newly added group members into an ongoing call.
examples/GroupCallingHost.tsx owns account cleanup, session renewal, native call lifetime and interruption handling. Pass stable authenticated callbacks and mount it once under the account provider. Its optional NativeGroupCallingOverlay renders the member grid and the same customizable controls, labels and sounds. Import the overlay from /native-video. Keep your own UI by using only the controller or engine.
Screen sharing is an independent, optional video-call feature. Your backend must also attest screenSharingAllowed: true for a same-app pair, or screenSharing: true for eligible group members. Cross-app pairs require calling.screen_sharing: true in both capability records. Enable it in the builder and set {video: true, screenSharing: true} on the Expo plugin. The plugin adds the iOS broadcast extension and shared app group, plus Android capture permissions. Existing native projects need one rebuild after adding these capabilities. Capture starts only with the person’s permission; no phone settings need changing.
For iPhone signing, the plugin creates the RobonoScreenBroadcast extension with bundle ID <your ios.bundleIdentifier>.screenbroadcast. Its default shared container is group.<your ios.bundleIdentifier>.calling. In Apple Developer → Certificates, Identifiers & Profiles, register that App Group and select it under App Groups → Configure for both your main App ID and the extension App ID. Refresh the two provisioning profiles before building. This is a one-time developer setup for each app variant, not a step for app users. An App Store Connect API key alone does not create or associate the shared container. If you already have a suitable registered group, pass screenSharing: {appGroup: "group.your.shared.container"} instead; both targets must belong to it. See Apple’s App Group setup.
controller.startScreenSharing() is called from the user's tap and opens the OS permission picker. stopScreenSharing() ends capture and restores the camera's previous enabled state. One participant shares at a time. Microphone audio continues separately; screen audio is not captured. Holding, leaving, or losing authorization stops the share. The supplied screen includes these controls; a custom screen can use the same actions and state. The engine exposes screen-sharing state and streams without imposing an interface.
Android screen sharing uses the WebRTC library’s media-projection foreground service. The optional native adapter enables that service before the system consent prompt; the screen-sharing plugin declares its permission. For a non-Expo native project, declare FOREGROUND_SERVICE_MEDIA_PROJECTION alongside FOREGROUND_SERVICE in the Android manifest. Capture starts only after the person chooses Share screen and accepts the operating system prompt. System sound is not captured. Stopping sharing restores the camera and preserves its previous on/off choice.
The included GroupCallingHost.tsx handles authenticated group sessions, renewal, account cleanup, continuous notification startup and the optional member grid. ExpoGroupCallingHost.tsx connects the group notification events to that host. If your app offers both direct and group calls, keep separate sessions and route each event family to its corresponding host.
Group and video call layout
The supplied screen uses the same layout on iOS, Android and the website preview. Participant tiles adapt to the available width and height. Video calls keep Mute, Camera, More and End call in a compact bottom dock; More opens Speaker, Flip camera and Share screen when available. Voice groups keep Mute, Speaker and End call directly visible. A shared screen takes the main view, with other participants in a horizontal strip. Apple and Android still provide their own permission and capture-consent dialogs.
These screens remain optional. Existing components.Controls and components.ActionButton overrides continue to work, and the More label can be customized with appearance.labels.more.
Event-based listening
Use @robono/[email protected] with @robono/[email protected] when using the optional mobile interface. Existing custom interfaces remain supported. See https://robono.com/docs#calling-events for the lifecycle and recovery contract.
- Foreground, idle: an authenticated WebSocket listens for incoming calls. No periodic state polling. A ping/pong every 20 seconds maintains presence.
- Active calls: events trigger state reconciliation immediately; a state health check runs every 3 seconds. The optional native runtime also provides a three-second background recovery check when device timers are suspended; simultaneous refreshes share one request.
- Idle in background: call
setForeground(false). The event socket and state checks stop. Your backend delivers Robono's signed incoming-call events through your app's APNs/FCM notifications. A WebSocket does not replace push delivery. - Return to foreground: call
setForeground(true). The socket reconnects and current state is checked. Do not create a new call to recover a listening session. The optional controller forwards this lifecycle method to the engine. - Event reconnection: delays start at 1 second, double to 30 seconds (plus up to 20% jitter), honor Retry-After, and stop after eight retries. Foreground re-entry can restart recovery. State recovery stops after six consecutive failed idle checks.
- Expired idle sessions:
onSessionExpiredrequests new admission without presenting a failed-call screen. Dispose the expired client and create a new one with a new session from your backend. Use bounded backoff for admission failures. Authorization revocation is not a retryable session expiration. An active call cannot be transferred to a new session.
createHttpTransport supplies the event subscription automatically. If wrapping it, preserve request.subscribe = transport.subscribe. A custom request without subscribe, or {events:false}, retains the compatibility polling interval (pollMs, default 1000 ms).
The 0.1.2 engine had polling and retry backoff but did not include this event transport. No native permissions or rebuild are added by this JavaScript patch to an app already using the native calling package.
Connection details
Direct and group clients expose getDiagnostics() for local connection measurements without addresses, media or credentials. The supplied call overlays include an optional Connection details panel; custom interfaces can use the same measurements. Guide, fields and customization. Missing measurements remain unknown, and the first sample cannot calculate interval rates.
Recording, captions and local call tools
Robono hosts optional call recording and transcription. Enable recording once in the existing Calling settings; every participant must agree before capture, and anyone can stop it. The supplied controls include the consent notice, active-recording status and captions. No customer recording server is required.
The supplied adapters also offer camera/microphone/speaker checks and camera background blur. Screen sharing is separate. Phone blur requires rebuilding the native app; browser blur downloads its model only when selected and needs the documented content-security policy. Background processing stays on the device.
See the recording and call tools guide for prices, retention, short-lived downloads, deletion, platform requirements and label customization. Captions arrive in short batches with several seconds of delay and can be inaccurate; incomplete transcripts are marked.
