npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2026 – Pkg Stats / Ryan Hefner

@robono/messaging-react-native

v0.25.1

Published

Optional, composable direct and group messaging screens for Robono.

Readme

Optional Robono messaging screens

Customers can upload an iPhone call icon in the website designer and save/apply their design. With this SDK and calling SDK 0.11.3+, branding syncs automatically when the app opens and stays cached for locked incoming calls. Existing apps need one native update; subsequent logo changes need no developer handoff or rebuild.

Small interface customizations

Choose fonts, text size, message spacing and bubble shape in Features & preview → Appearance. Saved appearance.presentation settings reach the supplied phone UI and web preview. Platform fonts differ; device accessibility scaling is retained. See the customization guide.

The supplied screen accepts components.MessageBody, components.MessageFooter and components.HeaderActions in addition to whole-screen replacements. These small regions let you add customer actions without recreating the player, composer or message gestures. They use the same contract on web and phones.

import {View, Pressable, Text} from 'react-native';
import type {MessagingCustomization} from '@robono/messaging-react-native';
const components: MessagingCustomization = {
  MessageBody: ({children}) => <View>{children}</View>,
  HeaderActions: ({contact}) => (
    <Pressable accessibilityRole="button" accessibilityLabel="Profile"
      onPress={() => openCustomerProfile(contact)}
      style={{minWidth:44,minHeight:44,justifyContent:'center'}}>
      <Text>Profile</Text>
    </Pressable>
  ),
};
// Pass components to ExpoMessenger/ExpoMessagingScreen.
// Merge with existing components (such as a supplied TrackingMap), if present.

Define these components outside render. MessageBody receives the supplied body as children; preserve it to retain the standard text, media, poll and translation behavior. MessageFooter adds an optional region inside the bubble. Both receive message, mine, appearance and optional pendingStatus, and are omitted for deleted messages. Header actions receive conversationId, contact, appearance. The status indicator, swipe gestures and permission enforcement remain in place. Custom actions still require the customer's own authorization.

Recommended hosted installation

Run npx --package @robono/server robono-messenger-install in your Expo project. The installer sets up the connection and native plugin. Robono runs the communication services; your server verifies the existing login and issues its short-lived session. See the server package's hosted guide.

import {createHostedExpoMessenger, ExpoMessenger} from '@robono/messaging-react-native/expo';
import {hostedRobonoTokenProvider} from '@robono/messaging';
const messenger = await createHostedExpoMessenger({
  userId: session.userId,
  tokenProvider: hostedRobonoTokenProvider({
    tokenEndpoint: 'https://your-app.example/api/robono-token',
    getAccessToken: () => session.accessToken(),
  }),
});
<ExpoMessenger {...messenger} userId={session.userId}
  companyName="Your company" contacts={contacts} />
try { await messenger.signOut(); } finally { await session.signOut(); }

Create this connection outside repeated renders, and dispose it when unmounting. Use the generated component to handle account changes and retries automatically. The lower-level createExpoMessenger and server forwarding adapters remain available for an optional self-hosted connection.

Install the native dependencies below and rebuild both platforms. For alerts outside the app, createExpoMessenger connects the managed service automatically. Use the Account screen’s Enable notifications action and follow @robono/server/NOTIFICATIONS.md: iPhone needs your Apple Team ID, APNs Key ID, private .p8 key and Bundle ID; Android needs your Firebase project, app configuration and a service-account key uploaded in Robono’s private notification setup. Never ship private keys in the app. Website chat itself does not require these mobile credentials.

The supplied group owner, shared-media, reply and pinned-message screens use the same popup boundaries as Messenger. Global search and group controls require the matching server and service migrations. Imported groups need a server-assigned owner before users can edit them. Optional offline received history is disabled by default; its network-selected expiry is honored and it is read-only offline. Revocation while disconnected is not known until reconnection or expiry. Logout clears the local account's history. persistence:false disables these local stores.

Use a ready-made direct or group conversation screen, replace its sections, or compose the exported components into your own layout. Use ExpoMessenger for the complete inbox and conversation flow, or the individual components inside your existing navigation. The complete Expo messenger connects notification registration; nothing requests permission on mount. The shared icon controls require react-native-svg (install it with your framework’s native dependency installer).

Connected features

The complete messenger connects selected calling, chat weather/tracking and Maps through Robono’s authenticated hosted connection. Customers do not supply fake demo callbacks or create separate call controllers for this setup. Feature selection and appearance remain in Features & preview. Advanced custom interfaces can still use individual components and callbacks.

Synchronize permitted contacts once on your server:

await messenger.synchronizeContact({
  externalUserIds: [firstUserId, secondUserId],
  allowed: currentPermission,
  revision: savedPermissionRevision,
});

This atomically updates texting and calling permission. It does not buy a service, start a call or start location tracking. Use a saved, increasing revision from your own database; retries with the same values are safe. Keep group membership in the messaging group API; eligible groups use that same membership for calls. Supergroups never start calls, and voice/video calls remain limited to eight people.

For the optional self-hosted connection, the host's authorize function checks calling.*, extras.* and location.* as well as messaging operations. Account checks have no conversation ID; call actions use the actual conversation from the service, never a caller-supplied claim. Keep current membership, suspension and feature restrictions in those checks.

Incoming calls use the same configured notification providers as messages. The supplied client registers its call handler automatically. Native apps need their own Apple APNs key/bundle ID and Google Firebase service account; upload them only to Robono's private notification setup. A website needs its HTTPS origin and chat path, not Apple/Google keys. Users still choose whether to allow notifications. These are ordinary app/browser alerts: the OS can delay or suppress them, and an alert never answers a call or turns on a microphone automatically.

Await the returned signOut() before ending your own login session. It stops capture and calls, cancels unfinished tracking and unregisters the device. Old account credentials and unfinished work must never be reused for another person.

Individual screen inside existing navigation

import {MessagingScreen} from '@robono/messaging-react-native';

<MessagingScreen
  client={messagingClient}
  userId={session.userId}
  contact={{name: contact.displayName, avatarUrl: contact.avatarUrl}}
  active={isConversationFocused}
  onBack={navigation.goBack}
  onMessageOptions={message => navigation.openMessageActions(message)}
  pickAttachment={(kind, limits) => media.pickAndUpload(kind, limits)}
  openAttachment={message => media.openAuthorized(message.media!.assetId)}
