Skip to content

Your Android phone and your Windows PC, working as one. Local-first, end-to-end encrypted, no account.

15.1 KB
Raw Blame
// SPDX-License-Identifier: MPL-2.0
//! Continuity Camera: a paired PC asks a phone to take a photo or scan a
//! document (`camera.capture.request`), and the phone streams the captured
//! image back on a dedicated `camera` / `result` stream.

use std::{sync::Arc, time::Duration};

use iroh::endpoint::{RecvStream, SendStream};
use nectarlink_protocol::{
    DeviceId, Envelope, ErrorCode,
    messages::{
        CameraCaptureCancel, CameraCaptureMode, CameraCaptureOk, CameraCaptureRequest,
        CameraCaptureResultMeta, StreamHeader, continuity_camera, types,
    },
    read_frame, write_frame,
};

use crate::{Error, NodeEvent, Result, error::net, node::Shared, session::Session};

/// Per-device toggle that gates Continuity Camera along with photo sharing.
pub const TOGGLE: &str = "photos";

const RESULT_TIMEOUT: Duration = Duration::from_secs(60);
const CHUNK_BYTES: usize = 64 * 1024;

/// How long a capture this device asked for may take: the phone's user
/// takes the photo or scan.
const CAPTURE_WAIT: Duration = Duration::from_secs(10 * 60);

/// Captures this device asked for and hasn't received: a result is saved
/// only for one of these, never for a picture a phone sends unasked.
static ASKED: std::sync::Mutex<Vec<(DeviceId, String, std::time::Instant)>> =
    std::sync::Mutex::new(Vec::new());

fn asked() -> std::sync::MutexGuard<'static, Vec<(DeviceId, String, std::time::Instant)>> {
    let mut asked = ASKED.lock().unwrap_or_else(|e| e.into_inner());
    asked.retain(|(_, _, at)| at.elapsed() < CAPTURE_WAIT);
    asked
}

/// Takes the outstanding request `request_id` to `peer`, if there is one.
fn take_asked(peer: &DeviceId, request_id: &str) -> bool {
    let mut asked = asked();
    let before = asked.len();
    asked.retain(|(p, id, _)| !(p == peer && id == request_id));
    asked.len() < before
}

/// Whether a Continuity Camera `request_id` meets the protocol bounds.
pub fn valid_request_id(id: &str) -> bool {
    !id.is_empty() && id.len() <= continuity_camera::MAX_ID_BYTES && !id.chars().any(char::is_control)
}

fn detail_for_mode(mode: CameraCaptureMode) -> &'static str {
    match mode {
        CameraCaptureMode::Photo => "Continuity Camera · Photo",
        CameraCaptureMode::Scan => "Continuity Camera · Document scan",
    }
}

pub(crate) async fn request_on_session(
    shared: &Shared,
    session: &Session,
    request_id: String,
    mode: CameraCaptureMode,
) -> Result<()> {
    if !valid_request_id(&request_id) {
        return Err(Error::Protocol("invalid continuity camera request_id".into()));
    }
    if !shared.toggle_on(&session.peer, TOGGLE) {
        return Err(Error::Denied);
    }
    let env = Envelope::new(
        types::CAMERA_CAPTURE_REQUEST,
        &CameraCaptureRequest { request_id: request_id.clone(), mode },
    )?;
    session.send(env).await?;
    asked().push((session.peer, request_id, std::time::Instant::now()));
    Ok(())
}

/// Asks a paired phone to open its camera UI and capture a photo or scan a document.
pub(crate) async fn request(
    shared: &Shared,
    peer: DeviceId,
    request_id: String,
    mode: CameraCaptureMode,
) -> Result<()> {
    if !valid_request_id(&request_id) {
        return Err(Error::Protocol("invalid continuity camera request_id".into()));
    }
    if !shared.store.is_paired(&peer)? {
        return Err(Error::NotPaired);
    }
    if !shared.toggle_on(&peer, TOGGLE) {
        return Err(Error::Denied);
    }
    if !shared.store.has_active_queue_for_peer(&peer).unwrap_or(false)
        && let Some(session) = shared.session(&peer)
    {
        match request_on_session(shared, &session, request_id.clone(), mode).await {
            Ok(()) => return Ok(()),
            Err(e) if !crate::actions::is_transient_send_error(&e) => return Err(e),
            Err(_) => {}
        }
    }
    let id = crate::transfer::new_id();
    let payload = crate::QueuePayload::CameraRequest { request_id, mode };
    shared.store.enqueue_send_item(&id, &peer, &payload, None, crate::now_unix_ms())?;
    shared.emit(NodeEvent::QueueChanged);
    shared.queue_notify.notify_waiters();
    Ok(())
}

