termusic 0.13.2 

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

use std::{fmt::Debug, pin::Pin};

use anyhow::{Context, Result};
use futures_util::Stream;
use termusiclib::player::{PlayerProgress, StreamUpdates, UpdateEvents};
use tokio_stream::StreamExt;
use tuirealm::{
    Event,
    listener::{ListenerResult, PollAsync},
};

use crate::ui::{model::UserEvent, msg::Msg};

pub type WrappedStreamEvents = Pin<Box<dyn Stream<Item = Result<StreamUpdates>> + Send>>;

/// tuirealm async port to provide events that are not "common" in tuirealm.
pub struct PortStreamEvents(WrappedStreamEvents);

impl PortStreamEvents {
    pub fn new(stream_events: WrappedStreamEvents) -> Self {
        Self(stream_events)
    }
}

impl Debug for PortStreamEvents {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_tuple("PortStreamEvents")
            .field(&"<stream>")
            .finish()
    }
}

#[tuirealm::async_trait]
impl PollAsync<UserEvent> for PortStreamEvents {
    async fn poll(&mut self) -> ListenerResult<Option<Event<UserEvent>>> {
        match self.0.next().await {
            Some(ev) => {
                let ev = match ev
                    .map(UpdateEvents::try_from)
                    .context("Conversion from StreamUpdates to UpdateEvents failed!")
                {
                    Ok(v) => v,
                    Err(err) => {
                        error!("Failed to convert UpdateEvent: {err:#?}");
                        return Ok(None);
                    }
                };

                // dont log progress events, as that spams the log
                if log::log_enabled!(log::Level::Debug) && !is_progress(&ev) {
                    debug!("Stream Event: {ev:?}");
                }

                // just exit on first error, but still print it first
                let Ok(ev) = ev else {
                    return Ok(None);
                };
                Ok(Some(Event::User(UserEvent::Forward(Msg::StreamUpdate(ev)))))
            }
            None => Ok(None),
        }
    }
}

/// Determine if a given event is a [`UpdateEvents::Progress`].
fn is_progress(ev: &Result<UpdateEvents>) -> bool {
    if let Ok(ev) = ev {
        std::mem::discriminant(ev)
            == std::mem::discriminant(&UpdateEvents::Progress(PlayerProgress {
                position: None,
                total_duration: None,
            }))
    } else {
        false
    }
}