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

Commit cd28838e authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "floss: Restore discoverable and connectable after resuming from... 

Merge "floss: Restore discoverable and connectable after resuming from suspend" am: 3cd6c100 am: ef0d2e48

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



Change-Id: Ibdebebb8610b06bb8c1d691592916ac4c83e5963
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents a47fb143 ef0d2e48

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

+32 −10
Original line number Diff line number Diff line
@@ -712,6 +712,20 @@ impl Bluetooth { 
        Ok(())

    }



    /// Returns whether the adapter is connectable.

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

        match self.properties.get(&BtPropertyType::AdapterScanMode) {

            Some(prop) => match prop {

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

                    BtScanMode::Connectable | BtScanMode::ConnectableDiscoverable => true,

                    _ => false,

                },

                _ => false,

            },

            _ => false,

        }

    }



    /// Sets the adapter's connectable mode for classic connections.

    pub(crate) fn set_connectable_internal(&mut self, mode: bool) -> bool {

        self.is_connectable = mode;
@@ -723,6 +737,23 @@ impl Bluetooth { 
        )) == 0

    }



    /// Returns adapter's discoverable mode.

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

        let off_mode = BtDiscMode::NonDiscoverable;



        match self.properties.get(&BtPropertyType::AdapterScanMode) {

            Some(prop) => match prop {

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

                    BtScanMode::ConnectableDiscoverable => BtDiscMode::GeneralDiscoverable,

                    BtScanMode::ConnectableLimitedDiscoverable => BtDiscMode::LimitedDiscoverable,

                    _ => off_mode,

                },

                _ => off_mode,

            },

            _ => off_mode,

        }

    }



    /// Returns all bonded and connected devices.

    pub(crate) fn get_bonded_and_connected_devices(&mut self) -> Vec<BluetoothDevice> {

        self.bonded_devices
@@ -2486,16 +2517,7 @@ impl BtifHHCallbacks for Bluetooth { 


impl IBluetoothQALegacy for Bluetooth {

    fn get_connectable(&self) -> bool {

        match self.properties.get(&BtPropertyType::AdapterScanMode) {

            Some(prop) => match prop {

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

                    BtScanMode::Connectable | BtScanMode::ConnectableDiscoverable => true,

                    _ => false,

                },

                _ => false,

            },

            _ => false,

        }

        self.get_connectable_internal()

    }



    fn set_connectable(&mut self, mode: bool) -> bool {

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

+17 −3
Original line number Diff line number Diff line 
//! Suspend/Resume API.



use crate::bluetooth::{Bluetooth, BluetoothDevice, BtifBluetoothCallbacks, DelayedActions};

use crate::bluetooth::{

    Bluetooth, BluetoothDevice, BtifBluetoothCallbacks, DelayedActions, IBluetooth,

};

use crate::bluetooth_media::BluetoothMedia;

use crate::callbacks::Callbacks;

use crate::{BluetoothGatt, Message, RPCProxy};

use bt_topshim::btif::BluetoothInterface;

use bt_topshim::btif::{BluetoothInterface, BtDiscMode};

use log::warn;

use num_derive::{FromPrimitive, ToPrimitive};

use std::sync::{Arc, Mutex};
@@ -105,6 +107,11 @@ pub struct Suspend { 


    suspend_timeout_joinhandle: Option<tokio::task::JoinHandle<()>>,

    suspend_state: Arc<Mutex<SuspendState>>,



    /// Bluetooth adapter connectable state before suspending.

    connectable_to_restore: bool,

    /// Bluetooth adapter discoverable mode before suspending.

    discoverable_mode_to_restore: BtDiscMode,

}



impl Suspend {
@@ -126,6 +133,8 @@ impl Suspend { 
            audio_reconnect_joinhandle: None,

            suspend_timeout_joinhandle: None,

            suspend_state: Arc::new(Mutex::new(SuspendState::new())),

            connectable_to_restore: false,

            discoverable_mode_to_restore: BtDiscMode::NonDiscoverable,

        }

    }
@@ -185,6 +194,8 @@ impl ISuspend for Suspend { 
        // Set suspend event mask

        self.intf.lock().unwrap().set_default_event_mask_except(MASKED_EVENTS_FOR_SUSPEND, 0u64);



        self.connectable_to_restore = self.bt.lock().unwrap().get_connectable_internal();

        self.discoverable_mode_to_restore = self.bt.lock().unwrap().get_discoverable_mode();

        self.bt.lock().unwrap().set_connectable_internal(false);

        self.intf.lock().unwrap().clear_event_filter();

        self.intf.lock().unwrap().clear_filter_accept_list();
@@ -248,7 +259,10 @@ impl ISuspend for Suspend { 
        self.intf.lock().unwrap().clear_event_filter();

        self.intf.lock().unwrap().clear_filter_accept_list();

        self.intf.lock().unwrap().restore_filter_accept_list();

        self.bt.lock().unwrap().set_connectable_internal(true);

        self.bt.lock().unwrap().set_connectable_internal(self.connectable_to_restore);

        if self.discoverable_mode_to_restore != BtDiscMode::NonDiscoverable {

            self.bt.lock().unwrap().set_discoverable(self.discoverable_mode_to_restore.clone(), 0);

        }



        if !self.audio_reconnect_list.is_empty() {

            let reconnect_list = self.audio_reconnect_list.clone();