playtron-core 1.0.0

Playtron GameOS core utilities for Rust
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

use std::fmt;

use zbus::Connection;

use crate::dbus::{
    sdk_manager_interface::SdkManagerInterfaceProxy,
    sdk_pact_interface::{SdkPactInterfaceProxy, SessionInfo},
};

#[derive(Debug, Clone, PartialEq)]
pub enum ManagerError {
    DbusConnectionFailed(zbus::Error),
    DbusMessageFailed(zbus::fdo::Error),
}

impl fmt::Display for ManagerError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ManagerError::DbusConnectionFailed(e) => write!(f, "D-Bus connection failed: {e}"),
            ManagerError::DbusMessageFailed(e) => write!(f, "D-Bus message failed: {e}"),
        }
    }
}

pub struct Manager {
    connection: Connection,
}

impl Manager {
    pub async fn new() -> Result<Self, ManagerError> {
        let connection = Connection::session()
            .await
            .map_err(ManagerError::DbusConnectionFailed)?;

        Ok(Manager { connection })
    }

    pub async fn is_playtron(&self) -> Result<bool, ManagerError> {
        let proxy = self.get_manager_proxy().await?;
        proxy
            .is_playtron()
            .await
            .map_err(ManagerError::DbusMessageFailed)
    }

    pub async fn is_keyboard_open(&self) -> Result<bool, ManagerError> {
        let proxy = self.get_manager_proxy().await?;
        proxy
            .is_keyboard_open()
            .await
            .map_err(ManagerError::DbusMessageFailed)
    }

    pub async fn show_keyboard(&self) -> Result<(), ManagerError> {
        let proxy = self.get_manager_proxy().await?;
        proxy
            .show_keyboard()
            .await
            .map_err(ManagerError::DbusMessageFailed)
    }

    pub async fn hide_keyboard(&self) -> Result<(), ManagerError> {
        let proxy = self.get_manager_proxy().await?;
        proxy
            .hide_keyboard()
            .await
            .map_err(ManagerError::DbusMessageFailed)
    }

    pub async fn open_browser(&self, url: String) -> Result<(), ManagerError> {
        let proxy = self.get_manager_proxy().await?;
        proxy
            .open_browser(url)
            .await
            .map_err(ManagerError::DbusMessageFailed)
    }

    pub async fn close_browser(&self) -> Result<(), ManagerError> {
        let proxy = self.get_manager_proxy().await?;
        proxy
            .close_browser()
            .await
            .map_err(ManagerError::DbusMessageFailed)
    }

    async fn get_manager_proxy(&self) -> Result<SdkManagerInterfaceProxy<'_>, ManagerError> {
        SdkManagerInterfaceProxy::builder(&self.connection)
            .build()
            .await
            .map_err(ManagerError::DbusConnectionFailed)
    }

    pub async fn create_pact_session(&self) -> Result<SessionInfo, ManagerError> {
        let proxy = self.get_pact_proxy().await?;
        proxy
            .create_session()
            .await
            .map_err(ManagerError::DbusMessageFailed)
    }

    pub async fn get_pact_quote(&self, nonce: Vec<u8>) -> Result<String, ManagerError> {
        let proxy = self.get_pact_proxy().await?;
        proxy
            .get_quote(nonce)
            .await
            .map_err(ManagerError::DbusMessageFailed)
    }

    async fn get_pact_proxy(&self) -> Result<SdkPactInterfaceProxy<'_>, ManagerError> {
        SdkPactInterfaceProxy::builder(&self.connection)
            .build()
            .await
            .map_err(ManagerError::DbusConnectionFailed)
    }
}