tauri-plugin-media 0.1.1

Advanced system media control integration plugin for Tauri applications with comprehensive playback controls, rich metadata support, and seamless native OS media interface integration across Windows, macOS, and Linux
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

use serde::de::DeserializeOwned;
use std::sync::{Arc, Mutex};
use tauri::{plugin::PluginApi, AppHandle, Runtime};

use crate::models::*;
use crate::platform;

pub fn init<R: Runtime, C: DeserializeOwned>(
    app: &AppHandle<R>,
    _api: PluginApi<R, C>,
) -> crate::Result<Media<R>> {
    let controller = platform::create_media_controller();
    Ok(Media {
        _app_handle: app.clone(),
        controller: Arc::new(Mutex::new(controller)),
    })
}

/// Access to the media APIs.
pub struct Media<R: Runtime> {
    _app_handle: AppHandle<R>,
    controller: Arc<Mutex<Box<dyn platform::MediaController + Send>>>,
}

impl<R: Runtime> Media<R> {
    pub fn initialize_session(&self, request: InitializeMediaSessionRequest) -> crate::Result<()> {
        let mut controller = self.controller.lock().unwrap();
        controller
            .initialize_session(request.app_id, request.app_name)
            .map_err(|e| crate::Error::String(e.to_string()))
    }

    pub fn set_metadata(&self, metadata: MediaMetadata) -> crate::Result<()> {
        let mut controller = self.controller.lock().unwrap();
        controller
            .set_metadata(metadata)
            .map_err(|e| crate::Error::String(e.to_string()))
    }

    pub fn set_playback_info(&self, info: PlaybackInfo) -> crate::Result<()> {
        let mut controller = self.controller.lock().unwrap();
        controller
            .set_playback_info(info)
            .map_err(|e| crate::Error::String(e.to_string()))
    }

    pub fn set_playback_status(&self, status: PlaybackStatus) -> crate::Result<()> {
        let mut controller = self.controller.lock().unwrap();
        controller
            .set_playback_status(status)
            .map_err(|e| crate::Error::String(e.to_string()))
    }

    pub fn set_position(&self, position: f64) -> crate::Result<()> {
        let mut controller = self.controller.lock().unwrap();
        controller
            .set_position(position)
            .map_err(|e| crate::Error::String(e.to_string()))
    }

    pub fn clear_metadata(&self) -> crate::Result<()> {
        let mut controller = self.controller.lock().unwrap();
        controller
            .clear_metadata()
            .map_err(|e| crate::Error::String(e.to_string()))
    }

    pub fn set_event_handler<F>(&self, handler: F)
    where
        F: Fn(MediaControlEvent) + Send + 'static,
    {
        let mut controller = self.controller.lock().unwrap();
        controller.set_event_handler(Box::new(handler));
    }

    pub fn get_metadata(&self) -> crate::Result<Option<MediaMetadata>> {
        let controller = self.controller.lock().unwrap();
        controller
            .get_metadata()
            .map_err(|e| crate::Error::String(e.to_string()))
    }

    pub fn get_playback_info(&self) -> crate::Result<Option<PlaybackInfo>> {
        let controller = self.controller.lock().unwrap();
        controller
            .get_playback_info()
            .map_err(|e| crate::Error::String(e.to_string()))
    }

    pub fn get_playback_status(&self) -> crate::Result<PlaybackStatus> {
        let controller = self.controller.lock().unwrap();
        controller
            .get_playback_status()
            .map_err(|e| crate::Error::String(e.to_string()))
    }

    pub fn get_position(&self) -> crate::Result<f64> {
        let controller = self.controller.lock().unwrap();
        controller
            .get_position()
            .map_err(|e| crate::Error::String(e.to_string()))
    }

    pub fn is_enabled(&self) -> crate::Result<bool> {
        let controller = self.controller.lock().unwrap();
        controller
            .is_enabled()
            .map_err(|e| crate::Error::String(e.to_string()))
    }
}