/>

The client is from @robono/messaging; initialize it with the authenticated backend transport and open the conversation before rendering. Your existing navigation, account/contact services and private media store supply the referenced callbacks. Mount inside your safe area. Pause polling in the background and dispose the client when the user signs out. No separate Robono end-user account is needed.

Enabled message kinds come from the server. In text-only mode there are no attachment controls. Voice-only mode has no text field. pickAttachment(kind, {maxDurationMs}) receives the configured voice limit. Stop recording at that limit on both iOS and Android and show the remaining time. Cancel without sending when recording fails. Your backend must check the actual file duration too. The recorder displays the limit, and the client rejects oversized recordings before sending. pickAttachment handles the device picker or recording flow, uploads privately, and returns an asset reference or null on cancellation. openAttachment checks access through your backend and uses your media viewer/player. A missing callback never sends a fabricated attachment. Connect safety callbacks to your app's existing report/block actions.

Message presentation and camera

Text uses a send icon; appearance.labels.send remains its accessible label. Voice messages show a play control, waveform area and duration. Photos and videos use thumbnail bubbles, and files show a document icon, filename, type and size. Sent and received messages use the corresponding colors and alignment.

Supply attachmentPreview(message) to resolve {uri?, waveform?} after checking the current user's media access. uri is an image thumbnail (a poster frame for video); waveform contains 32 normalized amplitude values between 0 and 1. These stay in component state, not in the message payload. Without metadata the SDK shows a neutral media tile or waveform track. openAttachment remains responsible for authorized media access. The Expo screen supplies inline voice playback and the shared full-screen media viewer. To connect a different audio engine, supply components.VoiceMessage and render the exported VoicePlayback with its playback state and callbacks. MediaViewer, ZoomablePhoto and MediaPlaybackControls are also exported for hosts with their own media engines.

Photos, videos and files share an Attach menu. Set appearance.showCamera to offer Camera inside that menu beside the library options; photo or video messaging must also be enabled. The option defaults off for existing integrations. Camera calls pickAttachment('image', {...limits, source: 'camera'}), so captures follow the same photo restrictions and review/upload process. Hosts supplying their own media callback must handle that source explicitly. The Expo adapter requests camera permission only on selection and opens the device camera on iOS and Android. Configure the expo-image-picker plugin's cameraPermission explanation in your native build. Cancelling or refusing permission sends nothing.

Reuse or replace components

The screen accepts components={{Header, Message, List, Composer}}. Replacements read the same client state, theme, selected reply and callbacks through useMessagingUI().

For complete layout control, wrap MessagingHeader, MessagingList and MessagingComposer in MessagingProvider. Use MessagingBubble for the standard message view. Supply only the components you want. The headless client works without this package.

Appearance comes from the selected integration's Messaging page, with an optional per-screen appearance override. The service still enforces message permissions even when your UI is fully custom. A local appearance override cannot change permissions.

The same React Native components support iOS and Android. Keyboard handling uses iOS padding and Android's host window configuration. Your host app owns microphone/library permissions, media audio focus, foreground notification behavior and navigation. Report component inventory through client.reportUsage; it is distinct from accepted-message usage.

Recording and attachments with Expo

The optional @robono/messaging-react-native/expo entry supplies recording, review, voice playback and seeking, photo/video picking and preview, document selection, and private upload/download progress. Users explicitly send after review. A failed upload can retry with the same upload identity; cancelling removes the adapter's cache copy, never the original library item. Viewer copies are removed when the viewer closes. Managed voice and video play directly from private storage using native streaming. By default, ExpoMessagingScreen preloads up to six recent photos and voice clips in the open conversation (2 MiB per file, 6 MiB total, two background transfers at a time). Custom adapters without streaming can also preload small videos within those limits. Each transfer uses the authenticated storage adapter and counts as normal transfer usage. The cache is cleared when the app backgrounds, the conversation changes, access fails, or messages disappear; cached files require a fresh download on opening if their message has not been refreshed from the conversation history within 60 seconds. Cold voice/video streams and document downloads start on tap; an already authorized cached voice clip starts locally without waiting for another transfer. Explicit Download and Share always recheck current access. Set preloadRecentMedia={false} to keep all media transfers on demand. The recorder reserves 100 milliseconds at the duration limit for encoder padding; storage completion verifies the finished file. Recording stops when the app backgrounds or a call takes audio priority, leaving a review rather than sending automatically.

Install native dependencies with your Expo project's installer so their versions match your SDK:

npx expo install expo-audio expo-image-picker expo-document-picker expo-file-system expo-media-library expo-sharing expo-video expo-crypto react-native-safe-area-context react-native-svg

This entry targets Expo SDK 55–56; the core components do not require Expo.

When using Expo's fingerprint runtime policy, run the public @robono/messaging-react-native/prepare-native helper from your app's postinstall script. Call prepareNativeDependencies(projectRoot, {backupBackgroundTasks: true}) when automatic backups are enabled, or omit the option otherwise. This prepares the SDK's Expo native corrections before fingerprinting; the config plugin repeats the same idempotent step at prebuild. See backup build configuration.

| Project | Supplied integration | | --- | --- | | Expo 55 or 56 | Use the /expo entry and npx expo install for matching native packages. | | Expo 54 or earlier | The supplied Expo adapter is not supported. Upgrade Expo before running setup; do not force incompatible peer dependencies. | | React Native without Expo | Use the core UI and documented device/storage adapters. The Expo version range does not apply to these components. |

The installer checks the Expo version before changing files. Pin the Robono version in your lockfile and update through the setup command so required native changes are reported. Optional calling and background movement require a rebuilt native app; Expo Go does not include those modules. A successful package installation is not a guarantee that unsupported Expo versions will work.

Configure the expo-audio plugin's microphonePermission with your app's explanation (for example, “Allow microphone access to record voice messages”). Keep background recording disabled. Native dependency or permission changes need a new development/store build; screen changes do not. The standard system photo picker does not require full photo-library access. Documents use the platform's file picker, without broad storage access.

