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

Commit bbefba70 authored by Chen Chen's avatar Chen Chen Committed by Automerger Merge Worker
Browse files

Merge "ProfileConnectionFailureReason: Log HIDD and HIDH failures with counter... 

Merge "ProfileConnectionFailureReason: Log HIDD and HIDH failures with counter metrics" am: 1cc672ee am: 9daae152

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



Change-Id: I8a6ae3631ae83b9cd49a8e607a0cff219c9a4719
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 4a0bbe2f 9daae152

system/bta/hd/bta_hd_act.cc

+6 −0
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ 
 *  This file contains the HID device action functions.

 *

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

#include <frameworks/proto_logging/stats/enums/bluetooth/enums.pb.h>



#include <cstdint>

#include <string>
@@ -32,6 +33,7 @@ 


#include "bta/hd/bta_hd_int.h"

#include "include/hardware/bt_hd.h"

#include "main/shim/metrics_api.h"

#include "osi/include/allocator.h"

#include "osi/include/log.h"

#include "stack/include/bt_hdr.h"
@@ -172,6 +174,10 @@ void bta_hd_register_act(tBTA_HD_DATA* p_data) { 
    APPL_TRACE_ERROR("%s: Descriptor is too long or malformed", __func__);

    ret.reg_status.status = BTA_HD_ERROR;

    (*bta_hd_cb.p_cback)(BTA_HD_REGISTER_APP_EVT, &ret);

    bluetooth::shim::CountCounterMetrics(

        android::bluetooth::CodePathCounterKeyEnum::

            HIDD_REGISTER_DESCRIPTOR_MALFORMED,

        1);

    return;

  }

