Implement A2DP sink and AVRCP controller binder server (69986fe3) · Commits · e / os / android_packages_modules_Bluetooth

system/service/Android.bp

+9 −1

Original line number	Diff line number	Diff line
		@@ -14,11 +14,15 @@ cc_defaults {
		// Source variables
		// ========================================================
		btserviceDaemonSrc = [
		"a2dp_sink.cc",
		"adapter.cc",
		"avrcp_control.cc",
		"daemon.cc",
		"gatt_client.cc",
		"gatt_server.cc",
		"gatt_server_old.cc",
		"hal/bluetooth_av_interface.cc",
		"hal/bluetooth_avrcp_interface.cc",
		"hal/bluetooth_gatt_interface.cc",
		"hal/bluetooth_interface.cc",
		"ipc/ipc_handler.cc",
		@@ -36,6 +40,8 @@ btserviceLinuxSrc = [
		]

		btserviceBinderDaemonSrc = [
		"ipc/binder/bluetooth_a2dp_sink_binder_server.cc",
		"ipc/binder/bluetooth_avrcp_control_binder_server.cc",
		"ipc/binder/bluetooth_binder_server.cc",
		"ipc/binder/bluetooth_gatt_client_binder_server.cc",
		"ipc/binder/bluetooth_gatt_server_binder_server.cc",
		@@ -49,8 +55,10 @@ btserviceBinderDaemonSrc = [
		// Main unit test sources. These get built for host and target.
		// ========================================================
		btserviceBaseTestSrc = [
		"hal/fake_bluetooth_av_interface.cc",
		"hal/fake_bluetooth_gatt_interface.cc",
		"hal/fake_bluetooth_interface.cc",
		"test/a2dp_sink_unittest.cc",
		"test/adapter_unittest.cc",
		"test/advertise_data_unittest.cc",
		"test/fake_hal_util.cc",
		@@ -109,6 +117,7 @@ cc_test {
		"libgmock",
		"liblog",
		"libbluetooth-types",
		"libutils",
		],
		host_supported: true,
		target: {
		@@ -124,7 +133,6 @@ cc_test {
		],
		shared_libs: [
		"libbinder",
		"libutils",
		],
		},
		host: {

system/service/a2dp_sink.cc

0 → 100644

+154 −0

Original line number	Diff line number	Diff line
		//
		// Copyright 2017 Google, Inc.
		//
		// Licensed under the Apache License, Version 2.0 (the "License");
		// you may not use this file except in compliance with the License.
		// You may obtain a copy of the License at:
		//
		// http://www.apache.org/licenses/LICENSE-2.0
		//
		// Unless required by applicable law or agreed to in writing, software
		// distributed under the License is distributed on an "AS IS" BASIS,
		// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		// See the License for the specific language governing permissions and
		// limitations under the License.
		//

		#include "service/a2dp_sink.h"

		#include <base/logging.h>
		#include <base/memory/ptr_util.h>

		#include "service/logging_helpers.h"

		using bluetooth::hal::BluetoothAvInterface;

		namespace bluetooth {

		// static
		const int A2dpSink::kSingletonInstanceId = 0;

		A2dpSink::A2dpSink(const Uuid& uuid) : app_identifier_(uuid) {
		hal::BluetoothAvInterface::Get()->AddA2dpSinkObserver(this);
		}

		A2dpSink::~A2dpSink() {
		hal::BluetoothAvInterface::Get()->RemoveA2dpSinkObserver(this);
		}

		const Uuid& A2dpSink::GetAppIdentifier() const { return app_identifier_; }

		int A2dpSink::GetInstanceId() const { return kSingletonInstanceId; }

		void A2dpSink::SetDelegate(Delegate* delegate) {
		std::lock_guard<std::mutex> lock(delegate_mutex_);
		delegate_ = delegate;
		}

		bool A2dpSink::Enable() {
		std::lock_guard<std::mutex> lock(mutex_);
		return hal::BluetoothAvInterface::Get()->A2dpSinkEnable();
		}

		void A2dpSink::Disable() {
		std::lock_guard<std::mutex> lock(mutex_);
		hal::BluetoothAvInterface::Get()->A2dpSinkDisable();
		}

		bool A2dpSink::Connect(const std::string& device_address) {
		std::lock_guard<std::mutex> lock(mutex_);
		RawAddress addr;
		if (!RawAddress::FromString(device_address, addr)) {
		LOG(ERROR) << "Invalid device address given: " << device_address;
		return false;
		}

		bt_status_t status =
		hal::BluetoothAvInterface::Get()->GetA2dpSinkHALInterface()->connect(
		addr);
		if (status != BT_STATUS_SUCCESS) {
		LOG(ERROR) << "Failed to connect";
		return false;
		}

		return true;
		}

		bool A2dpSink::Disconnect(const std::string& device_address) {
		std::lock_guard<std::mutex> lock(mutex_);
		RawAddress addr;
		if (!RawAddress::FromString(device_address, addr)) {
		LOG(ERROR) << "Invalid device address given: " << device_address;
		return false;
		}

		bt_status_t status =
		hal::BluetoothAvInterface::Get()->GetA2dpSinkHALInterface()->disconnect(
		addr);
		if (status != BT_STATUS_SUCCESS) {
		LOG(ERROR) << "Failed to disconnect";
		return false;
		}

		return true;
		}

		void A2dpSink::SetAudioFocusState(int focus_state) {
		std::lock_guard<std::mutex> lock(mutex_);
		hal::BluetoothAvInterface::Get()
		->GetA2dpSinkHALInterface()
		->set_audio_focus_state(focus_state);
		}

		void A2dpSink::SetAudioTrackGain(float gain) {
		std::lock_guard<std::mutex> lock(mutex_);
		hal::BluetoothAvInterface::Get()
		->GetA2dpSinkHALInterface()
		->set_audio_track_gain(gain);
		}

		void A2dpSink::ConnectionStateCallback(BluetoothAvInterface* iface,
		const RawAddress& bd_addr,
		btav_connection_state_t state) {
		std::string device_address = BtAddrString(&bd_addr);
		std::lock_guard<std::mutex> lock(delegate_mutex_);

		if (delegate_)
		delegate_->OnConnectionState(device_address, static_cast<int>(state));
		}

		void A2dpSink::AudioStateCallback(BluetoothAvInterface* iface,
		const RawAddress& bd_addr,
		btav_audio_state_t state) {
		std::string device_address = BtAddrString(&bd_addr);
		std::lock_guard<std::mutex> lock(delegate_mutex_);

		if (delegate_)
		delegate_->OnAudioState(device_address, static_cast<int>(state));
		}

		void A2dpSink::AudioConfigCallback(BluetoothAvInterface* iface,
		const RawAddress& bd_addr,
		uint32_t sample_rate,
		uint8_t channel_count) {
		std::string device_address = BtAddrString(&bd_addr);
		std::lock_guard<std::mutex> lock(delegate_mutex_);
		if (delegate_)
		delegate_->OnAudioConfig(device_address, sample_rate, channel_count);
		}

		// A2dpSinkFactory implementation
		// ========================================================
		A2dpSinkFactory::A2dpSinkFactory() = default;
		A2dpSinkFactory::~A2dpSinkFactory() = default;

		bool A2dpSinkFactory::RegisterInstance(const Uuid& uuid,
		const RegisterCallback& callback) {
		VLOG(1) << __func__ << " - Uuid: " << uuid.ToString();

		auto a2dp_sink = base::WrapUnique(new A2dpSink(uuid));
		callback(BLE_STATUS_SUCCESS, uuid, std::move(a2dp_sink));
		return true;
		}

		} // namespace bluetooth

system/service/a2dp_sink.h

0 → 100644

+103 −0

Original line number	Diff line number	Diff line
		//
		// Copyright (C) 2017 Google, Inc.
		//
		// Licensed under the Apache License, Version 2.0 (the "License");
		// you may not use this file except in compliance with the License.
		// You may obtain a copy of the License at:
		//
		// http://www.apache.org/licenses/LICENSE-2.0
		//
		// Unless required by applicable law or agreed to in writing, software
		// distributed under the License is distributed on an "AS IS" BASIS,
		// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		// See the License for the specific language governing permissions and
		// limitations under the License.
		//

		#pragma once

		#include <atomic>
		#include <mutex>
		#include <string>
		#include <vector>

		#include <base/macros.h>

		#include "service/bluetooth_instance.h"
		#include "service/hal/bluetooth_av_interface.h"

		namespace bluetooth {

		class A2dpSink : public BluetoothInstance,
		private hal::BluetoothAvInterface::A2dpSinkObserver {
		public:
		// We only allow one instance of this object at a time.
		static const int kSingletonInstanceId;

		class Delegate {
		public:
		virtual void OnConnectionState(const std::string& device_address,
		int state) = 0;
		virtual void OnAudioState(const std::string& device_address, int state) = 0;
		virtual void OnAudioConfig(const std::string& device_address,
		uint32_t sample_rate, uint8_t channel_count) = 0;

		protected:
		virtual ~Delegate() = default;
		};

		~A2dpSink() override;

		void SetDelegate(Delegate* delegate);

		// BluetoothInstance implementation:
		const Uuid& GetAppIdentifier() const override;
		int GetInstanceId() const override;

		bool Enable();
		void Disable();
		bool Connect(const std::string& device_address);
		bool Disconnect(const std::string& device_address);
		void SetAudioFocusState(int focus_state);
		void SetAudioTrackGain(float gain);

		private:
		friend class A2dpSinkFactory;

		explicit A2dpSink(const Uuid& uuid);

		// hal::bluetooth::hal::BluetoothAvInterface::Observer implementation:
		void ConnectionStateCallback(bluetooth::hal::BluetoothAvInterface* iface,
		const RawAddress& bd_addr,
		btav_connection_state_t state) override;
		void AudioStateCallback(bluetooth::hal::BluetoothAvInterface* iface,
		const RawAddress& bd_addr,
		btav_audio_state_t state) override;
		void AudioConfigCallback(bluetooth::hal::BluetoothAvInterface* iface,
		const RawAddress& bd_addr, uint32_t sample_rate,
		uint8_t channel_count) override;

		// See getters above for documentation.
		const Uuid app_identifier_;

		std::mutex mutex_;
		std::mutex delegate_mutex_;
		Delegate* delegate_ = nullptr;

		DISALLOW_COPY_AND_ASSIGN(A2dpSink);
		};

		class A2dpSinkFactory : public BluetoothInstanceFactory {
		public:
		A2dpSinkFactory();
		~A2dpSinkFactory() override;

		// BluetoothInstanceFactory override:
		bool RegisterInstance(const Uuid& uuid,
		const RegisterCallback& callback) override;

		private:
		DISALLOW_COPY_AND_ASSIGN(A2dpSinkFactory);
		};

		} // namespace bluetooth

system/service/adapter.cc

+377 −2

Original line number	Diff line number	Diff line
		@@ -24,6 +24,8 @@
		#include <base/logging.h>
		#include <base/observer_list.h>

		#include "service/a2dp_sink.h"
		#include "service/avrcp_control.h"
		#include "service/common/bluetooth/util/atomic_string.h"
		#include "service/gatt_client.h"
		#include "service/gatt_server.h"
		@@ -33,11 +35,97 @@
		#include "service/low_energy_client.h"
		#include "service/low_energy_scanner.h"

		using android::String16;
		using std::lock_guard;
		using std::mutex;

		namespace bluetooth {

		namespace {

		RemoteDeviceProps ParseRemoteDeviceProps(int num_properties,
		bt_property_t* properties) {
		android::String16 name;
		android::String16 address;
		std::vector<Uuid> service_uuids;
		int32_t device_class = 0;
		int32_t device_type = 0;
		int32_t rssi = 0;

		for (int i = 0; i < num_properties; ++i) {
		bt_property_t* property = properties + i;
		switch (property->type) {
		case BT_PROPERTY_BDNAME: {
		if (property->len < 0) {
		NOTREACHED() << "Invalid length for BT_PROPERTY_BDNAME";
		break;
		}
		bt_bdname_t* hal_name = reinterpret_cast<bt_bdname_t*>(property->val);
		name = String16(reinterpret_cast<char*>(hal_name->name));
		break;
		}
		case BT_PROPERTY_BDADDR: {
		if (property->len != sizeof(RawAddress)) {
		NOTREACHED() << "Invalid length for BT_PROPERTY_BDADDR";
		break;
		}
		std::string remote_bdaddr_str =
		BtAddrString(reinterpret_cast<RawAddress*>(property->val));
		address = String16(remote_bdaddr_str.c_str(), remote_bdaddr_str.size());
		break;
		}
		case BT_PROPERTY_UUIDS: {
		if (property->len < 0) {
		NOTREACHED() << "Negative length on BT_PROPERTY_UUIDS:";
		break;
		}
		if (property->len % sizeof(Uuid::UUID128Bit) != 0) {
		NOTREACHED() << "Trailing bytes on BT_PROPERTY_UUIDS:";
		}
		auto uuids = static_cast<const Uuid::UUID128Bit*>(property->val);

		for (size_t i = 0; i < property->len / sizeof(Uuid::UUID128Bit); ++i) {
		service_uuids.push_back(Uuid::From128BitLE(uuids[i]));
		}
		break;
		}
		case BT_PROPERTY_CLASS_OF_DEVICE: {
		if (property->len != sizeof(int32_t)) {
		NOTREACHED() << "Invalid length for BT_PROPERTY_CLASS_OF_DEVICE";
		break;
		}
		device_class = reinterpret_cast<const int32_t>(property->val);
		break;
		}
		case BT_PROPERTY_TYPE_OF_DEVICE: {
		if (property->len != sizeof(int32_t)) {
		NOTREACHED() << "Invalid length for BT_PROPERTY_TYPE_OF_DEVICE";
		break;
		}
		device_type = reinterpret_cast<const int32_t>(property->val);
		break;
		}
		case BT_PROPERTY_REMOTE_RSSI: {
		if (property->len != sizeof(int8_t)) {
		NOTREACHED() << "Invalid length for BT_PROPERTY_REMOTE_RSSI";
		break;
		}
		rssi = reinterpret_cast<const int8_t>(property->val);
		break;
		}
		default:
		VLOG(1) << "Unhandled adapter property: "
		<< BtPropertyText(property->type);
		break;
		}
		}

		return RemoteDeviceProps(name, address, service_uuids, device_class,
		device_type, rssi);
		}

		} // namespace

		// static
		const char Adapter::kDefaultAddress[] = "00:00:00:00:00:00";
		// static
		@@ -69,6 +157,41 @@ void Adapter::Observer::OnDeviceConnectionStateChanged(
		// Default implementation does nothing
		}

		void Adapter::Observer::OnScanEnableChanged(Adapter* adapter,
		bool scan_enabled) {
		// Default implementation does nothing
		}

		void Adapter::Observer::OnSspRequest(Adapter* adapter,
		const std::string& device_address,
		const std::string& device_name, int cod,
		int pairing_variant, int pass_key) {
		// Default implementation does nothing
		}

		void Adapter::Observer::OnBondStateChanged(Adapter* adapter, int status,
		const std::string& device_address,
		int state) {
		// Default implementation does nothing
		}

		void Adapter::Observer::OnGetBondedDevices(
		Adapter* adapter, int status,
		const std::vector<std::string>& bonded_devices) {
		// Default implementation does nothing
		}

		void Adapter::Observer::OnGetRemoteDeviceProperties(
		Adapter* adapter, int status, const std::string& device_address,
		const RemoteDeviceProps& properties) {
		// Default implementation does nothing
		}

		void Adapter::Observer::OnDeviceFound(Adapter* adapter,
		const RemoteDeviceProps& properties) {
		// Default implementation does nothing
		}

		// The real Adapter implementation used in production.
		class AdapterImpl : public Adapter, public hal::BluetoothInterface::Observer {
		public:
		@@ -78,6 +201,8 @@ class AdapterImpl : public Adapter, public hal::BluetoothInterface::Observer {
		name_(kDefaultName) {
		memset(&local_le_features_, 0, sizeof(local_le_features_));
		hal::BluetoothInterface::Get()->AddObserver(this);
		a2dp_sink_factory_.reset(new A2dpSinkFactory);
		avrcp_control_factory_.reset(new AvrcpControlFactory);
		ble_client_factory_.reset(new LowEnergyClientFactory(*this));
		ble_advertiser_factory_.reset(new LowEnergyAdvertiserFactory());
		ble_scanner_factory_.reset(new LowEnergyScannerFactory(*this));
		@@ -183,6 +308,84 @@ class AdapterImpl : public Adapter, public hal::BluetoothInterface::Observer {

		std::string GetAddress() const override { return address_.Get(); }

		bool SetScanMode(int scan_mode) override {
		switch (scan_mode) {
		case BT_SCAN_MODE_NONE:
		case BT_SCAN_MODE_CONNECTABLE:
		case BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE:
		break;
		default:
		LOG(ERROR) << "Unknown scan mode: " << scan_mode;
		return false;
		}

		auto bd_scanmode = static_cast<bt_scan_mode_t>(scan_mode);

		if (!SetAdapterProperty(BT_PROPERTY_ADAPTER_SCAN_MODE, &bd_scanmode,
		sizeof(bd_scanmode))) {
		LOG(ERROR) << "Failed to set scan mode to : " << scan_mode;
		return false;
		}

		return true;
		}

		bool SetScanEnable(bool scan_enable) override {
		if (scan_enable) {
		int status =
		hal::BluetoothInterface::Get()->GetHALInterface()->start_discovery();
		if (status != BT_STATUS_SUCCESS) {
		LOG(ERROR) << "Failed to enable scanning";
		return false;
		}
		} else {
		int status =
		hal::BluetoothInterface::Get()->GetHALInterface()->cancel_discovery();
		if (status != BT_STATUS_SUCCESS) {
		LOG(ERROR) << "Failed to disable scanning";
		return false;
		}
		}
		return true;
		}

		bool SspReply(const std::string& device_address, int variant, bool accept,
		int32_t pass_key) override {
		RawAddress addr;
		if (!RawAddress::FromString(device_address, addr)) {
		LOG(ERROR) << "Invalid device address given: " << device_address;
		return false;
		}

		int status = hal::BluetoothInterface::Get()->GetHALInterface()->ssp_reply(
		&addr, static_cast<bt_ssp_variant_t>(variant), accept, pass_key);
		if (status != BT_STATUS_SUCCESS) {
		LOG(ERROR) << "Failed to send SSP response - status: "
		<< BtStatusText((const bt_status_t)status);
		return false;
		}

		return true;
		}

		bool CreateBond(const std::string& device_address, int transport) override {
		RawAddress addr;
		if (!RawAddress::FromString(device_address, addr)) {
		LOG(ERROR) << "Invalid device address given: " << device_address;
		return false;
		}

		int status = hal::BluetoothInterface::Get()->GetHALInterface()->create_bond(
		&addr, transport);
		if (status != BT_STATUS_SUCCESS) {
		LOG(ERROR) << "Failed to create bond - status: "
		<< BtStatusText((const bt_status_t)status);
		return false;
		}

		return true;
		}

		bool IsMultiAdvertisementSupported() override {
		lock_guard<mutex> lock(local_le_features_lock_);
		return local_le_features_.max_adv_instance >= kMinAdvInstancesForMultiAdv;
		@@ -209,6 +412,64 @@ class AdapterImpl : public Adapter, public hal::BluetoothInterface::Observer {
		kMinOffloadedScanStorageBytes;
		}

		bool GetBondedDevices() override {
		int status =
		hal::BluetoothInterface::Get()->GetHALInterface()->get_adapter_property(
		BT_PROPERTY_ADAPTER_BONDED_DEVICES);
		if (status != BT_STATUS_SUCCESS) {
		LOG(ERROR) << "Failed to get bonded devices. Status: "
		<< BtStatusText(static_cast<bt_status_t>(status));
		return false;
		}

		return true;
		}

		bool RemoveBond(const std::string& device_address) override {
		RawAddress addr;
		if (!RawAddress::FromString(device_address, addr)) {
		LOG(ERROR) << "Invalid device address given: " << device_address;
		return false;
		}

		int status =
		hal::BluetoothInterface::Get()->GetHALInterface()->remove_bond(&addr);
		if (status != BT_STATUS_SUCCESS) {
		LOG(ERROR) << "Failed to send remove bond - status: "
		<< BtStatusText(static_cast<bt_status_t>(status));
		return false;
		}

		return true;
		}

		bool GetRemoteDeviceProperties(const std::string& device_address) override {
		RawAddress addr;
		if (!RawAddress::FromString(device_address, addr)) {
		LOG(ERROR) << "Invalid device address given: " << device_address;
		return false;
		}

		int status = hal::BluetoothInterface::Get()
		->GetHALInterface()
		->get_remote_device_properties(&addr);
		if (status != BT_STATUS_SUCCESS) {
		LOG(ERROR) << "Failed to send GetRemoteDeviceProperties - status: "
		<< BtStatusText((const bt_status_t)status);
		return false;
		}

		return true;
		}

		A2dpSinkFactory* GetA2dpSinkFactory() const override {
		return a2dp_sink_factory_.get();
		}

		AvrcpControlFactory* GetAvrcpControlFactory() const override {
		return avrcp_control_factory_.get();
		}

		LowEnergyClientFactory* GetLowEnergyClientFactory() const override {
		return ble_client_factory_.get();
		}
		@@ -257,6 +518,16 @@ class AdapterImpl : public Adapter, public hal::BluetoothInterface::Observer {

		if (status != BT_STATUS_SUCCESS) {
		LOG(ERROR) << "status: " << BtStatusText(status);

		for (int i = 0; i < num_properties; ++i) {
		bt_property_t* property = properties + i;
		if (property->type == BT_PROPERTY_ADAPTER_BONDED_DEVICES) {
		lock_guard<mutex> lock(observers_lock_);
		for (auto& observer : observers_) {
		observer.OnGetBondedDevices(this, status, {});
		}
		}
		}
		return;
		}

		@@ -290,6 +561,29 @@ class AdapterImpl : public Adapter, public hal::BluetoothInterface::Observer {
		LOG(INFO) << "Supported LE features updated";
		break;
		}
		case BT_PROPERTY_ADAPTER_BONDED_DEVICES: {
		if (property->len < 0) {
		NOTREACHED() << "Negative property length";
		break;
		}
		auto addrs = reinterpret_cast<const RawAddress*>(property->val);
		if (property->len % sizeof(addrs[0]) != 0) {
		LOG(ERROR) << "Invalid property length: " << property->len;
		// TODO(bcf): Seems to be a bug where we hit this somewhat
		// frequently.
		break;
		}
		std::vector<std::string> str_addrs;

		for (size_t i = 0; i < property->len / sizeof(addrs[0]); ++i)
		str_addrs.push_back(BtAddrString(addrs + i));

		lock_guard<mutex> lock(observers_lock_);
		for (auto& observer : observers_) {
		observer.OnGetBondedDevices(this, status, str_addrs);
		}
		break;
		}
		default:
		VLOG(1) << "Unhandled adapter property: "
		<< BtPropertyText(property->type);
		@@ -300,9 +594,84 @@ class AdapterImpl : public Adapter, public hal::BluetoothInterface::Observer {
		}
		}

		void SSPRequestCallback(RawAddress, bt_bdname_t, uint32_t, bt_ssp_variant_t,
		void RemoteDevicePropertiesCallback(bt_status_t status,
		RawAddress* remote_bdaddr,
		int num_properties,
		bt_property_t* properties) override {
		std::string device_address = BtAddrString(remote_bdaddr);
		if (status != BT_STATUS_SUCCESS) {
		lock_guard<mutex> lock(observers_lock_);
		for (auto& observer : observers_) {
		observer.OnGetRemoteDeviceProperties(this, status, device_address,
		RemoteDeviceProps());
		}
		return;
		}

		RemoteDeviceProps props =
		ParseRemoteDeviceProps(num_properties, properties);

		std::string remote_bdaddr_str = BtAddrString(remote_bdaddr);
		android::String16 address =
		String16(remote_bdaddr_str.c_str(), remote_bdaddr_str.size());
		props.set_address(address);

		lock_guard<mutex> lock(observers_lock_);
		for (auto& observer : observers_) {
		observer.OnGetRemoteDeviceProperties(this, status, device_address, props);
		}
		}

		void DeviceFoundCallback(int num_properties,
		bt_property_t* properties) override {
		RemoteDeviceProps props =
		ParseRemoteDeviceProps(num_properties, properties);

		lock_guard<mutex> lock(observers_lock_);
		for (auto& observer : observers_) {
		observer.OnDeviceFound(this, props);
		}
		}

		void DiscoveryStateChangedCallback(bt_discovery_state_t state) override {
		bool enabled = false;
		switch (state) {
		case BT_DISCOVERY_STOPPED:
		enabled = false;
		break;
		case BT_DISCOVERY_STARTED:
		enabled = true;
		break;
		default:
		NOTREACHED();
		}

		for (auto& observer : observers_) {
		observer.OnScanEnableChanged(this, enabled);
		}
		}

		void SSPRequestCallback(RawAddress* remote_bdaddr, bt_bdname_t* bd_name,
		uint32_t cod, bt_ssp_variant_t pairing_variant,
		uint32_t pass_key) override {
		LOG(INFO) << "Passkey is: " << pass_key;
		std::string device_address = BtAddrString(remote_bdaddr);
		std::string name = reinterpret_cast<char*>(bd_name->name);

		lock_guard<mutex> lock(observers_lock_);
		for (auto& observer : observers_) {
		observer.OnSspRequest(this, device_address, name, cod, pairing_variant,
		pass_key);
		}
		}

		void BondStateChangedCallback(bt_status_t status, RawAddress* remote_bdaddr,
		bt_bond_state_t state) override {
		std::string device_address = BtAddrString(remote_bdaddr);

		lock_guard<mutex> lock(observers_lock_);
		for (auto& observer : observers_) {
		observer.OnBondStateChanged(this, status, device_address, state);
		}
		}

		void AclStateChangedCallback(bt_status_t status,
		@@ -392,6 +761,12 @@ class AdapterImpl : public Adapter, public hal::BluetoothInterface::Observer {
		std::mutex connected_devices_lock_;
		std::unordered_set<std::string> connected_devices_;

		// Factory used to create per-app A2dpSink instances.
		std::unique_ptr<A2dpSinkFactory> a2dp_sink_factory_;

		// Factory used to create per-app AvrcpControl instances.
		std::unique_ptr<AvrcpControlFactory> avrcp_control_factory_;

		// Factory used to create per-app LowEnergyClient instances.
		std::unique_ptr<LowEnergyClientFactory> ble_client_factory_;

system/service/adapter.h

+67 −1

File changed.

Preview size limit exceeded, changes collapsed.