/// Cancels an in-flight Continuity Camera capture request on either side.
pub(crate) async fn cancel(
    shared: &Shared,
    peer: DeviceId,
    request_id: String,
    reason: Option<String>,
) -> Result<()> {
    if !valid_request_id(&request_id) {
        return Err(Error::Protocol("invalid continuity camera request_id".into()));
    }
    if !shared.store.is_paired(&peer)? {
        return Err(Error::NotPaired);
    }
    take_asked(&peer, &request_id);
    let session = shared.session(&peer).ok_or(Error::Offline)?;
    let env = Envelope::new(types::CAMERA_CAPTURE_CANCEL, &CameraCaptureCancel { request_id, reason })?;
    session.send(env).await
}

/// Handles `camera.capture.*` messages on the control stream.
pub(crate) async fn handle(shared: &Arc<Shared>, session: &Arc<Session>, env: &Envelope) -> Result<bool> {
    match env.t.as_str() {
        types::CAMERA_CAPTURE_REQUEST => {
            let req: CameraCaptureRequest = env.body()?;
            if !valid_request_id(&req.request_id) {
                return Err(Error::Protocol("invalid continuity camera request_id".into()));
            }
            if !shared.toggle_on(&session.peer, TOGGLE) {
                let cancel = Envelope::new(
                    types::CAMERA_CAPTURE_CANCEL,
                    &CameraCaptureCancel {
                        request_id: req.request_id,
                        reason: Some("photos sharing is turned off".into()),
                    },
                )?;
                let _ = session.send(cancel).await;
                return Ok(true);
            }
            match shared.platform.camera_capture_requested(&session.peer, &req) {
                Ok(()) => {
                    let ok = Envelope::new(
                        types::CAMERA_CAPTURE_OK,
                        &CameraCaptureOk { request_id: req.request_id.clone() },
                    )?;
                    let _ = session.send(ok).await;
                    shared.emit(NodeEvent::CameraCaptureRequested {
                        device: session.peer,
                        request_id: req.request_id,
                        mode: req.mode,
                    });
                }
                Err(reason) => {
                    let cancel = Envelope::new(
                        types::CAMERA_CAPTURE_CANCEL,
                        &CameraCaptureCancel { request_id: req.request_id, reason: Some(reason) },
                    )?;
                    let _ = session.send(cancel).await;
                }
            }
            Ok(true)
        }
        types::CAMERA_CAPTURE_OK => {
            let ok: CameraCaptureOk = env.body()?;
            if !valid_request_id(&ok.request_id) {
                return Err(Error::Protocol("invalid continuity camera request_id".into()));
            }
            Ok(true)
        }
        types::CAMERA_CAPTURE_CANCEL => {
            let cancel: CameraCaptureCancel = env.body()?;
            if !valid_request_id(&cancel.request_id) {
                return Err(Error::Protocol("invalid continuity camera request_id".into()));
            }
            shared.platform.camera_capture_cancelled(&session.peer, &cancel.request_id);
            shared.emit(NodeEvent::CameraCaptureCancelled {
                device: session.peer,
                request_id: cancel.request_id,
                reason: cancel.reason,
            });
            Ok(true)
        }
        _ => Ok(false),
    }
}

