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

Commit 1b09dc8e authored by Jakub Pawlowski's avatar Jakub Pawlowski
Browse files

Modernize BLE Scanner implementation (2/3)

Get rid of BTA state machine states for BLE scanning.

Test: sl4a FilteringTest
Bug: 30622771
Change-Id: I8a879604f413c9980cf64983d8ef6b9a94669295
parent 0aa69dab
Loading
Loading
Loading
Loading
+78 −64
Original line number Diff line number Diff line
@@ -4257,12 +4257,12 @@ void bta_dm_ble_set_conn_params(tBTA_DM_MSG* p_data) {
 * Parameters:
 *
 ******************************************************************************/
void bta_dm_ble_set_scan_params(tBTA_DM_MSG* p_data) {
  BTM_BleSetScanParams(p_data->ble_set_scan_params.client_if,
                       p_data->ble_set_scan_params.scan_int,
                       p_data->ble_set_scan_params.scan_window,
                       p_data->ble_set_scan_params.scan_mode,
                       p_data->ble_set_scan_params.scan_param_setup_cback);
void bta_dm_ble_set_scan_params(
    tBTA_GATTC_IF client_if, uint32_t scan_int, uint32_t scan_window,
    tBLE_SCAN_MODE scan_mode,
    tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback) {
  BTM_BleSetScanParams(client_if, scan_int, scan_window, scan_mode,
                       scan_param_setup_cback);
}

/*******************************************************************************
@@ -4384,7 +4384,13 @@ void bta_dm_ble_set_data_length(tBTA_DM_MSG* p_data) {
 * Parameters:
 *
 ******************************************************************************/
void bta_dm_ble_setup_storage(tBTA_DM_MSG* p_data) {
void bta_dm_ble_setup_storage(uint8_t batch_scan_full_max,
                              uint8_t batch_scan_trunc_max,
                              uint8_t batch_scan_notify_threshold,
                              tBTA_BLE_SCAN_SETUP_CBACK* p_setup_cback,
                              tBTA_BLE_SCAN_THRESHOLD_CBACK* p_thres_cback,
                              tBTA_BLE_SCAN_REP_CBACK* p_read_rep_cback,
                              tBTA_DM_BLE_REF_VALUE ref_value) {
  tBTM_STATUS btm_status = 0;
  tBTM_BLE_VSC_CB cmn_ble_vsc_cb;

@@ -4392,18 +4398,13 @@ void bta_dm_ble_setup_storage(tBTA_DM_MSG* p_data) {

  if (0 != cmn_ble_vsc_cb.tot_scan_results_strg) {
    btm_status = BTM_BleSetStorageConfig(
        p_data->ble_set_storage.batch_scan_full_max,
        p_data->ble_set_storage.batch_scan_trunc_max,
        p_data->ble_set_storage.batch_scan_notify_threshold,
        p_data->ble_set_storage.p_setup_cback,
        p_data->ble_set_storage.p_thres_cback,
        p_data->ble_set_storage.p_read_rep_cback,
        p_data->ble_set_storage.ref_value);
        batch_scan_full_max, batch_scan_trunc_max, batch_scan_notify_threshold,
        p_setup_cback, p_thres_cback, p_read_rep_cback, ref_value);
  }

  if (BTM_CMD_STARTED != btm_status)
    bta_ble_scan_setup_cb(BTM_BLE_BATCH_SCAN_CFG_STRG_EVT,
                          p_data->ble_set_storage.ref_value, btm_status);
    bta_ble_scan_setup_cb(BTM_BLE_BATCH_SCAN_CFG_STRG_EVT, ref_value,
                          btm_status);
}

/*******************************************************************************
@@ -4415,23 +4416,23 @@ void bta_dm_ble_setup_storage(tBTA_DM_MSG* p_data) {
 * Parameters:
 *
 ******************************************************************************/
void bta_dm_ble_enable_batch_scan(tBTA_DM_MSG* p_data) {
void bta_dm_ble_enable_batch_scan(tBTA_BLE_BATCH_SCAN_MODE scan_mode,
                                  uint32_t scan_int, uint32_t scan_window,
                                  tBTA_BLE_DISCARD_RULE discard_rule,
                                  tBLE_ADDR_TYPE addr_type,
                                  tBTA_DM_BLE_REF_VALUE ref_value) {
  tBTM_STATUS btm_status = 0;
  tBTM_BLE_VSC_CB cmn_ble_vsc_cb;

  BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);

  if (0 != cmn_ble_vsc_cb.tot_scan_results_strg) {
    btm_status = BTM_BleEnableBatchScan(
        p_data->ble_enable_scan.scan_mode, p_data->ble_enable_scan.scan_int,
        p_data->ble_enable_scan.scan_window,
        p_data->ble_enable_scan.discard_rule, p_data->ble_enable_scan.addr_type,
        p_data->ble_enable_scan.ref_value);
    btm_status = BTM_BleEnableBatchScan(scan_mode, scan_int, scan_window,
                                        discard_rule, addr_type, ref_value);
  }

  if (BTM_CMD_STARTED != btm_status)
    bta_ble_scan_setup_cb(BTM_BLE_BATCH_SCAN_ENABLE_EVT,
                          p_data->ble_enable_scan.ref_value, btm_status);
    bta_ble_scan_setup_cb(BTM_BLE_BATCH_SCAN_ENABLE_EVT, ref_value, btm_status);
}

/*******************************************************************************
@@ -4443,19 +4444,19 @@ void bta_dm_ble_enable_batch_scan(tBTA_DM_MSG* p_data) {
 * Parameters:
 *
 ******************************************************************************/
void bta_dm_ble_disable_batch_scan(UNUSED_ATTR tBTA_DM_MSG* p_data) {
void bta_dm_ble_disable_batch_scan(tBTA_DM_BLE_REF_VALUE ref_value) {
  tBTM_STATUS btm_status = 0;
  tBTM_BLE_VSC_CB cmn_ble_vsc_cb;

  BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);

  if (0 != cmn_ble_vsc_cb.tot_scan_results_strg) {
    btm_status = BTM_BleDisableBatchScan(p_data->ble_disable_scan.ref_value);
    btm_status = BTM_BleDisableBatchScan(ref_value);
  }

  if (BTM_CMD_STARTED != btm_status)
    bta_ble_scan_setup_cb(BTM_BLE_BATCH_SCAN_DISABLE_EVT,
                          p_data->ble_enable_scan.ref_value, btm_status);
    bta_ble_scan_setup_cb(BTM_BLE_BATCH_SCAN_DISABLE_EVT, ref_value,
                          btm_status);
}

/*******************************************************************************
@@ -4467,20 +4468,20 @@ void bta_dm_ble_disable_batch_scan(UNUSED_ATTR tBTA_DM_MSG* p_data) {
 * Parameters:
 *
 ******************************************************************************/
void bta_dm_ble_read_scan_reports(tBTA_DM_MSG* p_data) {
void bta_dm_ble_read_scan_reports(tBTA_BLE_BATCH_SCAN_MODE scan_type,
                                  tBTA_DM_BLE_REF_VALUE ref_value) {
  tBTM_STATUS btm_status = 0;
  tBTM_BLE_VSC_CB cmn_ble_vsc_cb;

  BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);

  if (0 != cmn_ble_vsc_cb.tot_scan_results_strg) {
    btm_status = BTM_BleReadScanReports(p_data->ble_read_reports.scan_type,
                                        p_data->ble_read_reports.ref_value);
    btm_status = BTM_BleReadScanReports(scan_type, ref_value);
  }

  if (BTM_CMD_STARTED != btm_status)
    bta_ble_scan_setup_cb(BTM_BLE_BATCH_SCAN_READ_REPTS_EVT,
                          p_data->ble_enable_scan.ref_value, btm_status);
    bta_ble_scan_setup_cb(BTM_BLE_BATCH_SCAN_READ_REPTS_EVT, ref_value,
                          btm_status);
}

/*******************************************************************************
@@ -4588,7 +4589,12 @@ static void bta_ble_scan_cfg_cmpl(tBTM_BLE_PF_ACTION action,
 * Parameters:
 *
 ******************************************************************************/
void bta_dm_cfg_filter_cond(tBTA_DM_MSG* p_data) {
void bta_dm_cfg_filter_cond(tBTA_DM_BLE_SCAN_COND_OP action,
                            tBTA_DM_BLE_PF_COND_TYPE cond_type,
                            tBTA_DM_BLE_PF_FILT_INDEX filt_index,
                            tBTA_DM_BLE_PF_COND_PARAM* p_cond_param,
                            tBTA_DM_BLE_PF_CFG_CBACK* p_filt_cfg_cback,
                            tBTA_DM_BLE_REF_VALUE ref_value) {
  tBTM_STATUS st = BTM_MODE_UNSUPPORTED;
  tBTA_STATUS status = BTA_FAILURE;

@@ -4597,25 +4603,41 @@ void bta_dm_cfg_filter_cond(tBTA_DM_MSG* p_data) {
  APPL_TRACE_DEBUG("bta_dm_cfg_filter_cond");
  BTM_BleGetVendorCapabilities(&cmn_vsc_cb);
  if (0 != cmn_vsc_cb.filter_support) {
    st = BTM_BleCfgFilterCondition(
        p_data->ble_cfg_filter_cond.action,
        p_data->ble_cfg_filter_cond.cond_type,
        (tBTM_BLE_PF_FILT_INDEX)p_data->ble_cfg_filter_cond.filt_index,
        (tBTM_BLE_PF_COND_PARAM*)p_data->ble_cfg_filter_cond.p_cond_param,
        bta_ble_scan_cfg_cmpl, p_data->ble_cfg_filter_cond.ref_value);
    st = BTM_BleCfgFilterCondition(action, cond_type,
                                   (tBTM_BLE_PF_FILT_INDEX)filt_index,
                                   (tBTM_BLE_PF_COND_PARAM*)p_cond_param,
                                   bta_ble_scan_cfg_cmpl, ref_value);
    if (st == BTM_CMD_STARTED) {
      bta_dm_cb.p_scan_filt_cfg_cback =
          p_data->ble_cfg_filter_cond.p_filt_cfg_cback;
      bta_dm_cb.p_scan_filt_cfg_cback = p_filt_cfg_cback;
      return;
    }
  }

  if (p_data->ble_cfg_filter_cond.p_filt_cfg_cback)
    p_data->ble_cfg_filter_cond.p_filt_cfg_cback(
        BTA_DM_BLE_PF_CONFIG_EVT, p_data->ble_cfg_filter_cond.cond_type, 0,
        status, p_data->ble_cfg_filter_cond.ref_value);
  if (p_filt_cfg_cback)
    p_filt_cfg_cback(BTA_DM_BLE_PF_CONFIG_EVT, cond_type, 0, status, ref_value);
}

void bta_dm_scan_filter_clear(tBTA_DM_BLE_REF_VALUE ref_value,
                              tBTM_BLE_PF_FILT_INDEX filt_index,
                              tBTA_DM_BLE_PF_CFG_CBACK* p_filt_cfg_cback) {
  tBTM_BLE_VSC_CB cmn_vsc_cb;

  APPL_TRACE_DEBUG("%s:", __func__);
  BTM_BleGetVendorCapabilities(&cmn_vsc_cb);
  if (cmn_vsc_cb.filter_support != 0) {
    tBTM_STATUS st = BTM_BleCfgFilterCondition(
        BTM_BLE_SCAN_COND_CLEAR, BTM_BLE_PF_TYPE_ALL, filt_index, nullptr,
        bta_ble_scan_cfg_cmpl, ref_value);
    if (st == BTM_CMD_STARTED) {
      bta_dm_cb.p_scan_filt_cfg_cback = p_filt_cfg_cback;
      return;
    }
  }

  if (p_filt_cfg_cback)
    p_filt_cfg_cback(BTA_DM_BLE_PF_CONFIG_EVT, BTM_BLE_PF_TYPE_ALL, 0,
                     BTA_FAILURE, ref_value);
}

/*******************************************************************************
 *
@@ -4626,29 +4648,21 @@ void bta_dm_cfg_filter_cond(tBTA_DM_MSG* p_data) {
 * Parameters:
 *
 ******************************************************************************/
void bta_dm_enable_scan_filter(tBTA_DM_MSG* p_data) {
  tBTM_STATUS st = BTM_MODE_UNSUPPORTED;
  tBTA_STATUS status = BTA_FAILURE;

void bta_dm_enable_scan_filter(uint8_t action,
                               tBTA_DM_BLE_PF_STATUS_CBACK* p_filt_status_cback,
                               tBTA_DM_BLE_REF_VALUE ref_value) {
  APPL_TRACE_DEBUG("%s", __func__);
  tBTM_BLE_VSC_CB cmn_vsc_cb;
  APPL_TRACE_DEBUG("bta_dm_enable_scan_filter");
  BTM_BleGetVendorCapabilities(&cmn_vsc_cb);

  if (0 != cmn_vsc_cb.filter_support) {
    st = BTM_BleEnableDisableFilterFeature(
        p_data->ble_enable_scan_filt.action,
        p_data->ble_enable_scan_filt.p_filt_status_cback,
        (tBTM_BLE_REF_VALUE)p_data->ble_enable_scan_filt.ref_value);
    if (st == BTM_CMD_STARTED)
      bta_dm_cb.p_scan_filt_status_cback =
          p_data->ble_enable_scan_filt.p_filt_status_cback;
  if (cmn_vsc_cb.filter_support != 0) {
    if (p_filt_status_cback)
      p_filt_status_cback(BTA_DM_BLE_PF_ENABLE_EVT, ref_value, BTA_FAILURE);
    return;
  }

  if (p_data->ble_enable_scan_filt.p_filt_status_cback)
    p_data->ble_enable_scan_filt.p_filt_status_cback(
        BTA_DM_BLE_PF_ENABLE_EVT, p_data->ble_enable_scan_filt.ref_value,
        status);
  BTM_BleEnableDisableFilterFeature(action, p_filt_status_cback,
                                    (tBTM_BLE_REF_VALUE)ref_value);
}

/*******************************************************************************
+100 −176
Original line number Diff line number Diff line
@@ -804,44 +804,9 @@ void BTA_DmSetBleScanParams(
    tGATT_IF client_if, uint32_t scan_interval, uint32_t scan_window,
    tBLE_SCAN_MODE scan_mode,
    tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback) {
  tBTA_DM_API_BLE_SCAN_PARAMS* p_msg = (tBTA_DM_API_BLE_SCAN_PARAMS*)osi_calloc(
      sizeof(tBTA_DM_API_BLE_SCAN_PARAMS));

  p_msg->hdr.event = BTA_DM_API_BLE_SCAN_PARAM_EVT;
  p_msg->client_if = client_if;
  p_msg->scan_int = scan_interval;
  p_msg->scan_window = scan_window;
  p_msg->scan_mode = scan_mode;
  p_msg->scan_param_setup_cback = scan_param_setup_cback;

  bta_sys_sendmsg(p_msg);
}

/*******************************************************************************
 *
 * Function         BTA_DmSetBleAdvParams
 *
 * Description      This function sets the advertising parameters BLE
 *                  functionality.
 *                  It is to be called when device act in peripheral or
 *                  broadcaster role.
 *
 *
 * Returns          void
 *
 ******************************************************************************/
void BTA_DmSetBleAdvParams(uint16_t adv_int_min, uint16_t adv_int_max,
                           tBLE_BD_ADDR* p_dir_bda) {
  if (p_dir_bda != NULL) {
    tBLE_BD_ADDR* bda = new tBLE_BD_ADDR;
    memcpy(bda, p_dir_bda, sizeof(tBLE_BD_ADDR));
    do_in_bta_thread(FROM_HERE,
                     base::Bind(&bta_dm_ble_set_adv_params, adv_int_min,
                                adv_int_max, base::Owned(bda)));
  }

  do_in_bta_thread(FROM_HERE, base::Bind(&bta_dm_ble_set_adv_params,
                                         adv_int_min, adv_int_max, nullptr));
  do_in_bta_thread(FROM_HERE, base::Bind(&bta_dm_ble_set_scan_params, client_if,
                                         scan_interval, scan_window, scan_mode,
                                         scan_param_setup_cback));
}

/*******************************************************************************
@@ -874,22 +839,12 @@ extern void BTA_DmBleSetStorageParams(
    tBTA_BLE_SCAN_SETUP_CBACK* p_setup_cback,
    tBTA_BLE_SCAN_THRESHOLD_CBACK* p_thres_cback,
    tBTA_BLE_SCAN_REP_CBACK* p_rep_cback, tBTA_DM_BLE_REF_VALUE ref_value) {
  tBTA_DM_API_SET_STORAGE_CONFIG* p_msg =
      (tBTA_DM_API_SET_STORAGE_CONFIG*)osi_malloc(
          sizeof(tBTA_DM_API_SET_STORAGE_CONFIG));

  bta_dm_cb.p_setup_cback = p_setup_cback;

  p_msg->hdr.event = BTA_DM_API_BLE_SETUP_STORAGE_EVT;
  p_msg->p_setup_cback = bta_ble_scan_setup_cb;
  p_msg->p_thres_cback = p_thres_cback;
  p_msg->p_read_rep_cback = p_rep_cback;
  p_msg->ref_value = ref_value;
  p_msg->batch_scan_full_max = batch_scan_full_max;
  p_msg->batch_scan_trunc_max = batch_scan_trunc_max;
  p_msg->batch_scan_notify_threshold = batch_scan_notify_threshold;

  bta_sys_sendmsg(p_msg);
  do_in_bta_thread(
      FROM_HERE,
      base::Bind(&bta_dm_ble_setup_storage, batch_scan_full_max,
                 batch_scan_trunc_max, batch_scan_notify_threshold,
                 bta_ble_scan_setup_cb, p_thres_cback, p_rep_cback, ref_value));
}

/*******************************************************************************
@@ -914,18 +869,9 @@ extern void BTA_DmBleEnableBatchScan(tBTA_BLE_BATCH_SCAN_MODE scan_mode,
                                     tBTA_BLE_DISCARD_RULE discard_rule,
                                     tBLE_ADDR_TYPE addr_type,
                                     tBTA_DM_BLE_REF_VALUE ref_value) {
  tBTA_DM_API_ENABLE_SCAN* p_msg =
      (tBTA_DM_API_ENABLE_SCAN*)osi_malloc(sizeof(tBTA_DM_API_ENABLE_SCAN));

  p_msg->hdr.event = BTA_DM_API_BLE_ENABLE_BATCH_SCAN_EVT;
  p_msg->scan_mode = scan_mode;
  p_msg->scan_int = scan_interval;
  p_msg->scan_window = scan_window;
  p_msg->discard_rule = discard_rule;
  p_msg->addr_type = addr_type;
  p_msg->ref_value = ref_value;

  bta_sys_sendmsg(p_msg);
  do_in_bta_thread(FROM_HERE, base::Bind(&bta_dm_ble_enable_batch_scan,
                                         scan_mode, scan_interval, scan_window,
                                         discard_rule, addr_type, ref_value));
}

/*******************************************************************************
@@ -940,13 +886,8 @@ extern void BTA_DmBleEnableBatchScan(tBTA_BLE_BATCH_SCAN_MODE scan_mode,
 *
 ******************************************************************************/
extern void BTA_DmBleDisableBatchScan(tBTA_DM_BLE_REF_VALUE ref_value) {
  tBTA_DM_API_DISABLE_SCAN* p_msg =
      (tBTA_DM_API_DISABLE_SCAN*)osi_malloc(sizeof(tBTA_DM_API_DISABLE_SCAN));

  p_msg->hdr.event = BTA_DM_API_BLE_DISABLE_BATCH_SCAN_EVT;
  p_msg->ref_value = ref_value;

  bta_sys_sendmsg(p_msg);
  do_in_bta_thread(FROM_HERE,
                   base::Bind(&bta_dm_ble_disable_batch_scan, ref_value));
}

/*******************************************************************************
@@ -963,15 +904,8 @@ extern void BTA_DmBleDisableBatchScan(tBTA_DM_BLE_REF_VALUE ref_value) {
 ******************************************************************************/
extern void BTA_DmBleReadScanReports(tBTA_BLE_BATCH_SCAN_MODE scan_type,
                                     tBTA_DM_BLE_REF_VALUE ref_value) {
  tBTA_DM_API_READ_SCAN_REPORTS* p_msg =
      (tBTA_DM_API_READ_SCAN_REPORTS*)osi_malloc(
          sizeof(tBTA_DM_API_READ_SCAN_REPORTS));

  p_msg->hdr.event = BTA_DM_API_BLE_READ_SCAN_REPORTS_EVT;
  p_msg->scan_type = scan_type;
  p_msg->ref_value = ref_value;

  bta_sys_sendmsg(p_msg);
  do_in_bta_thread(FROM_HERE, base::Bind(&bta_dm_ble_read_scan_reports,
                                         scan_type, ref_value));
}

/*******************************************************************************
@@ -1229,14 +1163,17 @@ void BTA_DmBleCfgFilterCondition(tBTA_DM_BLE_SCAN_COND_OP action,
                                 tBTA_DM_BLE_PF_COND_PARAM* p_cond,
                                 tBTA_DM_BLE_PF_CFG_CBACK* p_cmpl_cback,
                                 tBTA_DM_BLE_REF_VALUE ref_value) {
  tBTA_DM_API_CFG_FILTER_COND* p_msg;
  APPL_TRACE_API("BTA_DmBleCfgFilterCondition: %d, %d", action, cond_type);

  uint16_t len =
      sizeof(tBTA_DM_API_CFG_FILTER_COND) + sizeof(tBTA_DM_BLE_PF_COND_PARAM);
  if (!p_cond) {
    do_in_bta_thread(FROM_HERE,
                     base::Bind(&bta_dm_cfg_filter_cond, action, cond_type,
                                filt_index, nullptr, p_cmpl_cback, ref_value));
  }

  uint16_t len = sizeof(tBTA_DM_BLE_PF_COND_PARAM);
  uint8_t* p;

  if (NULL != p_cond) {
  switch (cond_type) {
    case BTA_DM_BLE_PF_SRVC_DATA_PATTERN:
    case BTA_DM_BLE_PF_MANU_DATA:
@@ -1258,63 +1195,56 @@ void BTA_DmBleCfgFilterCondition(tBTA_DM_BLE_SCAN_COND_OP action,
    default:
      break;
  }
  }

  p_msg = (tBTA_DM_API_CFG_FILTER_COND*)osi_calloc(len);
  p_msg->hdr.event = BTA_DM_API_CFG_FILTER_COND_EVT;
  p_msg->action = action;
  p_msg->cond_type = cond_type;
  p_msg->filt_index = filt_index;
  p_msg->p_filt_cfg_cback = p_cmpl_cback;
  p_msg->ref_value = ref_value;
  if (p_cond) {
    p_msg->p_cond_param = (tBTA_DM_BLE_PF_COND_PARAM*)(p_msg + 1);
    memcpy(p_msg->p_cond_param, p_cond, sizeof(tBTA_DM_BLE_PF_COND_PARAM));
  // base::Owned will free it
  tBTA_DM_BLE_PF_COND_PARAM* p_cond_param = new tBTA_DM_BLE_PF_COND_PARAM;
  memcpy(p_cond_param, p_cond, sizeof(tBTA_DM_BLE_PF_COND_PARAM));

    p = (uint8_t*)(p_msg->p_cond_param + 1);
  p = p_cond_param->additional_data;

  if (cond_type == BTA_DM_BLE_PF_SRVC_DATA_PATTERN ||
      cond_type == BTA_DM_BLE_PF_MANU_DATA) {
      p_msg->p_cond_param->manu_data.p_pattern = p;
      p_msg->p_cond_param->manu_data.data_len = p_cond->manu_data.data_len;
      memcpy(p_msg->p_cond_param->manu_data.p_pattern,
             p_cond->manu_data.p_pattern, p_cond->manu_data.data_len);
    p_cond_param->manu_data.p_pattern = p;
    p_cond_param->manu_data.data_len = p_cond->manu_data.data_len;
    memcpy(p_cond_param->manu_data.p_pattern, p_cond->manu_data.p_pattern,
           p_cond->manu_data.data_len);
    p += p_cond->manu_data.data_len;

    if (cond_type == BTA_DM_BLE_PF_MANU_DATA) {
        p_msg->p_cond_param->manu_data.company_id_mask =
      p_cond_param->manu_data.company_id_mask =
          p_cond->manu_data.company_id_mask;
      if (p_cond->manu_data.p_pattern_mask != NULL) {
          p_msg->p_cond_param->manu_data.p_pattern_mask = p;
          memcpy(p_msg->p_cond_param->manu_data.p_pattern_mask,
        p_cond_param->manu_data.p_pattern_mask = p;
        memcpy(p_cond_param->manu_data.p_pattern_mask,
               p_cond->manu_data.p_pattern_mask, p_cond->manu_data.data_len);
      }
    }
  } else if (cond_type == BTA_DM_BLE_PF_LOCAL_NAME) {
      p_msg->p_cond_param->local_name.p_data = p;
      p_msg->p_cond_param->local_name.data_len = p_cond->local_name.data_len;
      memcpy(p_msg->p_cond_param->local_name.p_data, p_cond->local_name.p_data,
    p_cond_param->local_name.p_data = p;
    p_cond_param->local_name.data_len = p_cond->local_name.data_len;
    memcpy(p_cond_param->local_name.p_data, p_cond->local_name.p_data,
           p_cond->local_name.data_len);
  } else if (cond_type == BTM_BLE_PF_SRVC_UUID ||
             cond_type == BTM_BLE_PF_SRVC_SOL_UUID) {
    if (p_cond->srvc_uuid.p_target_addr != NULL) {
        p_msg->p_cond_param->srvc_uuid.p_target_addr = (tBLE_BD_ADDR*)(p);
        p_msg->p_cond_param->srvc_uuid.p_target_addr->type =
      p_cond_param->srvc_uuid.p_target_addr = (tBLE_BD_ADDR*)(p);
      p_cond_param->srvc_uuid.p_target_addr->type =
          p_cond->srvc_uuid.p_target_addr->type;
        memcpy(p_msg->p_cond_param->srvc_uuid.p_target_addr->bda,
      memcpy(p_cond_param->srvc_uuid.p_target_addr->bda,
             p_cond->srvc_uuid.p_target_addr->bda, BD_ADDR_LEN);
        p = (uint8_t*)(p_msg->p_cond_param->srvc_uuid.p_target_addr + 1);
      p = (uint8_t*)(p_cond_param->srvc_uuid.p_target_addr + 1);
    }
    if (p_cond->srvc_uuid.p_uuid_mask) {
        p_msg->p_cond_param->srvc_uuid.p_uuid_mask =
            (tBTA_DM_BLE_PF_COND_MASK*)p;
        memcpy(p_msg->p_cond_param->srvc_uuid.p_uuid_mask,
               p_cond->srvc_uuid.p_uuid_mask, sizeof(tBTA_DM_BLE_PF_COND_MASK));
      }
      p_cond_param->srvc_uuid.p_uuid_mask = (tBTA_DM_BLE_PF_COND_MASK*)p;
      memcpy(p_cond_param->srvc_uuid.p_uuid_mask, p_cond->srvc_uuid.p_uuid_mask,
             sizeof(tBTA_DM_BLE_PF_COND_MASK));
    }
  }

  bta_sys_sendmsg(p_msg);
  do_in_bta_thread(
      FROM_HERE,
      base::Bind(&bta_dm_cfg_filter_cond, action, cond_type, filt_index,
                 base::Owned(p_cond_param), p_cmpl_cback, ref_value));
}
#else
void BTA_DmBleCfgFilterCondition(
@@ -1326,6 +1256,15 @@ void BTA_DmBleCfgFilterCondition(
    UNUSED_ATTR tBTA_DM_BLE_REF_VALUE ref_value) {}
#endif

void BTA_DmBleScanFilterClear(tBTA_DM_BLE_REF_VALUE ref_value,
                              tBTA_DM_BLE_PF_FILT_INDEX filt_index,
                              tBTA_DM_BLE_PF_CFG_CBACK* p_cmpl_cback) {
#if (BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE)
  do_in_bta_thread(FROM_HERE, base::Bind(&bta_dm_scan_filter_clear, ref_value,
                                         filt_index, p_cmpl_cback));
#endif
}

/*******************************************************************************
 *
 * Function         BTA_DmBleScanFilterSetup
@@ -1395,30 +1334,15 @@ void BTA_DmBleGetEnergyInfo(tBTA_BLE_ENERGY_INFO_CBACK* p_cmpl_cback) {
 * Returns          void
 *
 ******************************************************************************/
#if (BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE)
void BTA_DmEnableScanFilter(uint8_t action,
                            tBTA_DM_BLE_PF_STATUS_CBACK* p_cmpl_cback,
                            tBTA_DM_BLE_REF_VALUE ref_value) {
  const size_t len =
      sizeof(tBTA_DM_API_ENABLE_SCAN_FILTER) + sizeof(tBLE_BD_ADDR);
  tBTA_DM_API_ENABLE_SCAN_FILTER* p_msg =
      (tBTA_DM_API_ENABLE_SCAN_FILTER*)osi_calloc(len);

#if (BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE)
  APPL_TRACE_API("%s: %d", __func__, action);

  p_msg->hdr.event = BTA_DM_API_SCAN_FILTER_ENABLE_EVT;
  p_msg->action = action;
  p_msg->ref_value = ref_value;
  p_msg->p_filt_status_cback = p_cmpl_cback;

  bta_sys_sendmsg(p_msg);
}
#else
void BTA_DmEnableScanFilter(
    UNUSED_ATTR uint8_t action,
    UNUSED_ATTR tBTA_DM_BLE_PF_STATUS_CBACK* p_cmpl_cback,
    UNUSED_ATTR tBTA_DM_BLE_REF_VALUE ref_value) {}
  do_in_bta_thread(FROM_HERE, base::Bind(&bta_dm_enable_scan_filter, action,
                                         p_cmpl_cback, ref_value));
#endif
}

/*******************************************************************************
 *
+31 −79

File changed.

Preview size limit exceeded, changes collapsed.

+0 −9
Original line number Diff line number Diff line
@@ -77,21 +77,12 @@ const tBTA_DM_ACTION bta_dm_action[] = {
    bta_dm_security_grant, bta_dm_ble_set_bg_conn_type,
    bta_dm_ble_set_conn_params,      /* BTA_DM_API_BLE_CONN_PARAM_EVT */
    bta_dm_ble_set_conn_scan_params, /* BTA_DM_API_BLE_CONN_SCAN_PARAM_EVT */
    bta_dm_ble_set_scan_params,      /* BTA_DM_API_BLE_SCAN_PARAM_EVT */
    bta_dm_ble_observe,
    bta_dm_ble_update_conn_params, /* BTA_DM_API_UPDATE_CONN_PARAM_EVT */
#if (BLE_PRIVACY_SPT == TRUE)
    bta_dm_ble_config_local_privacy, /* BTA_DM_API_LOCAL_PRIVACY_EVT */
#endif
    bta_dm_ble_set_data_length, /* BTA_DM_API_SET_DATA_LENGTH_EVT */
#if (BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE)
    bta_dm_cfg_filter_cond,         /* BTA_DM_API_CFG_FILTER_COND_EVT */
    bta_dm_enable_scan_filter,      /* BTA_DM_API_SCAN_FILTER_ENABLE_EVT */
#endif
    bta_dm_ble_setup_storage,      /* BTA_DM_API_BLE_SETUP_STORAGE_EVT */
    bta_dm_ble_enable_batch_scan,  /* BTA_DM_API_BLE_ENABLE_BATCH_SCAN_EVT */
    bta_dm_ble_disable_batch_scan, /* BTA_DM_API_BLE_DISABLE_BATCH_SCAN_EVT */
    bta_dm_ble_read_scan_reports,  /* BTA_DM_API_BLE_READ_SCAN_REPORTS_EVT */
    bta_dm_ble_track_advertiser,   /* BTA_DM_API_BLE_TRACK_ADVERTISER_EVT */
    bta_dm_ble_get_energy_info,    /* BTA_DM_API_BLE_ENERGY_INFO_EVT */

+5 −18
Original line number Diff line number Diff line
@@ -442,6 +442,7 @@ typedef union {
  tBTA_DM_BLE_PF_UUID_COND
      solicitate_uuid; /* solicitated service UUID filtering */
  tBTA_DM_BLE_PF_SRVC_PATTERN_COND srvc_data; /* service data pattern */
  uint8_t additional_data[2000];
} tBTA_DM_BLE_PF_COND_PARAM;

typedef uint8_t tBTA_DM_BLE_PF_FILT_INDEX;
@@ -1697,24 +1698,6 @@ extern void BTA_DmSetBleScanParams(
    tBLE_SCAN_MODE scan_mode,
    tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_status_cback);

/*******************************************************************************
 *
 * Function         BTA_DmSetBleAdvParams
 *
 * Description      This function sets the advertising parameters BLE
 *                  functionality.
 *                  It is to be called when device act in peripheral or
 *                  broadcaster role.
 *
 * Parameters:      adv_int_min    - adv interval minimum
 *                  adv_int_max    - adv interval max
 *                  p_dir_bda      - directed adv initator address
 *
 * Returns          void
 *
 ******************************************************************************/
extern void BTA_DmSetBleAdvParams(uint16_t adv_int_min, uint16_t adv_int_max,
                                  tBLE_BD_ADDR* p_dir_bda);
/*******************************************************************************
 *
 * Function         BTA_DmSearchExt
@@ -2031,6 +2014,10 @@ extern void BTA_DmBleCfgFilterCondition(tBTA_DM_BLE_SCAN_COND_OP action,
                                        tBTA_DM_BLE_PF_CFG_CBACK* p_cmpl_cback,
                                        tBTA_DM_BLE_REF_VALUE ref_value);

extern void BTA_DmBleScanFilterClear(tBTA_DM_BLE_REF_VALUE ref_value,
                                     tBTA_DM_BLE_PF_FILT_INDEX filt_index,
                                     tBTA_DM_BLE_PF_CFG_CBACK* p_cmpl_cback);

/*******************************************************************************
 *
 * Function         BTA_DmBleTrackAdvertiser
Loading