Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b9625dde authored by Sonny Sasaka's avatar Sonny Sasaka Committed by Gerrit Code Review
Browse files

Merge changes I623e129a,Icf20fc6f 

* changes:
  floss: Implement IBluetoothGatt ClientDisconnect
  floss: Implement UnregisterClient and ClientConnect
parents d9c1195e f6752409

system/gd/rust/linux/service/src/iface_bluetooth_gatt.rs

+26 −1
Original line number Diff line number Diff line
@@ -27,6 +27,16 @@ struct BluetoothGattCallbackDBus {} 
impl IBluetoothGattCallback for BluetoothGattCallbackDBus {

    #[dbus_method("OnClientRegistered")]

    fn on_client_registered(&self, _status: i32, _scanner_id: i32) {}



    #[dbus_method("OnClientConnectionState")]

    fn on_client_connection_state(

        &self,

        status: i32,

        client_id: i32,

        connected: bool,

        addr: String,

    ) {

    }

}



#[allow(dead_code)]
@@ -84,5 +94,20 @@ impl IBluetoothGatt for IBluetoothGattDBus { 
    }



    #[dbus_method("UnregisterClient")]

    fn unregister_client(&self, client_if: i32) {}

    fn unregister_client(&mut self, client_id: i32) {}



    #[dbus_method("ClientConnect")]

    fn client_connect(

        &self,

        client_id: i32,

        addr: String,

        is_direct: bool,

        transport: i32,

        opportunistic: bool,

        phy: i32,

    ) {

    }



    #[dbus_method("ClientDisconnect")]

    fn client_disconnect(&self, client_id: i32, addr: String) {}

}

system/gd/rust/linux/stack/src/bluetooth_gatt.rs

+256 −20
Original line number Diff line number Diff line
@@ -6,16 +6,91 @@ use bt_topshim::bindings::root::bluetooth::Uuid; 
use bt_topshim::btif::{BluetoothInterface, RawAddress};

use bt_topshim::profiles::gatt::{

    Gatt, GattClientCallbacks, GattClientCallbacksDispatcher, GattServerCallbacksDispatcher,

    GattStatus,

};

use bt_topshim::topstack;



use std::collections::HashMap;

use num_traits::cast::FromPrimitive;



use std::sync::{Arc, Mutex};



use tokio::sync::mpsc::Sender;



use crate::{Message, RPCProxy};



struct Client {

    id: Option<i32>,

    uuid: Uuid128Bit,

    callback: Box<dyn IBluetoothGattCallback + Send>,

}



struct Connection {

    conn_id: i32,

    address: String,

    client_id: i32,

}



struct ContextMap {

    // TODO(b/196635530): Consider using `multimap` for a more efficient implementation of get by

    // multiple keys.

    clients: Vec<Client>,

    connections: Vec<Connection>,

}



impl ContextMap {

    fn new() -> ContextMap {

        ContextMap { clients: vec![], connections: vec![] }

    }



    fn get_by_uuid(&self, uuid: &Uuid128Bit) -> Option<&Client> {

        self.clients.iter().find(|client| client.uuid == *uuid)

    }



    fn get_by_client_id(&self, client_id: i32) -> Option<&Client> {

        self.clients.iter().find(|client| client.id.is_some() && client.id.unwrap() == client_id)

    }



    fn add(&mut self, uuid: &Uuid128Bit, callback: Box<dyn IBluetoothGattCallback + Send>) {

        if self.get_by_uuid(uuid).is_some() {

            return;

        }



        self.clients.push(Client { id: None, uuid: uuid.clone(), callback });

    }



    fn remove(&mut self, id: i32) {

        self.clients.retain(|client| !(client.id.is_some() && client.id.unwrap() == id));

    }



    fn set_client_id(&mut self, uuid: &Uuid128Bit, id: i32) {

        let client = self.clients.iter_mut().find(|client| client.uuid == *uuid);

        if client.is_none() {

            return;

        }



        client.unwrap().id = Some(id);

    }



    fn add_connection(&mut self, client_id: i32, conn_id: i32, address: &String) {

        if self.get_conn_id_from_address(client_id, address).is_some() {

            return;

        }



        self.connections.push(Connection { conn_id, address: address.clone(), client_id });

    }



