btleplug 0.13.0

A Cross-Platform Rust Bluetooth Low Energy (BLE) GATT library.
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

pub mod objects;

use ::jni::errors::ThrowRuntimeExAndDefault;
use ::jni::{
    Env, EnvUnowned, NativeMethod, jni_str, native_method,
    objects::{JObject, Reference},
};
use jni::{objects::JString, sys::jboolean};
use std::ffi::c_void;
use std::sync::OnceLock;

static INIT: OnceLock<()> = OnceLock::new();

pub fn init(env: &mut Env) -> crate::Result<()> {
    match INIT.get() {
        Some(()) => Ok(()),
        None => {
            let result = init_inner(env);
            if result.is_ok() {
                let _ = INIT.set(());
            }
            result
        }
    }
}

fn init_inner(env: &mut Env) -> crate::Result<()> {
    // Seed the JavaVM singleton so JavaVM::singleton() works from any thread.
    env.get_java_vm()?;
    {
        let adapter_class =
            env.find_class(jni_str!("com/nonpolynomial/btleplug/android/impl/Adapter"))?;
        unsafe {
            env.register_native_methods(
                &adapter_class,
                &[
                    // Can't use native_method! here — JObject maps to Ljava/lang/Object; but the
                    // Java side declares the parameter as ScanResult. JNI requires exact signature match.
                    NativeMethod::from_raw_parts(
                        jni_str!("reportScanResult"),
                        jni_str!("(Landroid/bluetooth/le/ScanResult;)V"),
                        adapter_report_scan_result as *mut c_void,
                    ),
                    native_method! {
                        name = "onConnectionStateChanged",
                        sig = (addr: JString, connected: jboolean) -> (),
                        fn = adapter_on_connection_state_changed,
                    },
                ],
            )?
        };
        use super::jni_utils::{
            future::{JFuture, JFutureException},
            ops::{JFnAdapter, JFnBiFunctionImpl, JFnFunctionImpl, JFnRunnableImpl},
            stream::{JStream, JStreamPoll},
            task::{JPollResult, JWaker},
        };
        use objects::*;

        let loader = jni::objects::LoaderContext::default();
        <JPeripheral as Reference>::lookup_class(env, &loader)?;
        <JScanFilterClass as Reference>::lookup_class(env, &loader)?;
        <JNotConnectedException as Reference>::lookup_class(env, &loader)?;
        <JPermissionDeniedException as Reference>::lookup_class(env, &loader)?;
        <JUnexpectedCallbackException as Reference>::lookup_class(env, &loader)?;
        <JUnexpectedCharacteristicException as Reference>::lookup_class(env, &loader)?;
        <JNoSuchCharacteristicException as Reference>::lookup_class(env, &loader)?;
        <JNoBluetoothAdapterException as Reference>::lookup_class(env, &loader)?;
        <JFuture as Reference>::lookup_class(env, &loader)?;
        <JFutureException as Reference>::lookup_class(env, &loader)?;
        <JFnAdapter as Reference>::lookup_class(env, &loader)?;
        <JStream as Reference>::lookup_class(env, &loader)?;
        <JStreamPoll as Reference>::lookup_class(env, &loader)?;
        <JWaker as Reference>::lookup_class(env, &loader)?;
        <JPollResult as Reference>::lookup_class(env, &loader)?;
        <JFnRunnableImpl as Reference>::lookup_class(env, &loader)?;
        <JFnBiFunctionImpl as Reference>::lookup_class(env, &loader)?;
        <JFnFunctionImpl as Reference>::lookup_class(env, &loader)?;

        // FnAdapter native method registration
        let fn_adapter_class = <JFnAdapter as Reference>::lookup_class(env, &loader)?;
        unsafe {
            env.register_native_methods(
            &*fn_adapter_class,
            &[
                NativeMethod::from_raw_parts(
                    jni_str!("callInternal"),
                    jni_str!("(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;"),
                    super::jni_utils::ops::fn_adapter_call_internal as *mut c_void,
                ),
                NativeMethod::from_raw_parts(
                    jni_str!("closeInternal"),
                    jni_str!("()V"),
                    super::jni_utils::ops::fn_adapter_close_internal as *mut c_void,
                ),
            ],
        )?
        };
    }
    Ok(())
}

pub fn jvm() -> crate::Result<jni::JavaVM> {
    jni::JavaVM::singleton().map_err(|e| crate::Error::Other(Box::new(e)))
}

impl From<::jni::errors::Error> for crate::Error {
    fn from(err: ::jni::errors::Error) -> Self {
        Self::Other(Box::new(err))
    }
}

extern "C" fn adapter_report_scan_result<'local>(
    mut env: EnvUnowned<'local>,
    obj: JObject<'local>,
    scan_result: JObject<'local>,
) {
    env.with_env(|env| super::adapter::adapter_report_scan_result_internal(env, &obj, scan_result))
        .resolve::<ThrowRuntimeExAndDefault>();
}

fn adapter_on_connection_state_changed<'local>(
    env: &mut Env<'local>,
    obj: JObject<'local>,
    addr: JString<'local>,
    connected: jboolean,
) -> jni::errors::Result<()> {
    if let Err(e) =
        super::adapter::adapter_on_connection_state_changed_internal(env, &obj, addr, connected)
        && !env.exception_check()
    {
        let _ = env.throw(format!("Rust error: {e}"));
    }
    Ok(())
}