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

use std::sync::Arc;

use music_player_playback::player::{Player, PlayerEngine};
use tokio::sync::Mutex;

use crate::{
    api::v1alpha1::{
        playback_service_server::PlaybackService, GetCurrentlyPlayingSongRequest,
        GetCurrentlyPlayingSongResponse, GetPlaybackStateRequest, GetPlaybackStateResponse,
        GetTimePositionRequest, GetTimePositionResponse, NextRequest, NextResponse, PauseRequest,
        PauseResponse, PlayRequest, PlayResponse, PreviousRequest, PreviousResponse, SeekRequest,
        SeekResponse, StopRequest, StopResponse,
    },
    metadata::v1alpha1::{Album, Artist, Track},
};

pub struct Playback {
    player: Arc<Mutex<Player>>,
}

impl Playback {
    pub fn new(player: Arc<Mutex<Player>>) -> Self {
        Self { player }
    }
}

#[tonic::async_trait]
impl PlaybackService for Playback {
    async fn get_currently_playing_song(
        &self,
        _request: tonic::Request<GetCurrentlyPlayingSongRequest>,
    ) -> Result<tonic::Response<GetCurrentlyPlayingSongResponse>, tonic::Status> {
        let player = self.player.lock().await;
        let track = player.get_current_track().await;
        if track.is_none() {
            let response = GetCurrentlyPlayingSongResponse { track: None };
            return Ok(tonic::Response::new(response));
        }
        let track = track.unwrap();
        let response = GetCurrentlyPlayingSongResponse {
            track: Some(Track {
                id: track.id,
                title: track.title,
                uri: track.uri,
                disc_number: i32::try_from(track.track.unwrap_or(0)).unwrap(),
                artists: vec![Artist {
                    name: track.artist,
                    ..Default::default()
                }],
                album: Some(Album {
                    // id: track.album_id.unwrap(),
                    title: track.album,
                    year: i32::try_from(track.year.unwrap_or(0)).unwrap(),
                    ..Default::default()
                }),
                ..Default::default()
            }),
        };
        Ok(tonic::Response::new(response))
    }
    async fn get_playback_state(
        &self,
        _request: tonic::Request<GetPlaybackStateRequest>,
    ) -> Result<tonic::Response<GetPlaybackStateResponse>, tonic::Status> {
        let response = GetPlaybackStateResponse {};
        Ok(tonic::Response::new(response))
    }
    async fn get_time_position(
        &self,
        _request: tonic::Request<GetTimePositionRequest>,
    ) -> Result<tonic::Response<GetTimePositionResponse>, tonic::Status> {
        let response = GetTimePositionResponse {};
        Ok(tonic::Response::new(response))
    }
    async fn next(
        &self,
        _request: tonic::Request<NextRequest>,
    ) -> Result<tonic::Response<NextResponse>, tonic::Status> {
        self.player.lock().await.next();
        let response = NextResponse {};
        Ok(tonic::Response::new(response))
    }
    async fn previous(
        &self,
        _request: tonic::Request<PreviousRequest>,
    ) -> Result<tonic::Response<PreviousResponse>, tonic::Status> {
        self.player.lock().await.previous();
        let response = PreviousResponse {};
        Ok(tonic::Response::new(response))
    }
    async fn play(
        &self,
        _request: tonic::Request<PlayRequest>,
    ) -> Result<tonic::Response<PlayResponse>, tonic::Status> {
        self.player.lock().await.play();
        let response = PlayResponse {};
        Ok(tonic::Response::new(response))
    }
    async fn pause(
        &self,
        _request: tonic::Request<PauseRequest>,
    ) -> Result<tonic::Response<PauseResponse>, tonic::Status> {
        self.player.lock().await.pause();
        let response = PauseResponse {};
        Ok(tonic::Response::new(response))
    }
    async fn stop(
        &self,
        _request: tonic::Request<StopRequest>,
    ) -> Result<tonic::Response<StopResponse>, tonic::Status> {
        self.player.lock().await.stop();
        let response = StopResponse {};
        Ok(tonic::Response::new(response))
    }
    async fn seek(
        &self,
        _request: tonic::Request<SeekRequest>,
    ) -> Result<tonic::Response<SeekResponse>, tonic::Status> {
        self.player.lock().await.seek(12);
        let response = SeekResponse {};
        Ok(tonic::Response::new(response))
    }
}