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

Commit 7d9b3489 authored by Aritra Sen's avatar Aritra Sen
Browse files

Use LOG_LEVEL to replace LOG(LEVEL) through out the hearing_aid codebase for a... 

Use LOG_LEVEL to replace LOG(LEVEL) through out the hearing_aid codebase for a consistent logging experience.

Since LOG_LEVEL uses string formatting we do the following conversions :
1. All enums are rendered as %u unless it already supports string mapping.
2. All std::string need to be converted to char* using c_str()
3. All RawAddress need to be converted to string using ToStringForLogging() and then to char*.

LOG(INFO) -> LOG_INFO
LOG(WARNING) -> LOG_WARN
LOG(ERROR) -> LOG_ERROR
LOG(FATAL) -> LOG_ALWAYS_FATAL

Bug: 226483111
Test: cert
Change-Id: I961f267025c9589a894eedf2ec1720557b3afe7b
parent bf15bee5

system/bta/hearing_aid/hearing_aid.cc

+188 −198

File changed.

Preview size limit exceeded, changes collapsed.

system/bta/hearing_aid/hearing_aid_audio_source.cc

+33 −37
Original line number Original line Diff line number Diff line
@@ -18,6 +18,7 @@ 




#include <base/files/file_util.h>

#include <base/files/file_util.h>

#include <base/logging.h>

#include <base/logging.h>



#include <cstdint>

#include <cstdint>

#include <memory>

#include <memory>

#include <sstream>

#include <sstream>
@@ -28,6 +29,7 @@ 
#include "bta/include/bta_hearing_aid_api.h"

#include "bta/include/bta_hearing_aid_api.h"

#include "common/repeating_timer.h"

#include "common/repeating_timer.h"

#include "common/time_util.h"

#include "common/time_util.h"

#include "osi/include/log.h"

#include "osi/include/wakelock.h"

#include "osi/include/wakelock.h"

#include "stack/include/btu.h"  // get_main_thread

#include "stack/include/btu.h"  // get_main_thread

#include "udrv/include/uipc.h"

#include "udrv/include/uipc.h"
@@ -122,7 +124,7 @@ void hearing_aid_send_ack(tHEARING_AID_CTRL_ACK status) { 
void start_audio_ticks() {

void start_audio_ticks() {

  if (data_interval_ms != HA_INTERVAL_10_MS &&

  if (data_interval_ms != HA_INTERVAL_10_MS &&

      data_interval_ms != HA_INTERVAL_20_MS) {

      data_interval_ms != HA_INTERVAL_20_MS) {

    LOG(FATAL) << " Unsupported data interval: " << data_interval_ms;

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

  }

  }





  wakelock_acquire();

  wakelock_acquire();
@@ -133,11 +135,11 @@ void start_audio_ticks() { 
#else

#else

      base::Milliseconds(data_interval_ms));

      base::Milliseconds(data_interval_ms));

#endif

#endif

  LOG(INFO) << __func__ << ": running with data interval: " << data_interval_ms;

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

}

}





