retrom-plugin-steam 0.7.14

Retrom plugin to facilitate steam apps integration.
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

use std::collections::HashSet;

use notify::{EventKind, Watcher};
use tauri::{
    plugin::{Builder, TauriPlugin},
    Emitter, Manager, Runtime,
};

mod commands;
mod desktop;
mod error;

pub use error::{Error, Result};

use desktop::Steam;
use tracing::instrument;

/// Extensions to [`tauri::App`], [`tauri::AppHandle`] and [`tauri::Window`] to access the steam APIs.
pub trait SteamExt<R: Runtime> {
    fn steam(&self) -> &Steam<R>;
}

impl<R: Runtime, T: Manager<R>> crate::SteamExt<R> for T {
    fn steam(&self) -> &Steam<R> {
        self.state::<Steam<R>>().inner()
    }
}

/// Initializes the plugin.
#[instrument(skip_all)]
pub fn init<R: Runtime>() -> TauriPlugin<R> {
    Builder::new("steam")
        .invoke_handler(tauri::generate_handler![])
        .setup(|app, api| {
            let steam = match desktop::init(app, api) {
                Ok(steam) => steam,
                Err(e) => {
                    tracing::warn!(
                        "Failed to initialize steam plugin, is steam installed: {:?}",
                        e
                    );
                    return Ok(());
                }
            };

            let handle = app.app_handle().clone();
            std::thread::spawn(move || {
                let steam = match steamlocate::SteamDir::locate() {
                    Ok(steam) => steam,
                    Err(e) => {
                        tracing::debug!("Could not locate steam directory: {:?}", e);
                        return;
                    }
                };

                let libraries = steam.library_paths().unwrap_or_default();

                let mut apps_installed = match steam.libraries() {
                    Ok(libraries) => libraries
                        .filter_map(std::result::Result::ok)
                        .flat_map(|lib| lib.app_ids().to_vec())
                        .collect::<HashSet<_>>(),

                    Err(e) => {
                        tracing::debug!("Could not get steam libraries: {:?}", e);
                        return;
                    }
                };

                let (tx, rx) = std::sync::mpsc::channel::<notify::Result<notify::Event>>();

                let mut watchers = vec![];
                for lib in libraries.iter() {
                    let tx = tx.clone();
                    let mut watcher = match notify::recommended_watcher(tx) {
                        Ok(watcher) => watcher,
                        Err(e) => {
                            tracing::warn!("Error creating watcher: {:?}", e);
                            continue;
                        }
                    };

                    if let Err(why) = watcher.watch(lib.as_path(), notify::RecursiveMode::Recursive)
                    {
                        tracing::warn!("Error watching directory: {:?}", why);
                        continue;
                    }

                    watchers.push(watcher);
                }

                for res in rx {
                    match res {
                        Ok(event) => match event.kind {
                            EventKind::Create(_) | EventKind::Remove(_) => {
                                let libraries = match steam.libraries() {
                                    Ok(libraries) => libraries,
                                    Err(e) => {
                                        tracing::warn!("Could not get steam libraries: {:?}", e);
                                        continue;
                                    }
                                };

                                let app_ids = libraries
                                    .filter_map(std::result::Result::ok)
                                    .flat_map(|lib| lib.app_ids().to_vec())
                                    .collect::<HashSet<_>>();

                                let newly_installed = app_ids.difference(&apps_installed);
                                let newly_uninstalled = apps_installed.difference(&app_ids);

                                if newly_installed.count() > 0 {
                                    if let Err(why) = handle.emit("steam-game-installed", ()) {
                                        tracing::error!("Error emitting event: {:?}", why);
                                    }
                                }

                                if newly_uninstalled.count() > 0 {
                                    if let Err(why) = handle.emit("steam-game-uninstalled", ()) {
                                        tracing::error!("Error emitting event: {:?}", why);
                                    }
                                }

                                apps_installed = app_ids;
                            }
                            _ => {}
                        },
                        Err(e) => {
                            tracing::error!("watch error: {:?}", e);
                        }
                    }
                }
            });

            app.manage(steam);
            Ok(())
        })
        .build()
}