rusty_libimobiledevice 0.1.7

An ergonomic library to communicate with 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

// jkcoxson

use std::os::raw::c_char;

use log::info;

use crate::{
    bindings as unsafe_bindings, error::ScreenshotrError, idevice::Device,
    services::lockdownd::LockdowndService,
};

pub struct ScreenshotrClient<'a> {
    pub(crate) pointer: unsafe_bindings::screenshotr_client_t,
    phantom: std::marker::PhantomData<&'a Device>,
}

impl ScreenshotrClient<'_> {
    /// Creates a preboard client from a screenshotr service
    /// # Arguments
    /// * `device` - The device to connect to
    /// * `descriptor` - The lockdown service to connect on
    /// # Returns
    /// A struct containing the handle to the connection
    ///
    /// ***Verified:*** False
    pub fn new(device: &Device, descriptor: LockdowndService) -> Result<Self, ScreenshotrError> {
        let mut pointer = std::ptr::null_mut();
        let result = unsafe {
            unsafe_bindings::screenshotr_client_new(
                device.pointer,
                descriptor.pointer,
                &mut pointer,
            )
        }
        .into();

        if result != ScreenshotrError::Success {
            return Err(result);
        }

        Ok(ScreenshotrClient {
            pointer,
            phantom: std::marker::PhantomData,
        })
    }

    /// Starts a new connection and adds a screenshotr client to it
    /// # Arguments
    /// * `device` - The device to connect to
    /// * `label` - The label for the connection
    /// # Returns
    /// A struct containing the handle to the connection
    ///
    /// ***Verified:*** False
    pub fn start_service(
        device: &Device,
        label: impl Into<String>,
    ) -> Result<Self, ScreenshotrError> {
        let mut pointer = std::ptr::null_mut();
        let result = unsafe {
            unsafe_bindings::screenshotr_client_start_service(
                device.pointer,
                &mut pointer,
                label.into().as_ptr() as *const c_char,
            )
        }
        .into();

        if result != ScreenshotrError::Success {
            return Err(result);
        }

        Ok(ScreenshotrClient {
            pointer,
            phantom: std::marker::PhantomData,
        })
    }

    /// Takes a screenshot on the device
    /// # Arguments
    /// *none*
    /// # Returns
    /// A vector of bytes containing a .png
    ///
    /// ***Verified:*** False
    pub fn take_screenshot(&self) -> Result<Vec<u8>, ScreenshotrError> {
        let mut data = unsafe { std::mem::zeroed() };
        let mut size = 0;
        let result = unsafe {
            unsafe_bindings::screenshotr_take_screenshot(self.pointer, &mut data, &mut size)
        }
        .into();

        if result != ScreenshotrError::Success {
            return Err(result);
        }

        info!("Screenshot size: {}", size);

        Ok(unsafe { std::vec::Vec::from_raw_parts(data as *mut u8, size as usize, size as usize) })
    }
}

impl Drop for ScreenshotrClient<'_> {
    fn drop(&mut self) {
        unsafe {
            unsafe_bindings::screenshotr_client_free(self.pointer);
        }
    }
}