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

Commit 419d0b7a authored by Henri Chataing's avatar Henri Chataing Committed by Automerger Merge Worker
Browse files

Merge changes I7458df80,I784e0e10,I99b0dc1d,I80125dca,I7ca86bc4, ... into main... 

Merge changes I7458df80,I784e0e10,I99b0dc1d,I80125dca,I7ca86bc4, ... into main am: ab76afa2 am: 3bc36bda

Original change: https://android-review.googlesource.com/c/platform/packages/modules/Bluetooth/+/2974119



Change-Id: I337de9b4c18cfbc867cff693af006007381e9ddd
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents fd2fa92e 3bc36bda

system/bta/hf_client/bta_hf_client_act.cc

+22 −30
Original line number Diff line number Diff line
@@ -23,6 +23,8 @@ 
 *

 ******************************************************************************/



#include <bluetooth/log.h>



#include "bta/hf_client/bta_hf_client_int.h"

#include "bta/include/bta_dm_api.h"

#include "os/log.h"
@@ -31,6 +33,8 @@ 
#include "stack/include/sdp_status.h"

#include "types/raw_address.h"



using namespace bluetooth;



/*****************************************************************************

 *  Constants

 ****************************************************************************/
@@ -52,8 +56,7 @@ void bta_hf_client_start_close(tBTA_HF_CLIENT_DATA* p_data) { 
  tBTA_HF_CLIENT_CB* client_cb =

      bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);

  if (client_cb == NULL) {

    LOG_ERROR("%s: wrong handle to control block %d", __func__,

              p_data->hdr.layer_specific);

    log::error("wrong handle to control block {}", p_data->hdr.layer_specific);

    return;

  }
@@ -86,8 +89,7 @@ void bta_hf_client_start_open(tBTA_HF_CLIENT_DATA* p_data) { 
  tBTA_HF_CLIENT_CB* client_cb =

      bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);

  if (client_cb == NULL) {

    LOG_ERROR("%s: wrong handle to control block %d", __func__,

              p_data->hdr.layer_specific);

    log::error("wrong handle to control block {}", p_data->hdr.layer_specific);

    return;

  }
