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

Commit 4d517ada authored by Henri Chataing's avatar Henri Chataing
Browse files

system/bta/hearing_aid: Migrate to libbluetooth_log 

Test: m com.android.btservices
Bug: 305066880
Flag: EXEMPT, mechanical refactor
Change-Id: I098fe24fd192bf3289283348b35cd9f8f9f37d11
parent 545b5519

system/bta/hearing_aid/hearing_aid.cc

+254 −265

File changed.

Preview size limit exceeded, changes collapsed.

system/bta/hearing_aid/hearing_aid_audio_source.cc

+47 −31
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ 


#include <base/files/file_util.h>

#include <base/logging.h>

#include <bluetooth/log.h>



#include <cstdint>

#include <memory>
@@ -35,6 +36,20 @@ 
#include "udrv/include/uipc.h"



using base::FilePath;

using namespace bluetooth;



namespace fmt {

template <>

struct formatter<bt_status_t> : enum_formatter<bt_status_t> {};

template <>

struct formatter<tUIPC_EVENT> : enum_formatter<tUIPC_EVENT> {};

template <>

struct formatter<tHEARING_AID_CTRL_ACK>

    : enum_formatter<tHEARING_AID_CTRL_ACK> {};

template <>

struct formatter<tHEARING_AID_CTRL_CMD>

    : enum_formatter<tHEARING_AID_CTRL_CMD> {};

}  // namespace fmt



