blurdroid 0.1.6

Bluetooth lib for Rust using Android's bluedroid
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

use bluetooth_gatt_characteristic::Characteristic;
use ffi;
use std::cell::Cell;
use std::error::Error;
use std::os::raw::{c_int};
use std::ptr::{self};
use std::sync::Arc;
use utils;

#[derive(Clone, Debug)]
struct IDescriptor {
    descriptor: Cell<*mut ffi::BluetoothDescriptor>,
}

#[derive(Debug)]
pub struct Descriptor {
    i: Box<IDescriptor>,
    id: String,
}

impl Descriptor {
    #[inline(always)]
    pub fn descriptor(&self) -> *mut ffi::BluetoothDescriptor {
        self.i.descriptor.get()
    }

    pub fn new(characteristic: Arc<Characteristic>, id: String) -> Descriptor {
        let descriptor = unsafe { ffi::bluetooth_descriptor_create_descriptor(characteristic.characteristic(), id.parse::<i32>().unwrap()) };
        Descriptor {
            i: Box::new(IDescriptor { descriptor: Cell::new(descriptor) }),
            id: id.clone(),
        }
    }

    pub fn get_id(&self) -> String {
        self.id.clone()
    }

    pub fn get_uuid(&self) -> Result<String, Box<Error>> {
        let uuid = unsafe { ffi::bluetooth_descriptor_get_uuid(self.descriptor()) };
        check_null!(&uuid, "No uuid found!");
        let res = try!(utils::convert_cstr(&uuid, "No uuid found!"));
        unsafe { ffi::jni_free_string(uuid) };
        Ok(res)
    }

    pub fn get_value(&self) -> Result<Vec<u8>, Box<Error>> {
        let mut v = vec!();
        unsafe {
            let values = ffi::bluetooth_descriptor_get_value(self.descriptor());
            check_null!(&values, "No value found!");
            let max = ffi::bluetooth_descriptor_get_value_size(self.descriptor()) as isize;
            for i in 0..max {
                let val_ptr = *values.offset(i);
                let val = (val_ptr as i32) as u8;
                v.push(val);
            }
            if max > 0 {
                ffi::jni_free_int_array(values);
            }
        }
        Ok(v)
    }

    pub fn read_value(&self) -> Result<Vec<u8>, Box<Error>> {
        let values = unsafe { ffi::bluetooth_descriptor_read_value(self.descriptor()) };
        if !values.is_positive() {
            return Err(Box::from("Read value error!"));
        }
        self.get_value()
    }

    pub fn write_value(&self, values: Vec<u8>) -> Result<(), Box<Error>> {
        let v = values.iter().map(|&x| x as i32).collect::<Vec<i32>>();
        let value = unsafe { ffi::bluetooth_descriptor_write_value(self.descriptor(), v.as_ptr() as *const c_int, v.len() as c_int) };
        if !value.is_positive() {
            return Err(Box::from("Write value error!"));
        }
        Ok(())
    }

    pub fn get_flags(&self) -> Result<Vec<String>, Box<Error>> {
        Err(Box::from(utils::NOT_SUPPORTED_ERROR))
    }
}

impl Clone for Descriptor {
    fn clone(&self) -> Descriptor {
        unsafe { ffi::bluetooth_descriptor_inc_refcount(self.descriptor()) };
        Descriptor {
            i: self.i.clone(),
            id: self.id.clone(),
        }
    }
}

impl Drop for Descriptor {
    fn drop(&mut self) {
        unsafe {
            ffi::bluetooth_descriptor_dec_refcount(self.descriptor());
            ffi::bluetooth_descriptor_free_descriptor(self.descriptor());
        }
    }
}