system/stack/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -916,6 +916,7 @@ cc_test { 
        ":TestMockStackL2cap",

        ":TestMockStackSdp",

        ":TestMockStackBtm",

        ":TestMockStackMetrics",

        ":TestStubLegacyTrace",

        "hid/hidd_api.cc",

        "hid/hidd_conn.cc",

system/stack/hid/hidd_api.cc

+57 −5
Original line number Diff line number Diff line
@@ -25,6 +25,7 @@ 


#include "hidd_api.h"



#include <frameworks/proto_logging/stats/enums/bluetooth/enums.pb.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>
@@ -35,6 +36,7 @@ 
#include "osi/include/allocator.h"

#include "stack/btm/btm_sec.h"

#include "stack/include/bt_types.h"

#include "stack/include/stack_metrics_logging.h"

#include "types/bluetooth/uuid.h"

#include "types/raw_address.h"
@@ -89,9 +91,19 @@ tHID_STATUS HID_DevRegister(tHID_DEV_HOST_CALLBACK* host_cback) { 


  HIDD_TRACE_API("%s", __func__);



  if (hd_cb.reg_flag) return HID_ERR_ALREADY_REGISTERED;

  if (hd_cb.reg_flag) {

    log_counter_metrics(

        android::bluetooth::CodePathCounterKeyEnum::HIDD_ERR_ALREADY_REGISTERED,

        1);

    return HID_ERR_ALREADY_REGISTERED;

  }



  if (host_cback == NULL) return HID_ERR_INVALID_PARAM;

  if (host_cback == NULL) {

    log_counter_metrics(

        android::bluetooth::CodePathCounterKeyEnum::HIDD_ERR_HOST_CALLBACK_NULL,

        1);

    return HID_ERR_INVALID_PARAM;

  }



  /* Register with L2CAP */

  st = hidd_conn_reg();
@@ -120,7 +132,12 @@ tHID_STATUS HID_DevRegister(tHID_DEV_HOST_CALLBACK* host_cback) { 
tHID_STATUS HID_DevDeregister(void) {

  HIDD_TRACE_API("%s", __func__);



  if (!hd_cb.reg_flag) return (HID_ERR_NOT_REGISTERED);

  if (!hd_cb.reg_flag) {

    log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                            HIDD_ERR_NOT_REGISTERED_AT_DEREGISTER,

                        1);

    return (HID_ERR_NOT_REGISTERED);

  }



  hidd_conn_dereg();
@@ -256,6 +273,10 @@ tHID_STATUS HID_DevAddRecord(uint32_t handle, char* p_name, char* p_description, 
      if (desc_len > HIDD_APP_DESCRIPTOR_LEN) {

        HIDD_TRACE_ERROR("%s: descriptor length = %d, larger than max %d",

                         __func__, desc_len, HIDD_APP_DESCRIPTOR_LEN);

        log_counter_metrics(

            android::bluetooth::CodePathCounterKeyEnum::

                HIDD_ERR_NOT_REGISTERED_DUE_TO_DESCRIPTOR_LENGTH,

            1);

        return HID_ERR_NOT_REGISTERED;

      };
@@ -264,6 +285,10 @@ tHID_STATUS HID_DevAddRecord(uint32_t handle, char* p_name, char* p_description, 
      if (p_buf == NULL) {

        HIDD_TRACE_ERROR("%s: Buffer allocation failure for size = 2048 ",

                         __func__);

        log_counter_metrics(

            android::bluetooth::CodePathCounterKeyEnum::

                HIDD_ERR_NOT_REGISTERED_DUE_TO_BUFFER_ALLOCATION,

            1);

        return HID_ERR_NOT_REGISTERED;

      }
@@ -328,7 +353,9 @@ tHID_STATUS HID_DevAddRecord(uint32_t handle, char* p_name, char* p_description, 


  if (!result) {

    HIDD_TRACE_ERROR("%s: failed to complete SDP record", __func__);



    log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                            HIDD_ERR_NOT_REGISTERED_AT_SDP,

                        1);

    return HID_ERR_NOT_REGISTERED;

  }
@@ -359,7 +386,9 @@ tHID_STATUS HID_DevSendReport(uint8_t channel, uint8_t type, uint8_t id, 
    return hidd_conn_send_data(HID_CHANNEL_INTR, HID_TRANS_DATA,

                               HID_PAR_REP_TYPE_INPUT, id, len, p_data);

  }



  log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                          HIDD_ERR_INVALID_PARAM_SEND_REPORT,

                      1);

  return HID_ERR_INVALID_PARAM;

}
@@ -426,14 +455,22 @@ tHID_STATUS HID_DevUnplugDevice(const RawAddress& addr) { 
 ******************************************************************************/

tHID_STATUS HID_DevConnect(void) {

  if (!hd_cb.reg_flag) {

    log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                            HIDD_ERR_NOT_REGISTERED_AT_CONNECT,

                        1);

    return HID_ERR_NOT_REGISTERED;

  }



  if (!hd_cb.device.in_use) {

    log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                            HIDD_ERR_DEVICE_NOT_IN_USE_AT_CONNECT,

                        1);

    return HID_ERR_INVALID_PARAM;

  }



  if (hd_cb.device.state != HIDD_DEV_NO_CONN) {

    log_counter_metrics(

        android::bluetooth::CodePathCounterKeyEnum::HIDD_ERR_ALREADY_CONN, 1);

    return HID_ERR_ALREADY_CONN;

  }
@@ -451,10 +488,16 @@ tHID_STATUS HID_DevConnect(void) { 
 ******************************************************************************/

tHID_STATUS HID_DevDisconnect(void) {

  if (!hd_cb.reg_flag) {

    log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                            HIDD_ERR_NOT_REGISTERED_AT_DISCONNECT,

                        1);

    return HID_ERR_NOT_REGISTERED;

  }



  if (!hd_cb.device.in_use) {

    log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                            HIDD_ERR_DEVICE_NOT_IN_USE_AT_DISCONNECT,

                        1);

    return HID_ERR_INVALID_PARAM;

  }
@@ -465,8 +508,14 @@ tHID_STATUS HID_DevDisconnect(void) { 
      hd_cb.device.conn.conn_state = HID_CONN_STATE_UNUSED;

      hd_cb.callback(hd_cb.device.addr, HID_DHOST_EVT_CLOSE,

                     HID_ERR_DISCONNECTING, NULL);

      log_counter_metrics(

          android::bluetooth::CodePathCounterKeyEnum::HIDD_ERR_DISCONNECTING,

          1);

      return ret;

    }

    log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                            HIDD_ERR_NO_CONNECTION_AT_DISCONNECT,

                        1);

    return HID_ERR_NO_CONNECTION;

  }
@@ -536,6 +585,9 @@ tHID_STATUS HID_DevGetDevice(RawAddress* addr) { 
  if (hd_cb.device.in_use) {

    *addr = hd_cb.device.addr;

  } else {

    log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                            HIDD_ERR_NOT_REGISTERED_AT_GET_DEVICE,

                        1);

    return HID_ERR_NOT_REGISTERED;

  }

system/stack/hid/hidd_conn.cc

+42 −5
Original line number Diff line number Diff line
@@ -23,6 +23,9 @@ 
 *

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



#include <base/logging.h>

#include <frameworks/proto_logging/stats/enums/bluetooth/enums.pb.h>



#include <cstdint>



#include "bta/include/bta_api.h"
@@ -31,10 +34,9 @@ 
#include "stack/hid/hidd_int.h"

#include "stack/include/bt_hdr.h"

#include "stack/include/bt_types.h"

#include "stack/include/stack_metrics_logging.h"

#include "types/raw_address.h"



#include <base/logging.h>



static void hidd_l2cif_connect_ind(const RawAddress& bd_addr, uint16_t cid,

                                   uint16_t psm, uint8_t id);

static void hidd_l2cif_connect_cfm(uint16_t cid, uint16_t result);
@@ -288,6 +290,9 @@ static void hidd_l2cif_config_cfm(uint16_t cid, uint16_t initiator, 
                           __func__);

        hd_cb.callback(hd_cb.device.addr, HID_DHOST_EVT_CLOSE,

                       HID_ERR_L2CAP_FAILED, NULL);

        log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                                HIDD_ERR_L2CAP_NOT_STARTED_INCOMING,

                            1);

        return;

      } else {

        p_hcon->conn_state = HID_CONN_STATE_CONNECTING_INTR;
@@ -574,6 +579,9 @@ tHID_STATUS hidd_conn_reg(void) { 
                      nullptr, HID_DEV_MTU_SIZE, 0,

                      BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT)) {

    HIDD_TRACE_ERROR("HID Control (device) registration failed");

    log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                            HIDD_ERR_L2CAP_FAILED_CONTROL,

                        1);

    return (HID_ERR_L2CAP_FAILED);

  }