namespace {

#define CASE_RETURN_STR(const) \
@@ -100,7 +115,7 @@ void send_audio_data() { 
                           bytes_per_tick);

  }



  LOG_DEBUG("bytes_read: %u", bytes_read);

  log::debug("bytes_read: {}", bytes_read);

  if (bytes_read < bytes_per_tick) {

    stats.media_read_total_underflow_bytes += bytes_per_tick - bytes_read;

    stats.media_read_total_underflow_count++;
@@ -117,34 +132,34 @@ void send_audio_data() { 


void hearing_aid_send_ack(tHEARING_AID_CTRL_ACK status) {

  uint8_t ack = status;

  LOG_DEBUG("Hearing Aid audio ctrl ack: %u", status);

  log::debug("Hearing Aid audio ctrl ack: {}", status);

  UIPC_Send(*uipc_hearing_aid, UIPC_CH_ID_AV_CTRL, 0, &ack, sizeof(ack));

}



void start_audio_ticks() {

  if (data_interval_ms != HA_INTERVAL_10_MS &&

      data_interval_ms != HA_INTERVAL_20_MS) {

    LOG_ALWAYS_FATAL("Unsupported data interval: %d", data_interval_ms);

    log::fatal("Unsupported data interval: {}", data_interval_ms);

  }



  wakelock_acquire();

  audio_timer.SchedulePeriodic(get_main_thread()->GetWeakPtr(), FROM_HERE,

                               base::BindRepeating(&send_audio_data),

                               std::chrono::milliseconds(data_interval_ms));

  LOG_INFO("running with data interval: %d", data_interval_ms);

  log::info("running with data interval: {}", data_interval_ms);

}



void stop_audio_ticks() {

  LOG_INFO("stopped");

  log::info("stopped");

  audio_timer.CancelAndWait();

  wakelock_release();

}



void hearing_aid_data_cb(tUIPC_CH_ID, tUIPC_EVENT event) {

  LOG_DEBUG("Hearing Aid audio data event: %u", event);

  log::debug("Hearing Aid audio data event: {}", event);

  switch (event) {

    case UIPC_OPEN_EVT:

      LOG_INFO("UIPC_OPEN_EVT");

      log::info("UIPC_OPEN_EVT");

      /*

       * Read directly from media task from here on (keep callback for

       * connection events.
@@ -157,12 +172,12 @@ void hearing_aid_data_cb(tUIPC_CH_ID, tUIPC_EVENT event) { 
      do_in_main_thread(FROM_HERE, base::BindOnce(start_audio_ticks));

      break;

    case UIPC_CLOSE_EVT:

      LOG_INFO("UIPC_CLOSE_EVT");

      log::info("UIPC_CLOSE_EVT");

      hearing_aid_send_ack(HEARING_AID_CTRL_ACK_SUCCESS);

      do_in_main_thread(FROM_HERE, base::BindOnce(stop_audio_ticks));

      break;

    default:

      LOG_ERROR("Hearing Aid audio data event not recognized: %u", event);

      log::error("Hearing Aid audio data event not recognized: {}", event);

  }

}
@@ -176,12 +191,12 @@ void hearing_aid_recv_ctrl_data() { 


  /* detach on ctrl channel means audioflinger process was terminated */

  if (n == 0) {

    LOG_WARN("CTRL CH DETACHED");

    log::warn("CTRL CH DETACHED");

    UIPC_Close(*uipc_hearing_aid, UIPC_CH_ID_AV_CTRL);

    return;

  }



  LOG_INFO("%s", audio_ha_hw_dump_ctrl_event(cmd));

  log::info("{}", audio_ha_hw_dump_ctrl_event(cmd));

  //  a2dp_cmd_pending = cmd;



  tHEARING_AID_CTRL_ACK ctrl_ack_status;
@@ -205,7 +220,7 @@ void hearing_aid_recv_ctrl_data() { 


    case HEARING_AID_CTRL_CMD_STOP:

      if (!hearing_aid_on_suspend_req()) {

        LOG_INFO(

        log::info(

            "HEARING_AID_CTRL_CMD_STOP: hearing_aid_on_suspend_req() errs, but "

            "ignored.");

      }
@@ -230,7 +245,7 @@ void hearing_aid_recv_ctrl_data() { 
        codec_config.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_24000;

        codec_capability.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_24000;

      } else {

        LOG_ALWAYS_FATAL("unsupported sample rate: %d", sample_rate);

        log::fatal("unsupported sample rate: {}", sample_rate);

      }



      codec_config.bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16;
@@ -278,14 +293,14 @@ void hearing_aid_recv_ctrl_data() { 
                    reinterpret_cast<uint8_t*>(&codec_config.sample_rate),

                    sizeof(btav_a2dp_codec_sample_rate_t)) !=

          sizeof(btav_a2dp_codec_sample_rate_t)) {

        LOG_ERROR("Error reading sample rate from audio HAL");

        log::error("Error reading sample rate from audio HAL");

        break;

      }

      if (UIPC_Read(*uipc_hearing_aid, UIPC_CH_ID_AV_CTRL,

                    reinterpret_cast<uint8_t*>(&codec_config.bits_per_sample),

                    sizeof(btav_a2dp_codec_bits_per_sample_t)) !=

          sizeof(btav_a2dp_codec_bits_per_sample_t)) {

        LOG_ERROR("Error reading bits per sample from audio HAL");

        log::error("Error reading bits per sample from audio HAL");



        break;

      }
@@ -293,28 +308,28 @@ void hearing_aid_recv_ctrl_data() { 
                    reinterpret_cast<uint8_t*>(&codec_config.channel_mode),

                    sizeof(btav_a2dp_codec_channel_mode_t)) !=

          sizeof(btav_a2dp_codec_channel_mode_t)) {

        LOG_ERROR("Error reading channel mode from audio HAL");

        log::error("Error reading channel mode from audio HAL");



        break;

      }

      LOG_INFO(

          "HEARING_AID_CTRL_SET_OUTPUT_AUDIO_CONFIG: sample_rate=%u, "

          "bits_per_sample=%u,channel_mode=%u",

      log::info(

          "HEARING_AID_CTRL_SET_OUTPUT_AUDIO_CONFIG: sample_rate={}, "

          "bits_per_sample={},channel_mode={}",

          codec_config.sample_rate, codec_config.bits_per_sample,

          codec_config.channel_mode);

      break;

    }



    default:

      LOG_ERROR("UNSUPPORTED CMD: %u", cmd);

      log::error("UNSUPPORTED CMD: {}", cmd);

      hearing_aid_send_ack(HEARING_AID_CTRL_ACK_FAILURE);

      break;

  }

  LOG_INFO("a2dp-ctrl-cmd : %s DONE", audio_ha_hw_dump_ctrl_event(cmd));

  log::info("a2dp-ctrl-cmd : {} DONE", audio_ha_hw_dump_ctrl_event(cmd));

}



void hearing_aid_ctrl_cb(tUIPC_CH_ID, tUIPC_EVENT event) {

  LOG_DEBUG("Hearing Aid audio ctrl event: %u", event);

  log::debug("Hearing Aid audio ctrl event: {}", event);

  switch (event) {

    case UIPC_OPEN_EVT:

      break;
@@ -329,13 +344,13 @@ void hearing_aid_ctrl_cb(tUIPC_CH_ID, tUIPC_EVENT event) { 
      hearing_aid_recv_ctrl_data();

      break;

    default:

      LOG_ERROR("Hearing Aid audio ctrl unrecognized event: %u", event);

      log::error("Hearing Aid audio ctrl unrecognized event: {}", event);

  }

}



bool hearing_aid_on_resume_req(bool start_media_task) {

  if (localAudioReceiver == nullptr) {

    LOG_ERROR("HEARING_AID_CTRL_CMD_START: audio receiver not started");

    log::error("HEARING_AID_CTRL_CMD_START: audio receiver not started");

    return false;

  }

  bt_status_t status;
@@ -346,7 +361,7 @@ bool hearing_aid_on_resume_req(bool start_media_task) { 
                                  start_audio_ticks));

  } else {

    auto start_dummy_ticks = []() {

      LOG_INFO("start_audio_ticks: waiting for data path opened");

      log::info("start_audio_ticks: waiting for data path opened");

    };

    status = do_in_main_thread(

        FROM_HERE, base::BindOnce(&HearingAidAudioReceiver::OnAudioResume,
@@ -354,7 +369,7 @@ bool hearing_aid_on_resume_req(bool start_media_task) { 
                                  start_dummy_ticks));

  }

  if (status != BT_STATUS_SUCCESS) {

    LOG_ERROR("HEARING_AID_CTRL_CMD_START: do_in_main_thread err=%u", status);

    log::error("HEARING_AID_CTRL_CMD_START: do_in_main_thread err={}", status);

    return false;

  }

  return true;
@@ -362,7 +377,7 @@ bool hearing_aid_on_resume_req(bool start_media_task) { 


bool hearing_aid_on_suspend_req() {

  if (localAudioReceiver == nullptr) {

    LOG_ERROR("HEARING_AID_CTRL_CMD_SUSPEND: audio receiver not started");

    log::error("HEARING_AID_CTRL_CMD_SUSPEND: audio receiver not started");

    return false;

  }

  bt_status_t status = do_in_main_thread(
@@ -370,7 +385,8 @@ bool hearing_aid_on_suspend_req() { 
      base::BindOnce(&HearingAidAudioReceiver::OnAudioSuspend,

                     base::Unretained(localAudioReceiver), stop_audio_ticks));

  if (status != BT_STATUS_SUCCESS) {

    LOG_ERROR("HEARING_AID_CTRL_CMD_SUSPEND: do_in_main_thread err=%u", status);

    log::error("HEARING_AID_CTRL_CMD_SUSPEND: do_in_main_thread err={}",

               status);

    return false;

  }

  return true;
@@ -380,7 +396,7 @@ bool hearing_aid_on_suspend_req() { 
void HearingAidAudioSource::Start(const CodecConfiguration& codecConfiguration,

                                  HearingAidAudioReceiver* audioReceiver,

                                  uint16_t remote_delay_ms) {

  LOG_INFO("Hearing Aid Source Open");

  log::info("Hearing Aid Source Open");



  bit_rate = codecConfiguration.bit_rate;

  sample_rate = codecConfiguration.sample_rate;
@@ -396,7 +412,7 @@ void HearingAidAudioSource::Start(const CodecConfiguration& codecConfiguration, 
}



void HearingAidAudioSource::Stop() {

  LOG_INFO("Hearing Aid Source Close");

  log::info("Hearing Aid Source Close");



  localAudioReceiver = nullptr;

  if (bluetooth::audio::hearing_aid::is_hal_enabled()) {
@@ -412,7 +428,7 @@ void HearingAidAudioSource::Initialize() { 
      .on_suspend_ = hearing_aid_on_suspend_req,

  };

  if (!bluetooth::audio::hearing_aid::init(stream_cb, get_main_thread())) {

    LOG_WARN("Using legacy HAL");

    log::warn("Using legacy HAL");

    uipc_hearing_aid = UIPC_Init();

    UIPC_Open(*uipc_hearing_aid, UIPC_CH_ID_AV_CTRL, hearing_aid_ctrl_cb, HEARING_AID_CTRL_PATH);

  }

system/bta/include/bta_hearing_aid_api.h

+7 −0
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ 
#pragma once



#include <base/functional/callback_forward.h>

#include <bluetooth/log.h>

#include <hardware/bt_hearing_aid.h>



#include <cstdint>
@@ -286,3 +287,9 @@ class HearingAidAudioSource { 
  static void CleanUp();

  static void DebugDump(int fd);

};



namespace fmt {

template <>

struct formatter<connection_update_status_t>

    : enum_formatter<connection_update_status_t> {};

}  // namespace fmt