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

Commit 95f43bab authored by Henri Chataing's avatar Henri Chataing
Browse files

system/gd: Merge StackManager into shim::Stack 

StackManager is no longer used as an indenpendent object
and its functionalities can be added to shim::Stack.

Bug: 333555245
Test: m com.android.btservices
Flag: EXEMPT, no logical change
Change-Id: If1422266331d483bbf1412e38530d9e03227cd3c
parent 0f1bd20e

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