app-tauri-plugin-player 0.2.0

Player plugin
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

# Tauri Plugin Player

A Tauri plugin that provides media player control functionality for desktop and mobile platforms (Android, with iOS planned).

## Features

- **Player State Management**: Update and manage player state including playback status, position, seek, volume, and playlists
- **Media Event Channel**: Receive media control events (play/pause, next/previous track) from native platform integrations
- **Cross-Platform Support**: Works on desktop (stub implementation) and Android (full native integration)
- **Type-Safe API**: Fully typed Rust and Kotlin APIs with serde serialization

## Architecture

### Rust Core (`src/`)

- **`lib.rs`**: Plugin initialization and registration with Tauri
- **`commands.rs`**: Tauri command handlers (`update_state`)
- **`models.rs`**: Shared data models (`Track`, `Playlist`, `UpdateState`, `MediaEvent`, etc.)
- **`error.rs`**: Error types and result handling
- **`desktop.rs`**: Desktop platform implementation (stub)
- **`mobile.rs`**: Mobile platform implementation (delegates to native code)

### Android Implementation (`android/`)

- **`PlayerPlugin.kt`**: Tauri plugin interface with commands:
    - `initChannel`: Initialize event channel for media events
    - `updateState`: Update player state from frontend
- **`Player.kt`**: Player implementation with state management and event emission

## Data Models

### Track

```rust
pub struct Track {
    pub id: String,
    pub number: u32,
    pub title: String,
    pub album: String,
    pub album_cover: Option<String>,
    pub artist: String,
    pub artist_cover: Option<String>,
    pub duration: f64,
}
```

### Playlist

```rust
pub struct Playlist {
    pub tracks: Vec<Track>,
}
```

### UpdateState

```rust
pub struct UpdateState {
    pub playing: Option<bool>,
    pub position: Option<u16>,
    pub seek: Option<f64>,
    pub volume: Option<f64>,
    pub playlist: Option<Playlist>,
}
```

### MediaEvent

```rust
pub struct MediaEvent {
    pub play: Option<bool>,
    pub next_track: Option<bool>,
    pub prev_track: Option<bool>,
}
```

### InitChannel

```rust
pub struct InitChannel {
    pub channel: Channel,
}
```

## Usage

### Setup

Add the plugin to your Tauri application in `src-tauri/src/main.rs`:

```rust
fn main() {
    tauri::Builder::default()
        .plugin(app_tauri_plugin_player::init())
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}
```

### Rust API

Access the player from any Tauri context:

```rust
use app_tauri_plugin_player::PlayerExt;

fn example<R: Runtime>(app: &AppHandle<R>) {
    let player = app.player();
    // Use player methods
}
```

Primary methods on `Player`:

- `update_state(payload: UpdateState) -> Result<StateResponse>`: Updates playback state, position, seek, volume, and playlist
- `init_channel(payload: InitChannel) -> Result<InitChannelResponse>`: Initializes the media event channel for native play/pause/next/previous events

### Command API

The plugin exposes the following Tauri command:

- `update_state`: Update player state from the frontend

## Dependencies

- `tauri`: ^2.0.0
- `serde`: Serialization framework
- `thiserror`: Error handling

## Platform Support

- **Desktop** (Windows, macOS, Linux): Stub implementation (methods return empty responses)
- **Android**: Full native implementation with media session integration
- **iOS**: Planned (native bindings defined but not implemented)

## Development

### Building

```bash
cargo build
```

### Android

The Android implementation is located in `android/` and follows standard Tauri plugin conventions for mobile platforms.

## Package Information

- **Name**: `app-tauri-plugin-player`
- **Version**: 0.1.4
- **Description**: Player plugin
- **License**: See workspace license

## Notes

- The desktop implementation currently provides stub methods that return empty responses
- The iOS implementation structure exists but is not yet fully implemented
- The JavaScript/TypeScript guest bindings (`guest-js/`) are not currently included in the repository