    fn get_conn_id_from_address(&self, client_id: i32, address: &String) -> Option<i32> {

        match self

            .connections

            .iter()

            .find(|conn| conn.client_id == client_id && conn.address == *address)

        {

            None => None,

            Some(conn) => Some(conn.conn_id),

        }

    }

}



/// Defines the GATT API.

pub trait IBluetoothGatt {

    fn register_scanner(&self, callback: Box<dyn IScannerCallback + Send>);
@@ -34,13 +109,36 @@ pub trait IBluetoothGatt { 
    );



    /// Unregisters a GATT Client.

    fn unregister_client(&self, client_if: i32);

    fn unregister_client(&mut self, client_id: i32);



    /// Initiates a GATT connection to a peer device.

    fn client_connect(

        &self,

        client_id: i32,

        addr: String,

        is_direct: bool,

        transport: i32,

        opportunistic: bool,

        phy: i32,

    );



    /// Disconnects a GATT connection.

    fn client_disconnect(&self, client_id: i32, addr: String);

}



/// Callback for GATT Client API.

pub trait IBluetoothGattCallback: RPCProxy {

    /// When the `register_client` request is done.

    fn on_client_registered(&self, status: i32, client_if: i32);

    fn on_client_registered(&self, status: i32, client_id: i32);



    /// When there is a change in the state of a GATT client connection.

    fn on_client_connection_state(

        &self,

        status: i32,

        client_id: i32,

        connected: bool,

        addr: String,

    );

}



/// Interface for scanner callbacks to clients, passed to `IBluetoothGatt::register_scanner`.
@@ -91,13 +189,13 @@ pub struct BluetoothGatt { 
    intf: Arc<Mutex<BluetoothInterface>>,

    gatt: Option<Gatt>,



    gatt_client_map: HashMap<Uuid128Bit, Box<dyn IBluetoothGattCallback + Send>>,

    context_map: ContextMap,

}



impl BluetoothGatt {

    /// Constructs a new IBluetoothGatt implementation.

    pub fn new(intf: Arc<Mutex<BluetoothInterface>>) -> BluetoothGatt {

        BluetoothGatt { intf: intf, gatt: None, gatt_client_map: HashMap::new() }

        BluetoothGatt { intf: intf, gatt: None, context_map: ContextMap::new() }

    }



