VoIP Calls

[dependencies]
whatsapp-rust = { version = "0.7", features = ["voip"] }
tokio = { version = "1.53", features = ["macros", "rt-multi-thread"] }

use whatsapp_rust::client::Client;
use whatsapp_rust::types::events::Event;
use whatsapp_rust::wacore::types::call::CallAction;

async fn on_event(client: &Client, event: Event) -> anyhow::Result<()> {
    match event {
        Event::IncomingCall(incoming) => {
            // Borrow the action so `incoming` is not partially moved before `.accept(&incoming)`.
            // group_jid: None excludes group offers — see the Note above.
            if let CallAction::Offer { is_video, group_jid: None, .. } = &incoming.action {
                let mut call = client.voip()
                    .accept(&incoming)
                    .audio(mic_source, speaker_sink);
                if *is_video {
                    // Required to answer a video-from-the-start offer.
                    call = call.video(camera_source, video_sink);
                }
                // If `is_video` was false, `start()` accepts audio-only — video can still be
                // added later via `CallHandle::start_video`.
                let handle = call.start().await?;

                // Resolves when either side hangs up
                handle.wait_ended().await;
            }
        }
        _ => {}
    }
    Ok(())
}

use whatsapp_rust::types::Jid;
use whatsapp_rust::voip::CallTermination;

let peer: Jid = "15551234567@s.whatsapp.net".parse()?;

let handle = client.voip()
    .call(&peer)
    .audio(mic_source, speaker_sink)
    .video(camera_source, video_sink) // omit for an audio-only call
    .start()
    .await?;

// End the call from your side: sends <terminate> to the peer and tears down local media.
// Addressed at whichever devices still need to hear it — the call scope for a group or
// call-link call, the device that answered a direct call, or every device an unanswered
// outgoing call is still ringing.
match handle.terminate().await {
    CallTermination::PeerNotified | CallTermination::AlreadyEnded => {}
    CallTermination::PartlyNotified { notified, unconfirmed } => {
        // Some rung devices weren't confirmed and may keep ringing until their own
        // transport times out. The local side is down either way.
        warn!("terminate reached {notified} device(s), {unconfirmed} unconfirmed");
    }
    CallTermination::LocalOnly(e) => {
        // No send was confirmed. The peer may not learn the call ended until its
        // own transport times out — see `CallTermination` below for details.
        warn!("terminate unconfirmed ({e}); ended locally");
    }
    // CallTermination is #[non_exhaustive]: a wildcard arm is required outside
    // the whatsapp-rust crate even though every current variant is matched above.
    _ => {}
}

// Or wait for the remote side to hang up
handle.wait_ended().await;

cargo run -p whatsapp-rust-voip-cli -- loopback

use whatsapp_rust::voip::{AudioSource, AudioSink};
use whatsapp_rust::async_channel;

struct MyMic { receiver: async_channel::Receiver<Vec<i16>> }
struct MySpeaker { sender: async_channel::Sender<Vec<i16>> }

impl AudioSource for MyMic {
    // Frames are 16 kHz wideband PCM (60 ms = 960 samples per Vec)
    fn frames(&self) -> async_channel::Receiver<Vec<i16>> {
        self.receiver.clone()
    }
}

impl AudioSink for MySpeaker {
    fn playout(&self) -> async_channel::Sender<Vec<i16>> {
        self.sender.clone()
    }
}

PCM source ── MLOW adapter ──┐
                             ├── RTP + SRTP/WARP ── WhatsApp relay
encoded source/sink ─────────┘

use whatsapp_rust::bytes::Bytes;
use whatsapp_rust::async_channel;
use whatsapp_rust::voip::{AudioFormat, EncodedAudioFrame};

let (encoded_tx, encoded_rx) = async_channel::bounded::<Bytes>(3);
let (playout_tx, playout_rx) = async_channel::bounded::<EncodedAudioFrame>(3);

let call = client
    .voip()
    .call(&peer)
    .encoded_audio(AudioFormat::OPUS_16KHZ_60MS, encoded_rx, playout_tx)
    .start()
    .await?;

// Feed your encoder's output in: encoded_tx.send(packet).await?; (one raw Opus packet per Bytes)
// Drain decoded frames for playback: while let Ok(frame) = playout_rx.recv().await { play(frame.data) }

WA_AUDIO_CODEC=mlow cargo run -p whatsapp-rust-voip-cli --release -- listen accept
WA_AUDIO_CODEC=opus cargo run -p whatsapp-rust-voip-cli --release -- listen accept

WA_AUDIO_CODEC=opus WA_AUDIO_PROFILE=pt111 cargo run -p whatsapp-rust-voip-cli --release -- listen accept

use whatsapp_rust::voip::{VideoSource, VideoSink, VideoFrame};
use whatsapp_rust::async_channel;

struct MyCamera { receiver: async_channel::Receiver<Vec<u8>> }
struct MyDisplay { sender: async_channel::Sender<VideoFrame> }

