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

Commit 4bc38ac1 authored by Whale Chang's avatar Whale Chang Committed by Gerrit Code Review
Browse files

Merge changes I43efc81e,Iabd179b7,I294bdfb9,I7270de77,I3c0dbafb, ... into main 

* changes:
  Floss: Remove automatic SCO call start
  Floss: Call IBluetoothTelephonyCallback method on UHid Open/Close events
  Floss: Add UHID Mute support
  Floss: Add CallSource to CallInfo
  Floss: Add set_mps_qualification_enabled flag
  Floss: Add UHID device creation
parents 12dc5c43 0a52cf7f

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

+48 −4
Original line number Diff line number Diff line
@@ -3,9 +3,10 @@ use crate::dbus_iface::{ 
    export_admin_policy_callback_dbus_intf, export_advertising_set_callback_dbus_intf,

    export_bluetooth_callback_dbus_intf, export_bluetooth_connection_callback_dbus_intf,

    export_bluetooth_gatt_callback_dbus_intf, export_bluetooth_manager_callback_dbus_intf,

    export_bluetooth_media_callback_dbus_intf, export_gatt_server_callback_dbus_intf,

    export_qa_callback_dbus_intf, export_scanner_callback_dbus_intf,

    export_socket_callback_dbus_intf, export_suspend_callback_dbus_intf,

    export_bluetooth_media_callback_dbus_intf, export_bluetooth_telephony_callback_dbus_intf,

    export_gatt_server_callback_dbus_intf, export_qa_callback_dbus_intf,

    export_scanner_callback_dbus_intf, export_socket_callback_dbus_intf,

    export_suspend_callback_dbus_intf,

};

use crate::ClientContext;

use crate::{console_red, console_yellow, print_error, print_info};
@@ -22,7 +23,9 @@ use btstack::bluetooth_gatt::{ 
    BluetoothGattService, IBluetoothGattCallback, IBluetoothGattServerCallback, IScannerCallback,

    ScanResult,

};

use btstack::bluetooth_media::{BluetoothAudioDevice, IBluetoothMediaCallback};

use btstack::bluetooth_media::{

    BluetoothAudioDevice, IBluetoothMediaCallback, IBluetoothTelephonyCallback,

};

use btstack::bluetooth_qa::IBluetoothQACallback;

use btstack::socket_manager::{

    BluetoothServerSocket, BluetoothSocket, IBluetoothSocketManager,
@@ -1424,3 +1427,44 @@ impl RPCProxy for MediaCallback { 
        cr.lock().unwrap().insert(self.get_object_id(), &[iface], Arc::new(Mutex::new(self)));

    }

}



pub(crate) struct TelephonyCallback {

    objpath: String,

    context: Arc<Mutex<ClientContext>>,



    dbus_connection: Arc<SyncConnection>,

    dbus_crossroads: Arc<Mutex<Crossroads>>,

}



impl TelephonyCallback {

    pub(crate) fn new(

        objpath: String,

        context: Arc<Mutex<ClientContext>>,

        dbus_connection: Arc<SyncConnection>,

        dbus_crossroads: Arc<Mutex<Crossroads>>,

    ) -> Self {

        Self { objpath, context, dbus_connection, dbus_crossroads }

    }

}



impl IBluetoothTelephonyCallback for TelephonyCallback {

    fn on_telephony_use(&mut self, addr: String, state: bool) {

        print_info!("Telephony use changed: [{}] state: {}", addr, state);

    }

}



impl RPCProxy for TelephonyCallback {

    fn get_object_id(&self) -> String {

        self.objpath.clone()

    }



    fn export_for_rpc(self: Box<Self>) {

        let cr = self.dbus_crossroads.clone();

        let iface = export_bluetooth_telephony_callback_dbus_intf(

            self.dbus_connection.clone(),

            &mut cr.lock().unwrap(),

            Arc::new(Mutex::new(DisconnectWatcher::new())),

        );

        cr.lock().unwrap().insert(self.get_object_id(), &[iface], Arc::new(Mutex::new(self)));

    }

}

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