/// Sends a captured photo or scanned document from the phone to the requesting PC.
pub(crate) async fn send_result(
    shared: &Arc<Shared>,
    session: &Arc<Session>,
    meta: CameraCaptureResultMeta,
    bytes: Vec<u8>,
) -> Result<()> {
    if !valid_request_id(&meta.request_id) {
        return Err(Error::Protocol("invalid continuity camera request_id".into()));
    }
    if meta.file_name.trim().is_empty() || meta.file_name.len() > continuity_camera::MAX_NAME_BYTES {
        return Err(Error::Protocol("invalid continuity camera file_name".into()));
    }
    if !matches!(meta.mime.as_str(), "image/jpeg" | "image/png") {
        return Err(Error::Protocol("unsupported continuity camera mime".into()));
    }
    if meta.size > continuity_camera::MAX_IMAGE_BYTES
        || bytes.len() as u64 > continuity_camera::MAX_IMAGE_BYTES
    {
        return Err(Error::TooLarge);
    }
    if meta.size == 0 || bytes.len() as u64 != meta.size {
        return Err(Error::Protocol("continuity camera size mismatch".into()));
    }
    if !shared.toggle_on(&session.peer, TOGGLE) {
        return Err(Error::Denied);
    }

    let safe_name = crate::transfer::safe_file_name(&meta.file_name);
    let clean_meta = CameraCaptureResultMeta { file_name: safe_name.clone(), ..meta };

    let exchange = async {
        let (mut send, mut recv) = session.conn.open_bi().await.map_err(net)?;
        let header = StreamHeader {
            svc: continuity_camera::SERVICE.into(),
            op: continuity_camera::OP_RESULT.into(),
            v: continuity_camera::VERSION,
        };
        write_frame(&mut send, &Envelope::new(types::STREAM, &header)?.to_cbor()).await?;
        write_frame(&mut send, &Envelope::new(continuity_camera::RESULT_META, &clean_meta)?.to_cbor())
            .await?;
        for chunk in bytes.chunks(CHUNK_BYTES) {
            if let Err(e) = send.write_all(chunk).await {
                let _ = send.finish();
                if let Ok(Some(reply_bytes)) = read_frame(&mut recv).await
                    && let Ok(env) = Envelope::from_cbor(&reply_bytes)
                {
                    env.expect(types::OK)?;
                }
                return Err(net(e));
            }
        }
        let _ = send.finish();
        let reply = read_frame(&mut recv).await?.ok_or(Error::Offline)?;
        Envelope::from_cbor(&reply)?.expect(types::OK)?;
        Ok::<(), Error>(())
    };

    tokio::time::timeout(RESULT_TIMEOUT, exchange).await.map_err(|_| Error::Timeout)??;

    let _ = shared.record_timeline(crate::timeline::NewTimelineEntry {
        kind: crate::TimelineKind::Photo,
        device_id: session.peer,
        device_name: shared.peer_name(&session.peer),
        incoming: false,
        timestamp: crate::now_unix(),
        title: safe_name,
        detail: detail_for_mode(clean_meta.mode).into(),
        target: String::new(),
        size_bytes: clean_meta.size,
        duration_secs: 0,
        ref_id: None,
    });

    Ok(())
}

/// Receives a Continuity Camera capture result stream on the PC.
pub(crate) async fn receive_result(
    shared: Arc<Shared>,
    peer: DeviceId,
    mut send: SendStream,
    mut recv: RecvStream,
) {
    let reply = match tokio::time::timeout(RESULT_TIMEOUT, take_result(&shared, peer, &mut recv)).await {
        Ok(Ok(())) => Envelope::empty(types::OK),
        Ok(Err((code, msg))) => Envelope::error(code, msg),
        Err(_) => Envelope::error(ErrorCode::Internal, "continuity camera transfer timed out"),
    };
    if reply.t != types::OK {
        let _ = recv.stop(0u32.into());
    }
    let _ = write_frame(&mut send, &reply.to_cbor()).await;
    let _ = send.finish();
    let _ = tokio::time::timeout(Duration::from_secs(2), send.stopped()).await;
}