import {
  ExpoMessagingScreen, createExpoMessagingStorage,
  createExpoMessagingAudioSession, createExpoMessagingClient,
} from '@robono/messaging-react-native/expo';

const messagingClient = createExpoMessagingClient({
  url: appConfig.messagingEndpoint,
  userId: session.userId,
  getAccessToken: () => sessions.accessToken(),
});

const storage = createExpoMessagingStorage({
  url: appConfig.messagingMediaEndpoint,
  getAccessToken: () => sessions.accessToken(),
});
const audioSession = createExpoMessagingAudioSession({
  isCallActive: () => calls.isActive(),
});

<ExpoMessagingScreen
  client={messagingClient}
  userId={session.userId}
  contact={{name: contact.displayName, avatarUrl: contact.avatarUrl}}
  active={isConversationFocused}
  onBack={navigation.goBack}
  storage={storage}
  audioSession={audioSession}
  onMessageOptions={message => navigation.openMessageActions(message)}
/>

Open the conversation with await messagingClient.open(conversationId), then call messagingClient.start() while it is active. Call stop() when it backgrounds and start() when it returns; call dispose() when the owning client is no longer used. The screen subscribes to the client but does not own its polling lifecycle.

Managed attachment history includes short-lived download authorization. The Expo adapter uses it to begin a fresh transfer without another authorization request; absent, mismatched or expired grants use the authenticated media endpoint. Keep grants in memory only and out of logs and persisted chat history. The bucket remains private. As with other issued transfer links, revocation can leave an already issued link usable for up to 60 seconds, unless the object has already been removed.

Managed voice messages and videos use progressive streaming: the native player can start before the complete original file has downloaded and request byte ranges when seeking. No lower-resolution copy or new streaming subscription is required. Photos and documents retain verified whole-file downloads. Set streaming: false in createExpoMessagingStorage to use whole-file downloads for voice/video too. Custom MessagingMediaStorage adapters may implement optional stream(message, context) returning {...metadata, uri, stream: {headers?}}; omit it or return null to use download.

If native streaming fails or a later range request encounters an expired link, the screen makes one recovery attempt through the existing authorized download path, preserving playback position and whether playback was paused. Denied access still fails; it does not bypass authorization or loop retries. Native buffers are temporary; streaming URLs and headers must never be persisted. Usage counts bytes served, including additional ranges or recovery downloads, rather than treating each range as a whole-file download.

The adapter prepares private file storage alongside download authorization, and prepares voice audio output alongside native file loading. Transfers still require authorization; playback waits for native media readiness and the audio session. Video rendering can prepare while audio initializes, with playback controls enabled only after audio is ready.

For performance measurement, onMediaReady reports {messageId, kind, stage, elapsedMs} from a photo's load, a video's first frame or advancing voice playback. Disable preloading to measure on-demand media startup. Streaming readiness means the player has usable data, not that it downloaded the whole file. This callback does not measure the exact audible onset at the speaker.

Create stable storage and audio-session instances outside rendering or with useMemo. Mount within your existing SafeAreaProvider. If your app already coordinates calls and media, supply its own MessagingAudioSession.acquire() lease instead. A lease returns an idempotent release function. isAvailable() must return false while a call owns audio. The supplied coordinator stops media when that guard changes and avoids overwriting the call's audio mode. Your call integration remains responsible for acquiring its own native audio session.

Photos, Videos and Files each have an allowed MIME-type list and maximum file size. Videos also have a duration limit. Files cannot be used to bypass image, video or voice restrictions. A phone may list more formats than the app allows; selection is checked before upload and again against verified metadata on the backend. Allowing a container format does not guarantee that every codec in it plays on every device. Choose formats compatible with your supported phones, or convert media in your storage pipeline. Documents open the native share/open menu; installed document viewers vary by phone.

The bundled adapter uses your private storage endpoint, described below. You can instead implement MessagingMediaStorage with your existing upload/download service, or use the core MessagingScreen callbacks. None of these screens or adapters is mandatory.

Private media endpoint

The complete createRobonoMessengerServer route already supplies managed private uploads, downloads, metadata verification and configured screening. No separate storage implementation is needed. Only follow this section when deliberately using your own storage.

Mount createMessagingMediaBackendAdapter from @robono/server behind your existing session authentication. Supply the same RobonoMessagingBackend as your messaging endpoint, your authorization checks, and a MessagingPrivateStorage implementation for your storage provider. The adapter checks current conversation access and policy before asking storage for a transfer. Phone requests never contain Robono API keys or storage credentials.

The storage implementation has four operations:

  • prepare: persist upload ID, actor, conversation, message kind and proposed metadata together; return a short-lived private HTTPS PUT URL and required headers. Retrying the same upload ID must resolve the same upload. Reject conflicting reuse.
  • complete: verify that actor/conversation own the upload; inspect the stored bytes to determine the actual format, size and recording/video duration. Return the persisted kind and verified metadata. A filename, extension or phone-provided MIME type is not verification. Repeated completion must return the same asset.
  • download: return a short-lived private HTTPS URL for the authorized message's asset. Robono checks that the message still exists; storage also verifies its asset belongs to that message/conversation.
  • discard: revoke/delete only that actor's uncommitted upload. It must be safe to repeat, including after a lost completion response, and must never delete an asset already referenced by an accepted message.

The HTTP protocol uses POST with {operation, ...}. prepare takes uploadId, conversationId, kind, and file metadata; it returns {url, headers?} or {media} for an already verified upload. complete takes uploadId and conversationId, returning {media}. download takes conversationId and messageId, returning {url, headers?, media}. discard takes uploadId, returning {ok:true}. Errors use {error:{code,message}} and an appropriate HTTP status.

Also supply resolveMedia to createMessagingBackendAdapter, resolving the authenticated actor, conversation and asset ID to your verified stored metadata. This replaces untrusted phone claims before sending. Keep asset IDs opaque and unique per message. Check blocks/permissions in both endpoints. Restrict signed uploads to the prepared object and size where supported; delete rejected objects. Expire abandoned uploads and private cache files through your storage lifecycle. With custom storage, your app owns storage retention and any malware/content checks; configure these separately from Robono’s managed screening. Files must remain private.

