idevice 0.1.68

A Rust library to interact with services on 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

//! Fetch rendered application icons as PNGs

use serde::Deserialize;
use tracing::warn;

use crate::{IdeviceError, ReadWrite, obf};

use super::{CoreDeviceError, CoreDeviceServiceClient};

#[derive(Debug)]
pub struct IconServiceClient<R: ReadWrite> {
    inner: CoreDeviceServiceClient<R>,
}

#[cfg(feature = "rsd")]
impl crate::RsdService for IconServiceClient<Box<dyn ReadWrite>> {
    fn rsd_service_name() -> std::borrow::Cow<'static, str> {
        obf!("com.apple.coredevice.iconservice")
    }

    async fn from_stream(stream: Box<dyn ReadWrite>) -> Result<Self, IdeviceError> {
        Ok(Self {
            inner: CoreDeviceServiceClient::new(stream).await?,
        })
    }
}

#[derive(Debug, Clone)]
pub enum AppIconTarget {
    BundleIdentifier(String),
    AppPath(String),
}

#[derive(Debug, Clone, Deserialize)]
pub struct AppIcon {
    /// The icon itself, PNG-encoded.
    #[serde(rename = "pngData")]
    pub png_data: plist::Data,
    /// Icon dimensions in pixels, i.e. `size` multiplied by `scale`.
    #[serde(rename = "pixelSize")]
    pub pixel_size: (f64, f64),
    /// Icon dimensions in points, as actually rendered. May be smaller than
    /// what was requested.
    pub size: (f64, f64),
    pub scale: f64,
    /// `true` when the device had no real icon for the app and rendered a
    /// generic placeholder instead.
    #[serde(rename = "isAppIconPlaceholder")]
    pub is_placeholder: bool,
}

impl<R: ReadWrite> IconServiceClient<R> {
    pub async fn new(inner: R) -> Result<Self, IdeviceError> {
        Ok(Self {
            inner: CoreDeviceServiceClient::new(inner).await?,
        })
    }

    /// Fetches one app's icon.
    pub async fn fetch_icon(
        &mut self,
        target: AppIconTarget,
        width: f32,
        height: f32,
        scale: f32,
        allow_placeholder: bool,
    ) -> Result<AppIcon, IdeviceError> {
        let (bundle_identifier, app_path) = match target {
            AppIconTarget::BundleIdentifier(b) => (Some(b), None),
            AppIconTarget::AppPath(p) => (None, Some(p)),
        };

        let feature = obf!("com.apple.coredevice.feature.fetchappicons");

        let res = self
            .inner
            .invoke_with_plist(
                feature,
                crate::plist!({
                    "bundleIdentifier":? bundle_identifier,
                    "appPath":? app_path,
                    "width": width,
                    "height": height,
                    "scale": scale,
                    "allowPlaceholder": allow_placeholder,
                })
                .into_dictionary()
                .unwrap(),
            )
            .await?;

        let info = res
            .as_dictionary()
            .and_then(|x| x.get("appIconInfo"))
            .ok_or(CoreDeviceError::MissingField("appIconInfo"))?;

        match plist::from_value(info) {
            Ok(icon) => Ok(icon),
            Err(e) => {
                warn!("Could not parse appIconInfo: {e:?}");
                Err(IdeviceError::UnexpectedResponse(
                    "failed to parse appIconInfo in fetch icon response".into(),
                ))
            }
        }
    }
}