Fluoride Bluetooth stack

typedef struct {
  void (*init_stack)(bluetooth::core::CoreInterface*);
  void (*start_up_stack_async)(bluetooth::core::CoreInterface*, ProfileStartCallback,
                               ProfileStopCallback);
  void (*shut_down_stack_async)(ProfileStopCallback);
  void (*clean_up_stack)(ProfileStopCallback);
  void (*start_up_rust_module_async)(std::promise<void> promise);
  void (*shut_down_rust_module_async)();

  bool (*get_stack_is_running)(void);
} stack_manager_t;

const stack_manager_t* stack_manager_get_interface();

static const stack_manager_t interface = {
        init_stack,          start_up_stack_async,       shut_down_stack_async,
        clean_up_stack,      start_up_rust_module_async, shut_down_rust_module_async,
        get_stack_is_running};

const stack_manager_t* stack_manager_get_interface() {
  ensure_manager_initialized();
  return &interface;
}

static void event_init_stack(std::promise<void> promise, bluetooth::core::CoreInterface* interface);
static void event_start_up_stack(bluetooth::core::CoreInterface* interface,
                                 ProfileStartCallback startProfiles,
                                 ProfileStopCallback stopProfiles);
static void event_shut_down_stack(ProfileStopCallback stopProfiles);
static void event_clean_up_stack(std::promise<void> promise, ProfileStopCallback stopProfiles);
static void event_start_up_rust_module(std::promise<void> promise);
static void event_shut_down_rust_module();

static void event_signal_stack_up(void* context);
static void event_signal_stack_down(void* context);

static void init_stack_internal(bluetooth::core::CoreInterface* interface) {
  // all callbacks out of libbluetooth-core happen via this interface
  interfaceToProfiles = interface;

  module_management_start();

  main_thread_start_up();

  module_init(get_local_module(DEVICE_IOT_CONFIG_MODULE));
  module_init(get_local_module(OSI_MODULE));
  module_start_up(get_local_module(GD_SHIM_MODULE));
  module_init(get_local_module(BTIF_CONFIG_MODULE));
  btif_init_bluetooth();

  module_init(get_local_module(INTEROP_MODULE));
  module_init(get_local_module(STACK_CONFIG_MODULE));

  // stack init is synchronous, so no waiting necessary here
  stack_is_initialized = true;
}

extern const module_t bt_utils_module;
extern const module_t btif_config_module;
extern const module_t gd_shim_module;
extern const module_t interop_module;
extern const module_t osi_module;
extern const module_t rust_module;
extern const module_t stack_config_module;
extern const module_t device_iot_config_module;

struct module_lookup {
  const char* name;
  const module_t* module;
};

const struct module_lookup module_table[] = {
        {BTIF_CONFIG_MODULE, &btif_config_module},
        {GD_SHIM_MODULE, &gd_shim_module},
        {INTEROP_MODULE, &interop_module},
        {OSI_MODULE, &osi_module},
        {RUST_MODULE, &rust_module},
        {STACK_CONFIG_MODULE, &stack_config_module},
        {DEVICE_IOT_CONFIG_MODULE, &device_iot_config_module},
        {NULL, NULL},
};

inline const module_t* get_local_module(const char* name) {
  size_t len = strlen(name);

  for (const struct module_lookup* l = module_table; l->module; l++) {
    if (strncmp(l->name, name, len) == 0) {
      return l->module;
    }
  }

  fatal("Cannot find module {}, aborting", name);
  return nullptr;
}

static void event_start_up_stack(bluetooth::core::CoreInterface* interface,
                                 ProfileStartCallback startProfiles,
                                 ProfileStopCallback stopProfiles) {
  if (stack_is_running) {
    info("stack already brought up");
    return;
  }

  ensure_stack_is_initialized(interface);

  info("is bringing up the stack");
  future_t* local_hack_future = future_new();
  hack_future = local_hack_future;

  info("Gd shim module enabled");
  get_btm_client_interface().lifecycle.btm_init();
  module_start_up(get_local_module(BTIF_CONFIG_MODULE));

  l2c_init();
  sdp_init();
  gatt_init();
  SMP_Init(get_btm_client_interface().security.BTM_GetSecurityMode());
  get_btm_client_interface().lifecycle.btm_ble_init();

  RFCOMM_Init();
  GAP_Init();
  AIS_Init();

  startProfiles();

  bta_sys_init();

  btif_init_ok();
  BTA_dm_init();
  bta_dm_enable(btif_dm_sec_evt, btif_dm_acl_evt);

  btm_acl_device_down();
  get_btm_client_interface().lifecycle.BTM_reset_complete();

  BTA_dm_on_hw_on();

  if (future_await(local_hack_future) != FUTURE_SUCCESS) {
    error("failed to start up the stack");
    stack_is_running = true;  // So stack shutdown actually happens
    event_shut_down_stack(stopProfiles);
    return;
  }

  if (!com::android::bluetooth::flags::only_start_scan_during_ble_on()) {
    info("Starting rust module");
    module_start_up(get_local_module(RUST_MODULE));
    if (com::android::bluetooth::flags::channel_sounding_in_stack()) {
      bluetooth::ras::GetRasServer()->Initialize();
      bluetooth::ras::GetRasClient()->Initialize();
    }
  }

  stack_is_running = true;
  info("finished");
  do_in_jni_thread(base::BindOnce(event_signal_stack_up, nullptr));
}