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

Commit 89d1708e authored by HsingYuan Lo's avatar HsingYuan Lo Committed by Automerger Merge Worker
Browse files

Implement robust caching (client) am: bf008c60 am: d7525d07 

Original change: https://android-review.googlesource.com/c/platform/system/bt/+/1398285

MUST ONLY BE SUBMITTED BY AUTOMERGER

Change-Id: Iab3c7add020cb8dc831c1ce63fe4dba7ddf54d50
parents 1cecd19f d7525d07

system/bta/gatt/bta_gattc_act.cc

+59 −14
Original line number Diff line number Diff line
@@ -487,6 +487,12 @@ void bta_gattc_conn(tBTA_GATTC_CLCB* p_clcb, tBTA_GATTC_DATA* p_data) { 
    /* a pending service handle change indication */

    if (p_clcb->p_srcb->srvc_hdl_chg) {

      p_clcb->p_srcb->srvc_hdl_chg = false;



      /* set true to read database hash before service discovery */

      if (bta_gattc_is_robust_caching_enabled()) {

        p_clcb->p_srcb->srvc_hdl_db_hash = true;

      }



      /* start discovery */

      bta_gattc_sm_execute(p_clcb, BTA_GATTC_INT_DISCOVER_EVT, NULL);

    }
@@ -595,6 +601,8 @@ void bta_gattc_set_discover_st(tBTA_GATTC_SERV* p_srcb) { 
    if (bta_gattc_cb.clcb[i].p_srcb == p_srcb) {

      bta_gattc_cb.clcb[i].status = GATT_SUCCESS;

      bta_gattc_cb.clcb[i].state = BTA_GATTC_DISCOVER_ST;

      bta_gattc_cb.clcb[i].request_during_discovery =

          BTA_GATTC_DISCOVER_REQ_NONE;

    }

  }

}
@@ -625,6 +633,20 @@ void bta_gattc_cfg_mtu(tBTA_GATTC_CLCB* p_clcb, tBTA_GATTC_DATA* p_data) { 
  }

}



void bta_gattc_start_discover_internal(tBTA_GATTC_CLCB* p_clcb) {

  if (p_clcb->transport == BT_TRANSPORT_LE)

    L2CA_EnableUpdateBleConnParams(p_clcb->p_srcb->server_bda, false);



  bta_gattc_init_cache(p_clcb->p_srcb);

  p_clcb->status = bta_gattc_discover_pri_service(

      p_clcb->bta_conn_id, p_clcb->p_srcb, GATT_DISC_SRVC_ALL);

  if (p_clcb->status != GATT_SUCCESS) {

    LOG(ERROR) << "discovery on server failed";

    bta_gattc_reset_discover_st(p_clcb->p_srcb, p_clcb->status);

  } else

    p_clcb->disc_active = true;

}



/** Start a discovery on server */

