idevice 0.1.59

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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Condition inducer service - Simulate network/thermal conditions on the device

use plist::Value;

use super::message::AuxValue;
use super::remote_server::{Channel, RemoteServerClient};
use crate::{IdeviceError, ReadWrite, obf};

/// A condition inducer group with a list of profiles
#[derive(Debug, Clone)]
pub struct ConditionInducerGroup {
    pub identifier: String,
    pub profiles: Vec<ConditionProfile>,
}

/// A specific condition profile that can be enabled
#[derive(Debug, Clone)]
pub struct ConditionProfile {
    pub identifier: String,
    pub description: String,
}

/// Client for inducing network/thermal conditions
#[derive(Debug)]
pub struct ConditionInducerClient<'a, R: ReadWrite> {
    channel: Channel<'a, R>,
}

impl<'a, R: ReadWrite> ConditionInducerClient<'a, R> {
    pub async fn new(client: &'a mut RemoteServerClient<R>) -> Result<Self, IdeviceError> {
        let channel = client
            .make_channel(obf!(
                "com.apple.instruments.server.services.ConditionInducer"
            ))
            .await?;
        Ok(Self { channel })
    }

    /// Returns available condition inducers grouped by category
    pub async fn available_conditions(
        &mut self,
    ) -> Result<Vec<ConditionInducerGroup>, IdeviceError> {
        self.channel
            .call_method(
                Some(Value::String("availableConditionInducers".into())),
                None,
                true,
            )
            .await?;
        let msg = self.channel.read_message().await?;
        let data = msg
            .data
            .ok_or_else(|| IdeviceError::UnexpectedResponse("expected array".into()))?;
        let arr = data
            .into_array()
            .ok_or_else(|| IdeviceError::UnexpectedResponse("expected array".into()))?;

        let mut groups = Vec::new();
        for item in arr {
            if let Some(dict) = item.into_dictionary() {
                let identifier = dict
                    .get("identifier")
                    .and_then(|v| v.as_string())
                    .unwrap_or("")
                    .to_string();
                let profiles = dict
                    .get("profiles")
                    .and_then(|v| v.as_array())
                    .cloned()
                    .unwrap_or_default()
                    .into_iter()
                    .filter_map(|p| {
                        let pd = p.into_dictionary()?;
                        Some(ConditionProfile {
                            identifier: pd
                                .get("identifier")
                                .and_then(|v| v.as_string())
                                .unwrap_or("")
                                .to_string(),
                            description: pd
                                .get("description")
                                .and_then(|v| v.as_string())
                                .unwrap_or("")
                                .to_string(),
                        })
                    })
                    .collect();
                groups.push(ConditionInducerGroup {
                    identifier,
                    profiles,
                });
            }
        }
        Ok(groups)
    }

    /// Enables a specific condition profile
    pub async fn enable_condition(
        &mut self,
        condition_identifier: &str,
        profile_identifier: &str,
    ) -> Result<(), IdeviceError> {
        self.channel
            .call_method(
                Some(Value::String(
                    "enableConditionWithIdentifier:profileIdentifier:".into(),
                )),
                Some(vec![
                    AuxValue::archived_value(Value::String(condition_identifier.to_string())),
                    AuxValue::archived_value(Value::String(profile_identifier.to_string())),
                ]),
                true,
            )
            .await?;
        // Consume reply
        self.channel.read_message().await?;
        Ok(())
    }

    /// Disables the currently active condition
    pub async fn disable_condition(&mut self) -> Result<(), IdeviceError> {
        self.channel
            .call_method(
                Some(Value::String("disableActiveCondition".into())),
                None,
                false,
            )
            .await
    }
}