impl VideoSource for MyCamera {
    // Each item is one complete H.264 Annex-B access unit.
    fn frames(&self) -> async_channel::Receiver<Vec<u8>> {
        self.receiver.clone()
    }

    // RTP clock increment between access units (90_000 / fps). Must be non-zero;
    // defaults to the 15 fps cadence if not overridden.
    fn rtp_timestamp_stride(&self) -> u32 {
        90_000 / 20 // 20 fps
    }
}

impl VideoSink for MyDisplay {
    fn playout(&self) -> async_channel::Sender<VideoFrame> {
        self.sender.clone()
    }
}

handle.start_video(camera_source, video_sink).await?;

CallEvent::VideoStateChanged { state, upgrade_token: Some(token), .. } if state.is_upgrade_request() => {
    // Sends both the accept and the Enabled stanza in one call — no extra step needed on this side.
    handle.accept_video(token, camera_source, video_sink).await?;
}

handle.stop_video().await?; // Idempotent.

use whatsapp_rust::types::Jid;

let alice: Jid = "15551234567@lid".parse()?;
let bob: Jid = "15557654321@lid".parse()?;

// Ad-hoc call to specific users
let handle = client.voip()
    .group_call(&[alice, bob])
    .audio(mic_source, speaker_sink)
    .start()
    .await?;

// Call the current members of an existing group.
// audio()/video() take their endpoints by value, so this call needs its own
// AudioSource/AudioSink instances rather than reusing mic_source/speaker_sink above.
let group_jid: Jid = "120363012345678901@g.us".parse()?;
let handle = client.voip()
    .group_call_by_id(&group_jid)
    .audio(other_mic_source, other_speaker_sink)
    .start()
    .await?;

if let CallAction::Offer { group_jid: Some(group_jid), .. } = &incoming.action {
    // Optional: send <preaccept> before your UI is ready to attach media.
    client.voip().preaccept_group_invite(&incoming).await?;

    // Send <accept> once the user answers...
    client.voip().accept_group_invite(&incoming).await?;
    // ...then attach media the same way you'd place the call yourself.
    let handle = client.voip()
        .group_call_by_id(group_jid)
        .audio(mic_source, speaker_sink)
        .start()
        .await?;
}

// Add someone who isn't in the call yet
handle.invite_participant(&carol).await?;

// Ring someone the roster already knows about but who isn't currently connected
handle.ring_participant(&dave).await?;

if let Some(state) = handle.group_state() {
    if let Some(snapshot) = state.snapshot() {
        for participant in &snapshot.participants {
            println!("{}: connected={}", participant.jid, participant.is_connected());
        }
    }
}

use whatsapp_rust::voip::CallLinkMedia;

// Create a link you can share
let link = client.voip().create_call_link(CallLinkMedia::Video).await?;
let url = link.url(); // https://call.whatsapp.com/video/<token>
println!("share: {url}");

// Anyone holding that URL (or just the bare token) can preview it without joining
// (creator, waiting-room state, whether they're the admin)
let preview = client.voip().preview_call_link(&url, CallLinkMedia::Video).await?;

// ...and join it, attaching media the same way as group_call/group_call_by_id
let handle = client.voip()
    .call_link(&url, CallLinkMedia::Video)
    .audio(mic_source, speaker_sink)
    .video(camera_source, video_sink)
    .start()
    .await?;

handle.set_approval_required(true).await?;      // turn the waiting room on/off
handle.admit_waiting_user(&pending_jid).await?; // let someone in
handle.deny_waiting_user(&pending_jid).await?;  // turn someone away

handle.set_hand_raised(true).await?;    // raise/lower your hand
handle.send_reaction("🎉")?;             // send an emoji reaction (not async)
handle.send_reaction("")?;              // clear your own reaction
handle.start_screen_share(None).await?; // share your video plane as a screen share
handle.stop_screen_share().await?;

use std::sync::Arc;
use whatsapp_rust::async_trait;
use whatsapp_rust::voip::{RelayEndpointParams, RelayTransportFactory, RelayTransportProvider};

struct MyProvider { /* whatever a factory needs to build one, e.g. JS handles */ }

// Mirrors the trait's own `#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]` — a
// wasm32 provider built around JS handles is typically !Send, and plain `#[async_trait]`
// requires Send.
#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
impl RelayTransportProvider for MyProvider {
    // Called per relay endpoint — the server names the relay per call, so a plain factory
    // could never have been the injection point.
    async fn factory(
        &self,
        relay: &RelayEndpointParams,
    ) -> whatsapp_rust::anyhow::Result<Arc<dyn RelayTransportFactory>> {
        // relay.addr is where the relay is; relay.ice_ufrag / relay.ice_pwd are what a synthetic
        // SDP answer names to reach it — the same "synthetic-SDP / wrtc dance" the native
        // transport's own DataChannel setup already does by hand, with `id=0`, `ordered=false`,
        // `maxRetransmits=0`.
        Ok(Arc::new(build_my_factory(relay).await?))
    }
}

client.set_relay_transport_provider(Arc::new(MyProvider { /* ... */ }));