@@ -582,6 +590,9 @@ tHID_STATUS hidd_conn_reg(void) { 
                      BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT)) {

    L2CA_Deregister(HID_PSM_CONTROL);

    HIDD_TRACE_ERROR("HID Interrupt (device) registration failed");

    log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                            HIDD_ERR_L2CAP_FAILED_INTERRUPT,

                        1);

    return (HID_ERR_L2CAP_FAILED);

  }
@@ -620,11 +631,17 @@ tHID_STATUS hidd_conn_initiate(void) { 


  if (!p_dev->in_use) {

    HIDD_TRACE_WARNING("%s: no virtual cable established", __func__);

    log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                            HIDD_ERR_NOT_REGISTERED_AT_INITIATE,

                        1);

    return (HID_ERR_NOT_REGISTERED);

  }



  if (p_dev->conn.conn_state != HID_CONN_STATE_UNUSED) {

    HIDD_TRACE_WARNING("%s: connection already in progress", __func__);

    log_counter_metrics(

        android::bluetooth::CodePathCounterKeyEnum::HIDD_ERR_CONN_IN_PROCESS,

        1);

    return (HID_ERR_CONN_IN_PROCESS);

  }
@@ -641,6 +658,9 @@ tHID_STATUS hidd_conn_initiate(void) { 
    HIDD_TRACE_WARNING("%s: could not start L2CAP connection", __func__);

    hd_cb.callback(hd_cb.device.addr, HID_DHOST_EVT_CLOSE, HID_ERR_L2CAP_FAILED,

                   NULL);

    log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                            HIDD_ERR_L2CAP_FAILED_INITIATE,

                        1);

  } else {

    p_dev->conn.conn_state = HID_CONN_STATE_CONNECTING_CTRL;

  }
@@ -712,6 +732,9 @@ tHID_STATUS hidd_conn_send_data(uint8_t channel, uint8_t msg_type, 
  tHID_CONN* p_hcon = &hd_cb.device.conn;



  if (p_hcon->conn_flags & HID_CONN_FLAGS_CONGESTED) {

    log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                            HIDD_ERR_CONGESTED_AT_FLAG_CHECK,

                        1);

    return HID_ERR_CONGESTED;

  }
