Calls over WebRTC

The SDK's calls carry their audio over a WebSocket, which works on every network but sounds lossy on a lossy one. Add the SDK's WebRTC module and the same calls — the ones the user places and the ones Graine rings — carry it over WebRTC: a jitter buffer and loss concealment keep the agent's voice steady through a moment's loss, and the platform's echo canceller runs on the call. New in 0.9.0.

Nothing else changes. The ring, the call screen, Connecting…, mute, the loudspeaker, the outcomes, who the user is, memory, variables, screen context, actions and Call History are the same. A call that WebRTC cannot set up continues on the WebSocket inside the same call.

What it needs in the dashboard

Nothing else: the same agent, key and push credentials as your calls today.

What to do, in order

1. Add WebRTC to the build: the iOS package GraineInAppRTC, the Android module ai.graine:inapp-android-rtc — each at the same version as its SDK — or, in React Native and Flutter, the build switch. It is native code: a new store build, not an over-the-air update.
2. Choose, if you want to — callTransport in the calls configuration: auto (the default — WebRTC when the module is in the app), websocket or webrtc. Most apps leave it.
3. Place a call, or answer one Graine rang. → The call is prepared at the tap, or while the ring shows, so it connects as fast as before; the agent greets the user with nothing clipped.
4. Read which one carried it once the call is active: transport (webrtc or websocket) and, for a call that tried WebRTC and runs on the WebSocket, transportFallbackReason — log it, or send it with your analytics.
5. Try the switch: set the agent's In-app call audio to Standard, restart the app, place a call → transport is websocket. Set it back.

What the user notices: on a weak or changing network — a lift, a train, a crowded café — the agent's voice holds up instead of stalling and catching up. Over WebRTC it arrives at telephone bandwidth today: steadier through a weak network, narrower than the WebSocket's on a perfect one.

When WebRTC cannot carry a call — a network that blocks it, a refusal, no answer within 12 seconds in all — the call continues on the WebSocket inside the same call: no second ring, no new call screen, no error; Connecting… lasts a moment longer. A call the agent cannot take at all (no credit left, the agent switched off) ends with that reason, as it does without the module. Once the audio flows a call never changes road: a dropped connection gets one chance to recover, then the call ends failed.

What it adds to your app: a prebuilt WebRTC library (Google's WebRTC, BSD 3-Clause), its symbols renamed so it never clashes with another copy in your app — about 12 MB installed on an iPhone (about 6 MB to download) and about 7.4 MB on a 64-bit Android phone. List it in your app's open-source licences. On Android the module adds ACCESS_NETWORK_STATE, a normal permission: nothing is asked.

The code, platform by platform

dependencies: [
    .package(url: "https://github.com/GraineAI/inapp-ios", from: "0.10.3"),
    .package(url: "https://github.com/GraineAI/inapp-ios-rtc", from: "0.10.3"),
],
targets: [
    .target(name: "MyApp", dependencies: [
        .product(name: "GraineInApp", package: "inapp-ios"),
        .product(name: "GraineInAppRTC", package: "inapp-ios-rtc"),
    ]),
]

import GraineInAppRTC
 
GraineRTC.install()   // optional: makes WebRTC available now, rather than when the first call looks for it

GraineInApp.shared.calls.configure(GraineCallsConfig(displayName: "Asha from Acme", callTransport: .auto))

final class TransportLog: GraineCallsListener {
    func onCallState(_ state: GraineCallState, callId: String?) {
        guard state == .active else { return }
        let calls = GraineInApp.shared.calls
        print("call \(callId ?? "?") on \(calls.transport?.rawValue ?? "unknown")", calls.transportFallbackReason ?? "")
    }
}
 
let transportLog = TransportLog()
GraineInApp.shared.calls.addListener(transportLog)   // held weakly

Troubleshooting

In depth: WebRTC or the WebSocket · SDK reference → Calls over WebRTC.