wayclip-daemon 0.2.0

Recording and management of Wayclip daemon
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

use chrono::Utc;
use tokio::sync::mpsc;
use tokio_util::sync::CancellationToken;
use wayclip_core::{models::error::WayclipError, settings::UserSettings};

use crate::{
    common::misc::discord::{DiscordPresenceManager, DiscordPresenceState},
    linux::{
        ipc::commands::IpcCommand,
        services::{discovery::Discovery, keybinds::KeybindsService, tray::TrayManager},
        session::CurrentSession,
    },
};

pub mod discovery;
pub mod keybinds;
pub mod tray;

pub struct DaemonServices {
    pub discovery: Option<Discovery>,
    discord: Option<DiscordPresenceManager>,
    keybinds: KeybindsService,
    tray: TrayManager,
}

impl DaemonServices {
    pub fn new(
        user_settings: &UserSettings,
        cancel_token: CancellationToken,
    ) -> Result<Self, WayclipError> {
        let discovery = match user_settings.game_discovery.enabled {
            true => Some(Discovery::new()?),
            false => None,
        };

        let discord = match user_settings.game_discovery.discord_rich_presence.enabled {
            true => {
                let state = if let Some(custom) = user_settings
                    .game_discovery
                    .discord_rich_presence
                    .custom
                    .clone()
                {
                    DiscordPresenceState::Custom(custom.into())
                } else {
                    DiscordPresenceState::Default
                };

                Some(DiscordPresenceManager::new(state))
            }
            false => None,
        };

        Ok(Self {
            discord,
            discovery,
            tray: TrayManager::new(user_settings.tray.clone(), cancel_token.clone()),
            keybinds: KeybindsService::new(user_settings)?,
        })
    }

    pub fn update(&mut self, current_session: &mut CurrentSession) -> Result<(), WayclipError> {
        if let Some(ref mut disc) = self.discovery {
            if let Some(new_game) = disc.poll_changed() {
                log::info!("Game changed to: {:?}", new_game.as_ref().map(|g| &g.name));
                current_session.tick(new_game, None);
                if let Some(ref d) = self.discord {
                    d.set_recording(current_session.clone());
                }
            }
        }

        // if user saved clip, the status would've updated, but it is not changed back unless a game
        // has changed. now, we make sure to update status once last clip was more than 3 min ago
        if let Some(ref last) = current_session.last_clip
            && last
                .timestamp
                .signed_duration_since(Utc::now())
                .num_minutes()
                >= 3
        {
            if let Some(ref d) = self.discord {
                d.set_recording(current_session.clone());
            }
        }
        Ok(())
    }

    pub fn saving(&mut self, current_session: CurrentSession) -> Result<(), WayclipError> {
        if let Some(ref d) = self.discord {
            d.set_saving(current_session);
        }

        Ok(())
    }

    pub fn start_services(
        &mut self,
        user_settings: &UserSettings,
        command_sender: &mpsc::Sender<IpcCommand>,
        current_session: &mut CurrentSession,
    ) -> Result<(), WayclipError> {
        self.tray.start(command_sender);
        self.keybinds
            .setup_keybinds(user_settings, command_sender)?;
        // active it once, so even if no game is playing, discord status shows up
        if let Some(ref d) = self.discord {
            d.set_recording(current_session.clone());
        }
        Ok(())
    }

    pub async fn stop_services(&mut self) -> Result<(), WayclipError> {
        self.tray.stop().await;
        self.keybinds.stop()
    }
}