Merge "system/gd: Merge StackManager into shim::Stack" into main am: f55bea1d01 (8081a350) · Commits · e / os / android_packages_modules_Bluetooth

system/gd/Android.bp

+0 −2

Original line number	Diff line number	Diff line
		@@ -135,7 +135,6 @@ cc_defaults {
		":BluetoothPacketSources",
		":BluetoothStorageSources",
		"module.cc",
		"stack_manager.cc",
		],
		shared_libs: [
		"libcrypto",
		@@ -338,7 +337,6 @@ cc_test {
		":TestCommonMockFunctions",
		":TestMockStackMetrics",
		"module_unittest.cc",
		"stack_manager_unittest.cc",
		],
		static_libs: [
		"bluetooth_flags_c_lib_for_test",

system/gd/BUILD.gn

+0 −1

Original line number	Diff line number	Diff line
		@@ -53,7 +53,6 @@ group("gd_default_deps") {
		static_library("libbluetooth_gd") {
		sources = [
		"module.cc",
		"stack_manager.cc",
		]

		include_dirs = [ "." ]

system/gd/module.h

+4 −1

Original line number	Diff line number	Diff line
		@@ -32,6 +32,9 @@
		#include "os/thread.h"

		namespace bluetooth {
		namespace shim {
		class Stack;
		} // namespace shim

		class Module;
		class ModuleRegistry;
		@@ -122,7 +125,7 @@ private:

		class ModuleRegistry {
		friend Module;
		friend class StackManager;
		friend shim::Stack;

		public:
		template <class T>

system/gd/stack_manager.cc

deleted100644 → 0

+0 −105

Original line number	Diff line number	Diff line
		/*
		* Copyright 2019 The Android Open Source Project
		*
		* 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 "stack_manager.h"

		#include <bluetooth/log.h>

		#include <chrono>
		#include <future>
		#include <queue>

		#include "common/bind.h"
		#include "module.h"
		#include "os/handler.h"
		#include "os/system_properties.h"
		#include "os/thread.h"
		#include "os/wakelock_manager.h"

		using ::bluetooth::os::Handler;
		using ::bluetooth::os::Thread;
		using ::bluetooth::os::WakelockManager;

		namespace bluetooth {

		void StackManager::StartUp(ModuleList* modules, Thread* stack_thread) {
		management_thread_ = new Thread("management_thread", Thread::Priority::NORMAL);
		handler_ = new Handler(management_thread_);

		WakelockManager::Get().Acquire();

		std::promise<void> promise;
		auto future = promise.get_future();
		handler_->Post(common::BindOnce(&StackManager::handle_start_up, common::Unretained(this), modules,
		stack_thread, std::move(promise)));

		auto init_status = future.wait_for(
		std::chrono::milliseconds(get_gd_stack_timeout_ms(/* is_start = */ true)));

		WakelockManager::Get().Release();

		log::info("init_status == {}", int(init_status));

		log::assert_that(init_status == std::future_status::ready, "Can't start stack, last instance: {}",
		registry_.last_instance_);

		log::info("init complete");
		}

		void StackManager::handle_start_up(ModuleList* modules, Thread* stack_thread,
		std::promise<void> promise) {
		registry_.Start(modules, stack_thread);
		promise.set_value();
		}

		void StackManager::ShutDown() {
		WakelockManager::Get().Acquire();

		std::promise<void> promise;
		auto future = promise.get_future();
		handler_->Post(common::BindOnce(&StackManager::handle_shut_down, common::Unretained(this),
		std::move(promise)));

		auto stop_status = future.wait_for(
		std::chrono::milliseconds(get_gd_stack_timeout_ms(/* is_start = */ false)));

		WakelockManager::Get().Release();
		WakelockManager::Get().CleanUp();

		log::assert_that(stop_status == std::future_status::ready, "Can't stop stack, last instance: {}",
		registry_.last_instance_);

		handler_->Clear();
		handler_->WaitUntilStopped(std::chrono::milliseconds(2000));
		delete handler_;
		delete management_thread_;
		}

		void StackManager::handle_shut_down(std::promise<void> promise) {
		registry_.StopAll();
		promise.set_value();
		}

		std::chrono::milliseconds StackManager::get_gd_stack_timeout_ms(bool is_start) {
		auto gd_timeout = os::GetSystemPropertyUint32(
		is_start ? "bluetooth.gd.start_timeout" : "bluetooth.gd.stop_timeout",
		/* default_value = */ is_start ? 3000 : 5000);
		return std::chrono::milliseconds(gd_timeout *
		os::GetSystemPropertyUint32("ro.hw_timeout_multiplier",
		/* default_value = */ 1));
		}

		} // namespace bluetooth

system/gd/stack_manager.h

deleted100644 → 0

+0 −50

Original line number	Diff line number	Diff line
		/*
		* Copyright 2019 The Android Open Source Project
		*
		* 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 "module.h"
		#include "os/handler.h"
		#include "os/thread.h"

		namespace bluetooth {

		class StackManager {
		public:
		void StartUp(ModuleList* modules, os::Thread* stack_thread);
		void ShutDown();

		template <class T>
		T* GetInstance() const {
		return static_cast<T*>(registry_.Get(&T::Factory));
		}

		template <class T>
		bool IsStarted() const {
		return registry_.IsStarted(&T::Factory);
		}

		private:
		os::Thread* management_thread_ = nullptr;
		os::Handler* handler_ = nullptr;
		ModuleRegistry registry_;

		void handle_start_up(ModuleList* modules, os::Thread* stack_thread, std::promise<void> promise);
		void handle_shut_down(std::promise<void> promise);
		static std::chrono::milliseconds get_gd_stack_timeout_ms(bool is_start);
		};

		} // namespace bluetooth