gpapi 1.0.0

A library for interacting with the Google Play API
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

use std::collections::HashMap;
use std::fs::{self, File};
use std::io::Write;
use std::path::Path;

use configparser::ini::Ini;
use protobuf::{RepeatedField, SingularField, SingularPtrField};

use googleplay_protobuf::{AndroidBuildProto, AndroidCheckinProto, DeviceConfigurationProto};

fn main() {
    if !Path::new("src/device_properties.bin").exists()
        || !Path::new("src/android_checkins.bin").exists()
    {
        let mut config = Ini::new();
        config
            .read(fs::read_to_string("device.properties").unwrap())
            .unwrap();

        let mut device_configurations = HashMap::new();
        let mut android_checkins = HashMap::new();
        for section in config.sections() {
            let mut android_build = AndroidBuildProto::new();
            android_build.id = SingularField::from(config.get(&section, "Build.FINGERPRINT"));
            android_build.product = SingularField::from(config.get(&section, "Build.HARDWARE"));
            android_build.carrier = SingularField::from(config.get(&section, "Build.BRAND"));
            android_build.radio = SingularField::from(config.get(&section, "Build.RADIO"));
            android_build.bootloader =
                SingularField::from(config.get(&section, "Build.BOOTLOADER"));
            android_build.device = SingularField::from(config.get(&section, "Build.DEVICE"));
            android_build.sdkVersion = config
                .getint(&section, "Build.VERSION.SDK_INT")
                .unwrap()
                .map(|v| v as i32);
            android_build.model = SingularField::from(config.get(&section, "Build.MODEL"));
            android_build.manufacturer =
                SingularField::from(config.get(&section, "Build.MANUFACTURER"));
            android_build.buildProduct = SingularField::from(config.get(&section, "Build.PRODUCT"));
            android_build.client = SingularField::from(config.get(&section, "Client"));
            android_build.otaInstalled = Some(false);
            android_build.googleServices = config
                .getint(&section, "GSF.version")
                .unwrap()
                .map(|v| v as i32);
            let mut android_checkin = AndroidCheckinProto::new();
            android_checkin.build = SingularPtrField::from(Some(android_build));
            android_checkin.lastCheckinMsec = Some(0);
            android_checkin.cellOperator =
                SingularField::from(config.get(&section, "CellOperator"));
            android_checkin.simOperator = SingularField::from(config.get(&section, "SimOperator"));
            android_checkin.roaming = SingularField::from(config.get(&section, "Roaming"));
            android_checkin.userNumber = Some(0);
            android_checkins.insert(section.clone(), android_checkin);

            let mut device_configuration = DeviceConfigurationProto::new();
            device_configuration.touchScreen = config
                .getint(&section, "TouchScreen")
                .unwrap()
                .map(|v| v as i32);
            device_configuration.keyboard = config
                .getint(&section, "Keyboard")
                .unwrap()
                .map(|v| v as i32);
            device_configuration.navigation = config
                .getint(&section, "Navigation")
                .unwrap()
                .map(|v| v as i32);
            device_configuration.screenLayout = config
                .getint(&section, "ScreenLayout")
                .unwrap()
                .map(|v| v as i32);
            device_configuration.hasHardKeyboard =
                config.getbool(&section, "HasHardKeyboard").unwrap();
            device_configuration.hasFiveWayNavigation =
                config.getbool(&section, "HasFiveWayNavigation").unwrap();
            device_configuration.screenDensity = config
                .getint(&section, "Screen.Density")
                .unwrap()
                .map(|v| v as i32);
            device_configuration.glEsVersion = config
                .getint(&section, "GL.Version")
                .unwrap()
                .map(|v| v as i32);
            device_configuration.systemSharedLibrary = RepeatedField::from_vec(
                config
                    .get(&section, "SharedLibraries")
                    .unwrap()
                    .split(",")
                    .map(|s| String::from(s))
                    .collect(),
            );
            device_configuration.systemAvailableFeature = RepeatedField::from_vec(
                config
                    .get(&section, "Features")
                    .unwrap()
                    .split(",")
                    .map(|s| String::from(s))
                    .collect(),
            );
            device_configuration.nativePlatform = RepeatedField::from_vec(
                config
                    .get(&section, "Platforms")
                    .unwrap()
                    .split(",")
                    .map(|s| String::from(s))
                    .collect(),
            );
            device_configuration.screenWidth = config
                .getint(&section, "Screen.Width")
                .unwrap()
                .map(|v| v as i32);
            device_configuration.systemSupportedLocale = RepeatedField::from_vec(
                config
                    .get(&section, "Locales")
                    .unwrap()
                    .split(",")
                    .map(|s| String::from(s))
                    .collect(),
            );
            device_configuration.glExtension = RepeatedField::from_vec(
                config
                    .get(&section, "GL.Extensions")
                    .unwrap()
                    .split(",")
                    .map(|s| String::from(s))
                    .collect(),
            );
            device_configurations.insert(section, device_configuration);
        }
        let devices_encoded: Vec<u8> = bincode::serialize(&device_configurations).unwrap();
        let mut file = File::create("src/device_properties.bin").unwrap();
        file.write_all(&devices_encoded).unwrap();

        let checkins_encoded: Vec<u8> = bincode::serialize(&android_checkins).unwrap();
        let mut file = File::create("src/android_checkins.bin").unwrap();
        file.write_all(&checkins_encoded).unwrap();
    }
}