@@ -125,12 +127,11 @@ void bta_hf_client_start_open(tBTA_HF_CLIENT_DATA* p_data) { 
 *

 ******************************************************************************/

void bta_hf_client_rfc_open(tBTA_HF_CLIENT_DATA* p_data) {

  LOG_VERBOSE("%s", __func__);

  log::verbose("");

  tBTA_HF_CLIENT_CB* client_cb =

      bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);

  if (client_cb == NULL) {

    LOG_ERROR("%s: cb not found for handle %d", __func__,

              p_data->hdr.layer_specific);

    log::error("cb not found for handle {}", p_data->hdr.layer_specific);

    return;

  }
@@ -151,25 +152,24 @@ void bta_hf_client_rfc_open(tBTA_HF_CLIENT_DATA* p_data) { 
 *

 ******************************************************************************/

void bta_hf_client_rfc_acp_open(tBTA_HF_CLIENT_DATA* p_data) {

  LOG_VERBOSE("%s", __func__);

  log::verbose("");

  tBTA_HF_CLIENT_CB* client_cb =

      bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);

  if (client_cb == NULL) {

    LOG_ERROR("%s: cb not found for handle %d", __func__,

              p_data->hdr.layer_specific);

    log::error("cb not found for handle {}", p_data->hdr.layer_specific);

    return;

  }

  /* set role */

  client_cb->role = BTA_HF_CLIENT_ACP;



  LOG_VERBOSE("%s: conn_handle %d", __func__, client_cb->conn_handle);

  log::verbose("conn_handle {}", client_cb->conn_handle);



  /* get bd addr of peer */

  uint16_t lcid = 0;

  RawAddress dev_addr = RawAddress::kEmpty;

  int status = PORT_CheckConnection(client_cb->conn_handle, &dev_addr, &lcid);

  if (status != PORT_SUCCESS) {

    LOG_ERROR("PORT_CheckConnection returned status:%d", status);

    log::error("PORT_CheckConnection returned status:{}", status);

  }



  /* Collision Handling */
@@ -209,8 +209,7 @@ void bta_hf_client_rfc_fail(tBTA_HF_CLIENT_DATA* p_data) { 
  tBTA_HF_CLIENT_CB* client_cb =

      bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);

  if (client_cb == NULL) {

    LOG_ERROR("%s: cb not found for handle %d", __func__,

              p_data->hdr.layer_specific);

    log::error("cb not found for handle {}", p_data->hdr.layer_specific);

    return;

  }
@@ -239,8 +238,7 @@ void bta_hf_client_disc_fail(tBTA_HF_CLIENT_DATA* p_data) { 
  tBTA_HF_CLIENT_CB* client_cb =

      bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);

  if (client_cb == NULL) {

    LOG_ERROR("%s: cb not found for handle %d", __func__,

              p_data->hdr.layer_specific);

    log::error("cb not found for handle {}", p_data->hdr.layer_specific);

    return;

  }

}
@@ -259,8 +257,7 @@ void bta_hf_client_open_fail(tBTA_HF_CLIENT_DATA* p_data) { 
  tBTA_HF_CLIENT_CB* client_cb =

      bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);

  if (client_cb == NULL) {

    LOG_ERROR("%s: cb not found for handle %d", __func__,

              p_data->hdr.layer_specific);

    log::error("cb not found for handle {}", p_data->hdr.layer_specific);

    return;

  }

}
@@ -279,8 +276,7 @@ void bta_hf_client_rfc_close(tBTA_HF_CLIENT_DATA* p_data) { 
  tBTA_HF_CLIENT_CB* client_cb =

      bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);

  if (client_cb == NULL) {

    LOG_ERROR("%s: cb not found for handle %d", __func__,

              p_data->hdr.layer_specific);

    log::error("cb not found for handle {}", p_data->hdr.layer_specific);

    return;

  }