Handle signed messaging.message_removed events to revoke and delete assets when history expires. Account deletion must also erase associated storage. A terminated app cannot run cache cleanup; the adapter's temporary files live under the OS cache directory, which can be purged by the OS. Do not treat device cache eviction as a fixed retention guarantee.

Custom composition: messaging and calling

The website Experience builder renders these messaging components and the optional calling components, with a local conversation transport. Saving a draft creates an immutable design version without changing active settings. Review and apply updates messaging and calling atomically, with revision checks against the existing editors. Use your existing settings/appearance fetches to receive the applied design. Service access and per-contact eligibility still apply.

For a conversation header with an optional voice-call action:

import { MessagingCallingScreen } from '@robono/messaging-react-native/calling';

<MessagingCallingScreen
  client={messagingClient}
  userId={signedInUserId}
  contact={contact}
  onCall={voiceAvailable ? () => callingController.call(connectionId, contact) : undefined}
/>

The shared @robono/calling-react-native UI package is installed automatically, including for the account device-check panel. Native call media and notification adapters remain optional. Mount the calling overlay and configure native audio/notifications through the existing calling integration. This entry creates no call client and requests no permission. Omit onCall to hide the action; backend admission remains authoritative. MessagingHeader also accepts children for custom header actions.

The website preview renders the same bubbles, inline voice controls, full-screen photo/file viewer and video transport controls through React Native Web. Phone/tablet and portrait/landscape choices resize the real layout viewport without reloading the conversation. Browser media elements and Expo players drive the shared controls; the browser preview does not substitute native browser player controls or a generic dialog. Camera/library/file selection and OS permission prompts still follow the platform. Preview interactions never contact real users or send billable events.

The standard chat uses compact grouped bubbles, a curved delivery indicator, swipe-to-reveal time, inline voice controls and Messenger’s attachment menu. Attach dismisses the keyboard; tap it again to return to typing. Android Back closes the tray first. The microphone remains available beside the text field, including while text is typed; Send is enabled when there is text or a finished voice recording. Camera remains available when capture is enabled, including with typed text or a reviewed voice recording. Captures join the existing pending attachments. New designs start with a light chat palette; existing saved colors remain unchanged. The builder’s “Use classic chat colors” action applies the default palette to the draft without changing enabled features.

Voice-only conversations use Robono Messenger’s compact composer: the duration-limit placeholder, embedded microphone and adjacent Send control. The Expo adapter records and reviews audio inline, with elapsed time, microphone metering, playback and removal before sending. The builder uses the same controls with a local browser microphone recording; no audio is uploaded from the preview. When texting is enabled, tap the microphone to record in the composer and tap it again to stop. Each completed recording becomes a separate playable attachment in the shared horizontal row, and the microphone is available for another recording. Typed text is preserved; Send puts accompanying text on the last attachment as its caption. Custom media adapters can use components.VoiceComposer, VoiceMessageComposer and VoiceDraftPlayback; renderTextComposer restores the text controls alongside the reviewed recording.

Recent attachments can appear directly beneath the attachment buttons. Photos, Videos and Files filter this strip; tapping the selected category again shows all enabled types. Tapping a thumbnail adds it above the composer as a pending attachment; its magnifying-glass button opens a preview instead. Remove unwanted attachments or press Send to submit the selection with any typed text. Camera starts capture. When no recent-media source is supplied, the category buttons open the device picker. Supply attachmentChoices with an ID, kind, name, and optional thumbnail URI/duration. Only enabled attachment types appear. With MessagingScreen, selecting a tile calls pickAttachment with options.attachmentId; use options.intent to distinguish selection (send, retained for adapter compatibility) from preview. Returning photo, video or document media stages it in the composer; returning null cancels without selecting it. Voice recordings also become pending attachments after recording stops. With ExpoMessagingScreen, supply resolveAttachmentChoice(id, signal) to return an authorized cache copy; the standard preview, validation, send and cleanup flow handles the rest. Keep originals in the user's library untouched. The host controls library access and which recent items it supplies.

Camera capture and library selection are separate controls. appearance.showPhotoLibrary and showVideoLibrary hide library choices without removing the corresponding message-type permission needed for camera captures. Both default to true for existing integrations. The builder manages these together with Camera, so enabling capture does not select Photos/Videos or insert example media. Parent and network message-type permissions remain enforced.

The Expo adapter keeps selected and recorded attachments locally until Send. Recording stops into a playable draft without uploading. Send immediately queues the bubbles, then uploads the selected files. A caption belongs to the final attachment; a quote belongs to the first. The batch preserves selection order when uploads finish out of order. Custom adapters can supply components.VoiceAttachment for draft playback and releaseAttachment for local cleanup.

Group conversations, reactions and polls

The same MessagingScreen opens direct or group conversations. Supply participants: {[userId]: {name, avatarUrl}} from your own authorized profile data. The service supplies the group name, membership and canSend; read-only members see the conversation without a composer. Your backend manages group membership through RobonoMessagingBackend.setGroup, never a mobile API key.

Enable reactions and polls in Experience builder. The screen includes the long-press reaction picker, reaction counts, poll composer and voting/results controls. These components share your configured message colors. PollMessage and PollComposer can also be used separately. Voting is visible to other participants; only a poll's creator can close it.

Optional message after no answer

The complete createExpoMessenger flow connects unanswered-call messages automatically. For custom composition, use ExpoMessagingCallingScreen from @robono/messaging-react-native/expo-calling for the supplied native media tools together with calling. It accepts the same storage and audioSession as ExpoMessagingScreen. For your own media adapter, use MessagingCallingScreen from the /calling entry to combine the optional call button and message composer. Connect the calling controller's onUnansweredCall callback to your existing conversation navigation, then pass unansweredCallId and onDismissCallMessage. The callback only runs for an outgoing call made in the current controller session that ended without an answer; opening old missed-call history does not trigger it.

UnansweredCallMessage is also exported separately for a custom composer. Place it inside MessagingProvider and supply your existing pickAttachment adapter. The adapter must support recording, review and private upload. Eligibility comes from your authenticated backend, and sending rechecks permissions. Recording is optional and starts only when the caller chooses it. An ordinary message is left in the chat, with normal history, retry and media rules.