@@ -731,11 +754,18 @@ tHID_STATUS hidd_conn_send_data(uint8_t channel, uint8_t msg_type, 
      }

      break;

    default:

      log_counter_metrics(

          android::bluetooth::CodePathCounterKeyEnum::HIDD_ERR_INVALID_PARAM,

          1);

      return (HID_ERR_INVALID_PARAM);

  }



  p_buf = (BT_HDR*)osi_malloc(buf_size);

  if (p_buf == NULL) return (HID_ERR_NO_RESOURCES);

  if (p_buf == NULL) {

    log_counter_metrics(

        android::bluetooth::CodePathCounterKeyEnum::HIDD_ERR_NO_RESOURCES, 1);

    return (HID_ERR_NO_RESOURCES);

  }



  p_buf->offset = L2CAP_MIN_OFFSET;
@@ -775,7 +805,9 @@ tHID_STATUS hidd_conn_send_data(uint8_t channel, uint8_t msg_type, 


      return HID_SUCCESS;

    }



    log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                            HIDD_ERR_NO_CONNECTION_AT_SEND_DATA,

                        1);

    return HID_ERR_NO_CONNECTION;

  }
@@ -786,7 +818,12 @@ tHID_STATUS hidd_conn_send_data(uint8_t channel, uint8_t msg_type, 
#endif

  HIDD_TRACE_VERBOSE("%s: report sent", __func__);



  if (!L2CA_DataWrite(cid, p_buf)) return (HID_ERR_CONGESTED);

  if (!L2CA_DataWrite(cid, p_buf)) {

    log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                            HIDD_ERR_CONGESTED_AT_DATA_WRITE,

                        1);

    return (HID_ERR_CONGESTED);

  }



  return (HID_SUCCESS);

}

system/stack/hid/hidh_api.cc

+59 −11
Original line number Diff line number Diff line
@@ -24,6 +24,7 @@ 


#include "hidh_api.h"



#include <frameworks/proto_logging/stats/enums/bluetooth/enums.pb.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>
@@ -35,6 +36,7 @@ 
#include "stack/btm/btm_dev.h"

#include "stack/btm/btm_sec.h"

#include "stack/include/bt_hdr.h"

#include "stack/include/stack_metrics_logging.h"

#include "types/bluetooth/uuid.h"

#include "types/raw_address.h"
@@ -56,8 +58,11 @@ static void hidh_search_callback(tSDP_RESULT sdp_result); 
tHID_STATUS HID_HostGetSDPRecord(const RawAddress& addr,

                                 tSDP_DISCOVERY_DB* p_db, uint32_t db_len,

                                 tHID_HOST_SDP_CALLBACK* sdp_cback) {



  if (hh_cb.sdp_busy) return HID_ERR_SDP_BUSY;

  if (hh_cb.sdp_busy) {

    log_counter_metrics(

        android::bluetooth::CodePathCounterKeyEnum::HIDH_ERR_SDP_BUSY, 1);

    return HID_ERR_SDP_BUSY;

  }



  hh_cb.p_sdp_db = p_db;

  Uuid uuid_list = Uuid::From16Bit(UUID_SERVCLASS_HUMAN_INTERFACE);
@@ -67,9 +72,13 @@ tHID_STATUS HID_HostGetSDPRecord(const RawAddress& addr, 
    hh_cb.sdp_cback = sdp_cback;

    hh_cb.sdp_busy = true;

    return HID_SUCCESS;

  } else

  } else {

    log_counter_metrics(

        android::bluetooth::CodePathCounterKeyEnum::HIDH_ERR_NO_RESOURCES_SDP,

        1);

    return HID_ERR_NO_RESOURCES;

  }

}



