charcoal-client 0.1.1

Client library for Hearth: A LavaLink alternative with 30X Higher performance
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

//! Standard actions that can be called on a PlayerObject

use std::time::Duration;
use hearth_interconnect::errors::ErrorReport;
use hearth_interconnect::messages::Metadata;
use log::error;
use crate::background::processor::IPCData;
use crate::PlayerObject;
use tokio::time::sleep;

pub trait CharcoalEventHandler {
    fn handle_error(&self, report: ErrorReport);
    fn handle_metadata_response(&self, metadata: Metadata);
}

impl PlayerObject {
    /// Register an error callback that will be called if an error occurs on this PlayerObject
    pub async fn register_event_handler(
        &mut self,
        event_handler: impl CharcoalEventHandler + Send + 'static,
    ) {
        let mut t_rx = self.tx.subscribe();
        let guild_id = self.guild_id.clone();
        tokio::spawn(async move {
            loop {
                let x = t_rx.try_recv();
                match x {
                    Ok(d) => match d {
                        IPCData::ErrorReport(error_report) => {
                            if guild_id == error_report.guild_id {
                                event_handler.handle_error(error_report);
                            }
                        }
                        IPCData::MetadataResult(metadata) => {
                            if guild_id == metadata.guild_id {
                                event_handler.handle_metadata_response(metadata);
                            }
                        }
                        _ => {}
                    },
                    Err(e) => {
                        if e.to_string() != *"channel empty" {
                            error!("Failed to RECV with error: {:?}", e);
                        }
                    }
                }
                sleep(Duration::from_millis(250)).await; // Don't max out the CPU
            }
        });
    }
}