mediapulse 0.1.3

A self-contained native media player built around mpv
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

// Tauri's generated command wrapper only implements `CommandArg` for owned
// managed state and window handles, so these public boundary signatures are
// intentionally values even when the command body only reads from them.
#![allow(clippy::needless_pass_by_value)]

use mediapulse_core::backend::{
    BackendError, BackendKind, PlaybackCommand, PlaybackSnapshot, PropertyUpdate, PropertyValue,
};
use serde::Serialize;
use tauri::{State, WebviewWindow};

use crate::state::AppState;

#[derive(Debug, Clone, Serialize)]
pub struct IpcError {
    pub code: String,
    pub message: String,
}

impl From<BackendError> for IpcError {
    fn from(error: BackendError) -> Self {
        let code = match error {
            BackendError::NotReady => "notReady",
            BackendError::Unsupported { .. } => "unsupported",
            BackendError::InvalidProperty { .. } => "invalidProperty",
            BackendError::Io { .. } => "io",
            BackendError::Timeout { .. } => "timeout",
            BackendError::Protocol { .. } => "protocol",
            BackendError::Engine { .. } => "engine",
        }
        .to_string();
        Self {
            code,
            message: error.to_string(),
        }
    }
}

#[tauri::command]
pub fn backend_kind(state: State<'_, AppState>) -> BackendKind {
    state.backend_kind()
}

#[tauri::command]
pub fn playback_snapshot(state: State<'_, AppState>) -> Result<PlaybackSnapshot, IpcError> {
    state.snapshot().map_err(IpcError::from)
}

#[tauri::command]
pub fn load_media(source: &str, state: State<'_, AppState>) -> Result<(), IpcError> {
    state.load(source).map_err(IpcError::from)
}

#[tauri::command]
pub fn playback_command(
    command: PlaybackCommand,
    state: State<'_, AppState>,
) -> Result<(), IpcError> {
    state.command(command).map_err(IpcError::from)
}

#[tauri::command]
pub fn set_playback_property(
    update: PropertyUpdate,
    state: State<'_, AppState>,
) -> Result<(), IpcError> {
    state.set_property(update).map_err(IpcError::from)
}

#[tauri::command]
pub fn get_playback_property(
    name: &str,
    state: State<'_, AppState>,
) -> Result<PropertyValue, IpcError> {
    state.get_property(name).map_err(IpcError::from)
}

#[tauri::command]
pub fn set_window_fullscreen(window: WebviewWindow, enabled: bool) -> Result<(), IpcError> {
    window
        .set_fullscreen(enabled)
        .map_err(|error| window_error(&error))
}

#[tauri::command]
pub fn minimize_window(window: WebviewWindow) -> Result<(), IpcError> {
    window.minimize().map_err(|error| window_error(&error))
}

#[tauri::command]
pub fn toggle_maximize_window(window: WebviewWindow) -> Result<(), IpcError> {
    if window
        .is_maximized()
        .map_err(|error| window_error(&error))?
    {
        window.unmaximize().map_err(|error| window_error(&error))
    } else {
        window.maximize().map_err(|error| window_error(&error))
    }
}

#[tauri::command]
pub fn close_window(window: WebviewWindow) -> Result<(), IpcError> {
    window.close().map_err(|error| window_error(&error))
}

fn window_error(error: &tauri::Error) -> IpcError {
    IpcError {
        code: "window".to_string(),
        message: error.to_string(),
    }
}