cranpose 0.1.145

Cranpose runtime and UI facade
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

use std::sync::Arc;

use cranpose_services::{
    HapticEffect, HapticFeedback, HapticPattern, Haptics, set_platform_haptics,
};
use objc2::{MainThreadMarker, MainThreadOnly};
use objc2_ui_kit::{
    UIImpactFeedbackGenerator, UIImpactFeedbackStyle, UINotificationFeedbackGenerator,
    UINotificationFeedbackType, UISelectionFeedbackGenerator,
};

pub(crate) fn register() {
    set_platform_haptics(Arc::new(IosHaptics));
}

struct IosHaptics;

impl Haptics for IosHaptics {
    fn perform(&self, feedback: HapticFeedback) {
        let Some(mtm) = MainThreadMarker::new() else {
            return;
        };
        match feedback {
            HapticFeedback::ImpactLight => impact(mtm, UIImpactFeedbackStyle::Light),
            HapticFeedback::ImpactMedium => impact(mtm, UIImpactFeedbackStyle::Medium),
            HapticFeedback::ImpactHeavy => impact(mtm, UIImpactFeedbackStyle::Heavy),
            HapticFeedback::Selection => {
                let generator = UISelectionFeedbackGenerator::new(mtm);
                generator.selectionChanged();
            }
            HapticFeedback::Success => notify(mtm, UINotificationFeedbackType::Success),
            HapticFeedback::Warning => notify(mtm, UINotificationFeedbackType::Warning),
            HapticFeedback::Error => notify(mtm, UINotificationFeedbackType::Error),
        }
    }

    fn vibrate(&self, _duration_ms: u32, amplitude: u8) {
        let Some(mtm) = MainThreadMarker::new() else {
            return;
        };
        #[allow(deprecated)]
        let generator = UIImpactFeedbackGenerator::initWithStyle(
            UIImpactFeedbackGenerator::alloc(mtm),
            UIImpactFeedbackStyle::Medium,
        );
        let intensity = f64::from(amplitude.max(1)) / 255.0;
        generator.impactOccurredWithIntensity(intensity);
    }

    fn play_pattern(&self, pattern: &HapticPattern) {
        let Some(mtm) = MainThreadMarker::new() else {
            return;
        };
        let Some(amplitude) = pattern
            .amplitudes()
            .iter()
            .copied()
            .find(|level| *level > 0)
            .or(Some(pattern.peak_amplitude()))
            .filter(|level| *level > 0)
        else {
            return;
        };
        let style = if amplitude >= 200 {
            UIImpactFeedbackStyle::Heavy
        } else if amplitude >= 110 {
            UIImpactFeedbackStyle::Medium
        } else {
            UIImpactFeedbackStyle::Light
        };
        impact(mtm, style);
    }

    fn perform_effect(&self, effect: HapticEffect) {
        self.perform(effect.closest_feedback());
    }

    fn cancel(&self) {}

    fn has_amplitude_control(&self) -> bool {
        true
    }
}

fn impact(mtm: MainThreadMarker, style: UIImpactFeedbackStyle) {
    #[allow(deprecated)]
    let generator =
        UIImpactFeedbackGenerator::initWithStyle(UIImpactFeedbackGenerator::alloc(mtm), style);
    generator.impactOccurred();
}

fn notify(mtm: MainThreadMarker, feedback: UINotificationFeedbackType) {
    let generator = UINotificationFeedbackGenerator::new(mtm);
    generator.notificationOccurred(feedback);
}