+2 −2
Original line number Diff line number Diff line
@@ -1848,7 +1848,7 @@ impl CommandHandler { 
            }

            "enable" => {

                let mut context = self.lock_context();

                context.telephony_dbus.as_mut().unwrap().set_phone_ops_enabled(true);

                context.telephony_dbus.as_mut().unwrap().set_mps_qualification_enabled(true);

                if context.mps_sdp_handle.is_none() {

                    let success = context

                        .adapter_dbus
@@ -1862,7 +1862,7 @@ impl CommandHandler { 
            }

            "disable" => {

                let mut context = self.lock_context();

                context.telephony_dbus.as_mut().unwrap().set_phone_ops_enabled(false);

                context.telephony_dbus.as_mut().unwrap().set_mps_qualification_enabled(false);

                if let Some(handle) = context.mps_sdp_handle.take() {

                    let success = context.adapter_dbus.as_mut().unwrap().remove_sdp_record(handle);

                    if !success {

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

+47 −7
Original line number Diff line number Diff line
@@ -37,6 +37,7 @@ use btstack::bluetooth_gatt::{ 
};

use btstack::bluetooth_media::{

    BluetoothAudioDevice, IBluetoothMedia, IBluetoothMediaCallback, IBluetoothTelephony,

    IBluetoothTelephonyCallback,

};

use btstack::bluetooth_qa::IBluetoothQA;

use btstack::socket_manager::{
@@ -2287,25 +2288,45 @@ impl ISuspendCallback for ISuspendCallbackDBus { 
    fn on_resumed(&mut self, suspend_id: i32) {}

}



pub(crate) struct BluetoothTelephonyDBusRPC {

    client_proxy: ClientDBusProxy,

}



pub(crate) struct BluetoothTelephonyDBus {

    client_proxy: ClientDBusProxy,

    pub rpc: BluetoothTelephonyDBusRPC,

}



impl BluetoothTelephonyDBus {

    pub(crate) fn new(conn: Arc<SyncConnection>, index: i32) -> BluetoothTelephonyDBus {

        BluetoothTelephonyDBus {

            client_proxy: ClientDBusProxy::new(

    fn make_client_proxy(conn: Arc<SyncConnection>, index: i32) -> ClientDBusProxy {

        ClientDBusProxy::new(

            conn.clone(),

            String::from("org.chromium.bluetooth"),

            make_object_path(index, "telephony"),

            String::from("org.chromium.bluetooth.BluetoothTelephony"),

            ),

        )

    }



    pub(crate) fn new(conn: Arc<SyncConnection>, index: i32) -> BluetoothTelephonyDBus {

        BluetoothTelephonyDBus {

            client_proxy: Self::make_client_proxy(conn.clone(), index),

            rpc: BluetoothTelephonyDBusRPC {

                client_proxy: Self::make_client_proxy(conn.clone(), index),

            },

        }

    }

}



#[generate_dbus_interface_client]

#[generate_dbus_interface_client(BluetoothTelephonyDBusRPC)]

impl IBluetoothTelephony for BluetoothTelephonyDBus {

    #[dbus_method("RegisterTelephonyCallback")]

    fn register_telephony_callback(

        &mut self,

        callback: Box<dyn IBluetoothTelephonyCallback + Send>,

    ) -> bool {

        dbus_generated!()

    }



    #[dbus_method("SetNetworkAvailable")]

    fn set_network_available(&mut self, network_available: bool) {

        dbus_generated!()
@@ -2326,6 +2347,10 @@ impl IBluetoothTelephony for BluetoothTelephonyDBus { 
    fn set_phone_ops_enabled(&mut self, enable: bool) {

        dbus_generated!()

    }

    #[dbus_method("SetMpsQualificationEnabled")]

    fn set_mps_qualification_enabled(&mut self, enable: bool) {

        dbus_generated!()

    }

    #[dbus_method("IncomingCall")]

    fn incoming_call(&mut self, number: String) -> bool {

        dbus_generated!()
@@ -2372,6 +2397,21 @@ impl IBluetoothTelephony for BluetoothTelephonyDBus { 
    }

}



struct IBluetoothTelephonyCallbackDBus {}



impl RPCProxy for IBluetoothTelephonyCallbackDBus {}



#[generate_dbus_exporter(

    export_bluetooth_telephony_callback_dbus_intf,

    "org.chromium.bluetooth.BluetoothTelephonyCallback"

)]

impl IBluetoothTelephonyCallback for IBluetoothTelephonyCallbackDBus {

    #[dbus_method("OnTelephonyUse")]

    fn on_telephony_use(&mut self, addr: String, state: bool) {

        dbus_generated!()

    }

}



pub(crate) struct BluetoothQADBusRPC {

    client_proxy: ClientDBusProxy,

}

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

+21 −0
Original line number Diff line number Diff line
@@ -16,6 +16,7 @@ use crate::bt_gatt::GattClientContext; 
use crate::callbacks::{

    AdminCallback, AdvertisingSetCallback, BtCallback, BtConnectionCallback, BtManagerCallback,

    BtSocketManagerCallback, MediaCallback, QACallback, ScannerCallback, SuspendCallback,

    TelephonyCallback,

};

use crate::command_handler::{CommandHandler, SocketSchedule};

use crate::dbus_iface::{
@@ -543,6 +544,10 @@ async fn handle_client_command( 
                    format!("/org/chromium/bluetooth/client/{}/qa_manager_callback", adapter);

                let media_cb_objpath: String =

                    format!("/org/chromium/bluetooth/client/{}/bluetooth_media_callback", adapter);

                let telephony_cb_objpath: String = format!(

                    "/org/chromium/bluetooth/client/{}/bluetooth_telephony_callback",

                    adapter

                );



                let dbus_connection = context.lock().unwrap().dbus_connection.clone();

                let dbus_crossroads = context.lock().unwrap().dbus_crossroads.clone();
@@ -690,6 +695,22 @@ async fn handle_client_command( 
                    .await

                    .expect("D-Bus error on IBluetoothMedia::RegisterCallback");



                context

                    .lock()

                    .unwrap()

                    .telephony_dbus

                    .as_mut()

                    .unwrap()

                    .rpc

                    .register_telephony_callback(Box::new(TelephonyCallback::new(

                        telephony_cb_objpath,

                        context.clone(),

                        dbus_connection.clone(),

                        dbus_crossroads.clone(),

                    )))

                    .await

                    .expect("D-Bus error on IBluetoothMedia::RegisterTelephonyCallback");



                context.lock().unwrap().adapter_ready = true;

                let adapter_address = context.lock().unwrap().update_adapter_address();

                context.lock().unwrap().update_bonded_devices();

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

+28 −2
Original line number Diff line number Diff line 
use btstack::bluetooth_media::IBluetoothTelephony;

use btstack::bluetooth_media::{IBluetoothTelephony, IBluetoothTelephonyCallback};

use btstack::RPCProxy;



use dbus_macros::{dbus_method, generate_dbus_exporter};

use dbus::Path;



use dbus_macros::{dbus_method, dbus_proxy_obj, generate_dbus_exporter};



use dbus_projection::prelude::*;



use crate::dbus_arg::DBusArg;



#[allow(dead_code)]

struct BluetoothTelephonyCallbackDBus {}



#[dbus_proxy_obj(BluetoothTelephonyCallback, "org.chromium.bluetooth.BluetoothTelephonyCallback")]

impl IBluetoothTelephonyCallback for BluetoothTelephonyCallbackDBus {

    #[dbus_method("OnTelephonyUse")]

    fn on_telephony_use(&mut self, addr: String, state: bool) {

        dbus_generated!()

    }

}



#[allow(dead_code)]

struct IBluetoothTelephonyDBus {}
@@ -14,6 +28,14 @@ struct IBluetoothTelephonyDBus {} 
    "org.chromium.bluetooth.BluetoothTelephony"

)]

impl IBluetoothTelephony for IBluetoothTelephonyDBus {

    #[dbus_method("RegisterTelephonyCallback")]

    fn register_telephony_callback(

        &mut self,

        callback: Box<dyn IBluetoothTelephonyCallback + Send>,

    ) -> bool {

        dbus_generated!()

    }



    #[dbus_method("SetNetworkAvailable")]

    fn set_network_available(&mut self, network_available: bool) {

        dbus_generated!()
@@ -34,6 +56,10 @@ impl IBluetoothTelephony for IBluetoothTelephonyDBus { 
    fn set_phone_ops_enabled(&mut self, enable: bool) {

        dbus_generated!()

    }

    #[dbus_method("SetMpsQualificationEnabled")]

    fn set_mps_qualification_enabled(&mut self, enable: bool) {

        dbus_generated!()

    }

    #[dbus_method("IncomingCall")]

    fn incoming_call(&mut self, number: String) -> bool {

        dbus_generated!()