game-scanner 1.1.0

Game Scanner for any launcher and OS
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
139
140
141
142
143
144
145
146
147

use std::path::{Path, PathBuf};

use crate::{
    error::{Error, ErrorKind, Result},
    prelude::{Game, GameCommands, GameState, GameType},
};

#[derive(Default)]
struct Manifest {
    id: String,
    dipinstallpath: String,
    previousstate: String,
    currentstate: String,
    downloading: bool,
    paused: bool,
    totaldownloadbytes: u64,
    totalbytes: u64,
    savedbytes: u64,
}

pub fn read(file: &Path, launcher_executable: &Path) -> Result<Game> {
    let manifest_data = std::fs::read_to_string(&file).map_err(|error| {
        Error::new(
            ErrorKind::InvalidManifest,
            format!(
                "Invalid Origin manifest: {} {}",
                file.display().to_string(),
                error.to_string()
            ),
        )
    })?;

    let manifest = String::from("http://localhost/") + &manifest_data;

    let manifest_url = url::Url::parse(&manifest).map_err(|error| {
        Error::new(
            ErrorKind::InvalidManifest,
            format!(
                "Error on read the Origin manifest: {} {}",
                file.display().to_string(),
                error.to_string()
            ),
        )
    })?;

    let manifest_entries = manifest_url
        .query_pairs()
        .map(|(attr, value)| (attr.to_string(), value.to_string()))
        .collect::<Vec<_>>();

    let mut manifest = Manifest::default();

    for (attr, value) in manifest_entries {
        match attr.as_str() {
            "id" => {
                manifest.id = value;
            }
            "dipinstallpath" => {
                manifest.dipinstallpath =
                    make_dip_install_path(&value).map_or(String::new(), |value| value);
            }
            "currentstate" => {
                manifest.currentstate = value;
            }
            "previousstate" => {
                manifest.previousstate = value;
            }
            "totaldownloadbytes" => {
                manifest.totaldownloadbytes = value.parse::<u64>().unwrap();
            }
            "totalbytes" => {
                manifest.totalbytes = value.parse::<u64>().unwrap();
            }
            "savedbytes" => {
                manifest.savedbytes = value.parse::<u64>().unwrap();
            }
            "downloading" => {
                if value == "1" {
                    manifest.downloading = true;
                } else {
                    manifest.downloading = false;
                }
            }
            "paused" => {
                if value == "1" {
                    manifest.paused = true;
                } else {
                    manifest.paused = false;
                }
            }
            _ => {}
        }
    }

    let name = get_game_name(file)
        .or(Some(String::from("Unknown")))
        .unwrap();

    return Ok(Game {
        _type: GameType::Origin.to_string(),
        id: manifest.id.clone(),
        name,
        path: Some(PathBuf::from(manifest.dipinstallpath)),
        commands: GameCommands {
            install: Some(vec![
                launcher_executable.display().to_string(),
                format!("origin2://game/download?offerId={}", &manifest.id),
            ]),
            launch: Some(vec![
                launcher_executable.display().to_string(),
                format!("origin2://game/launch?offerIds={}", &manifest.id),
            ]),
            uninstall: None,
        },
        state: GameState {
            installed: true,
            needs_update: (manifest.currentstate == "kTransferring"
                || manifest.currentstate == "kEnqueued"),
            downloading: manifest.currentstate == "kTransferring",
            total_bytes: Some(manifest.totalbytes),
            received_bytes: Some(manifest.savedbytes),
        },
    });
}

fn make_dip_install_path(value: &String) -> Option<String> {
    let separator = std::path::MAIN_SEPARATOR.to_string();

    return Option::from(value.clone())
        .map(|path| path.replace("%5c", &separator))
        .map(|path| path.replace("%5C", &separator))
        .map(|path| path.replace("%2f", &separator))
        .map(|path| path.replace("%2F", &separator))
        .map(|path| path.replace("%3a", ":"))
        .map(|path| path.replace("%3A", ":"))
        .map(|path| path.replace("%20", " "))
        .map(PathBuf::from)
        .map(|path| path.display().to_string());
}

fn get_game_name(file: &Path) -> Option<String> {
    return file
        .parent()
        .and_then(|path| path.file_name())
        .and_then(|path| path.to_str())
        .map(|path| path.to_string());
}