rtpmidi 0.4.4

A library for RTP-MIDI / AppleMIDI
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

use midi_types::MidiMessage;

use crate::participant::Participant;

pub(super) type MidiMessageListener = dyn Fn((MidiMessage, u32)) + Send + 'static;
pub(super) type SysExPacketListener = dyn for<'a> Fn(&'a [u8]) + Send + 'static;
pub(super) type ParticipantListener = dyn for<'a> Fn(&'a Participant) + Send + 'static;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum RtpMidiEventType {
    MidiMessage,
    SysExPacket,
    ParticipantJoined,
    ParticipantLeft,
}

pub struct EventListeners {
    midi_message: Vec<Box<MidiMessageListener>>,
    sysex_packet: Vec<Box<SysExPacketListener>>,
    participant_joined: Vec<Box<ParticipantListener>>,
    participant_left: Vec<Box<ParticipantListener>>,
}

pub struct MidiMessageEvent;
pub struct SysExPacketEvent;
pub struct ParticipantJoinedEvent;
pub struct ParticipantLeftEvent;

pub trait EventType {
    type Data<'a>;

    fn add_listener_to_storage<F>(listeners: &mut EventListeners, callback: F)
    where
        F: for<'a> Fn(Self::Data<'a>) + Send + 'static;
}

impl EventType for MidiMessageEvent {
    type Data<'a> = (MidiMessage, u32);

    fn add_listener_to_storage<F>(listeners: &mut EventListeners, callback: F)
    where
        F: for<'a> Fn(Self::Data<'a>) + Send + 'static,
    {
        listeners.midi_message.push(Box::new(callback));
    }
}

impl EventType for SysExPacketEvent {
    type Data<'a> = &'a [u8];

    fn add_listener_to_storage<F>(listeners: &mut EventListeners, callback: F)
    where
        F: for<'a> Fn(Self::Data<'a>) + Send + 'static,
    {
        listeners.sysex_packet.push(Box::new(callback));
    }
}

impl EventType for ParticipantJoinedEvent {
    type Data<'a> = &'a Participant;

    fn add_listener_to_storage<F>(listeners: &mut EventListeners, callback: F)
    where
        F: for<'a> Fn(Self::Data<'a>) + Send + 'static,
    {
        listeners.participant_joined.push(Box::new(callback));
    }
}

impl EventType for ParticipantLeftEvent {
    type Data<'a> = &'a Participant;

    fn add_listener_to_storage<F>(listeners: &mut EventListeners, callback: F)
    where
        F: for<'a> Fn(Self::Data<'a>) + Send + 'static,
    {
        listeners.participant_left.push(Box::new(callback));
    }
}

impl Default for EventListeners {
    fn default() -> Self {
        Self::new()
    }
}

impl EventListeners {
    pub fn new() -> Self {
        Self {
            midi_message: Vec::new(),
            sysex_packet: Vec::new(),
            participant_joined: Vec::new(),
            participant_left: Vec::new(),
        }
    }

    pub fn notify_midi_message(&self, message: MidiMessage, delta_time: u32) {
        for listener in &self.midi_message {
            listener((message, delta_time));
        }
    }

    pub fn notify_sysex_packet(&self, bytes: &[u8]) {
        for listener in &self.sysex_packet {
            listener(bytes);
        }
    }

    pub fn notify_participant_joined(&self, participant: &Participant) {
        for listener in &self.participant_joined {
            listener(participant);
        }
    }

    pub fn notify_participant_left(&self, participant: &Participant) {
        for listener in &self.participant_left {
            listener(participant);
        }
    }
}