Enable the offer in the website’s Calling options. A missed voice call can offer a voice message; a missed video call can offer a video message (or voice if selected). The caller records, plays the draft, and can Record again, Cancel, or Send message. Camera capture uses the phone’s system recorder; the shared Messenger supplies the final review and Send actions. Recording and review do not upload the file. Upload starts only after Send; failed uploads stay in the normal outgoing-message retry flow. This is a new chat message, not a recording of the call or a separate voicemail inbox.

Blocking, reporting, reactions and language tools

The conversation header’s three-dot menu includes Search this chat, plus Block/Unblock and Report when the authenticated backend advertises safety support. Saved belongs to the account and is in the separate Messages menu, never under a contact’s name. Hold a received bubble to report that message. onContactOptions optionally replaces the supplied contact menu with your existing safety flow. The exported MessagingSafety component can also be composed into your screen.

Blocking retains history and stops direct messages and calls for that pair in your app. Shared group messages remain visible. Reporting is separate: it shares the selected message, or up to five recent incoming messages, and the reason with your app’s moderators. It confirms success only after storage acknowledges the report. The SDK reuses the request ID on retry. Owners and administrators review reports in the Messaging workspace; private media is reviewed through your app’s authorized storage tools.

Enable Reactions to show an emoji ribbon beside the long-pressed bubble, or the hover smile icon on desktop. Selected reactions stay above the delivery indicator. Polls are interactive chat messages created from the attachment menu. Transcript is a separate voice-message action. In the header's three-dot menu, choose translation Off / Text / Voice and languages once for the conversation. The saved choice controls Translate or Play Translation on eligible incoming messages; own messages and matching sender/target languages do not show it. The result has Show original / Show translation controls. Expo supplies translated-voice playback and its audio session; an explicit Play Translation action starts playback when ready. language supplies the initial target and contact.language / participants[id].language supply known sender languages, with a saved conversation incoming-language fallback. Defaults to Off. The Expo private outbox retains preferences across restarts on this device. Custom contact menus can call client.setTranslationPreference({mode:'text',language:'es',sourceLanguage:'en'}). Connect MessagingClient.transformRequest to the authenticated createMessagingTransformBackendAdapter on your server.

November 1 behavior update

The default palette follows Messenger. Existing saved customer colors remain in place. Direct chats use the brand header; groups use Messenger’s blue header. Bubble padding is fixed; the legacy compact property is accepted for backwards compatibility but no longer changes core spacing.

Photo/video/file selections remain removable drafts; tapping a draft opens its viewer without deleting the selection. Expo supplies small image/video previews using expo-image-manipulator and expo-video-thumbnails; add those optional peers when using the Expo entry. Copy uses expo-clipboard. Native media downloads use photo-library permission; sharing uses the platform share sheet. New managed photo/video uploads have an authenticated preview (at most 480 pixels and 128 KiB) after the updated storage worker, inspector, media handler and migration 178 are deployed. Previews count toward normal storage/transfer usage. Older large uploads without a preview remain tap-to-open; originals over 2 MiB are never automatically downloaded to build thumbnails.

appearance.showWaveform controls display only. Verified waveform samples stay in media.waveform. The playback track remains seekable when the waveform is hidden. Managed storage computes waveform data independently of this preference.

Groups offer polls; direct chats offer a recipient-only Yes/No question whose first answer is final. Both use the same app-height popup frame as tracking and social previews. The hosted service supplies the required message and media support.

Optional downloads in the viewer

Select Download button in the website's Features & preview → Appearance, or set appearance.showDownloadButton: true. The Expo viewer shows the same Download action for photos, videos and files; it stays hidden by default. Photos and videos save to the device photo library after the user grants permission. On iPhone, documents open the native sheet with Save to Files. On Android, the user chooses a folder and the document is copied there in bounded chunks. Cancelling creates no file, and a failed copy removes its own partial output. Use expo-file-system 55.0.5 or later for Android document saving. Originals remain in private storage. This setting controls the visible action, not the authorization needed to view media.

createExpoMessagingClient keeps outgoing text, selected attachments and failed sends in your app's private document storage, separated by endpoint and user. ExpoMessagingScreen restores small previews and reuses the original upload/send identity when retrying. Call client.signOut() on logout to remove that user's saved work. dispose() preserves unfinished work for reopening. Use persistence: false to disable storage. No received history or download links are persisted by this store. The OS app sandbox protects these files; this is not an additional application encryption layer.

The shared message menu and media preview include Forward and sender Delete. Forward checks both chats and uploads a separate private attachment copy; retrying uses the same send ID. Edits can replace/remove attachments before a recipient opens them. Removing the only attachment requires text. Caption edits keep the original file. The ordinary composer draft is retained throughout editing.

MessagingInbox offers Mute/Unmute and Delete chat on long press (right-click on web), plus accessibility actions. Deletion clears only that user's view, up to the message shown when confirmation opened. New messages bring the chat back. When composing your own native navigation, pass onDeleted={id => messagingClient.forgetConversation(id)} to clear its local work. Updated backend support is required; old adapters hide these controls.

Saved and multiple-message actions

Long press a message, then choose Select to select more rows. The compact action bar supports chronological forwarding and deletion of eligible unread outgoing messages. A single selection also supports Copy, Save and Edit. Back clears the selection.

createExpoMessagingClient also supplies Saved: explicit local text and attachment copies in the app-private directory, separated by endpoint, account and namespace. The account-level Messages menu opens Saved from all conversations. Standalone chats have no account toolbar; place account navigation on the host inbox. For inbox navigation, keep one MessagingProvider mounted around MessagingConversation / MessagingInbox and pass headerActions={<MessagingAccountMenu/>} to the inbox; the Expo renderConversation callback supplies the same media adapters to that provider. Saving rechecks message access before and after making the copy, and marks incoming content consumed. Saved copies are independent of network retention; they never reuse signed URLs. client.signOut() deletes this account’s saved copies. Disabling persistence also disables Saved. Device storage is not a cloud backup or an additional app encryption layer. For a custom engine, supply a MessagingSavedStore to MessagingClient and openSavedAttachment to the shared screen.

Social previews

