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

Commit 32a79c24 authored by Hsin-chen Chuang's avatar Hsin-chen Chuang Committed by Automerger Merge Worker
Browse files

Merge "floss: Wire set_scan_mode to Rust layer" into main am: c87068c5 am: 7c16af67 

Original change: https://android-review.googlesource.com/c/platform/packages/modules/Bluetooth/+/3144979



Change-Id: Ide762c928b8bab636dd5fc9039424083daa623f2
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 89f5faf7 7c16af67

system/blueberry/facade/topshim/facade.proto

+1 −5
Original line number Diff line number Diff line
@@ -7,7 +7,7 @@ package blueberry.facade.topshim; 
service AdapterService {

  rpc FetchEvents(FetchEventsRequest) returns (stream FetchEventsResponse) {}

  rpc ToggleStack(ToggleStackRequest) returns (ToggleStackResponse) {}

  rpc SetDiscoveryMode(SetDiscoveryModeRequest) returns (SetDiscoveryModeResponse) {}

  rpc SetDiscoveryMode(SetDiscoveryModeRequest) returns (google.protobuf.Empty) {}

  rpc ClearEventFilter(google.protobuf.Empty) returns (google.protobuf.Empty) {}

  rpc ClearEventMask(google.protobuf.Empty) returns (google.protobuf.Empty) {}

  rpc ClearFilterAcceptList(google.protobuf.Empty) returns (google.protobuf.Empty) {}
@@ -156,10 +156,6 @@ message SetDiscoveryModeRequest { 
  bool enable_inquiry_scan = 2;

}



message SetDiscoveryModeResponse {

  int32 status = 1;

}



service MediaService {

  rpc StartA2dp(StartA2dpRequest) returns (StartA2dpResponse) {}

  rpc A2dpSourceConnect(A2dpSourceConnectRequest) returns (A2dpSourceConnectResponse) {}

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

+13 −58
Original line number Diff line number Diff line
@@ -914,15 +914,7 @@ impl Bluetooth { 


    /// Returns whether the adapter is connectable.

    pub(crate) fn get_connectable_internal(&self) -> bool {

        self.properties.get(&BtPropertyType::AdapterScanMode).map_or(false, |prop| match prop {

            BluetoothProperty::AdapterScanMode(mode) => match *mode {

                BtScanMode::Connectable

                | BtScanMode::ConnectableDiscoverable

                | BtScanMode::ConnectableLimitedDiscoverable => true,

                BtScanMode::None_ => false,

            },

            _ => false,

        })

        self.discoverable_mode != BtDiscMode::NonDiscoverable || self.is_connectable

    }



    /// Sets the adapter's connectable mode for classic connections.
@@ -940,33 +932,18 @@ impl Bluetooth { 
            self.is_connectable = mode;

            return true;

        }

        let status =

            self.intf.lock().unwrap().set_adapter_property(BluetoothProperty::AdapterScanMode(

                if mode { BtScanMode::Connectable } else { BtScanMode::None_ },

            ));

        let status = BtStatus::from(status as u32);

        if status != BtStatus::Success {

            warn!("Failed to set connectable mode: {:?}", status);

            return false;

        }

        self.intf.lock().unwrap().set_scan_mode(if mode {

            BtScanMode::Connectable

        } else {

            BtScanMode::None_

        });

        self.is_connectable = mode;

        true

    }



    /// Returns adapter's discoverable mode.

    pub(crate) fn get_discoverable_mode_internal(&self) -> BtDiscMode {

        let off_mode = BtDiscMode::NonDiscoverable;



        self.properties.get(&BtPropertyType::AdapterScanMode).map_or(off_mode.clone(), |prop| {

            match prop {

                BluetoothProperty::AdapterScanMode(mode) => match *mode {

                    BtScanMode::ConnectableDiscoverable => BtDiscMode::GeneralDiscoverable,

                    BtScanMode::ConnectableLimitedDiscoverable => BtDiscMode::LimitedDiscoverable,

                    BtScanMode::Connectable | BtScanMode::None_ => off_mode,

                },

                _ => off_mode,

            }

        })

        self.discoverable_mode.clone()

    }



    /// Set the suspend mode for scan mode (connectable/discoverable mode).
@@ -988,15 +965,7 @@ impl Bluetooth { 
        }

        self.set_scan_suspend_mode(SuspendMode::Suspending);



        if self

            .intf

            .lock()

            .unwrap()

            .set_adapter_property(BluetoothProperty::AdapterScanMode(BtScanMode::None_))

            != 0

        {

            warn!("scan_mode_enter_suspend: Failed to set BtScanMode::None_");

        }

        self.intf.lock().unwrap().set_scan_mode(BtScanMode::None_);



        self.set_scan_suspend_mode(SuspendMode::Suspended);
@@ -1018,15 +987,7 @@ impl Bluetooth { 
                false => BtScanMode::None_,

            },

        };

        if self

            .intf

            .lock()

            .unwrap()

            .set_adapter_property(BluetoothProperty::AdapterScanMode(mode.clone()))

            != 0

        {

            warn!("scan_mode_exit_suspend: Failed to restore scan mode {:?}", mode);

        }

        self.intf.lock().unwrap().set_scan_mode(mode);



        self.set_scan_suspend_mode(SuspendMode::Normal);
@@ -1595,9 +1556,6 @@ impl BtifBluetoothCallbacks for Bluetooth { 
                self.ble_scanner_uuid =

                    Some(self.bluetooth_gatt.lock().unwrap().register_scanner(callback_id));



                // LibBluetooth saves and restores the discoverable mode on the previous run.

                // But on Floss we always want non-discoverable mode on start.

                self.set_discoverable(BtDiscMode::NonDiscoverable, 0);

                // Update connectable mode so that disconnected bonded classic device can reconnect

                self.trigger_update_connectable_mode();
@@ -1687,12 +1645,6 @@ impl BtifBluetoothCallbacks for Bluetooth { 
                        callback.on_name_changed(bdname.clone());

                    });

                }

                BluetoothProperty::AdapterScanMode(mode) => {

                    self.callbacks.for_all_callbacks(|callback| {

                        callback

                            .on_discoverable_changed(*mode == BtScanMode::ConnectableDiscoverable);

                    });

                }

                _ => {}

            }
