ferrosonic 0.2.1

A terminal-based Subsonic music client with bit-perfect audio playback
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

use crossterm::event::{self, KeyCode};

use crate::app::models::SongOption;
use crate::error::Error;

use super::*;

impl App {
    pub(super) async fn handle_songs_key(&mut self, key: event::KeyEvent) -> Result<(), Error> {
        let mut state = self.state.write().await;
        match key.code {
            KeyCode::Up | KeyCode::Char('k') => match state.songs.focus {
                0 => {
                    match state.songs.selected_option {
                        Some(SongOption::Starred) => {}
                        Some(SongOption::Random) => {
                            state.songs.selected_option = Some(SongOption::Starred);
                            state.songs.scroll_offset = 0;
                            drop(state);
                            self.get_starred_songs().await;
                        }
                        None => {}
                    };
                }
                1 => {
                    if let Some(sel) = state.songs.selected_index {
                        if sel > 0 {
                            state.songs.selected_index = Some(sel - 1);
                        }
                    } else if !state.songs.songs.is_empty() {
                        state.songs.selected_index = Some(0);
                    }
                }
                _ => {}
            },
            KeyCode::Down | KeyCode::Char('j') => match state.songs.focus {
                0 => {
                    match state.songs.selected_option {
                        Some(SongOption::Starred) => {
                            state.songs.selected_option = Some(SongOption::Random);
                            state.songs.scroll_offset = 0;
                            drop(state);
                            self.get_random_songs().await;
                        }
                        Some(SongOption::Random) => {}
                        None => {}
                    };
                }
                1 => {
                    let max = state.songs.songs.len().saturating_sub(1);
                    if let Some(sel) = state.songs.selected_index {
                        if sel < max {
                            state.songs.selected_index = Some(sel + 1);
                        }
                    } else if !state.songs.songs.is_empty() {
                        state.songs.selected_index = Some(0);
                    }
                }
                _ => {}
            },
            KeyCode::Enter => {
                let selected_song = state
                    .songs
                    .selected_index
                    .filter(|&idx| idx < state.songs.songs.len());

                let Some(selected_song) = selected_song else {
                    return Ok(());
                };

                state.queue.clear();
                let songs = state.songs.songs.clone();
                state.queue.extend(songs);

                drop(state);

                return self.play_queue_position(selected_song).await;
            }
            KeyCode::Tab => state.songs.focus = if state.songs.focus == 1 { 0 } else { 1 },
            KeyCode::Char('f') => {
                if state.songs.focus == 1 {
                    let selected_song_idx = state
                        .songs
                        .selected_index
                        .filter(|&idx| idx < state.songs.songs.len());

                    let Some(selected_song_idx) = selected_song_idx else {
                        return Ok(());
                    };

                    let song = &mut state.songs.songs[selected_song_idx];
                    let id = song.id.clone();
                    let was_starred = song.starred.is_some();

                    if song.starred.is_some() {
                        song.starred = None;
                    } else {
                        song.starred = Some("starred".to_string());
                    }

                    let refresh_needed = state.songs.selected_option == Some(SongOption::Starred);
                    drop(state);

                    if was_starred {
                        self.unstar_song(id).await;
                    } else {
                        self.star_song(id).await;
                    }

                    if refresh_needed {
                        self.get_starred_songs().await;
                    }
                }
            }
            _ => {}
        }

        return Ok(());
    }
}