cargo-mobile2 0.22.4

Rust on mobile made easy!
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

mod device_list;
mod run;

pub use self::{device_list::*, run::*};

use serde::Deserialize;
use std::path::PathBuf;

#[derive(Clone, Debug, Deserialize)]
struct DeviceInfo {
    #[serde(rename = "DeviceIdentifier")]
    device_identifier: String,
    #[serde(rename = "DeviceName")]
    device_name: String,
    #[serde(rename = "modelArch")]
    model_arch: String,
    #[serde(rename = "modelName")]
    model_name: String,
}

#[derive(Debug, Deserialize)]
#[serde(tag = "Event")]
enum Event {
    #[serde(rename_all = "PascalCase")]
    #[allow(dead_code)]
    BundleCopy {
        percent: u32,
        overall_percent: u32,
        path: PathBuf,
    },
    #[serde(rename_all = "PascalCase")]
    #[allow(dead_code)]
    BundleInstall {
        percent: u32,
        overall_percent: u32,
        status: String,
    },
    #[serde(rename_all = "PascalCase")]
    DeviceDetected { device: DeviceInfo },
    #[serde(rename_all = "PascalCase")]
    #[allow(dead_code)]
    Error { code: u32, status: String },
    #[serde(other)]
    Unknown,
}

impl Event {
    fn parse_list(s: &str) -> Vec<Self> {
        fn parse_and_push(s: &str, docs: &mut Vec<Event>) {
            if !s.is_empty() {
                match serde_json::from_str(s) {
                    Ok(event) => {
                        log::debug!("parsed `ios-deploy` event: {:#?}", event);
                        docs.push(event)
                    }
                    Err(err) => {
                        log::error!(
                            "failed to parse `ios-deploy` event: {}\nraw event text:\n{}",
                            err,
                            s
                        );
                    }
                }
            }
        }

        let (mut docs, prev_index) =
            s.match_indices("}{")
                .fold((Vec::new(), 0), |(mut docs, prev_index), (index, _)| {
                    let end = index + 1;
                    parse_and_push(&s[prev_index..end], &mut docs);
                    (docs, end)
                });
        parse_and_push(&s[prev_index..], &mut docs);
        docs
    }

    fn device_info(&self) -> Option<&DeviceInfo> {
        if let Self::DeviceDetected { device } = self {
            Some(device)
        } else {
            None
        }
    }
}