Install react-native-webview with the Expo peer dependencies and rebuild the native app. ExpoMessagingScreen supplies the player and the standard shared popup; a custom engine can supply components.SocialPlayer. The updated server adapter and hosted messaging endpoint advertise support. Recognized links gain a small play action, while tapping the link still opens the original app/site. Players are loaded only after an explicit tap and fresh message authorization, require explicit playback, and are removed on close/background/navigation. Opening a player stops the current voice-message player and uses the supplied audio-session coordinator. No application cookies or local-file access are shared with the embedded page. Some providers/private posts cannot be embedded; the popup keeps an Open-original link.

The same provider parser is used by Messenger, the browser and the backend, including Snapchat and Rumble. Preview opens contribute to the per-network social.opened metric. This source change still requires coordinated endpoint and package deployment; installing a newer UI against an older adapter does not enable unsupported controls.

Multiple selections from one picker

The supplied Expo and browser pickers allow selecting several photos, videos, or files in one visit, up to ten total pending attachments. Selection stays local: each item has a removable thumbnail, preview is a separate tap, and upload begins only after Send. Order is preserved, the quote belongs to the first attachment, and the caption belongs to the last. Editing and call replies select one item.

A custom pickAttachment(kind, options) may return one MessageMedia, an ordered MessageMedia[], or null. Honor options.maxCount (the remaining slots) and the existing size/type/duration limits. Existing single-file adapters still work. The low-level MessagingMediaDevice.pickMany method is optional; MessagingMediaController.pickMany falls back to the single picker when absent. Cancellation or an invalid selection releases all private copies without sending or accepting a partial batch. Never delete the user's library originals.

Conversation search stays inline below the chat header with a match count and previous/next controls. Its authenticated search remains scoped to the open conversation. MessagingInbox provides a separate Search chats field over loaded chat titles and last-message text; optional searchText(row) adds the host's local retained-message index (used in the native review). It does not imply a server-wide search across unloaded conversations.

Company, account and call controls

companyName is the customer’s company name, not Robono’s. It labels the inbox only; when omitted, the configured appearance name is used. Conversation screens show only the friend/group header, never the company heading or account menu. The main three-dot dropdown contains Account and Saved. Supply account with name, optional avatarUrl, phone, and email. onEditProfile and onSignOut are optional host actions; unsupported actions are hidden. Sign-out must revoke your app session and call the messaging client’s signOut() to clear local data. The Account screen dismisses before opening the host’s profile/sign-out flow.

Direct conversations keep the customer’s accent header. Groups use Messenger’s blue #1F5F7A header with light text and icons. Phone/video icons use the same ink. Supply callActions.voice/video only while the contact/group is eligible for those calls. callActions.phoneNumber supplies a direct contact’s callable number, and callActions.phone(number) can override opening the system tel: handler. The phone button opens Messenger’s method choices when a number exists; otherwise it starts the available internet call directly. Groups never show a carrier choice. MessagingCallingScreen and ExpoMessagingCallingScreen still accept existing onCall/onVideoCall callbacks and use these same controls.

Managed notification lifecycle

For account-wide ringing, answer/decline behavior, unread synchronization and removal of delivered alerts, see multi-device behavior. The customer supplies its own Apple/Google app credentials once; Robono handles managed device registration, delivery and cleanup. Native background cleanup is best effort with reconciliation on reopening.

Server 0.18.0 and mobile 0.4.0 remove the customer notification database and worker. Upload your Apple/Google app credentials once under Your app → Message notifications. Include notifications.register-device in your server’s authenticated-user permission policy. Spread the complete connection returned by createExpoMessenger into ExpoMessenger; this includes its notification connection and Account action. Pass notifications:false when your app owns notifications instead.

Always await messenger.signOut() before ending your host login session, using a finally block to finish host sign-out even if the network is unavailable. The host still owns its global notification presentation handler; compose it with withMessagingNotificationPresentation if needed. Custom screens can continue using the separate ./expo-notifications connector. Apple/Google permissions and a real device are required to prove background delivery; signing in and seeing a chat is not enough.

For Android, include your Firebase project's downloaded Android client google-services.json in the signed app and point Expo's android.googleServicesFile to it. Its package name must match the app's Android package. This client configuration initializes FCM on the device; uploading a Firebase service-account key to the server does not replace it. Keep the private service-account key out of the app. Changing this native configuration requires a new signed Android build, not a JavaScript update.

When replacing a host's previous notification implementation, supply onNotificationRegistered to createExpoMessenger (onRegistered on the standalone connector). It runs after the server confirms this account's new device registration. Use its abort signal and your authenticated host endpoint to retire only the previous registration for this installation and account. Keep other devices and accounts intact. A failed callback retries when the app returns to the foreground; a rejected new registration never retires the old one. Do not run two alert senders for the same installation after migration.

For integration diagnostics, onNotificationDiagnostic (onDiagnostic on the standalone connector) reports response receipt, authorization and routing outcomes. It includes only stage names and boolean flags, never tokens or message contents. A diagnostics callback failure cannot interrupt notification handling.

Send later

With the scheduling service available, hold the composer Send button after writing text or selecting attachments. Choose the local date and time in the same bounded popup used by other Messenger tools. A normal tap still sends immediately; the empty-composer quick-reaction picker is unchanged. Open the chat's three-dot menu → Scheduled messages to reschedule or cancel. Pending messages are private to the sender. Times are stored in UTC and displayed in the device's current time zone.

Scheduling uploads selected attachments before confirming the queue; closing the app does not prevent server delivery afterward. The selected time is approximate to the minute. Current access, screening and spending rules still apply at send time. Stop a voice recording to stage it, then hold Send to schedule it just like a photo, video or file. Poll creation sends immediately; custom composers can schedule finalized content through the same API.

Screen sharing in the complete messenger

The installer configures @robono/calling-react-native with video:true and screenSharing:true. On iPhone, your Apple Developer team must sign both the app and generated RobonoScreenBroadcast extension with the App Group group.<your bundle ID>.calling (or your explicit plugin override). Xcode/EAS can register these using your Apple account. Android asks for screen-capture permission when the person starts sharing. Rebuild both apps after native configuration changes. The server's selected feature and current contact permissions still control access. An existing explicit screenSharing:false is preserved by upgrades; enable it and rebuild before offering screen sharing in that app.