void hidh_get_str_attr(tSDP_DISC_REC* p_rec, uint16_t attr_id, uint16_t max_len,

                       char* str) {
@@ -263,9 +272,19 @@ uint8_t HID_HostSetTraceLevel(uint8_t new_level) { 
tHID_STATUS HID_HostRegister(tHID_HOST_DEV_CALLBACK* dev_cback) {

  tHID_STATUS st;



  if (hh_cb.reg_flag) return HID_ERR_ALREADY_REGISTERED;

  if (hh_cb.reg_flag) {

    log_counter_metrics(

        android::bluetooth::CodePathCounterKeyEnum::HIDH_ERR_ALREADY_REGISTERED,

        1);

    return HID_ERR_ALREADY_REGISTERED;

  }



  if (dev_cback == NULL) return HID_ERR_INVALID_PARAM;

  if (dev_cback == NULL) {

    log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                            HIDH_ERR_INVALID_PARAM_AT_HOST_REGISTER,

                        1);

    return HID_ERR_INVALID_PARAM;

  }



  /* Register with L2CAP */

  st = hidh_conn_reg();
@@ -333,7 +352,12 @@ tHID_STATUS HID_HostAddDev(const RawAddress& addr, uint16_t attr_mask, 
    }

  }



  if (i == HID_HOST_MAX_DEVICES) return HID_ERR_NO_RESOURCES;

  if (i == HID_HOST_MAX_DEVICES) {

    log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                            HIDH_ERR_NO_RESOURCES_ADD_DEVICE,

                        1);

    return HID_ERR_NO_RESOURCES;

  }



  if (!hh_cb.devices[i].in_use) {

    hh_cb.devices[i].in_use = true;
@@ -363,8 +387,12 @@ tHID_STATUS HID_HostRemoveDev(uint8_t dev_handle) { 
  if (!hh_cb.reg_flag) return (HID_ERR_NOT_REGISTERED);



  if ((dev_handle >= HID_HOST_MAX_DEVICES) ||

      (!hh_cb.devices[dev_handle].in_use))

      (!hh_cb.devices[dev_handle].in_use)) {

    log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                            HIDH_ERR_INVALID_PARAM_AT_HOST_REMOVE_DEV,

                        1);

    return HID_ERR_INVALID_PARAM;

  }



  HID_HostCloseDev(dev_handle);

  hh_cb.devices[dev_handle].in_use = false;
@@ -390,10 +418,16 @@ tHID_STATUS HID_HostOpenDev(uint8_t dev_handle) { 


  if ((dev_handle >= HID_HOST_MAX_DEVICES) ||

      (!hh_cb.devices[dev_handle].in_use))

    log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                            HIDH_ERR_INVALID_PARAM_AT_HOST_OPEN_DEV,

                        1);

    return HID_ERR_INVALID_PARAM;



  if (hh_cb.devices[dev_handle].state != HID_DEV_NO_CONN)

    if (hh_cb.devices[dev_handle].state != HID_DEV_NO_CONN) {

      log_counter_metrics(

          android::bluetooth::CodePathCounterKeyEnum::HIDH_ERR_ALREADY_CONN, 1);

      return HID_ERR_ALREADY_CONN;

    }



  hh_cb.devices[dev_handle].conn_tries = 1;

  return hidh_conn_initiate(dev_handle);
@@ -423,11 +457,17 @@ tHID_STATUS HID_HostWriteDev(uint8_t dev_handle, uint8_t t_type, uint8_t param, 
  if ((dev_handle >= HID_HOST_MAX_DEVICES) ||

      (!hh_cb.devices[dev_handle].in_use)) {

    HIDH_TRACE_ERROR("HID_ERR_INVALID_PARAM");

    log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                            HIDH_ERR_INVALID_PARAM_AT_HOST_WRITE_DEV,

                        1);

    status = HID_ERR_INVALID_PARAM;

  }



  else if (hh_cb.devices[dev_handle].state != HID_DEV_CONNECTED) {

    HIDH_TRACE_ERROR("HID_ERR_NO_CONNECTION dev_handle %d", dev_handle);

    log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                            HIDH_ERR_NO_CONNECTION_AT_HOST_WRITE_DEV,

                        1);

    status = HID_ERR_NO_CONNECTION;

  }
@@ -453,11 +493,19 @@ tHID_STATUS HID_HostCloseDev(uint8_t dev_handle) { 
  if (!hh_cb.reg_flag) return (HID_ERR_NOT_REGISTERED);



  if ((dev_handle >= HID_HOST_MAX_DEVICES) ||

      (!hh_cb.devices[dev_handle].in_use))

      (!hh_cb.devices[dev_handle].in_use)) {

    log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                            HIDH_ERR_INVALID_PARAM_AT_HOST_CLOSE_DEV,

                        1);

    return HID_ERR_INVALID_PARAM;

  }



  if (hh_cb.devices[dev_handle].state != HID_DEV_CONNECTED)

  if (hh_cb.devices[dev_handle].state != HID_DEV_CONNECTED) {

    log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::

                            HIDH_ERR_NO_CONNECTION_AT_HOST_CLOSE_DEV,

                        1);

    return HID_ERR_NO_CONNECTION;

  }



  alarm_cancel(hh_cb.devices[dev_handle].conn.process_repage_timer);

  hh_cb.devices[dev_handle].conn_tries = HID_HOST_MAX_CONN_RETRY + 1;