ios-core 0.1.7

High-level device API, pairing transport, and discovery for iOS devices
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

//! DTX-based screenshot service (iOS 17+ via instruments, no DDI required).
//!
//! Service: `com.apple.instruments.server.services.screenshot`
//! Method: `takeScreenshot` → returns PNG bytes
//!
//! Reference: go-ios/ios/screenshot/screenshot.go

use bytes::Bytes;
use tokio::io::{AsyncRead, AsyncWrite};

use crate::services::dtx::codec::{DtxConnection, DtxError};
use crate::services::dtx::types::{DtxPayload, NSObject};

/// Take a screenshot via the DTX instruments screenshot service.
///
/// Returns PNG image bytes.
pub async fn take_screenshot_dtx<S>(stream: S) -> Result<Bytes, DtxError>
where
    S: AsyncRead + AsyncWrite + Unpin + Send,
{
    let mut conn = DtxConnection::new(stream);
    let ch = conn.request_channel(super::SCREENSHOT_SVC).await?;

    let msg = conn.method_call(ch, "takeScreenshot", &[]).await?;

    match msg.payload {
        DtxPayload::Response(NSObject::Data(data)) => Ok(data),
        DtxPayload::Response(NSObject::Dict(ref d)) => {
            // Some iOS versions wrap the PNG in a dict with "ScreenshotData" key
            if let Some(NSObject::Data(data)) = d.get("ScreenshotData") {
                Ok(data.clone())
            } else {
                Err(DtxError::Protocol(
                    "screenshot response dict missing ScreenshotData".into(),
                ))
            }
        }
        other => Err(DtxError::Protocol(format!(
            "unexpected screenshot response: {:?}",
            other
        ))),
    }
}

#[cfg(test)]
mod tests {
    use tokio::io::{duplex, AsyncWriteExt};

    use super::*;
    use crate::services::dtx::{encode_dtx, read_dtx_frame, DtxPayload, NSObject};

    const MSG_RESPONSE: u32 = 3;

    #[tokio::test]
    async fn download_screenshot_accepts_wrapped_screenshot_data() {
        let (client, mut server) = duplex(4096);
        let task = tokio::spawn(async move { take_screenshot_dtx(client).await.unwrap() });

        let channel_request = read_dtx_frame(&mut server).await.unwrap();
        match channel_request.payload {
            DtxPayload::MethodInvocation { selector, args } => {
                assert_eq!(selector, "_requestChannelWithCode:identifier:");
                assert!(
                    matches!(args.get(1), Some(NSObject::String(name)) if name == super::super::SCREENSHOT_SVC)
                );
            }
            other => panic!("unexpected channel request: {other:?}"),
        }
        server
            .write_all(&encode_dtx(
                channel_request.identifier,
                1,
                0,
                false,
                MSG_RESPONSE,
                &[],
                &[],
            ))
            .await
            .unwrap();

        let request = read_dtx_frame(&mut server).await.unwrap();
        match request.payload {
            DtxPayload::MethodInvocation { selector, args } => {
                assert_eq!(selector, "takeScreenshot");
                assert!(args.is_empty());
            }
            other => panic!("unexpected screenshot request: {other:?}"),
        }

        let payload = bytes::Bytes::from_static(b"png-bytes");
        let wrapped = crate::proto::nskeyedarchiver_encode::archive_dict(vec![(
            "ScreenshotData".to_string(),
            plist::Value::Data(payload.to_vec()),
        )]);
        server
            .write_all(&encode_dtx(
                request.identifier,
                1,
                request.channel_code,
                false,
                MSG_RESPONSE,
                &wrapped,
                &[],
            ))
            .await
            .unwrap();

        assert_eq!(task.await.unwrap(), payload);
    }

    #[tokio::test]
    async fn download_screenshot_rejects_dict_without_screenshot_data() {
        let (client, mut server) = duplex(4096);
        let task = tokio::spawn(async move { take_screenshot_dtx(client).await });

        let channel_request = read_dtx_frame(&mut server).await.unwrap();
        server
            .write_all(&encode_dtx(
                channel_request.identifier,
                1,
                0,
                false,
                MSG_RESPONSE,
                &[],
                &[],
            ))
            .await
            .unwrap();

        let request = read_dtx_frame(&mut server).await.unwrap();
        let wrapped = crate::proto::nskeyedarchiver_encode::archive_dict(vec![]);
        server
            .write_all(&encode_dtx(
                request.identifier,
                1,
                request.channel_code,
                false,
                MSG_RESPONSE,
                &wrapped,
                &[],
            ))
            .await
            .unwrap();

        let err = task.await.unwrap().expect_err("missing data must fail");
        assert!(err
            .to_string()
            .contains("screenshot response dict missing ScreenshotData"));
    }
}