Business messages

Use createMessageCard from @robono/messaging for supplied appointment/order cards. components.customMessages supports customer layouts and explicit format versions; components.onCustomMessageAction connects authorized actions. Unknown types use the required text fallback. Card setup and limits.

App-wide activity

The complete Messenger connection supplies foreground activity independently of the selected chat. Online now and optional Last seen are chosen in Features & preview. connection.availability can also supply an authorized contact list. Activity setup, privacy and timing.

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.

Customer-controlled links, downloads and account actions

linkHandling can disable URLs/addresses independently or route their taps through openUrl(url, message) / openAddress(address, message). A disabled link renders as ordinary text. Host overrides also suppress social/tracking shortcuts that would otherwise bypass the host's navigation policy.

onDownloadAttachment({file,message,signal}) changes the standard viewer's Download action to a host-owned destination. Enable appearance.showDownloadButton. The SDK rechecks access, supplies a private temporary file, and cleans it up afterward; copy it to your destination before resolving the callback. Do not retain its URI as a permanent saved file. Cancellation and permission changes still apply.

ExpoMessenger offers onNewConversation and inboxOverlay for a host-owned contact picker using the exported MessagingPopup. Account callbacks include onEditProfile, onDeleteAccount, and onSignOut; the host supplies its own confirmation and account service. These optional callbacks do not grant service permissions or delete an account by themselves.

Shared sign-in presentation

MessagingSignIn, MessagingPhoneInput and MessagingChoicePicker are optional shared UI components, also exported by @robono/messaging-web. Robono's new consumer app uses these same components. The card, code cells, consent row, buttons and field proportions follow the existing Messenger.

Continue using your existing login when embedding Messenger. These components add no second account, SMS provider, credential storage or authentication service. Your host controls stage, field values, validation, busy/error state, verification expiry and onSubmit. Supply your own company logo/name through logo or appearance, your colors through appearance.colors, consent copy and policy links through consent, and translated text through labels.

Render your MessagingPhoneInput and its MessagingChoicePicker together inside MessagingSignIn.phoneField; profile choices belong in profileFields. This keeps website pickers inside the sign-in container. The host supplies supported countries and validates/normalizes numbers with its own authentication provider. Use secondsRemaining only with an expiry returned by that provider. An expired code changes the submit action to “Send a new code”; the host performs that action. Never include private integration keys in these props.

MessagingConnectionState is the shared waiting/recovery screen used by customer starters and Robono Messenger. Pass error, onRetry, optional onSignOut, appearance, and translated labels. Account actions appear only on failure, never during normal connection startup. The hosted connection selects Robono's approved direct transport automatically; no extra phone setup is required.

Contacts before a conversation exists

The complete Messenger accepts directory and onOpenDirectoryContact. The host supplies its authenticated address book; Robono does not invent contacts or import permissions from another network. This works in ExpoMessenger, WebMessenger, and mountRobonoMessenger.

Each directory entry has id, name, status, detail, and available. Optional contactId, conversationId, and avatarUrl identify an existing chat and its avatar. Entries already represented by a loaded conversation are hidden to avoid duplicate rows. Search includes the directory. Unavailable entries show the supplied explanation without opening a composer or making a send request.

For an available entry, onOpenDirectoryContact(entry, signal) must ask your server to recheck membership/blocks and create or find the conversation. Return its ConversationSummary. Repeated opens should return the same conversation. Respect signal.aborted; late responses are discarded when the directory entry is removed, permission changes, the popup closes, or the account is switched. This is not a permission grant: Robono's regular server checks still apply.

On web, call messenger.updateDirectory(nextEntries) to update availability without resetting the current chat. React hosts update the directory prop. A directory does not copy historical messages or transfer acceptance of a connection from another network. Keep those migration decisions on your server.

Friends, chat and menu appearance

Use Features & preview → Appearance to choose Name & logo, Friends screen, Friends menu, Chat screen, or Chat menu. The preview uses these shared SDK screens, including for Robono Messenger. Uploading a logo changes the draft; Save changes → Apply to live app publishes it (or Apply to test app for a test connection). Online inboxes refresh settings automatically and when reopened. No restart or reinstall is needed for configuration changes; apps must first install this SDK update.

The friends header reserves 145 × 38 logical pixels/points for either the logo or app name. Logos keep their proportions, fit inside this box, and align to its right edge. Text uses the same box and supports device/serif/monospace fonts, size, weight and color. The chat header identifies the contact/group; it does not repeat the app logo. Uploaded logos keep their own colors.

The MessagingAppearance.screens options customize friends-list colors, avatars, last-message previews, branding text and direct/group header colors. menus.friends and menus.chat set menu background, text/icon colors and optional entries. These are display choices, never permission grants: entries still require the feature and user authorization. Account access and permitted Block/Report actions stay available. A host-provided appearance overrides server appearance; omit it to follow saved website settings. A host-provided companyName overrides the configured app name.

Profile, media and chat options

The conversation menu provides Profile (Group details for groups), Shared media, and Chat options. Chat options contains notification muting, Privacy Lens when allowed, and confirmed deletion of the current user's chat history. Deleting a chat leaves the other person's copy intact; a new incoming message can return the chat to the inbox. The complete Messenger connects these actions to the authenticated inbox automatically.

When composing only a conversation screen with your own inbox, supply conversationActions={{ muted, setMuted, deleteConversation }}. Both callbacks return a promise and must enforce the signed-in user's permissions on your server. Unavailable actions are hidden. Website customization controls the menu entries through appearance.menus.chat.items.media and .options; it does not grant access that the user's permissions deny.

Existing Bridge friends

Open an already accepted external-app user ↔ Robono-user connection in the standard Messenger using the original connection ID and retained history. See the Bridge Messenger guide and the included examples/existing-bridge-chat.tsx. This connector requires the matching core 0.13.0, server 0.32.0 and Expo 0.18.0 or web 0.17.0 release.

Standard media viewer

Photos and videos use the same viewer: Download, Delete, Forward, Share and Close, subject to customer permissions. There is no external-player Open action. Photos use original files, support pinch/pan and tap-to-expand; video uses the native playback controls, seeking and fullscreen. Close remains available on expanded photos.