@@ -2274,12 +2226,15 @@ impl IBluetooth for Bluetooth { 
            };

            if intf.set_adapter_property(BluetoothProperty::AdapterDiscoverableTimeout(duration))

                != 0

                || intf.set_adapter_property(BluetoothProperty::AdapterScanMode(scan_mode)) != 0

            {

                return false;

            }

            intf.set_scan_mode(scan_mode);

        }



        self.callbacks.for_all_callbacks(|callback| {

            callback.on_discoverable_changed(mode == BtDiscMode::GeneralDiscoverable);

        });

        self.discoverable_mode = mode.clone();



        // The old timer should be overwritten regardless of what the new mode is.

system/gd/rust/topshim/facade/src/adapter_service.rs

+5 −13
Original line number Diff line number Diff line
@@ -7,9 +7,8 @@ use crate::utils::converters::{bluetooth_property_to_event_data, event_data_from 
use bt_topshim_facade_protobuf::empty::Empty;

use bt_topshim_facade_protobuf::facade::{

    EventType, FetchEventsRequest, FetchEventsResponse, SetDefaultEventMaskExceptRequest,

    SetDiscoveryModeRequest, SetDiscoveryModeResponse, SetLocalIoCapsRequest,

    SetLocalIoCapsResponse, ToggleDiscoveryRequest, ToggleDiscoveryResponse, ToggleStackRequest,

    ToggleStackResponse,

    SetDiscoveryModeRequest, SetLocalIoCapsRequest, SetLocalIoCapsResponse, ToggleDiscoveryRequest,

    ToggleDiscoveryResponse, ToggleStackRequest, ToggleStackResponse,

};

use bt_topshim_facade_protobuf::facade_grpc::{create_adapter_service, AdapterService};

use futures::sink::SinkExt;
@@ -239,7 +238,7 @@ impl AdapterService for AdapterServiceImpl { 
        &mut self,

        ctx: RpcContext<'_>,

        req: SetDiscoveryModeRequest,

        sink: UnarySink<SetDiscoveryModeResponse>,

        sink: UnarySink<Empty>,

    ) {

        let scan_mode = if req.enable_inquiry_scan {

            btif::BtScanMode::ConnectableDiscoverable
@@ -248,16 +247,9 @@ impl AdapterService for AdapterServiceImpl { 
        } else {

            btif::BtScanMode::None_

        };

        let status = self

            .btif_intf

            .lock()

            .unwrap()

            .set_adapter_property(btif::BluetoothProperty::AdapterScanMode(scan_mode));



        let mut resp = SetDiscoveryModeResponse::new();

        resp.status = status;

        self.btif_intf.lock().unwrap().set_scan_mode(scan_mode);

        ctx.spawn(async move {

            sink.success(resp).await.unwrap();

            sink.success(Empty::default()).await.unwrap();

        })

    }

system/gd/rust/topshim/facade/src/utils.rs

+0 −3
Original line number Diff line number Diff line
@@ -19,9 +19,6 @@ pub mod converters { 
                }

                (String::from("Uuids"), event)

            }

            BluetoothProperty::AdapterScanMode(mode) => {

                (String::from("AdapterScanMode"), event_data_from_string(format!("{:?}", mode)))

            }

            BluetoothProperty::LocalIoCaps(caps) => {

                (String::from("LocalIoCaps"), event_data_from_string(format!("{:?}", caps)))

            }

system/gd/rust/topshim/src/btif.rs

+11 −10
Original line number Diff line number Diff line
@@ -151,7 +151,7 @@ pub enum BtPropertyType { 
    ClassOfDevice,

    TypeOfDevice,

    ServiceRecord,

    AdapterScanMode,

    Reserved07,

    AdapterBondedDevices,

    AdapterDiscoverableTimeout,

    RemoteFriendlyName,
@@ -328,6 +328,12 @@ impl From<bindings::bt_scan_mode_t> for BtScanMode { 
    }

}



impl Into<bindings::bt_scan_mode_t> for BtScanMode {

    fn into(self) -> bindings::bt_scan_mode_t {

        BtScanMode::to_u32(&self).unwrap_or_default()

    }

}



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

#[repr(u32)]

pub enum BtDiscMode {
@@ -573,7 +579,6 @@ pub enum BluetoothProperty { 
    ClassOfDevice(u32),

    TypeOfDevice(BtDeviceType),

    ServiceRecord(BtServiceRecord),

    AdapterScanMode(BtScanMode),

    AdapterBondedDevices(Vec<RawAddress>),

    AdapterDiscoverableTimeout(u32),

    RemoteFriendlyName(String),
@@ -612,7 +617,6 @@ impl BluetoothProperty { 
            BluetoothProperty::ClassOfDevice(_) => BtPropertyType::ClassOfDevice,

            BluetoothProperty::TypeOfDevice(_) => BtPropertyType::TypeOfDevice,

            BluetoothProperty::ServiceRecord(_) => BtPropertyType::ServiceRecord,

            BluetoothProperty::AdapterScanMode(_) => BtPropertyType::AdapterScanMode,

            BluetoothProperty::AdapterBondedDevices(_) => BtPropertyType::AdapterBondedDevices,

            BluetoothProperty::AdapterDiscoverableTimeout(_) => {

                BtPropertyType::AdapterDiscoverableTimeout
@@ -645,7 +649,6 @@ impl BluetoothProperty { 
            BluetoothProperty::ServiceRecord(rec) => {

                mem::size_of::<BtServiceRecord>() + cmp::min(PROPERTY_NAME_MAX, rec.name.len() + 1)

            }

            BluetoothProperty::AdapterScanMode(_) => mem::size_of::<BtScanMode>(),

            BluetoothProperty::AdapterBondedDevices(devlist) => {

                devlist.len() * mem::size_of::<RawAddress>()

            }
@@ -713,9 +716,6 @@ impl BluetoothProperty { 
                );

                record.name[name_len] = 0;

            }

            BluetoothProperty::AdapterScanMode(sm) => {

                data.copy_from_slice(&BtScanMode::to_u32(sm).unwrap_or_default().to_ne_bytes());

            }

            BluetoothProperty::AdapterBondedDevices(devlist) => {

                for (idx, &dev) in devlist.iter().enumerate() {

                    let start = idx * mem::size_of::<RawAddress>();
@@ -812,9 +812,6 @@ impl From<bindings::bt_property_t> for BluetoothProperty { 
                    unsafe { (prop.val as *const bindings::bt_service_record_t).read_unaligned() };

                BluetoothProperty::ServiceRecord(BtServiceRecord::from(v))

            }

            BtPropertyType::AdapterScanMode => BluetoothProperty::AdapterScanMode(

                BtScanMode::from_u32(u32_from_bytes(slice)).unwrap_or(BtScanMode::None_),

            ),

            BtPropertyType::AdapterBondedDevices => {

                let count = len / mem::size_of::<RawAddress>();

                BluetoothProperty::AdapterBondedDevices(ptr_to_vec(
@@ -1316,6 +1313,10 @@ impl BluetoothInterface { 
        ccall!(self, set_adapter_property, prop_ptr.into())

    }



    pub fn set_scan_mode(&self, mode: BtScanMode) {

        ccall!(self, set_scan_mode, mode.into())

    }



    pub fn get_remote_device_properties(&self, addr: &mut RawAddress) -> i32 {

        let addr_ptr = LTCheckedPtrMut::from_ref(addr);

        ccall!(self, get_remote_device_properties, addr_ptr.into())