    pub fn init_profiles(&mut self, tx: Sender<Message>) {
@@ -123,7 +221,9 @@ impl BluetoothGatt { 


// Temporary util that covers only basic string conversion.

// TODO(b/193685325): Implement more UUID utils by using Uuid from gd/hci/uuid.h with cxx.

fn parse_uuid_string(uuid: String) -> Option<Uuid> {

fn parse_uuid_string<T: Into<String>>(uuid: T) -> Option<Uuid> {

    let uuid = uuid.into();



    if uuid.len() != 32 {

        return None;

    }
@@ -165,52 +265,140 @@ impl IBluetoothGatt for BluetoothGatt { 
        eatt_support: bool,

    ) {

        let uuid = parse_uuid_string(app_uuid).unwrap();

        self.gatt_client_map.insert(uuid.uu, callback);

        self.context_map.add(&uuid.uu, callback);

        self.gatt.as_ref().unwrap().client.register_client(&uuid, eatt_support);

    }



    fn unregister_client(&self, _client_if: i32) {

        // TODO(b/193685325): implement

    fn unregister_client(&mut self, client_id: i32) {

        self.context_map.remove(client_id);

        self.gatt.as_ref().unwrap().client.unregister_client(client_id);

    }



    fn client_connect(

        &self,

        client_id: i32,

        addr: String,

        is_direct: bool,

        transport: i32,

        opportunistic: bool,

        phy: i32,

    ) {

        let address = match RawAddress::from_string(addr.clone()) {

            None => return,

            Some(addr) => addr,

        };



        self.gatt.as_ref().unwrap().client.connect(

            client_id,

            &address,

            is_direct,

            transport,

            opportunistic,

            phy,

        );

    }



    fn client_disconnect(&self, client_id: i32, address: String) {

        let conn_id = self.context_map.get_conn_id_from_address(client_id, &address);

        if conn_id.is_none() {

            return;

        }



        self.gatt.as_ref().unwrap().client.disconnect(

            client_id,

            &RawAddress::from_string(address).unwrap(),

            conn_id.unwrap(),

        );

    }

}



#[btif_callbacks_dispatcher(BluetoothGatt, dispatch_gatt_client_callbacks, GattClientCallbacks)]

pub(crate) trait BtifGattClientCallbacks {

    #[btif_callback(RegisterClient)]

    fn register_client_cb(&mut self, status: i32, client_if: i32, app_uuid: Uuid);

    fn register_client_cb(&mut self, status: i32, client_id: i32, app_uuid: Uuid);



    #[btif_callback(Connect)]

    fn connect_cb(&mut self, conn_id: i32, status: i32, client_if: i32, addr: RawAddress);

    fn connect_cb(&mut self, conn_id: i32, status: i32, client_id: i32, addr: RawAddress);



    // TODO(b/193685325): Define all callbacks.

}



impl BtifGattClientCallbacks for BluetoothGatt {

    fn register_client_cb(&mut self, status: i32, client_if: i32, app_uuid: Uuid) {

        let callback = self.gatt_client_map.get(&app_uuid.uu);

        if callback.is_none() {

            println!("Warning: Callback not registered for UUID {:?}", app_uuid.uu);

    fn register_client_cb(&mut self, status: i32, client_id: i32, app_uuid: Uuid) {

        self.context_map.set_client_id(&app_uuid.uu, client_id);



        let client = self.context_map.get_by_uuid(&app_uuid.uu);

        if client.is_none() {

            println!("Warning: Client not registered for UUID {:?}", app_uuid.uu);

            return;

        }



        callback.unwrap().on_client_registered(status, client_if);

        let callback = &client.unwrap().callback;

        callback.on_client_registered(status, client_id);

    }



    fn connect_cb(&mut self, conn_id: i32, status: i32, client_id: i32, addr: RawAddress) {

        if status == 0 {

            self.context_map.add_connection(client_id, conn_id, &addr.to_string());

        }



        let client = self.context_map.get_by_client_id(client_id);

        if client.is_none() {

            return;

        }



    fn connect_cb(&mut self, _conn_id: i32, _status: i32, _client_if: i32, _addr: RawAddress) {

        // TODO(b/193685325): handle;

        client.unwrap().callback.on_client_connection_state(

            status,

            client_id,

            match GattStatus::from_i32(status) {

                None => false,

                Some(gatt_status) => gatt_status == GattStatus::Success,

            },

            addr.to_string(),

        );

    }

}



#[cfg(test)]

mod tests {

    struct TestBluetoothGattCallback {

        id: String,

    }



    impl TestBluetoothGattCallback {

        fn new(id: String) -> TestBluetoothGattCallback {

            TestBluetoothGattCallback { id }

        }

    }



    impl IBluetoothGattCallback for TestBluetoothGattCallback {

        fn on_client_registered(&self, _status: i32, _client_id: i32) {}

        fn on_client_connection_state(

            &self,

            _status: i32,

            _client_id: i32,

            _connected: bool,

            _addr: String,

        ) {

        }

    }



    impl RPCProxy for TestBluetoothGattCallback {

        fn register_disconnect(&mut self, _f: Box<dyn Fn() + Send>) {}



        fn get_object_id(&self) -> String {

            self.id.clone()

        }

    }



    use super::*;



    #[test]

    fn test_uuid_from_string() {

        let uuid = parse_uuid_string(String::from("abcdef"));

        let uuid = parse_uuid_string("abcdef");

        assert!(uuid.is_none());



        let uuid = parse_uuid_string(String::from("0123456789abcdef0123456789abcdef"));

        let uuid = parse_uuid_string("0123456789abcdef0123456789abcdef");

        assert!(uuid.is_some());

        let expected: [u8; 16] = [

            0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab,
@@ -218,4 +406,52 @@ mod tests { 
        ];

        assert_eq!(Uuid { uu: expected }, uuid.unwrap());

    }



    #[test]

    fn test_context_map_clients() {

        let mut map = ContextMap::new();



        // Add client 1.

        let callback1 = Box::new(TestBluetoothGattCallback::new(String::from("Callback 1")));

        let uuid1 = parse_uuid_string("00000000000000000000000000000001").unwrap().uu;

        map.add(&uuid1, callback1);

        let found = map.get_by_uuid(&uuid1);

        assert!(found.is_some());

        assert_eq!("Callback 1", found.unwrap().callback.get_object_id());



        // Add client 2.

        let callback2 = Box::new(TestBluetoothGattCallback::new(String::from("Callback 2")));

        let uuid2 = parse_uuid_string("00000000000000000000000000000002").unwrap().uu;

        map.add(&uuid2, callback2);

        let found = map.get_by_uuid(&uuid2);

        assert!(found.is_some());

        assert_eq!("Callback 2", found.unwrap().callback.get_object_id());



        // Set client ID and get by client ID.

        map.set_client_id(&uuid1, 3);

        let found = map.get_by_client_id(3);

        assert!(found.is_some());



        // Remove client 1.

        map.remove(3);

        let found = map.get_by_uuid(&uuid1);

        assert!(found.is_none());

    }



    #[test]

    fn test_context_map_connections() {

        let mut map = ContextMap::new();

        let client_id = 1;



        map.add_connection(client_id, 3, &String::from("aa:bb:cc:dd:ee:ff"));

        map.add_connection(client_id, 4, &String::from("11:22:33:44:55:66"));



        let found = map.get_conn_id_from_address(client_id, &String::from("aa:bb:cc:dd:ee:ff"));

        assert!(found.is_some());

        assert_eq!(3, found.unwrap());



        let found = map.get_conn_id_from_address(client_id, &String::from("11:22:33:44:55:66"));

        assert!(found.is_some());

        assert_eq!(4, found.unwrap());

    }

}

system/gd/rust/topshim/src/profiles/gatt.rs

+53 −0
Original line number Diff line number Diff line
@@ -34,6 +34,59 @@ impl std::fmt::Debug for BtGattNotifyParams { 
    }

}



#[derive(Debug, FromPrimitive, PartialEq, PartialOrd)]

#[repr(u32)]

pub enum GattStatus {

    Success = 0x00,

    InvalidHandle = 0x01,

    ReadNotPermit = 0x02,

    WriteNotPermit = 0x03,

    InvalidPdu = 0x04,

    InsufAuthentication = 0x05,

    ReqNotSupported = 0x06,

    InvalidOffset = 0x07,

    InsufAuthorization = 0x08,

    PrepareQFull = 0x09,

    NotFound = 0x0a,

    NotLong = 0x0b,

    InsufKeySize = 0x0c,

    InvalidAttrLen = 0x0d,

    ErrUnlikely = 0x0e,

    InsufEncryption = 0x0f,

    UnsupportGrpType = 0x10,

    InsufResource = 0x11,

    DatabaseOutOfSync = 0x12,

    ValueNotAllowed = 0x13,

    IllegalParameter = 0x87,

    TooShort = 0x7f,

    NoResources = 0x80,

    InternalError = 0x81,

    WrongState = 0x82,

    DbFull = 0x83,

    Busy = 0x84,

    Error = 0x85,

    CmdStarted = 0x86,

    Pending = 0x88,

    AuthFail = 0x89,

    More = 0x8a,

    InvalidCfg = 0x8b,

    ServiceStarted = 0x8c,

    EncryptedNoMitm = 0x8d,

    NotEncrypted = 0x8e,

    Congested = 0x8f,

    DupReg = 0x90,      /* 0x90 */

    AlreadyOpen = 0x91, /* 0x91 */

    Cancel = 0x92,      /* 0x92 */

    /* = 0xE0 ~ 0xFC reserved for future use */



    /* Client Characteristic Configuration Descriptor Improperly Configured */

    CccCfgErr = 0xFD,

    /* Procedure Already in progress */

    PrcInProgress = 0xFE,

    /* Attribute value out of range */

    OutOfRange = 0xFF,

}



#[derive(Debug)]

pub enum GattClientCallbacks {

    RegisterClient(i32, i32, Uuid),