Disposable storage maintenance (0.21.0)

Call once at app startup, outside the render path:

import {configureExpoMessagingCache, maintainExpoMessagingCache}
  from '@robono/messaging-react-native/expo';
configureExpoMessagingCache({
  maxBytes: 150 * 1024 * 1024,
  maxAgeMs: 24 * 60 * 60 * 1000,
  minFreeBytes: 100 * 1024 * 1024,
});
await maintainExpoMessagingCache();

The SDK also checks at first allocation, periodically before new files, and when space is low before a download. requiredBytes requests room for an upcoming transfer. Limits are soft: active transfers, playback, viewers, and draft copies are protected even above the target. limitReached and protectedBytes explain why space could not be reclaimed. Never delete an active file to enforce a cap.

On account changes, close/dispose the old Messenger and call maintainExpoMessagingCache({clearUnused: true}). Cleanup may run with Messenger open: live files remain leased. Persistent outbox drafts and saved messages live outside this disposable cache; unfinished selected/recorded copies have persistent draft markers and survive crash cleanup. Explicit downloads in the host's Files or photo library are outside its scope. The cache is app-wide, not a permission cache: clearing files does not grant or revoke access.

Only SDK-owned robono-messaging files are swept. Streaming video uses useCaching: false, and audio does not request download-before-playback. Returned native thumbnail temporaries are deleted when their job finishes. Shared Expo/OS cache directories are not swept: a native operation that crashes before returning its temporary filename cannot safely be attributed to Robono. Unfinished native recordings are preserved rather than treated as disposable files.

Bubble appearance and delivery status

Choose Design → Chat screen → Messages & bubbles in the website customization tool. The shared preview uses the same renderer as the customer Messenger.

  • Bubble corners: standard, square (90°), or more rounded.
  • Bubble style: classic, a top tail on text/file bubbles (top right for sent messages, top left for received messages), or the original Messenger’s tighter sender-side bottom corner (3px, with 14px body corners). Voice messages keep their player shape; photos and videos fill their bubble without a padded outer background.
  • Delivery status: a bar inside the bubble, flush with its right edge, or a circle with a checkmark. Bar mode offers sent, delivered and seen/heard/watched colors. Each outgoing item has its own indicator, including attachments sent together. Incoming messages have no delivery indicator.

A circle is empty while sending, gains a checkmark on delivery and fills with the accent color when consumed. Viewing status is only shown when receipt permissions allow it; styling never overrides those permissions.

These choices are stored in appearance.presentation.bubbleShape, appearance.presentation.bubbleStyle, and appearance.messageStatus (style, position, sent, delivered, consumed). Existing designs default to the inside edge bar and classic bubbles. Customers need a package version containing these controls before saved designs can render them.

The website's Calling settings control the optional message offer after an unanswered call. The shared panel presents one recording preview, Record again, Cancel and an explicit Send action. Drafts are not uploaded until Send.

The website’s Design → Chat screen → Writing area offers an optional Message field border and its color. The thin outline follows the field corners without changing its size. These are appearance.composer.fieldBorder and fieldBorderColor; existing designs remain borderless.

The standard media preview loader may expose peek(message) to return an already authorized, memory-only preview synchronously. The Expo and browser adapters do this automatically. Hosts must scope previews to the current account/conversation, clear them on permission or identity changes, and keep private URLs out of persistent history. Server-provided thumbnails are displayed without another image conversion.

Delivery bar colors use appearance.messageStatus.sent, .delivered and .consumed. The website builder shows these color controls only when messageStatus.style is bar; choosing circle hides them and preserves the bar choices for switching back. Voice completion pauses playback and resets to zero; an ordinary Pause preserves the position and Play resumes from it on web, iPhone and Android.

The 12px status circle can sit inside or below each outgoing bubble via appearance.messageStatus.position: 'inside' | 'below' (default inside). Message time independently uses appearance.messageTime.position: 'inside' | 'below' | 'slide' (default slide). Below-bubble metadata moves with its own message during a swipe. These settings apply to web, iPhone and Android. appearance.screens.chat.messageWidth limits long bubbles to 70, 88 or 94 percent of the message area; short messages retain their natural width.

When top tails are selected, the delivery bar starts at the tail’s base with a rounded cap; it does not draw a stripe through the tail.

Parent message reviews

Use the shared ExpoMessageReviewInbox with the authenticated parent route described in the server integration instructions. Use the matching server and core packages, and confirm the public review API is available before enabling reviews.

import {MessageReviewClient} from '@robono/messaging';
import {ExpoMessageReviewInbox} from '@robono/messaging-react-native/expo';
const reviewClient = new MessageReviewClient(async (operation, input) => {
  const response = await fetch('/api/parent-message-reviews', {
    method: 'POST', credentials: 'include',
    headers: {'content-type': 'application/json'},
    body: JSON.stringify({...input, operation}),
  });
  const result = await response.json();
  if (!response.ok) throw Error(result.error?.message ?? 'Review unavailable');
  return result;
});
// Use your authenticated transport/session and account directory on mobile.
<ExpoMessageReviewInbox client={reviewClient} name={userDisplayName}
  conversationName={friendDisplayNameForConversation} />

Keep the client stable while the signed-in account is unchanged, and replace it on sign-out/account changes. Names are display data, never authorization. The parent sees the child, intended friend, exact words and private photo/video/voice preview. Pending and completed items are separate; only a pending item offers a decision. Approved items with interrupted delivery offer Retry delivery. Media is cleared when the item changes or the app backgrounds. Native hosts without Expo can use MessagingReviewInbox with their own authorized renderMedia callback.

Directory contacts now open the conversation destination immediately, without an “Opening chat” dialog. The shared screen keeps the friend's name and avatar visible while onOpenDirectoryContact resolves. No messages or composer are mounted before the authorized result. Return the conversation summary directly after the permission check; refreshing contact lists or the inbox must not delay that result. Back, account changes and revoked directory entries cancel pending opens and discard late responses. Unavailable contacts explain their status in the same conversation pane. This navigation correction is local and awaiting the combined SDK release.

Private Me chat

The shared friend list places the aut