djio 0.0.23

DJ Hardware Control(ler) Support
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

// SPDX-FileCopyrightText: The djio authors
// SPDX-License-Identifier: MPL-2.0

use crate::BoxedMidiController;

struct AttachedMidiController<T> {
    controller: BoxedMidiController<T>,
    controller_thread: Option<crate::ControllerThread>,
}

#[expect(missing_debug_implementations)]
#[derive(Default)]
pub struct SingleMidiControllerContext<T> {
    attached: Option<AttachedMidiController<T>>,
}

impl<T: crate::ControllerTypes> SingleMidiControllerContext<T> {
    #[must_use]
    pub fn attached_controller(&self) -> Option<&BoxedMidiController<T>> {
        Some(&self.attached.as_ref()?.controller)
    }

    pub fn attach_controller(
        &mut self,
        controller: BoxedMidiController<T>,
        controller_task: Option<crate::BoxedControllerTask>,
    ) {
        if let Some(detached_controller) = self.detach_controller() {
            log::warn!(
                "Detached existing MIDI controller {descriptor:?}",
                descriptor = detached_controller.device_descriptor()
            );
        }
        log::info!(
            "Attaching MIDI controller {descriptor:?}",
            descriptor = controller.device_descriptor()
        );
        let controller_thread = controller_task.map(crate::ControllerThread::spawn);
        self.attached = Some(AttachedMidiController {
            controller,
            controller_thread,
        });
    }

    pub fn detach_controller(&mut self) -> Option<BoxedMidiController<T>> {
        let AttachedMidiController {
            controller_thread,
            controller,
        } = self.attached.take()?;
        log::info!(
            "Detaching MIDI controller {descriptor:?}",
            descriptor = controller.device_descriptor()
        );
        if let Some(controller_thread) = controller_thread {
            log::debug!(
                "Aborting MIDI controller thread for {descriptor:?}",
                descriptor = controller.device_descriptor()
            );
            if let Err(err) = controller_thread.abort_and_join() {
                log::warn!(
                    "Unexpected error while detaching MIDI controller {descriptor:?}: {err}",
                    descriptor = controller.device_descriptor()
                );
            }
        }
        Some(controller)
    }

    #[must_use]
    pub fn map_input_event(
        &mut self,
        event: <T as crate::ControllerTypes>::InputEvent,
    ) -> Option<<T as crate::ControllerTypes>::ControlAction> {
        let Some(attached) = &mut self.attached else {
            log::debug!("Ignoring input {event:?}: No MIDI controller attached");
            return None;
        };
        attached.controller.map_input_event(event)
    }
}