void bta_gattc_start_discover(tBTA_GATTC_CLCB* p_clcb,

                              UNUSED_ATTR tBTA_GATTC_DATA* p_data) {
@@ -640,25 +662,24 @@ void bta_gattc_start_discover(tBTA_GATTC_CLCB* p_clcb, 
    p_clcb->auto_update = BTA_GATTC_NO_SCHEDULE;



    if (p_clcb->p_srcb != NULL) {

      /* set all srcb related clcb into discovery ST */

      bta_gattc_set_discover_st(p_clcb->p_srcb);



      /* clear the service change mask */

      p_clcb->p_srcb->srvc_hdl_chg = false;

      p_clcb->p_srcb->update_count = 0;

      p_clcb->p_srcb->state = BTA_GATTC_SERV_DISC_ACT;



      if (p_clcb->transport == BT_TRANSPORT_LE)

        L2CA_EnableUpdateBleConnParams(p_clcb->p_srcb->server_bda, false);



      /* set all srcb related clcb into discovery ST */

      bta_gattc_set_discover_st(p_clcb->p_srcb);

      /* read db hash if db hash characteristic exists */

      if (bta_gattc_is_robust_caching_enabled() &&

          p_clcb->p_srcb->srvc_hdl_db_hash && bta_gattc_read_db_hash(p_clcb)) {

        LOG(INFO) << __func__

                  << ": pending service discovery, read db hash first";

        p_clcb->p_srcb->srvc_hdl_db_hash = false;

        return;

      }



      bta_gattc_init_cache(p_clcb->p_srcb);

      p_clcb->status = bta_gattc_discover_pri_service(

          p_clcb->bta_conn_id, p_clcb->p_srcb, GATT_DISC_SRVC_ALL);

      if (p_clcb->status != GATT_SUCCESS) {

        LOG(ERROR) << "discovery on server failed";

        bta_gattc_reset_discover_st(p_clcb->p_srcb, p_clcb->status);

      } else

        p_clcb->disc_active = true;

      bta_gattc_start_discover_internal(p_clcb);

    } else {

      LOG(ERROR) << "unknown device, can not start discovery";

    }
@@ -961,8 +982,26 @@ void bta_gattc_op_cmpl(tBTA_GATTC_CLCB* p_clcb, tBTA_GATTC_DATA* p_data) { 
  else if (op == GATTC_OPTYPE_CONFIG)

    bta_gattc_cfg_mtu_cmpl(p_clcb, &p_data->op_cmpl);



  // If receive DATABASE_OUT_OF_SYNC error code, bta_gattc should start service

  // discovery immediately

  if (bta_gattc_is_robust_caching_enabled() &&

      p_data->op_cmpl.status == GATT_DATABASE_OUT_OF_SYNC) {

    LOG(INFO) << __func__ << ": DATABASE_OUT_OF_SYNC, re-discover service";

    p_clcb->auto_update = BTA_GATTC_REQ_WAITING;

    /* request read db hash first */

    p_clcb->p_srcb->srvc_hdl_db_hash = true;

    bta_gattc_sm_execute(p_clcb, BTA_GATTC_INT_DISCOVER_EVT, NULL);

    return;

  }



  if (p_clcb->auto_update == BTA_GATTC_DISC_WAITING) {

    p_clcb->auto_update = BTA_GATTC_REQ_WAITING;



    /* request read db hash first */

    if (bta_gattc_is_robust_caching_enabled()) {

      p_clcb->p_srcb->srvc_hdl_db_hash = true;

    }



    bta_gattc_sm_execute(p_clcb, BTA_GATTC_INT_DISCOVER_EVT, NULL);

  }

}
@@ -1160,7 +1199,13 @@ bool bta_gattc_process_srvc_chg_ind(uint16_t conn_id, tBTA_GATTC_RCB* p_clrcb, 
    GATTC_SendHandleValueConfirm(conn_id, p_notify->cid);



    /* if connection available, refresh cache by doing discovery now */

    if (p_clcb) bta_gattc_sm_execute(p_clcb, BTA_GATTC_INT_DISCOVER_EVT, NULL);

    if (p_clcb) {

      /* request read db hash first */

      if (bta_gattc_is_robust_caching_enabled()) {

        p_srcb->srvc_hdl_db_hash = true;

      }

      bta_gattc_sm_execute(p_clcb, BTA_GATTC_INT_DISCOVER_EVT, NULL);

    }

  }



  /* notify applicationf or service change */

system/bta/gatt/bta_gattc_cache.cc

+175 −56
Original line number Diff line number Diff line
@@ -68,6 +68,15 @@ const Characteristic* bta_gattc_get_characteristic_srcb(tBTA_GATTC_SERV* p_srcb, 
static void bta_gattc_explore_srvc_finished(uint16_t conn_id,

                                            tBTA_GATTC_SERV* p_srvc_cb);



static void bta_gattc_read_db_hash_cmpl(tBTA_GATTC_CLCB* p_clcb,

                                        tBTA_GATTC_OP_CMPL* p_data);



static void bta_gattc_read_ext_prop_desc_cmpl(tBTA_GATTC_CLCB* p_clcb,

                                              tBTA_GATTC_OP_CMPL* p_data);



// define the max retry count for DATABASE_OUT_OF_SYNC

#define BTA_GATTC_DISCOVER_RETRY_COUNT 2



#define BTA_GATT_SDP_DB_SIZE 4096



#define GATT_CACHE_PREFIX "/data/misc/bluetooth/gatt_cache_"
@@ -170,6 +179,10 @@ static void bta_gattc_explore_next_service(uint16_t conn_id, 
  const auto& descriptors =

      p_srvc_cb->pending_discovery.DescriptorHandlesToRead();

  if (!descriptors.empty()) {

    // set request field to READ_EXT_PROP_DESC

    p_clcb->request_during_discovery =

        BTA_GATTC_DISCOVER_REQ_READ_EXT_PROP_DESC;



    if (p_srvc_cb->read_multiple_not_supported) {

      tGATT_READ_PARAM read_param{

          .by_handle = {.handle = descriptors.front(),
@@ -226,6 +239,14 @@ static void bta_gattc_explore_srvc_finished(uint16_t conn_id, 
                          p_clcb->p_srcb->gatt_database.Serialize());

  }



  // After success, reset the count.

  if (bta_gattc_is_robust_caching_enabled()) {

    LOG(INFO) << __func__

              << ": service discovery succeed, reset count to zero, conn_id="

              << loghex(conn_id);

    p_srvc_cb->srvc_disc_count = 0;

  }



  bta_gattc_reset_discover_st(p_clcb->p_srcb, GATT_SUCCESS);

}
@@ -353,63 +374,27 @@ static tGATT_STATUS bta_gattc_sdp_service_disc(uint16_t conn_id, 
}



/** operation completed */

void bta_gattc_op_cmpl_during_discovery(UNUSED_ATTR tBTA_GATTC_CLCB* p_clcb,

void bta_gattc_op_cmpl_during_discovery(tBTA_GATTC_CLCB* p_clcb,

                                        tBTA_GATTC_DATA* p_data) {

  uint8_t op = (uint8_t)p_data->op_cmpl.op_code;



  if (op != GATTC_OPTYPE_READ) {

    /* receive op complete when discovery is started, ignore the response,

       and wait for discovery finish and resent */

    VLOG(1) << __func__ << ": op = " << +p_data->hdr.layer_specific;

    return;

  }

  // our read operation is finished.

  // TODO: check if we can get here when any other read operation i.e. initiated

  // by upper layer apps, can get us there.



  tBTA_GATTC_SERV* p_srvc_cb = p_clcb->p_srcb;

  const uint8_t status = p_data->op_cmpl.status;



  if (status == GATT_REQ_NOT_SUPPORTED &&

      !p_srvc_cb->read_multiple_not_supported) {

    // can't do "read multiple request", fall back to "read request"

    p_srvc_cb->read_multiple_not_supported = true;

    bta_gattc_explore_next_service(p_clcb->bta_conn_id, p_srvc_cb);

    return;

  }



  if (status != GATT_SUCCESS) {

    LOG(WARNING) << "Discovery on server failed: " << loghex(status);

    bta_gattc_reset_discover_st(p_clcb->p_srcb, GATT_ERROR);

  }



  const tGATT_VALUE& att_value = p_data->op_cmpl.p_cmpl->att_value;

  if (!p_srvc_cb->read_multiple_not_supported && att_value.len != 2) {

    // Just one Characteristic Extended Properties value at a time in Read

    // Response

    LOG(WARNING) << __func__ << " Read Response should be just 2 bytes!";

    bta_gattc_reset_discover_st(p_clcb->p_srcb, GATT_ERROR);

  }



  // Parsing is same for "Read Multiple Response", and for "Read Response"

  const uint8_t* p = att_value.value;

  std::vector<uint16_t> value_of_descriptors;

  while (p < att_value.value + att_value.len) {

    uint16_t extended_properties;

    STREAM_TO_UINT16(extended_properties, p);

    value_of_descriptors.push_back(extended_properties);

  // Currently, there are two cases needed to be handled.

  // 1. Read ext prop descriptor value after service discovery

  // 2. Read db hash before starting service discovery

  switch (p_clcb->request_during_discovery) {

    case BTA_GATTC_DISCOVER_REQ_READ_EXT_PROP_DESC:

      bta_gattc_read_ext_prop_desc_cmpl(p_clcb, &p_data->op_cmpl);

      break;

    case BTA_GATTC_DISCOVER_REQ_READ_DB_HASH:

      if (bta_gattc_is_robust_caching_enabled()) {

        bta_gattc_read_db_hash_cmpl(p_clcb, &p_data->op_cmpl);

      } else {

        // it is not possible here if flag is off, but just in case

        p_clcb->request_during_discovery = BTA_GATTC_DISCOVER_REQ_NONE;

      }



  bool ret =

      p_srvc_cb->pending_discovery.SetValueOfDescriptors(value_of_descriptors);

  if (!ret) {

    LOG(WARNING) << __func__

                 << " Problem setting Extended Properties descriptors values";

    bta_gattc_reset_discover_st(p_clcb->p_srcb, GATT_ERROR);

      break;

    case BTA_GATTC_DISCOVER_REQ_NONE:

    default:

      break;

  }



  // Continue service discovery

  bta_gattc_explore_next_service(p_clcb->bta_conn_id, p_srvc_cb);

}



/** callback function to GATT client stack */
@@ -456,14 +441,29 @@ void bta_gattc_disc_res_cback(uint16_t conn_id, tGATT_DISC_TYPE disc_type, 
void bta_gattc_disc_cmpl_cback(uint16_t conn_id, tGATT_DISC_TYPE disc_type,

                               tGATT_STATUS status) {

  tBTA_GATTC_CLCB* p_clcb = bta_gattc_find_clcb_by_conn_id(conn_id);

  tBTA_GATTC_SERV* p_srvc_cb = bta_gattc_find_scb_by_cid(conn_id);



  if (p_clcb && (status != GATT_SUCCESS || p_clcb->status != GATT_SUCCESS)) {

    if (status == GATT_SUCCESS) p_clcb->status = status;



    // if db out of sync is received, try to start service discovery if possible

    if (bta_gattc_is_robust_caching_enabled() &&

        status == GATT_DATABASE_OUT_OF_SYNC) {

      if (p_srvc_cb &&

          p_srvc_cb->srvc_disc_count < BTA_GATTC_DISCOVER_RETRY_COUNT) {

        p_srvc_cb->srvc_disc_count++;

        p_clcb->auto_update = BTA_GATTC_DISC_WAITING;

      } else {

        LOG(ERROR) << __func__

                   << ": retry limit exceeds for db out of sync, conn_id="

                   << conn_id;

      }

    }



    bta_gattc_sm_execute(p_clcb, BTA_GATTC_DISCOVER_CMPL_EVT, NULL);

    return;

  }



  tBTA_GATTC_SERV* p_srvc_cb = bta_gattc_find_scb_by_cid(conn_id);

  if (!p_srvc_cb) return;



  switch (disc_type) {
@@ -631,6 +631,125 @@ const Characteristic* bta_gattc_get_owning_characteristic(uint16_t conn_id, 
  return bta_gattc_get_owning_characteristic_srcb(p_clcb->p_srcb, handle);

}



/* request reading database hash */

bool bta_gattc_read_db_hash(tBTA_GATTC_CLCB* p_clcb) {

  tGATT_READ_PARAM read_param;

  memset(&read_param, 0, sizeof(tGATT_READ_BY_TYPE));



  read_param.char_type.s_handle = 0x0001;

  read_param.char_type.e_handle = 0xFFFF;

  read_param.char_type.uuid = Uuid::From16Bit(GATT_UUID_DATABASE_HASH);

  read_param.char_type.auth_req = GATT_AUTH_REQ_NONE;

  tGATT_STATUS status =

      GATTC_Read(p_clcb->bta_conn_id, GATT_READ_BY_TYPE, &read_param);



  if (status != GATT_SUCCESS) return false;

  p_clcb->request_during_discovery = BTA_GATTC_DISCOVER_REQ_READ_DB_HASH;



  return true;

}



/* handle response of reading database hash */

static void bta_gattc_read_db_hash_cmpl(tBTA_GATTC_CLCB* p_clcb,

                                        tBTA_GATTC_OP_CMPL* p_data) {

  uint8_t op = (uint8_t)p_data->op_code;

  if (op != GATTC_OPTYPE_READ) {

    VLOG(1) << __func__ << ": op = " << +p_data->hdr.layer_specific;

    return;

  }

  p_clcb->request_during_discovery = BTA_GATTC_DISCOVER_REQ_NONE;



  // run match flow only if the status is success

  bool matched = false;

  if (p_data->status == GATT_SUCCESS) {

    // start to compare local hash and remote hash

    uint16_t len = p_data->p_cmpl->att_value.len;

    uint8_t* data = p_data->p_cmpl->att_value.value;



    Octet16 remote_hash;

    if (len == remote_hash.size()) {

      uint8_t idx = 0;

      auto it = remote_hash.begin();

      for (; idx < len; idx++, data++, it++) *it = *data;



      Octet16 local_hash = p_clcb->p_srcb->gatt_database.Hash();

      matched = (local_hash == remote_hash);

    }

  }



  if (matched) {

    LOG(INFO) << __func__ << ": hash is the same, skip service discovery";

    p_clcb->p_srcb->state = BTA_GATTC_SERV_IDLE;

    bta_gattc_reset_discover_st(p_clcb->p_srcb, GATT_SUCCESS);

  } else {

    LOG(INFO) << __func__ << ": hash is not the same, start service discovery";

    bta_gattc_start_discover_internal(p_clcb);

  }

}



/* handle response of reading extended properties descriptor */

static void bta_gattc_read_ext_prop_desc_cmpl(tBTA_GATTC_CLCB* p_clcb,

                                              tBTA_GATTC_OP_CMPL* p_data) {

  uint8_t op = (uint8_t)p_data->op_code;

  if (op != GATTC_OPTYPE_READ) {

    VLOG(1) << __func__ << ": op = " << +p_data->hdr.layer_specific;

    return;

  }



  if (!p_clcb->disc_active) {

    VLOG(1) << __func__ << ": not active in discover state";

    return;

  }

  p_clcb->request_during_discovery = BTA_GATTC_DISCOVER_REQ_NONE;



  tBTA_GATTC_SERV* p_srvc_cb = p_clcb->p_srcb;

  const uint8_t status = p_data->status;



  if (status == GATT_REQ_NOT_SUPPORTED &&

      !p_srvc_cb->read_multiple_not_supported) {

    // can't do "read multiple request", fall back to "read request"

    p_srvc_cb->read_multiple_not_supported = true;

    bta_gattc_explore_next_service(p_clcb->bta_conn_id, p_srvc_cb);

    return;

  }



  if (status != GATT_SUCCESS) {

    LOG(WARNING) << "Discovery on server failed: " << loghex(status);

    bta_gattc_reset_discover_st(p_clcb->p_srcb, GATT_ERROR);

    return;

  }



  const tGATT_VALUE& att_value = p_data->p_cmpl->att_value;

  if (p_srvc_cb->read_multiple_not_supported && att_value.len != 2) {

    // Just one Characteristic Extended Properties value at a time in Read

    // Response

    LOG(WARNING) << __func__ << " Read Response should be just 2 bytes!";

    bta_gattc_reset_discover_st(p_clcb->p_srcb, GATT_ERROR);

    return;

  }



  // Parsing is same for "Read Multiple Response", and for "Read Response"

  const uint8_t* p = att_value.value;

  std::vector<uint16_t> value_of_descriptors;

  while (p < att_value.value + att_value.len) {

    uint16_t extended_properties;

    STREAM_TO_UINT16(extended_properties, p);

    value_of_descriptors.push_back(extended_properties);

  }



  bool ret =

      p_srvc_cb->pending_discovery.SetValueOfDescriptors(value_of_descriptors);

  if (!ret) {

    LOG(WARNING) << __func__

                 << " Problem setting Extended Properties descriptors values";

    bta_gattc_reset_discover_st(p_clcb->p_srcb, GATT_ERROR);

    return;

  }



  // Continue service discovery

  bta_gattc_explore_next_service(p_clcb->bta_conn_id, p_srvc_cb);

}



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

 *

 * Function         bta_gattc_fill_gatt_db_el

system/bta/gatt/bta_gattc_int.h

+13 −0
Original line number Diff line number Diff line
@@ -219,6 +219,8 @@ typedef struct { 
  bool read_multiple_not_supported;



  uint8_t srvc_hdl_chg; /* service handle change indication pending */

  bool srvc_hdl_db_hash;   /* read db hash pending */

  uint8_t srvc_disc_count; /* current discovery retry count */

  uint16_t attr_index;  /* cahce NV saving/loading attribute index */



  uint16_t mtu;
@@ -254,6 +256,13 @@ typedef struct { 
  tBTA_GATTC_SERV* p_srcb;  /* server cache CB */

  tBTA_GATTC_DATA* p_q_cmd; /* command in queue waiting for execution */



// request during discover state

#define BTA_GATTC_DISCOVER_REQ_NONE 0

#define BTA_GATTC_DISCOVER_REQ_READ_EXT_PROP_DESC 1

#define BTA_GATTC_DISCOVER_REQ_READ_DB_HASH 2



  uint8_t request_during_discovery; /* request during discover state */



#define BTA_GATTC_NO_SCHEDULE 0

#define BTA_GATTC_DISC_WAITING 0x01

#define BTA_GATTC_REQ_WAITING 0x10
@@ -352,6 +361,7 @@ extern void bta_gattc_disc_close(tBTA_GATTC_CLCB* p_clcb, 


extern void bta_gattc_start_discover(tBTA_GATTC_CLCB* p_clcb,

                                     tBTA_GATTC_DATA* p_data);

extern void bta_gattc_start_discover_internal(tBTA_GATTC_CLCB* p_clcb);

extern void bta_gattc_disc_cmpl(tBTA_GATTC_CLCB* p_clcb,

                                tBTA_GATTC_DATA* p_data);

extern void bta_gattc_read(tBTA_GATTC_CLCB* p_clcb, tBTA_GATTC_DATA* p_data);
@@ -418,6 +428,7 @@ extern void bta_gattc_clear_notif_registration(tBTA_GATTC_SERV* p_srcb, 
                                               uint16_t start_handle,

                                               uint16_t end_handle);

extern tBTA_GATTC_SERV* bta_gattc_find_srvr_cache(const RawAddress& bda);

extern bool bta_gattc_is_robust_caching_enabled();



/* discovery functions */

extern void bta_gattc_disc_res_cback(uint16_t conn_id,
@@ -459,4 +470,6 @@ extern bool bta_gattc_conn_dealloc(const RawAddress& remote_bda); 
extern bool bta_gattc_cache_load(tBTA_GATTC_SERV* p_srcb);

extern void bta_gattc_cache_reset(const RawAddress& server_bda);



extern bool bta_gattc_read_db_hash(tBTA_GATTC_CLCB* p_clcb);



#endif /* BTA_GATTC_INT_H */

system/bta/gatt/bta_gattc_utils.cc

+15 −2
Original line number Diff line number Diff line
@@ -24,14 +24,14 @@ 


#define LOG_TAG "bt_bta_gattc"



#include "bt_target.h"



#include <base/logging.h>

#include <string.h>



#include "bt_common.h"

#include "bt_target.h"

#include "bta_gattc_int.h"

#include "bta_sys.h"

#include "gd/common/init_flags.h"

#include "l2c_api.h"

#include "types/bt_transport.h"

#include "utl.h"
@@ -656,3 +656,16 @@ tBTA_GATTC_CLCB* bta_gattc_find_int_disconn_clcb(tBTA_GATTC_DATA* p_msg) { 
  }

  return p_clcb;

}



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

 *

 * Function         bta_gattc_is_robust_caching_enabled

 *

 * Description      check if robust caching is enabled

 *

 * Returns          true if enabled; otherwise false

 *

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

bool bta_gattc_is_robust_caching_enabled() {

  return bluetooth::common::init_flags::gatt_robust_caching_is_enabled();

}