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

Commit ef890700 authored by Ying Hsu's avatar Ying Hsu
Browse files

floss: Add advertise ext command 

`advertise ext` registers and starts extended advertising which allows
to advertise more data than legacy advertising.

Bug: 233128828
Tag: #floss
Test: build.py --target test
Test: manual test with btclient
Change-Id: Idfbc0ac3c85d3a165c17ac7f9e0f776ed923e085
parent a80d0f65

system/gd/rust/linux/client/src/bt_adv.rs

+35 −2
Original line number Diff line number Diff line 
use std::collections::HashMap;

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



use crate::ClientContext;

use crate::{console_yellow, print_info};



use bt_topshim::btif::Uuid;

use bt_topshim::profiles::gatt::LePhy;

use btstack::bluetooth_adv::{AdvertiseData, AdvertiserId, AdvertisingSetParameters};

use btstack::bluetooth_gatt::IBluetoothGatt;



/// Avertisement parameter and data for a BLE advertising set.

#[derive(Debug, Clone)]
@@ -21,11 +26,11 @@ pub(crate) struct AdvSet { 
}



impl AdvSet {

    pub(crate) fn new() -> Self {

    pub(crate) fn new(is_legacy: bool) -> Self {

        let params = AdvertisingSetParameters {

            connectable: false,

            scannable: false,

            is_legacy: true,

            is_legacy,

            is_anonymous: false,

            include_tx_power: true,

            primary_phy: LePhy::Phy1m,
@@ -63,4 +68,32 @@ impl AdvSet { 


        AdvSet { adv_id: None, params, data, scan_rsp }

    }



    pub(crate) fn start(context: Arc<Mutex<ClientContext>>, s: AdvSet, callback_id: u32) {

        let mut context = context.lock().unwrap();



        let reg_id = context.gatt_dbus.as_mut().unwrap().start_advertising_set(

            s.params.clone(),

            s.data.clone(),

            None,

            None,

            None,

            0,

            0,

            callback_id,

        );

        print_info!("Starting advertising set for reg_id = {}", reg_id);

        context.adv_sets.insert(reg_id, s);

    }



    pub(crate) fn stop_all(context: Arc<Mutex<ClientContext>>) {

        let mut context = context.lock().unwrap();



        let adv_ids: Vec<_> = context.adv_sets.iter().filter_map(|(_, s)| s.adv_id).collect();

        for adv_id in adv_ids {

            print_info!("Stopping advertising set {}", adv_id);

            context.gatt_dbus.as_mut().unwrap().stop_advertising_set(adv_id);

        }

        context.adv_sets.clear();

    }

}

system/gd/rust/linux/client/src/command_handler.rs

+11 −26
Original line number Diff line number Diff line
@@ -165,7 +165,7 @@ fn build_commands() -> HashMap<String, CommandOption> { 
        String::from("advertise"),

        CommandOption {

            rules: vec![

                String::from("advertise <on|off>"),

                String::from("advertise <on|off|ext>"),

                String::from("advertise set-interval <ms>"),

                String::from("advertise set-scan-rsp <enable|disable>"),

            ],
@@ -951,35 +951,20 @@ impl CommandHandler { 
        }

        let callback_id = self.context.lock().unwrap().advertiser_callback_id.clone().unwrap();



        let cmd_usage = "advertise <on|off|set-interval|set-scan-rsp>";

        let cmd_usage = "advertise <on|off|ext|set-interval|set-scan-rsp>";

        enforce_arg_len(args, 1, cmd_usage, || match &args[0][0..] {

            "on" => {

                let mut context = self.context.lock().unwrap();



                let s = AdvSet::new();

                let reg_id = context.gatt_dbus.as_mut().unwrap().start_advertising_set(

                    s.params.clone(),

                    s.data.clone(),

                    None,

                    None,

                    None,

                    0,

                    0,

                    callback_id,

                );

                print_info!("Starting advertising set for reg_id = {}", reg_id);

                context.adv_sets.insert(reg_id, s);

                print_info!("Creating legacy advertising set...");

                let s = AdvSet::new(true); // legacy advertising

                AdvSet::start(self.context.clone(), s, callback_id);

            }

            "off" => {

                let mut context = self.context.lock().unwrap();



                let adv_ids: Vec<_> =

                    context.adv_sets.iter().filter_map(|(_, s)| s.adv_id).collect();

                for adv_id in adv_ids {

                    print_info!("Stopping advertising set {}", adv_id);

                    context.gatt_dbus.as_mut().unwrap().stop_advertising_set(adv_id);

                AdvSet::stop_all(self.context.clone());

            }

                context.adv_sets.clear();

            "ext" => {

                print_info!("Creating extended advertising set...");

                let s = AdvSet::new(false); // extended advertising

                AdvSet::start(self.context.clone(), s, callback_id);

            }

            "set-interval" => {

                if args.len() < 2 {