void stop_audio_ticks() {

void stop_audio_ticks() {

  LOG(INFO) << __func__ << ": stopped";

  LOG_INFO("stopped");

  audio_timer.CancelAndWait();

  audio_timer.CancelAndWait();

  wakelock_release();

  wakelock_release();

}

}
@@ -146,7 +148,7 @@ void hearing_aid_data_cb(tUIPC_CH_ID, tUIPC_EVENT event) { 
  DVLOG(2) << __func__ << "Hearing Aid audio data event: " << event;

  DVLOG(2) << __func__ << "Hearing Aid audio data event: " << event;

  switch (event) {

  switch (event) {

    case UIPC_OPEN_EVT:

    case UIPC_OPEN_EVT:

      LOG(INFO) << __func__ << ": UIPC_OPEN_EVT";

      LOG_INFO("UIPC_OPEN_EVT");

      /*

      /*

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

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

       * connection events.

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

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

      break;

      break;

    case UIPC_CLOSE_EVT:

    case UIPC_CLOSE_EVT:

      LOG(INFO) << __func__ << ": UIPC_CLOSE_EVT";

      LOG_INFO("UIPC_CLOSE_EVT");

      hearing_aid_send_ack(HEARING_AID_CTRL_ACK_SUCCESS);

      hearing_aid_send_ack(HEARING_AID_CTRL_ACK_SUCCESS);

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

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

      break;

      break;

    default:

    default:

      LOG(ERROR) << "Hearing Aid audio data event not recognized:" << event;

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

  }

  }

}

}
@@ -178,12 +180,12 @@ void hearing_aid_recv_ctrl_data() { 




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

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

  if (n == 0) {

  if (n == 0) {

    LOG(WARNING) << __func__ << "CTRL CH DETACHED";

    LOG_WARN("CTRL CH DETACHED");

    UIPC_Close(*uipc_hearing_aid, UIPC_CH_ID_AV_CTRL);

    UIPC_Close(*uipc_hearing_aid, UIPC_CH_ID_AV_CTRL);

    return;

    return;

  }

  }





  LOG(INFO) << __func__ << " " << audio_ha_hw_dump_ctrl_event(cmd);

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

  //  a2dp_cmd_pending = cmd;

  //  a2dp_cmd_pending = cmd;





  tHEARING_AID_CTRL_ACK ctrl_ack_status;

  tHEARING_AID_CTRL_ACK ctrl_ack_status;
@@ -207,7 +209,9 @@ void hearing_aid_recv_ctrl_data() { 




    case HEARING_AID_CTRL_CMD_STOP:

    case HEARING_AID_CTRL_CMD_STOP:

      if (!hearing_aid_on_suspend_req()) {

      if (!hearing_aid_on_suspend_req()) {

        LOG(INFO) << __func__ << ":HEARING_AID_CTRL_CMD_STOP: hearing_aid_on_suspend_req() errs, but ignored.";

        LOG_INFO(

            "HEARING_AID_CTRL_CMD_STOP: hearing_aid_on_suspend_req() errs, but "

            "ignored.");

      }

      }

      hearing_aid_send_ack(HEARING_AID_CTRL_ACK_SUCCESS);

      hearing_aid_send_ack(HEARING_AID_CTRL_ACK_SUCCESS);

      break;

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

        codec_config.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_24000;

        codec_capability.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_24000;

        codec_capability.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_24000;

      } else {

      } else {

        LOG(FATAL) << "unsupported sample rate: " << sample_rate;

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

      }

      }





      codec_config.bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16;

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

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

                    sizeof(btav_a2dp_codec_sample_rate_t)) !=

                    sizeof(btav_a2dp_codec_sample_rate_t)) !=

          sizeof(btav_a2dp_codec_sample_rate_t)) {

          sizeof(btav_a2dp_codec_sample_rate_t)) {

        LOG(ERROR) << __func__ << "Error reading sample rate from audio HAL";

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

        break;

        break;

      }

      }

      if (UIPC_Read(*uipc_hearing_aid, UIPC_CH_ID_AV_CTRL,

      if (UIPC_Read(*uipc_hearing_aid, UIPC_CH_ID_AV_CTRL,

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

                    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)) !=

          sizeof(btav_a2dp_codec_bits_per_sample_t)) {

          sizeof(btav_a2dp_codec_bits_per_sample_t)) {

        LOG(ERROR) << __func__

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

                   << "Error reading bits per sample from audio HAL";





        break;

        break;

      }

      }
@@ -294,25 +297,24 @@ void hearing_aid_recv_ctrl_data() { 
                    reinterpret_cast<uint8_t*>(&codec_config.channel_mode),

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

                    sizeof(btav_a2dp_codec_channel_mode_t)) !=

                    sizeof(btav_a2dp_codec_channel_mode_t)) !=

          sizeof(btav_a2dp_codec_channel_mode_t)) {

          sizeof(btav_a2dp_codec_channel_mode_t)) {

        LOG(ERROR) << __func__ << "Error reading channel mode from audio HAL";

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





        break;

        break;

      }

      }

      LOG(INFO) << __func__ << " HEARING_AID_CTRL_SET_OUTPUT_AUDIO_CONFIG: "

      LOG_INFO(

                << "sample_rate=" << codec_config.sample_rate

          "HEARING_AID_CTRL_SET_OUTPUT_AUDIO_CONFIG: sample_rate=%u, "

                << "bits_per_sample=" << codec_config.bits_per_sample

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

                << "channel_mode=" << codec_config.channel_mode;

          codec_config.sample_rate, codec_config.bits_per_sample,

          codec_config.channel_mode);

      break;

      break;

    }

    }





    default:

    default:

      LOG(ERROR) << __func__ << "UNSUPPORTED CMD: " << cmd;

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

      hearing_aid_send_ack(HEARING_AID_CTRL_ACK_FAILURE);

      hearing_aid_send_ack(HEARING_AID_CTRL_ACK_FAILURE);

      break;

      break;

  }

  }

  LOG(INFO) << __func__

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

            << " a2dp-ctrl-cmd : " << audio_ha_hw_dump_ctrl_event(cmd)

            << " DONE";

}

}





void hearing_aid_ctrl_cb(tUIPC_CH_ID, tUIPC_EVENT event) {

void hearing_aid_ctrl_cb(tUIPC_CH_ID, tUIPC_EVENT event) {
@@ -331,14 +333,13 @@ void hearing_aid_ctrl_cb(tUIPC_CH_ID, tUIPC_EVENT event) { 
      hearing_aid_recv_ctrl_data();

      hearing_aid_recv_ctrl_data();

      break;

      break;

    default:

    default:

      LOG(ERROR) << "Hearing Aid audio ctrl unrecognized event: " << event;

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

  }

  }

}

}





bool hearing_aid_on_resume_req(bool start_media_task) {

bool hearing_aid_on_resume_req(bool start_media_task) {

  if (localAudioReceiver == nullptr) {

  if (localAudioReceiver == nullptr) {

    LOG(ERROR) << __func__

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

               << ": HEARING_AID_CTRL_CMD_START: audio receiver not started";

    return false;

    return false;

  }

  }

  bt_status_t status;

  bt_status_t status;
@@ -349,7 +350,7 @@ bool hearing_aid_on_resume_req(bool start_media_task) { 
                                  start_audio_ticks));

                                  start_audio_ticks));

  } else {

  } else {

    auto start_dummy_ticks = []() {

    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(

    status = do_in_main_thread(

        FROM_HERE, base::BindOnce(&HearingAidAudioReceiver::OnAudioResume,

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

                                  start_dummy_ticks));

  }

  }

  if (status != BT_STATUS_SUCCESS) {

  if (status != BT_STATUS_SUCCESS) {

    LOG(ERROR) << __func__

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

               << ": HEARING_AID_CTRL_CMD_START: do_in_main_thread err="

               << status;

    return false;

    return false;

  }

  }

  return true;

  return true;
@@ -367,8 +366,7 @@ bool hearing_aid_on_resume_req(bool start_media_task) { 




bool hearing_aid_on_suspend_req() {

bool hearing_aid_on_suspend_req() {

  if (localAudioReceiver == nullptr) {

  if (localAudioReceiver == nullptr) {

    LOG(ERROR) << __func__

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

               << ": HEARING_AID_CTRL_CMD_SUSPEND: audio receiver not started";

    return false;

    return false;

  }

  }

  bt_status_t status = do_in_main_thread(

  bt_status_t status = do_in_main_thread(
@@ -376,9 +374,7 @@ bool hearing_aid_on_suspend_req() { 
      base::BindOnce(&HearingAidAudioReceiver::OnAudioSuspend,

      base::BindOnce(&HearingAidAudioReceiver::OnAudioSuspend,

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

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

  if (status != BT_STATUS_SUCCESS) {

  if (status != BT_STATUS_SUCCESS) {

    LOG(ERROR) << __func__

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

               << ": HEARING_AID_CTRL_CMD_SUSPEND: do_in_main_thread err="

               << status;

    return false;

    return false;

  }

  }

  return true;

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

void HearingAidAudioSource::Start(const CodecConfiguration& codecConfiguration,

                                  HearingAidAudioReceiver* audioReceiver,

                                  HearingAidAudioReceiver* audioReceiver,

                                  uint16_t remote_delay_ms) {

                                  uint16_t remote_delay_ms) {

  LOG(INFO) << __func__ << ": Hearing Aid Source Open";

  LOG_INFO("Hearing Aid Source Open");





  bit_rate = codecConfiguration.bit_rate;

  bit_rate = codecConfiguration.bit_rate;

  sample_rate = codecConfiguration.sample_rate;

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

}





void HearingAidAudioSource::Stop() {

void HearingAidAudioSource::Stop() {

  LOG(INFO) << __func__ << ": Hearing Aid Source Close";

  LOG_INFO("Hearing Aid Source Close");





  localAudioReceiver = nullptr;

  localAudioReceiver = nullptr;

  if (bluetooth::audio::hearing_aid::is_hal_enabled()) {

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

      .on_suspend_ = hearing_aid_on_suspend_req,

  };

  };

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

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

    LOG(WARNING) << __func__ << ": Using legacy HAL";

    LOG_WARN("Using legacy HAL");

    uipc_hearing_aid = UIPC_Init();

    uipc_hearing_aid = UIPC_Init();

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

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

  }

  }