@@ -322,12 +318,11 @@ void bta_hf_client_rfc_close(tBTA_HF_CLIENT_DATA* p_data) { 
void bta_hf_client_disc_int_res(tBTA_HF_CLIENT_DATA* p_data) {

  uint16_t event = BTA_HF_CLIENT_DISC_FAIL_EVT;



  LOG_VERBOSE("%s: Status: %d", __func__, p_data->disc_result.status);

  log::verbose("Status: {}", p_data->disc_result.status);

  tBTA_HF_CLIENT_CB* client_cb =

      bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);

  if (client_cb == NULL) {

    LOG_ERROR("%s: cb not found for handle %d", __func__,

              p_data->hdr.layer_specific);

    log::error("cb not found for handle {}", p_data->hdr.layer_specific);

    return;

  }
@@ -361,8 +356,7 @@ void bta_hf_client_disc_acp_res(tBTA_HF_CLIENT_DATA* p_data) { 
  tBTA_HF_CLIENT_CB* client_cb =

      bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);

  if (client_cb == NULL) {

    LOG_ERROR("%s: cb not found for handle %d", __func__,

              p_data->hdr.layer_specific);

    log::error("cb not found for handle {}", p_data->hdr.layer_specific);

    return;

  }
@@ -391,8 +385,7 @@ void bta_hf_client_rfc_data(tBTA_HF_CLIENT_DATA* p_data) { 
  tBTA_HF_CLIENT_CB* client_cb =

      bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);

  if (client_cb == NULL) {

    LOG_ERROR("%s: cb not found for handle %d", __func__,

              p_data->hdr.layer_specific);

    log::error("cb not found for handle {}", p_data->hdr.layer_specific);

    return;

  }
@@ -427,12 +420,11 @@ void bta_hf_client_rfc_data(tBTA_HF_CLIENT_DATA* p_data) { 
 *

 ******************************************************************************/

void bta_hf_client_svc_conn_open(tBTA_HF_CLIENT_DATA* p_data) {

  LOG_VERBOSE("%s", __func__);

  log::verbose("");

  tBTA_HF_CLIENT_CB* client_cb =

      bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);

  if (client_cb == NULL) {

    LOG_ERROR("%s: cb not found for handle %d", __func__,

              p_data->hdr.layer_specific);

    log::error("cb not found for handle {}", p_data->hdr.layer_specific);

    return;

  }

system/bta/hf_client/bta_hf_client_api.cc

+5 −2
Original line number Diff line number Diff line
@@ -27,6 +27,7 @@ 
#include "bta/include/bta_hf_client_api.h"



#include <android_bluetooth_sysprop.h>

#include <bluetooth/log.h>



#include <cstdint>
@@ -38,6 +39,8 @@ 
#include "stack/include/bt_hdr.h"

#include "types/raw_address.h"



using namespace bluetooth;



/*****************************************************************************

 *  External Function Declarations

 ****************************************************************************/
@@ -85,12 +88,12 @@ void BTA_HfClientDisable(void) { bta_hf_client_api_disable(); } 
 *

 ******************************************************************************/

bt_status_t BTA_HfClientOpen(const RawAddress& bd_addr, uint16_t* p_handle) {

  LOG_VERBOSE("%s", __func__);

  log::verbose("");

  tBTA_HF_CLIENT_API_OPEN* p_buf =

      (tBTA_HF_CLIENT_API_OPEN*)osi_malloc(sizeof(tBTA_HF_CLIENT_API_OPEN));



  if (!bta_hf_client_allocate_handle(bd_addr, p_handle)) {

    LOG_ERROR("%s: could not allocate handle", __func__);

    log::error("could not allocate handle");

    return BT_STATUS_FAIL;

  }

system/bta/hf_client/bta_hf_client_at.cc

+114 −115

File changed.

Preview size limit exceeded, changes collapsed.

system/bta/hf_client/bta_hf_client_main.cc

+48 −49
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ 
 ******************************************************************************/



#include <base/logging.h>

#include <bluetooth/log.h>



#include <cstdint>

#include <cstdio>
@@ -33,6 +34,7 @@ 
#include "types/raw_address.h"



using namespace bluetooth::legacy::stack::sdp;

using namespace bluetooth;



static const char* bta_hf_client_evt_str(uint16_t event);

static const char* bta_hf_client_state_str(uint8_t state);
@@ -300,7 +302,7 @@ void bta_hf_client_cb_arr_init() { 
 *

 ******************************************************************************/

void bta_hf_client_cb_init(tBTA_HF_CLIENT_CB* client_cb, uint16_t handle) {

  LOG_VERBOSE("%s", __func__);

  log::verbose("");



  // Free any memory we need to explicity release

  alarm_free(client_cb->collision_timer);
@@ -330,7 +332,7 @@ void bta_hf_client_cb_init(tBTA_HF_CLIENT_CB* client_cb, uint16_t handle) { 
 *

 ******************************************************************************/

void bta_hf_client_resume_open(tBTA_HF_CLIENT_CB* client_cb) {

  LOG_VERBOSE("%s", __func__);

  log::verbose("");



  /* resume opening process.  */

  if (client_cb->state == BTA_HF_CLIENT_INIT_ST) {
@@ -353,7 +355,7 @@ void bta_hf_client_resume_open(tBTA_HF_CLIENT_CB* client_cb) { 
 *

 ******************************************************************************/

static void bta_hf_client_collision_timer_cback(void* data) {

  LOG_VERBOSE("%s", __func__);

  log::verbose("");

  tBTA_HF_CLIENT_CB* client_cb = (tBTA_HF_CLIENT_CB*)data;



  /* If the peer haven't opened connection, restart opening process */
@@ -377,12 +379,12 @@ void bta_hf_client_collision_cback(UNUSED_ATTR tBTA_SYS_CONN_STATUS status, 
  if (client_cb != NULL && client_cb->state == BTA_HF_CLIENT_OPENING_ST) {

    if (id == BTA_ID_SYS) /* ACL collision */

    {

      LOG_WARN("HF Client found collision (ACL) ...");

      log::warn("HF Client found collision (ACL) ...");

    } else if (id == BTA_ID_HS) /* RFCOMM collision */

    {

      LOG_WARN("HF Client found collision (RFCOMM) ...");

      log::warn("HF Client found collision (RFCOMM) ...");

    } else {

      LOG_WARN("HF Client found collision (\?\?\?) ...");

      log::warn("HF Client found collision (\?\?\?) ...");

    }



    client_cb->state = BTA_HF_CLIENT_INIT_ST;
@@ -420,7 +422,7 @@ tBTA_STATUS bta_hf_client_api_enable(tBTA_HF_CLIENT_CBACK* p_cback, 
                                     const char* p_service_name) {

  /* If already registered then return error */

  if (bta_sys_is_register(BTA_ID_HS)) {

    LOG_ERROR("BTA HF Client is already enabled, ignoring ...");

    log::error("BTA HF Client is already enabled, ignoring ...");

    return BTA_FAILURE;

  }
@@ -472,8 +474,8 @@ tBTA_STATUS bta_hf_client_api_enable(tBTA_HF_CLIENT_CBACK* p_cback, 
tBTA_HF_CLIENT_CB* bta_hf_client_find_cb_by_handle(uint16_t handle) {

  // Handles are limited from 1 through HF_CLIENT_MAX_DEVICES

  if (handle < 1 || handle > HF_CLIENT_MAX_DEVICES) {

    LOG_ERROR("%s: handle out of range (%d, %d) %d", __func__, 1,

              HF_CLIENT_MAX_DEVICES, handle);

    log::error("handle out of range ({}, {}) {}", 1, HF_CLIENT_MAX_DEVICES,

               handle);

    return NULL;

  }
@@ -481,7 +483,7 @@ tBTA_HF_CLIENT_CB* bta_hf_client_find_cb_by_handle(uint16_t handle) { 
  if (bta_hf_client_cb_arr.cb[handle - 1].is_allocated)

    return &(bta_hf_client_cb_arr.cb[handle - 1]);



  LOG_ERROR("%s: block not found for handle %d", __func__, handle);

  log::error("block not found for handle {}", handle);

  return NULL;

}
@@ -506,11 +508,11 @@ tBTA_HF_CLIENT_CB* bta_hf_client_find_cb_by_bda(const RawAddress& peer_addr) { 
    if (client_cb->is_allocated && peer_addr == client_cb->peer_addr) {

      return client_cb;

    } else {

      LOG_WARN("%s: bdaddr mismatch for handle %d alloc %d", __func__, i,

      log::warn("bdaddr mismatch for handle {} alloc {}", i,

                client_cb->is_allocated);

    }

  }

  LOG_ERROR("%s: block not found", __func__);

  log::error("block not found");

  return NULL;

}
@@ -533,18 +535,18 @@ tBTA_HF_CLIENT_CB* bta_hf_client_find_cb_by_rfc_handle(uint16_t handle) { 
    bool is_allocated = client_cb->is_allocated;

    uint16_t conn_handle = client_cb->conn_handle;



    LOG_VERBOSE("%s: cb rfc_handle %d alloc %d conn_handle %d", __func__,

                handle, is_allocated, conn_handle);

    log::verbose("cb rfc_handle {} alloc {} conn_handle {}", handle,

                 is_allocated, conn_handle);



    if (is_allocated && conn_handle == handle) {

      return client_cb;

    }



    LOG_WARN("%s: no cb yet %d alloc %d conn_handle %d", __func__, handle,

             is_allocated, conn_handle);

    log::warn("no cb yet {} alloc {} conn_handle {}", handle, is_allocated,

              conn_handle);

  }



  LOG_ERROR("%s: no cb found for rfc handle %d", __func__, handle);

  log::error("no cb found for rfc handle {}", handle);

  return NULL;

}
@@ -568,7 +570,7 @@ tBTA_HF_CLIENT_CB* bta_hf_client_find_cb_by_sco_handle(uint16_t handle) { 
      return client_cb;

    }

  }

  LOG_ERROR("%s: block not found for handle %d", __func__, handle);

  log::error("block not found for handle {}", handle);

  return NULL;

}
@@ -593,8 +595,7 @@ bool bta_hf_client_allocate_handle(const RawAddress& bd_addr, 
                                   uint16_t* p_handle) {

  tBTA_HF_CLIENT_CB* existing_cb = bta_hf_client_find_cb_by_bda(bd_addr);

  if (existing_cb != NULL) {

    LOG_ERROR("%s: cannot allocate handle since BDADDR already exists",

              __func__);

    log::error("cannot allocate handle since BDADDR already exists");

    return false;

  }

  /* Check that we do not have a request to for same device in the control
@@ -602,7 +603,7 @@ bool bta_hf_client_allocate_handle(const RawAddress& bd_addr, 
  for (int i = 0; i < HF_CLIENT_MAX_DEVICES; i++) {

    tBTA_HF_CLIENT_CB* client_cb = &bta_hf_client_cb_arr.cb[i];

    if (client_cb->is_allocated) {

      LOG_WARN("%s: control block already used index %d", __func__, i);

      log::warn("control block already used index {}", i);

      continue;

    }
@@ -610,8 +611,7 @@ bool bta_hf_client_allocate_handle(const RawAddress& bd_addr, 
    bta_hf_client_cb_init(client_cb, client_cb->handle);



    *p_handle = client_cb->handle;

    LOG_VERBOSE("%s: marking CB handle %d to true", __func__,

                client_cb->handle);

    log::verbose("marking CB handle {} to true", client_cb->handle);



    client_cb->is_allocated = true;

    client_cb->peer_addr = bd_addr;
@@ -620,7 +620,7 @@ bool bta_hf_client_allocate_handle(const RawAddress& bd_addr, 
  }



  return false;

  LOG_ERROR("%s: all control blocks in use!", __func__);

  log::error("all control blocks in use!");

}



/*******************************************************************************
@@ -651,7 +651,7 @@ void bta_hf_client_app_callback(uint16_t event, tBTA_HF_CLIENT* data) { 
 ******************************************************************************/

void bta_hf_client_api_disable() {

  if (!bta_sys_is_register(BTA_ID_HS)) {

    LOG_WARN("BTA HF Client is already disabled, ignoring ...");

    log::warn("BTA HF Client is already disabled, ignoring ...");

    return;

  }
@@ -688,7 +688,7 @@ void bta_hf_client_api_disable() { 
 *

 ******************************************************************************/

bool bta_hf_client_hdl_event(const BT_HDR_RIGID* p_msg) {

  LOG_VERBOSE("%s: %s (0x%x)", __func__, bta_hf_client_evt_str(p_msg->event),

  log::verbose("{} (0x{:x})", bta_hf_client_evt_str(p_msg->event),

               p_msg->event);

  bta_hf_client_sm_execute(p_msg->event, (tBTA_HF_CLIENT_DATA*)p_msg);

  return true;
@@ -708,8 +708,7 @@ void bta_hf_client_sm_execute(uint16_t event, tBTA_HF_CLIENT_DATA* p_data) { 
  tBTA_HF_CLIENT_CB* client_cb =

      bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);

  if (client_cb == NULL) {

    LOG_ERROR("%s: cb not found for handle %d", __func__,

              p_data->hdr.layer_specific);

    log::error("cb not found for handle {}", p_data->hdr.layer_specific);

    return;

  }
@@ -723,14 +722,14 @@ void bta_hf_client_sm_execute(uint16_t event, tBTA_HF_CLIENT_DATA* p_data) { 
  /* Ignore displaying of AT results when not connected (Ignored in state

   * machine) */

  if (client_cb->state == BTA_HF_CLIENT_OPEN_ST) {

    LOG_VERBOSE("HF Client evt : State %d (%s), Event 0x%04x (%s)",

    log::verbose("HF Client evt : State {} ({}), Event 0x{:04x} ({})",

                 client_cb->state, bta_hf_client_state_str(client_cb->state),

                 event, bta_hf_client_evt_str(event));

  }



  event &= 0x00FF;

  if (event >= (BTA_HF_CLIENT_MAX_EVT & 0x00FF)) {

    LOG_ERROR("HF Client evt out of range, ignoring...");

    log::error("HF Client evt out of range, ignoring...");

    return;

  }
@@ -752,15 +751,15 @@ void bta_hf_client_sm_execute(uint16_t event, tBTA_HF_CLIENT_DATA* p_data) { 


  /* If the state has changed then notify the app of the corresponding change */

  if (in_state != client_cb->state) {

    VLOG(1) << __func__ << ": notifying state change to " << in_state << " -> "

            << client_cb->state << " device " << client_cb->peer_addr;

    log::verbose("notifying state change to {} -> {} device {}", in_state,

                 client_cb->state,

                 ADDRESS_TO_LOGGABLE_STR(client_cb->peer_addr));

    tBTA_HF_CLIENT evt;

    memset(&evt, 0, sizeof(evt));

    evt.bd_addr = client_cb->peer_addr;

    if (client_cb->state == BTA_HF_CLIENT_INIT_ST) {

      bta_hf_client_app_callback(BTA_HF_CLIENT_CLOSE_EVT, &evt);

      LOG_VERBOSE("%s: marking CB handle %d to false", __func__,

                  client_cb->handle);

      log::verbose("marking CB handle {} to false", client_cb->handle);

      client_cb->is_allocated = false;

    } else if (client_cb->state == BTA_HF_CLIENT_OPEN_ST) {

      evt.open.handle = client_cb->handle;
@@ -768,10 +767,11 @@ void bta_hf_client_sm_execute(uint16_t event, tBTA_HF_CLIENT_DATA* p_data) { 
    }

  }



  VLOG(2) << __func__ << ": device " << client_cb->peer_addr

          << "state change: [" << bta_hf_client_state_str(in_state) << "] -> ["

          << bta_hf_client_state_str(client_cb->state) << "] after Event ["

          << bta_hf_client_evt_str(in_event) << "]";

  log::verbose("device {} state change: [{}] -> [{}] after Event [{}]",

               ADDRESS_TO_LOGGABLE_STR(client_cb->peer_addr),

               bta_hf_client_state_str(in_state),

               bta_hf_client_state_str(client_cb->state),

               bta_hf_client_evt_str(in_event));

}



static void send_post_slc_cmd(tBTA_HF_CLIENT_CB* client_cb) {
@@ -799,12 +799,12 @@ static void send_post_slc_cmd(tBTA_HF_CLIENT_CB* client_cb) { 
 *

 ******************************************************************************/

void bta_hf_client_slc_seq(tBTA_HF_CLIENT_CB* client_cb, bool error) {

  LOG_VERBOSE("bta_hf_client_slc_seq cmd: %u", client_cb->at_cb.current_cmd);

  log::verbose("bta_hf_client_slc_seq cmd: {}", client_cb->at_cb.current_cmd);



  if (error) {

    /* SLC establishment error, sent close rfcomm event */

    LOG_ERROR(

        "HFPClient: Failed to create SLC due to AT error, disconnecting (%u)",

    log::error(

        "HFPClient: Failed to create SLC due to AT error, disconnecting ({})",

        client_cb->at_cb.current_cmd);



    tBTA_HF_CLIENT_DATA msg;
@@ -814,8 +814,7 @@ void bta_hf_client_slc_seq(tBTA_HF_CLIENT_CB* client_cb, bool error) { 
  }



  if (client_cb->svc_conn) {

    LOG_WARN("%s: SLC already connected for CB handle %d", __func__,

             client_cb->handle);

    log::warn("SLC already connected for CB handle {}", client_cb->handle);

    return;

  }
@@ -890,9 +889,9 @@ void bta_hf_client_slc_seq(tBTA_HF_CLIENT_CB* client_cb, bool error) { 


    default: {

      /* If happen there is a bug in SLC creation procedure... */

      LOG_ERROR(

      log::error(

          "HFPClient: Failed to create SLCdue to unexpected AT command, "

          "disconnecting (%u)",

          "disconnecting ({})",

          client_cb->at_cb.current_cmd);



      tBTA_HF_CLIENT_DATA msg;

system/bta/hf_client/bta_hf_client_rfc.cc

+23 −25
Original line number Diff line number Diff line
@@ -25,6 +25,7 @@ 
 ******************************************************************************/



#include <base/logging.h>

#include <bluetooth/log.h>



#include <cstdint>
@@ -38,6 +39,7 @@ 
#include "types/raw_address.h"



using namespace bluetooth::legacy::stack::sdp;

using namespace bluetooth;



/*******************************************************************************

 *
@@ -56,7 +58,7 @@ static void bta_hf_client_port_cback(UNUSED_ATTR uint32_t code, 
  tBTA_HF_CLIENT_CB* client_cb =

      bta_hf_client_find_cb_by_rfc_handle(port_handle);

  if (client_cb == NULL) {

    LOG_ERROR("%s: cb not found for handle %d", __func__, port_handle);

    log::error("cb not found for handle {}", port_handle);

    return;

  }
@@ -81,13 +83,13 @@ static void bta_hf_client_mgmt_cback(uint32_t code, uint16_t port_handle) { 
  tBTA_HF_CLIENT_CB* client_cb =

      bta_hf_client_find_cb_by_rfc_handle(port_handle);



  LOG_VERBOSE("%s: code = %d, port_handle = %d serv = %d", __func__, code,

              port_handle, bta_hf_client_cb_arr.serv_handle);

  log::verbose("code = {}, port_handle = {} serv = {}", code, port_handle,

               bta_hf_client_cb_arr.serv_handle);



  /* ignore close event for port handles other than connected handle */

  if (code != PORT_SUCCESS && client_cb != NULL &&

      port_handle != client_cb->conn_handle) {

    LOG_VERBOSE("bta_hf_client_mgmt_cback ignoring handle:%d", port_handle);

    log::verbose("bta_hf_client_mgmt_cback ignoring handle:{}", port_handle);

    return;

  }
@@ -100,13 +102,13 @@ static void bta_hf_client_mgmt_cback(uint32_t code, uint16_t port_handle) { 
    } else if (port_handle == bta_hf_client_cb_arr.serv_handle) {

      p_buf->hdr.event = BTA_HF_CLIENT_RFC_OPEN_EVT;



      LOG_VERBOSE("%s: allocating a new CB for incoming connection", __func__);

      log::verbose("allocating a new CB for incoming connection");

      // Find the BDADDR of the peer device

      RawAddress peer_addr = RawAddress::kEmpty;

      uint16_t lcid = 0;

      int status = PORT_CheckConnection(port_handle, &peer_addr, &lcid);

      if (status != PORT_SUCCESS) {

        LOG(ERROR) << __func__ << ": PORT_CheckConnection returned " << status;

        log::error("PORT_CheckConnection returned {}", status);

      }



      // Since we accepted a remote request we should allocate a handle first.
@@ -116,7 +118,7 @@ static void bta_hf_client_mgmt_cback(uint32_t code, uint16_t port_handle) { 


      // If allocation fails then we abort.

      if (client_cb == NULL) {

        LOG_ERROR("%s: error allocating a new handle", __func__);

        log::error("error allocating a new handle");

        p_buf->hdr.event = BTA_HF_CLIENT_RFC_CLOSE_EVT;

        RFCOMM_RemoveConnection(port_handle);

      } else {
@@ -130,15 +132,14 @@ static void bta_hf_client_mgmt_cback(uint32_t code, uint16_t port_handle) { 
        bta_hf_client_start_server();

      }

    } else {

      LOG_ERROR("%s: PORT_SUCCESS, ignoring handle = %d", __func__,

                port_handle);

      log::error("PORT_SUCCESS, ignoring handle = {}", port_handle);

      osi_free(p_buf);

      return;

    }

  } else if (client_cb != NULL &&

             port_handle == client_cb->conn_handle) { /* code != PORT_SUC */

    LOG(ERROR) << __func__ << ": closing port handle " << port_handle << "dev "

               << client_cb->peer_addr;

    log::error("closing port handle {} dev {}", port_handle,

               ADDRESS_TO_LOGGABLE_STR(client_cb->peer_addr));



    RFCOMM_RemoveServer(port_handle);

    p_buf->hdr.event = BTA_HF_CLIENT_RFC_CLOSE_EVT;
@@ -181,7 +182,7 @@ void bta_hf_client_start_server() { 
  int port_status;



  if (bta_hf_client_cb_arr.serv_handle > 0) {

    LOG_VERBOSE("%s: already started, handle: %d", __func__,

    log::verbose("already started, handle: {}",

                 bta_hf_client_cb_arr.serv_handle);

    return;

  }
@@ -191,14 +192,13 @@ void bta_hf_client_start_server() { 
      BTA_HF_CLIENT_MTU, RawAddress::kAny, &(bta_hf_client_cb_arr.serv_handle),

      bta_hf_client_mgmt_cback, BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT);



  LOG_VERBOSE("%s: started rfcomm server with handle %d", __func__,

  log::verbose("started rfcomm server with handle {}",

               bta_hf_client_cb_arr.serv_handle);



  if (port_status == PORT_SUCCESS) {

    bta_hf_client_setup_port(bta_hf_client_cb_arr.serv_handle);

  } else {

    LOG_VERBOSE("%s: RFCOMM_CreateConnection returned error:%d", __func__,

                port_status);

    log::verbose("RFCOMM_CreateConnection returned error:{}", port_status);

  }

}
@@ -213,10 +213,10 @@ void bta_hf_client_start_server() { 
 *

 ******************************************************************************/

void bta_hf_client_close_server() {

  LOG_VERBOSE("%s: %d", __func__, bta_hf_client_cb_arr.serv_handle);

  log::verbose("{}", bta_hf_client_cb_arr.serv_handle);



  if (bta_hf_client_cb_arr.serv_handle == 0) {

    LOG_VERBOSE("%s: already stopped", __func__);

    log::verbose("already stopped");

    return;

  }
@@ -238,8 +238,7 @@ void bta_hf_client_rfc_do_open(tBTA_HF_CLIENT_DATA* p_data) { 
  tBTA_HF_CLIENT_CB* client_cb =

      bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);

  if (client_cb == NULL) {

    LOG_ERROR("%s: cb not found for handle %d", __func__,

              p_data->hdr.layer_specific);

    log::error("cb not found for handle {}", p_data->hdr.layer_specific);

    return;

  }
@@ -249,7 +248,7 @@ void bta_hf_client_rfc_do_open(tBTA_HF_CLIENT_DATA* p_data) { 
          bta_hf_client_mgmt_cback,

          BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT) == PORT_SUCCESS) {

    bta_hf_client_setup_port(client_cb->conn_handle);

    LOG_VERBOSE("bta_hf_client_rfc_do_open : conn_handle = %d",

    log::verbose("bta_hf_client_rfc_do_open : conn_handle = {}",

                 client_cb->conn_handle);

  }

  /* RFCOMM create connection failed; send ourselves RFCOMM close event */
@@ -272,8 +271,7 @@ void bta_hf_client_rfc_do_close(tBTA_HF_CLIENT_DATA* p_data) { 
  tBTA_HF_CLIENT_CB* client_cb =

      bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);

  if (client_cb == NULL) {

    LOG_ERROR("%s: cb not found for handle %d", __func__,

              p_data->hdr.layer_specific);

    log::error("cb not found for handle {}", p_data->hdr.layer_specific);

    return;

  }