async fn take_result(
    shared: &Arc<Shared>,
    peer: DeviceId,
    recv: &mut RecvStream,
) -> std::result::Result<(), (ErrorCode, &'static str)> {
    let meta = read_frame(recv)
        .await
        .ok()
        .flatten()
        .and_then(|bytes| Envelope::from_cbor(&bytes).ok())
        .and_then(|env| env.expect_body::<CameraCaptureResultMeta>(continuity_camera::RESULT_META).ok())
        .ok_or((ErrorCode::BadMessage, "invalid continuity camera metadata"))?;

    if !valid_request_id(&meta.request_id) {
        return Err((ErrorCode::BadMessage, "invalid request_id"));
    }
    if !matches!(meta.mime.as_str(), "image/jpeg" | "image/png") {
        return Err((ErrorCode::BadMessage, "unsupported continuity camera format"));
    }
    if meta.size == 0 || meta.size > continuity_camera::MAX_IMAGE_BYTES {
        return Err((ErrorCode::BadMessage, "invalid continuity camera size"));
    }
    if !shared.toggle_on(&peer, TOGGLE) {
        return Err((ErrorCode::Denied, "photos sharing is turned off"));
    }
    if !take_asked(&peer, &meta.request_id) {
        return Err((ErrorCode::Denied, "no capture was asked for"));
    }

    let size = usize::try_from(meta.size).map_err(|_| (ErrorCode::BadMessage, "image too large"))?;
    let mut data = Vec::with_capacity(size.min(CHUNK_BYTES));
    let mut buf = vec![0u8; CHUNK_BYTES];
    while data.len() < size {
        let want = (size - data.len()).min(buf.len());
        match recv.read(&mut buf[..want]).await {
            Ok(Some(n)) if n > 0 => data.extend_from_slice(&buf[..n]),
            _ => return Err((ErrorCode::BadMessage, "continuity camera stream ended early")),
        }
    }

    let default_ext = if meta.mime == "image/png" { "png" } else { "jpg" };
    let fallback_name = match meta.mode {
        CameraCaptureMode::Photo => format!("Photo.{default_ext}"),
        CameraCaptureMode::Scan => format!("Scan.{default_ext}"),
    };
    let raw_name = if meta.file_name.trim().is_empty() { &fallback_name } else { &meta.file_name };
    // Safe to save on any system: `C:x.jpg` must not become a path on drive C.
    let safe_name = crate::transfer::storable_name(&crate::transfer::safe_file_name(raw_name));

    let saved_path = match tokio::fs::create_dir_all(&shared.downloads_dir).await {
        Ok(()) => {
            let dest = crate::transfer::unique_path(&shared.downloads_dir, &safe_name);
            match tokio::fs::write(&dest, &data).await {
                Ok(()) => {
                    crate::transfer::mark_from_elsewhere(&dest);
                    Some(dest)
                }
                Err(e) => {
                    tracing::warn!(error = %e, "can't save continuity camera capture");
                    None
                }
            }
        }
        Err(e) => {
            tracing::warn!(error = %e, "can't create downloads dir for continuity camera capture");
            None
        }
    };

    let target = saved_path.as_ref().map(|p| p.to_string_lossy().into_owned()).unwrap_or_default();
    let _ = shared.record_timeline(crate::timeline::NewTimelineEntry {
        kind: crate::TimelineKind::Photo,
        device_id: peer,
        device_name: shared.peer_name(&peer),
        incoming: true,
        timestamp: crate::now_unix(),
        title: safe_name.clone(),
        detail: detail_for_mode(meta.mode).into(),
        target,
        size_bytes: meta.size,
        duration_secs: 0,
        ref_id: None,
    });

    shared.emit(NodeEvent::CameraCaptureReceived {
        device: peer,
        request_id: meta.request_id,
        mode: meta.mode,
        file_name: safe_name,
        mime: meta.mime,
        width: meta.width,
        height: meta.height,
        data,
        saved_path,
    });

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn request_id_validation() {
        assert!(valid_request_id("req-1234"));
        assert!(!valid_request_id(""));
        assert!(!valid_request_id("bad\nid"));
        assert!(!valid_request_id(&"x".repeat(continuity_camera::MAX_ID_BYTES + 1)));
    }
}