Function attach_android_data_channel

packages/server/src/transport/webrtc.rs:634–707

(
    channel: Arc<RTCDataChannel>,
    source: AndroidWebRtcSource,
    state: AppState,
    udid: String,
    stream_control_tx: mpsc::UnboundedSender<WebRtcStreamCommand>,
)

}

fn attach_android_data_channel(
    channel: Arc<RTCDataChannel>,
    source: AndroidWebRtcSource,
    state: AppState,
    udid: String,
    stream_control_tx: mpsc::UnboundedSender<WebRtcStreamCommand>,
) {
    let (control_tx, control_rx) = mpsc::unbounded_channel::<ControlMessage>();
    task::spawn(run_android_webrtc_control_queue(
        state.clone(),
        udid.clone(),
        control_rx,
    ));
    channel.on_message(Box::new(move |message: DataChannelMessage| {
        let source = source.clone();
        let state = state.clone();
        let udid = udid.clone();
        let stream_control_tx = stream_control_tx.clone();
        let control_tx = control_tx.clone();
        Box::pin(async move {
            let Ok(text) = std::str::from_utf8(&message.data) else {
                warn!("Invalid Android WebRTC control message bytes for {udid}");
                return;
            };
            if let Ok(message) = serde_json::from_str::<WebRtcDataChannelMessage>(text) {
                match message {
                    WebRtcDataChannelMessage::ClientStats { stats } => {
                        if !stats.client_id.trim().is_empty() && !stats.kind.trim().is_empty() {
                            state.metrics.record_client_stream_stats(*stats);
                        }
                    }
                    WebRtcDataChannelMessage::StreamControl {
                        client_id: _,
                        force_keyframe,
                        foreground: _,
                        snapshot,
                    } => {
                        let command = WebRtcStreamCommand {
                            force_keyframe: force_keyframe.unwrap_or(false),
                            snapshot: snapshot.unwrap_or(false),
                        };
                        if command.force_keyframe || command.snapshot {
                            source.request_keyframe();
                        }
                        let _ = stream_control_tx.send(command);
                    }
                    WebRtcDataChannelMessage::StreamQuality { config } => {
                        match android_h264_quality_from_payload(Some(&config)) {
                            Ok(quality) => source.reconfigure_h264(quality),
                            Err(error) => {
                                warn!(
                                    "Android WebRTC stream quality update failed for {udid}: {error}"
                                );
                                source.request_keyframe();
                            }
                        }
                    }
                }