Merge changes I17ccda26,Ie4904c38,I93b83535,I595819d0,Id2975243, ... am: d8170d3d7a (9ae81abc) · Commits · e / os / android_packages_modules_Bluetooth

system/gd/common/bind.h

+5 −0

Original line number	Diff line number	Diff line
		@@ -30,5 +30,10 @@ using base::Passed;
		using base::RetainedRef;
		using base::Unretained;

		template <typename T, typename Functor, typename... Args>
		inline base::Callback<base::MakeUnboundRunType<Functor, T, Args...>> BindOn(T* obj, Functor&& functor, Args&&... args) {
		return common::Bind(std::forward<Functor>(functor), common::Unretained(obj), std::forward<Args>(args)...);
		}

		} // namespace common
		} // namespace bluetooth

system/gd/hci/hci_layer.cc

+97 −167

Original line number	Diff line number	Diff line
		@@ -22,8 +22,10 @@
		#include "os/queue.h"
		#include "packet/packet_builder.h"

		namespace {
		namespace bluetooth {
		namespace hci {
		using bluetooth::common::Bind;
		using bluetooth::common::BindOn;
		using bluetooth::common::BindOnce;
		using bluetooth::common::Callback;
		using bluetooth::common::Closure;
		@@ -35,23 +37,37 @@ using bluetooth::hci::CommandStatusView;
		using bluetooth::hci::EventPacketView;
		using bluetooth::hci::LeMetaEventView;
		using bluetooth::os::Handler;
		using common::BidiQueue;
		using common::BidiQueueEnd;
		using hci::OpCode;
		using hci::ResetCompleteView;
		using os::Alarm;
		using os::Handler;

		static void fail_if_reset_complete_not_success(CommandCompleteView complete) {
		auto reset_complete = ResetCompleteView::Create(complete);
		ASSERT(reset_complete.IsValid());
		ASSERT(reset_complete.GetStatus() == ErrorCode::SUCCESS);
		}

		static void on_hci_timeout(OpCode op_code) {
		ASSERT_LOG(false, "Timed out waiting for 0x%02hx (%s)", op_code, OpCodeText(op_code).c_str());
		}

		template <typename T>
		class EventHandler {
		public:
		EventHandler() : event_handler(), handler(nullptr) {}
		EventHandler(Callback<void(EventPacketView)> on_event, Handler* on_event_handler)
		: event_handler(std::move(on_event)), handler(on_event_handler) {}
		Callback<void(EventPacketView)> event_handler;
		EventHandler() : callback(), handler(nullptr) {}
		EventHandler(Callback<void(T)> on_event, Handler* on_event_handler)
		: callback(std::move(on_event)), handler(on_event_handler) {}
		Callback<void(T)> callback;
		Handler* handler;
		};

		class SubeventHandler {
		public:
		SubeventHandler() : subevent_handler(), handler(nullptr) {}
		SubeventHandler(Callback<void(LeMetaEventView)> on_event, Handler* on_event_handler)
		: subevent_handler(std::move(on_event)), handler(on_event_handler) {}
		Callback<void(LeMetaEventView)> subevent_handler;
		Handler* handler;
		void Post(T event) {
		if (handler != nullptr) {
		handler->Post(BindOnce(callback, event));
		}
		}
		};

		class CommandQueueEntry {
		@@ -72,30 +88,6 @@ class CommandQueueEntry {
		OnceCallback<void(CommandCompleteView)> on_complete;
		Handler* caller_handler;
		};
		} // namespace

		namespace bluetooth {
		namespace hci {

		using common::BidiQueue;
		using common::BidiQueueEnd;
		using os::Alarm;
		using os::Handler;

		namespace {
		using hci::OpCode;
		using hci::ResetCompleteView;

		void fail_if_reset_complete_not_success(CommandCompleteView complete) {
		auto reset_complete = ResetCompleteView::Create(complete);
		ASSERT(reset_complete.IsValid());
		ASSERT(reset_complete.GetStatus() == ErrorCode::SUCCESS);
		}

		void on_hci_timeout(OpCode op_code) {
		ASSERT_LOG(false, "Timed out waiting for 0x%02hx (%s)", op_code, OpCodeText(op_code).c_str());
		}
		} // namespace

		template <typename T>
		class CommandInterfaceImpl : public CommandInterface<T> {
		@@ -115,7 +107,7 @@ class CommandInterfaceImpl : public CommandInterface<T> {
		HciLayer& hci_;
		};

		struct HciLayer::impl : public hal::HciHalCallbacks {
		struct HciLayer::impl {
		impl(HciLayer& module) : hal_(nullptr), module_(module) {}

		void Start(hal::HciHal* hal) {
		@@ -124,33 +116,29 @@ struct HciLayer::impl : public hal::HciHalCallbacks {

		auto queue_end = acl_queue_.GetDownEnd();
		Handler* handler = module_.GetHandler();
		queue_end->RegisterDequeue(handler, Bind(&impl::dequeue_and_send_acl, common::Unretained(this)));
		RegisterEventHandler(EventCode::COMMAND_COMPLETE, Bind(&impl::command_complete_callback, common::Unretained(this)),
		handler);
		RegisterEventHandler(EventCode::COMMAND_STATUS, Bind(&impl::command_status_callback, common::Unretained(this)),
		handler);
		RegisterEventHandler(EventCode::LE_META_EVENT, Bind(&impl::le_meta_event_callback, common::Unretained(this)),
		handler);
		queue_end->RegisterDequeue(handler, BindOn(this, &impl::on_outbound_acl_ready));
		module_.RegisterEventHandler(EventCode::COMMAND_COMPLETE, BindOn(this, &impl::on_command_complete), handler);
		module_.RegisterEventHandler(EventCode::COMMAND_STATUS, BindOn(this, &impl::on_command_status), handler);
		module_.RegisterEventHandler(EventCode::LE_META_EVENT, BindOn(this, &impl::on_le_meta_event), handler);
		// TODO find the right place
		RegisterEventHandler(EventCode::PAGE_SCAN_REPETITION_MODE_CHANGE, Bind(&impl::drop, common::Unretained(this)),
		handler);
		RegisterEventHandler(EventCode::MAX_SLOTS_CHANGE, Bind(&impl::drop, common::Unretained(this)), handler);
		RegisterEventHandler(EventCode::VENDOR_SPECIFIC, Bind(&impl::drop, common::Unretained(this)), handler);
		module_.RegisterEventHandler(EventCode::PAGE_SCAN_REPETITION_MODE_CHANGE, BindOn(this, &impl::drop), handler);
		module_.RegisterEventHandler(EventCode::MAX_SLOTS_CHANGE, BindOn(this, &impl::drop), handler);
		module_.RegisterEventHandler(EventCode::VENDOR_SPECIFIC, BindOn(this, &impl::drop), handler);

		EnqueueCommand(ResetBuilder::Create(), BindOnce(&fail_if_reset_complete_not_success), handler);
		hal_->registerIncomingPacketCallback(this);
		module_.EnqueueCommand(ResetBuilder::Create(), BindOnce(&fail_if_reset_complete_not_success), handler);
		}

		void drop(EventPacketView) {}

		void dequeue_and_send_acl() {
		void on_outbound_acl_ready() {
		auto packet = acl_queue_.GetDownEnd()->TryDequeue();
		send_acl(std::move(packet));
		std::vector<uint8_t> bytes;
		BitInserter bi(bytes);
		packet->Serialize(bi);
		hal_->sendAclData(bytes);
		}

		void Stop() {
		hal_->unregisterIncomingPacketCallback();

		acl_queue_.GetDownEnd()->UnregisterDequeue();
		incoming_acl_packet_buffer_.Clear();
		delete hci_timeout_alarm_;
		@@ -158,21 +146,7 @@ struct HciLayer::impl : public hal::HciHalCallbacks {
		hal_ = nullptr;
		}

		void send_acl(std::unique_ptr<hci::BasePacketBuilder> packet) {
		std::vector<uint8_t> bytes;
		BitInserter bi(bytes);
		packet->Serialize(bi);
		hal_->sendAclData(bytes);
		}

		void send_sco(std::unique_ptr<hci::BasePacketBuilder> packet) {
		std::vector<uint8_t> bytes;
		BitInserter bi(bytes);
		packet->Serialize(bi);
		hal_->sendScoData(bytes);
		}

		void command_status_callback(EventPacketView event) {
		void on_command_status(EventPacketView event) {
		CommandStatusView status_view = CommandStatusView::Create(event);
		ASSERT(status_view.IsValid());
		command_credits_ = status_view.GetNumHciCommandPackets();
		@@ -196,7 +170,7 @@ struct HciLayer::impl : public hal::HciHalCallbacks {
		send_next_command();
		}

		void command_complete_callback(EventPacketView event) {
		void on_command_complete(EventPacketView event) {
		CommandCompleteView complete_view = CommandCompleteView::Create(event);
		ASSERT(complete_view.IsValid());
		command_credits_ = complete_view.GetNumHciCommandPackets();
		@@ -220,66 +194,22 @@ struct HciLayer::impl : public hal::HciHalCallbacks {
		send_next_command();
		}

		void le_meta_event_callback(EventPacketView event) {
		void on_le_meta_event(EventPacketView event) {
		LeMetaEventView meta_event_view = LeMetaEventView::Create(event);
		ASSERT(meta_event_view.IsValid());
		SubeventCode subevent_code = meta_event_view.GetSubeventCode();
		ASSERT_LOG(subevent_handlers_.find(subevent_code) != subevent_handlers_.end(),
		"Unhandled le event of type 0x%02hhx (%s)", subevent_code, SubeventCodeText(subevent_code).c_str());
		auto& registered = subevent_handlers_[subevent_code];
		if (registered.handler != nullptr) {
		registered.handler->Post(BindOnce(registered.subevent_handler, meta_event_view));
		} else {
		LOG_DEBUG("Dropping unregistered le event of type 0x%02hhx (%s)", subevent_code,
		SubeventCodeText(subevent_code).c_str());
		}
		}

		// Invoked from HAL thread
		void hciEventReceived(hal::HciPacket event_bytes) override {
		auto packet = packet::PacketView<packet::kLittleEndian>(std::make_shared<std::vector<uint8_t>>(event_bytes));
		EventPacketView event = EventPacketView::Create(packet);
		ASSERT(event.IsValid());
		module_.GetHandler()->Post(
		BindOnce(&HciLayer::impl::hci_event_received_handler, common::Unretained(this), std::move(event)));
		subevent_handlers_[subevent_code].Post(meta_event_view);
		}

		void hci_event_received_handler(EventPacketView event) {
		void on_hci_event(EventPacketView event) {
		EventCode event_code = event.GetEventCode();
		if (event_handlers_.find(event_code) == event_handlers_.end()) {
		LOG_DEBUG("Dropping unregistered event of type 0x%02hhx (%s)", event_code, EventCodeText(event_code).c_str());
		return;
		}
		auto& registered = event_handlers_[event_code];
		if (registered.handler != nullptr) {
		registered.handler->Post(BindOnce(registered.event_handler, event));
		}
		}

		// From HAL thread
		void aclDataReceived(hal::HciPacket data_bytes) override {
		auto packet =
		packet::PacketView<packet::kLittleEndian>(std::make_shared<std::vector<uint8_t>>(std::move(data_bytes)));
		AclPacketView acl = AclPacketView::Create(packet);
		incoming_acl_packet_buffer_.Enqueue(std::make_unique<AclPacketView>(acl), module_.GetHandler());
		}

		void scoDataReceived(hal::HciPacket data_bytes) override {
		auto packet = packet::PacketView<packet::kLittleEndian>(std::make_shared<std::vector<uint8_t>>(data_bytes));
		ScoPacketView sco = ScoPacketView::Create(packet);
		}

		void EnqueueCommand(std::unique_ptr<CommandPacketBuilder> command,
		OnceCallback<void(CommandCompleteView)> on_complete, os::Handler* handler) {
		module_.GetHandler()->Post(common::BindOnce(&impl::handle_enqueue_command_with_complete, common::Unretained(this),
		std::move(command), std::move(on_complete),
		common::Unretained(handler)));
		}

		void EnqueueCommand(std::unique_ptr<CommandPacketBuilder> command, OnceCallback<void(CommandStatusView)> on_status,
		os::Handler* handler) {
		module_.GetHandler()->Post(common::BindOnce(&impl::handle_enqueue_command_with_status, common::Unretained(this),
		std::move(command), std::move(on_status), common::Unretained(handler)));
		event_handlers_[event_code].Post(event);
		}

		void handle_enqueue_command_with_complete(std::unique_ptr<CommandPacketBuilder> command,
		@@ -318,35 +248,15 @@ struct HciLayer::impl : public hal::HciHalCallbacks {
		hci_timeout_alarm_->Schedule(BindOnce(&on_hci_timeout, op_code), kHciTimeoutMs);
		}

		BidiQueueEnd<AclPacketBuilder, AclPacketView>* GetAclQueueEnd() {
		return acl_queue_.GetUpEnd();
		}

		void RegisterEventHandler(EventCode event_code, Callback<void(EventPacketView)> event_handler, os::Handler* handler) {
		module_.GetHandler()->Post(common::BindOnce(&impl::handle_register_event_handler, common::Unretained(this),
		event_code, event_handler, common::Unretained(handler)));
		}

		void handle_register_event_handler(EventCode event_code, Callback<void(EventPacketView)> event_handler,
		os::Handler* handler) {
		ASSERT_LOG(event_handlers_.count(event_code) == 0, "Can not register a second handler for event_code %02hhx (%s)",
		event_code, EventCodeText(event_code).c_str());
		event_handlers_[event_code] = EventHandler(event_handler, handler);
		}

		void UnregisterEventHandler(EventCode event_code) {
		module_.GetHandler()->Post(
		common::BindOnce(&impl::handle_unregister_event_handler, common::Unretained(this), event_code));
		event_handlers_[event_code] = EventHandler<EventPacketView>(event_handler, handler);
		}

		void handle_unregister_event_handler(EventCode event_code) {
		event_handlers_[event_code] = EventHandler();
		}

		void RegisterLeEventHandler(SubeventCode subevent_code, Callback<void(LeMetaEventView)> event_handler,
		os::Handler* handler) {
		module_.GetHandler()->Post(common::BindOnce(&impl::handle_register_le_event_handler, common::Unretained(this),
		subevent_code, event_handler, common::Unretained(handler)));
		event_handlers_[event_code] = EventHandler<EventPacketView>();
		}

		void handle_register_le_event_handler(SubeventCode subevent_code, Callback<void(LeMetaEventView)> subevent_handler,
		@@ -354,16 +264,11 @@ struct HciLayer::impl : public hal::HciHalCallbacks {
		ASSERT_LOG(subevent_handlers_.count(subevent_code) == 0,
		"Can not register a second handler for subevent_code %02hhx (%s)", subevent_code,
		SubeventCodeText(subevent_code).c_str());
		subevent_handlers_[subevent_code] = SubeventHandler(subevent_handler, handler);
		}

		void UnregisterLeEventHandler(SubeventCode subevent_code) {
		module_.GetHandler()->Post(
		common::BindOnce(&impl::handle_unregister_le_event_handler, common::Unretained(this), subevent_code));
		subevent_handlers_[subevent_code] = EventHandler<LeMetaEventView>(subevent_handler, handler);
		}

		void handle_unregister_le_event_handler(SubeventCode subevent_code) {
		subevent_handlers_[subevent_code] = SubeventHandler();
		subevent_handlers_[subevent_code] = EventHandler<LeMetaEventView>();
		}

		// The HAL
		@@ -383,8 +288,8 @@ struct HciLayer::impl : public hal::HciHalCallbacks {
		// Command Handling
		std::list<CommandQueueEntry> command_queue_;

		std::map<EventCode, EventHandler> event_handlers_;
		std::map<SubeventCode, SubeventHandler> subevent_handlers_;
		std::map<EventCode, EventHandler<EventPacketView>> event_handlers_;
		std::map<SubeventCode, EventHandler<LeMetaEventView>> subevent_handlers_;
		OpCode waiting_command_{OpCode::NONE};
		uint8_t command_credits_{1}; // Send reset first
		Alarm* hci_timeout_alarm_{nullptr};
		@@ -394,42 +299,70 @@ struct HciLayer::impl : public hal::HciHalCallbacks {
		os::EnqueueBuffer<AclPacketView> incoming_acl_packet_buffer_{acl_queue_.GetDownEnd()};
		};

		HciLayer::HciLayer() : impl_(std::make_unique<impl>(*this)) {}
		// All functions here are running on the HAL thread
		struct HciLayer::hal_callbacks : public hal::HciHalCallbacks {
		hal_callbacks(HciLayer& module) : module_(module) {}

		void hciEventReceived(hal::HciPacket event_bytes) override {
		auto packet = packet::PacketView<packet::kLittleEndian>(std::make_shared<std::vector<uint8_t>>(event_bytes));
		EventPacketView event = EventPacketView::Create(packet);
		ASSERT(event.IsValid());
		module_.CallOn(module_.impl_, &impl::on_hci_event, std::move(event));
		}

		void aclDataReceived(hal::HciPacket data_bytes) override {
		auto packet =
		packet::PacketView<packet::kLittleEndian>(std::make_shared<std::vector<uint8_t>>(std::move(data_bytes)));
		AclPacketView acl = AclPacketView::Create(packet);
		module_.impl_->incoming_acl_packet_buffer_.Enqueue(std::make_unique<AclPacketView>(acl), module_.GetHandler());
		}

		void scoDataReceived(hal::HciPacket data_bytes) override {
		// Not implemented yet
		}

		HciLayer& module_;
		};

		HciLayer::HciLayer() : impl_(new impl(this)), hal_callbacks_(new hal_callbacks(this)) {}

		HciLayer::~HciLayer() {
		impl_.reset();
		delete impl_;
		delete hal_callbacks_;
		}

		void HciLayer::EnqueueCommand(std::unique_ptr<CommandPacketBuilder> command,
		common::OnceCallback<void(CommandCompleteView)> on_complete, os::Handler* handler) {
		impl_->EnqueueCommand(std::move(command), std::move(on_complete), handler);
		CallOn(impl_, &impl::handle_enqueue_command_with_complete, std::move(command), std::move(on_complete),
		common::Unretained(handler));
		}

		void HciLayer::EnqueueCommand(std::unique_ptr<CommandPacketBuilder> command,
		common::OnceCallback<void(CommandStatusView)> on_status, os::Handler* handler) {
		impl_->EnqueueCommand(std::move(command), std::move(on_status), handler);
		CallOn(impl_, &impl::handle_enqueue_command_with_status, std::move(command), std::move(on_status),
		common::Unretained(handler));
		}

		common::BidiQueueEnd<AclPacketBuilder, AclPacketView>* HciLayer::GetAclQueueEnd() {
		return impl_->GetAclQueueEnd();
		return impl_->acl_queue_.GetUpEnd();
		}

		void HciLayer::RegisterEventHandler(EventCode event_code, common::Callback<void(EventPacketView)> event_handler,
		os::Handler* handler) {
		impl_->RegisterEventHandler(event_code, std::move(event_handler), handler);
		CallOn(impl_, &impl::handle_register_event_handler, event_code, event_handler, common::Unretained(handler));
		}

		void HciLayer::UnregisterEventHandler(EventCode event_code) {
		impl_->UnregisterEventHandler(event_code);
		CallOn(impl_, &impl::handle_unregister_event_handler, event_code);
		}

		void HciLayer::RegisterLeEventHandler(SubeventCode subevent_code, common::Callback<void(LeMetaEventView)> event_handler,
		os::Handler* handler) {
		impl_->RegisterLeEventHandler(subevent_code, std::move(event_handler), handler);
		CallOn(impl_, &impl::handle_register_le_event_handler, subevent_code, event_handler, common::Unretained(handler));
		}

		void HciLayer::UnregisterLeEventHandler(SubeventCode subevent_code) {
		impl_->UnregisterLeEventHandler(subevent_code);
		CallOn(impl_, &impl::handle_unregister_le_event_handler, subevent_code);
		}

		AclConnectionInterface* HciLayer::GetAclConnectionInterface(common::Callback<void(EventPacketView)> event_handler,
		@@ -488,20 +421,17 @@ void HciLayer::ListDependencies(ModuleList* list) {
		list->add<hal::HciHal>();
		}

		os::Handler* HciLayer::GetHciHandler() {
		return GetHandler();
		}

		void HciLayer::Start() {
		impl_->Start(GetDependency<hal::HciHal>());
		auto hal = GetDependency<hal::HciHal>();
		impl_->Start(hal);
		hal->registerIncomingPacketCallback(hal_callbacks_);
		}

		void HciLayer::Stop() {
		auto hal = GetDependency<hal::HciHal>();
		hal->unregisterIncomingPacketCallback();
		impl_->Stop();
		}

		std::string HciLayer::ToString() const {
		return "Hci Layer";
		}
		} // namespace hci
		} // namespace bluetooth

system/gd/hci/hci_layer.h

+14 −6

Original line number	Diff line number	Diff line
		@@ -82,22 +82,30 @@ class HciLayer : public Module, public CommandInterface<CommandPacketBuilder> {
		virtual LeScanningInterface* GetLeScanningInterface(common::Callback<void(LeMetaEventView)> event_handler,
		os::Handler* handler);

		os::Handler* GetHciHandler() {
		return GetHandler();
		}

		std::string ToString() const override {
		return "Hci Layer";
		}

		static constexpr std::chrono::milliseconds kHciTimeoutMs = std::chrono::milliseconds(2000);

		static const ModuleFactory Factory;

		protected:
		void ListDependencies(ModuleList* list) override;

		void Start() override;

		void Stop() override;

		os::Handler* GetHciHandler();

		std::string ToString() const override;
		static constexpr std::chrono::milliseconds kHciTimeoutMs = std::chrono::milliseconds(2000);

		private:
		struct impl;
		std::unique_ptr<impl> impl_;
		struct hal_callbacks;
		impl* impl_;
		hal_callbacks* hal_callbacks_;
		};
		} // namespace hci
		} // namespace bluetooth

system/gd/module.h

+11 −0

Original line number	Diff line number	Diff line
		@@ -99,6 +99,17 @@ class Module {
		return static_cast<T*>(GetDependency(&T::Factory));
		}

		template <typename Functor, typename... Args>
		void Call(Functor&& functor, Args&&... args) {
		GetHandler()->Post(common::BindOnce(std::forward<Functor>(functor), std::forward<Args>(args)...));
		}

		template <typename T, typename Functor, typename... Args>
		void CallOn(T* obj, Functor&& functor, Args&&... args) {
		GetHandler()->Post(
		common::BindOnce(std::forward<Functor>(functor), common::Unretained(obj), std::forward<Args>(args)...));
		}

		private:
		Module* GetDependency(const ModuleFactory* module) const;