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

Commit 1e3a115e authored by Zhengping Jiang's avatar Zhengping Jiang Committed by Automerger Merge Worker
Browse files

Floss: Add restart bluetooth and apply ll privacy status am: dc9b4b22 

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



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

system/gd/rust/linux/mgmt/src/bluetooth_manager.rs

+11 −0
Original line number Diff line number Diff line
@@ -60,6 +60,14 @@ impl BluetoothManager { 
    pub(crate) fn callback_disconnected(&mut self, id: u32) {

        self.callbacks.remove(&id);

    }



    pub(crate) fn restart_available_adapters(&mut self) {

        self.get_available_adapters()

            .into_iter()

            .filter(|adapter| adapter.enabled)

            .map(|adapter| VirtualHciIndex(adapter.hci_interface))

            .for_each(|virt_hci| self.proxy.restart_bluetooth(virt_hci));

    }

}



impl IBluetoothManager for BluetoothManager {
@@ -182,10 +190,13 @@ impl IBluetoothExperimental for BluetoothManager { 
            return;

        }



        info!("Set floss ll privacy to {}", enabled);

        if let Err(e) = config_util::write_floss_ll_privacy_enabled(enabled) {

            error!("Failed to write ll privacy status: {}", e);

            return;

        }



        self.restart_available_adapters();

    }



    fn set_devcoredump(&mut self, enabled: bool) -> bool {

system/gd/rust/linux/mgmt/src/state_machine.rs

+52 −0
Original line number Diff line number Diff line
@@ -38,6 +38,7 @@ pub enum ProcessState { 
    TurningOn = 1,  // We are not notified that the Bluetooth is running

    On = 2,         // Bluetooth is running

    TurningOff = 3, // We are not notified that the Bluetooth is stopped

    Restarting = 4, // Pending restart and not notified that the Bluetooth is stopped

}



/// Check whether adapter is enabled by checking internal state.
@@ -90,6 +91,7 @@ impl Display for RealHciIndex { 
pub enum AdapterStateActions {

    StartBluetooth(VirtualHciIndex),

    StopBluetooth(VirtualHciIndex),

    RestartBluetooth(VirtualHciIndex),

    BluetoothStarted(i32, RealHciIndex), // PID and HCI

    BluetoothStopped(RealHciIndex),

    HciDevicePresence(DevPath, RealHciIndex, bool),
@@ -186,6 +188,15 @@ impl StateMachineProxy { 
        });

    }



    pub fn restart_bluetooth(&self, hci: VirtualHciIndex) {

        let tx = self.tx.clone();

        tokio::spawn(async move {

            let _ = tx

                .send(Message::AdapterStateChange(AdapterStateActions::RestartBluetooth(hci)))

                .await;

        });

    }



    /// Read state for an hci device.

    pub fn get_state<T, F>(&self, hci: VirtualHciIndex, call: F) -> Option<T>

    where
@@ -654,6 +665,14 @@ pub async fn mainloop( 
                        let action = context.state_machine.action_stop_bluetooth(hci);

                        cmd_timeout.lock().unwrap().handle_timeout_action(hci, action);

                    }

                    AdapterStateActions::RestartBluetooth(i) => {

                        hci = *i;

                        prev_state = context.state_machine.get_process_state(hci);

                        next_state = ProcessState::Restarting;



                        let action = context.state_machine.action_restart_bluetooth(hci);

                        cmd_timeout.lock().unwrap().handle_timeout_action(hci, action);

                    }

                    AdapterStateActions::BluetoothStarted(pid, real_hci) => {

                        hci = match context.state_machine.get_virtual_id_by_real_id(*real_hci) {

                            Some(v) => v,
@@ -1310,6 +1329,32 @@ impl StateMachineInternal { 
        }

    }



    /// Returns true if we are restarting bluetooth process

    pub fn action_restart_bluetooth(&mut self, hci: VirtualHciIndex) -> CommandTimeoutAction {

        if !self.is_known(hci) {

            warn!("Attempting to restart unknown hci{}", hci);

            return CommandTimeoutAction::DoNothing;

        }



        let state = self.get_process_state(hci);

        let present = self.get_state(hci, move |a: &AdapterState| Some(a.present)).unwrap_or(false);

        let floss_enabled = self.get_floss_enabled();



        match state {

            ProcessState::On if present && floss_enabled => {

                self.modify_state(hci, |s: &mut AdapterState| s.state = ProcessState::Restarting);

                self.process_manager

                    .stop(hci.to_string(), self.get_real_hci_by_virtual_id(hci).to_string());

                CommandTimeoutAction::ResetTimer

            }

            ProcessState::TurningOn => {

                debug!("hci{} is already starting.", hci);

                CommandTimeoutAction::DoNothing

            }

            _ => CommandTimeoutAction::DoNothing,

        }

    }



    /// Handles a bluetooth started event. Always returns true even with unknown interfaces.

    pub fn action_on_bluetooth_started(

        &mut self,
@@ -1345,6 +1390,13 @@ impl StateMachineInternal { 
                self.modify_state(hci, |s: &mut AdapterState| s.state = ProcessState::Off);

                CommandTimeoutAction::CancelTimer

            }

            ProcessState::Restarting => {

                debug!("hci{} restarting", hci.to_i32());

                self.modify_state(hci, |s: &mut AdapterState| s.state = ProcessState::TurningOn);

                self.process_manager

                    .start(hci.to_string(), self.get_real_hci_by_virtual_id(hci).to_string());

                CommandTimeoutAction::ResetTimer

            }

            // Running bluetooth stopped unexpectedly.

            ProcessState::On if floss_enabled && config_enabled => {

                let restart_count =