Merge "Get rid of unused BTIF binding for scanning"

 *

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

#define LOG_TAG "bt_btif_scanner"

#include <hardware/ble_scanner.h>

#include <base/functional/bind.h>

#include <base/threading/thread.h>

#include <errno.h>

#include <hardware/bluetooth.h>

#include <hardware/bt_gatt.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unordered_set>

#include "advertise_data_parser.h"

#include "bta_api.h"

#include "bta_gatt_api.h"

#include "btif_common.h"

#include "btif_config.h"

#include "btif_dm.h"

#include "btif_gatt.h"

#include "btif_gatt_util.h"

#include "btif_storage.h"

#include "btif_util.h"

#include "device/include/controller.h"

#include "main/shim/le_scanning_manager.h"

#include "main/shim/shim.h"

#include "osi/include/log.h"

#include "stack/include/btm_ble_api.h"

#include "stack/include/btu.h"

#include "types/bluetooth/uuid.h"

#include "types/raw_address.h"

#include "vendor_api.h"

using base::Bind;

using base::Owned;

using std::vector;

using RegisterCallback = BleScannerInterface::RegisterCallback;

extern const btgatt_callbacks_t* bt_gatt_callbacks;

#define SCAN_CBACK_IN_JNI(P_CBACK, ...)                              \

  do {                                                               \

    if (bt_gatt_callbacks && bt_gatt_callbacks->scanner->P_CBACK) {  \

      BTIF_TRACE_API("HAL bt_gatt_callbacks->client->%s", #P_CBACK); \

      do_in_jni_thread(                                              \

          Bind(bt_gatt_callbacks->scanner->P_CBACK, __VA_ARGS__));   \

    } else {                                                         \

      ASSERTC(0, "Callback is NULL", 0);                             \

    }                                                                \

  } while (0)

namespace {

// all access to this variable should be done on the jni thread

std::set<RawAddress> remote_bdaddr_cache;

std::queue<RawAddress> remote_bdaddr_cache_ordered;

const size_t remote_bdaddr_cache_max_size = 1024;

void btif_address_cache_add(const RawAddress& p_bda, uint8_t addr_type) {

  // Remove the oldest entries

  while (remote_bdaddr_cache.size() >= remote_bdaddr_cache_max_size) {

    const RawAddress& raw_address = remote_bdaddr_cache_ordered.front();

    remote_bdaddr_cache.erase(raw_address);

    remote_bdaddr_cache_ordered.pop();

  }

  remote_bdaddr_cache.insert(p_bda);

  remote_bdaddr_cache_ordered.push(p_bda);

}

bool btif_address_cache_find(const RawAddress& p_bda) {

  return (remote_bdaddr_cache.find(p_bda) != remote_bdaddr_cache.end());

}

void btif_address_cache_init(void) {

  remote_bdaddr_cache.clear();

  remote_bdaddr_cache_ordered = {};

}

void bta_batch_scan_threshold_cb(tBTM_BLE_REF_VALUE ref_value) {

  SCAN_CBACK_IN_JNI(batchscan_threshold_cb, ref_value);

}

void bta_batch_scan_reports_cb(int client_id, tBTM_STATUS status,

                               uint8_t report_format, uint8_t num_records,

                               std::vector<uint8_t> data) {

  SCAN_CBACK_IN_JNI(batchscan_reports_cb, client_id, status, report_format,

                    num_records, std::move(data));

}

void bta_scan_results_cb_impl(RawAddress bd_addr, tBT_DEVICE_TYPE device_type,

                              int8_t rssi, tBLE_ADDR_TYPE addr_type,

                              uint16_t ble_evt_type, uint8_t ble_primary_phy,

                              uint8_t ble_secondary_phy,

                              uint8_t ble_advertising_sid, int8_t ble_tx_power,

                              uint16_t ble_periodic_adv_int,

                              vector<uint8_t> value, RawAddress original_bda) {

  uint8_t remote_name_len;

  bt_device_type_t dev_type;

  bt_property_t properties;

  const uint8_t* p_eir_remote_name = AdvertiseDataParser::GetFieldByType(

      value, HCI_EIR_COMPLETE_LOCAL_NAME_TYPE, &remote_name_len);

  if (p_eir_remote_name == NULL) {

    p_eir_remote_name = AdvertiseDataParser::GetFieldByType(

        value, HCI_EIR_SHORTENED_LOCAL_NAME_TYPE, &remote_name_len);

  }

  if (p_eir_remote_name) {

    if (!btif_address_cache_find(bd_addr)) {

      btif_address_cache_add(bd_addr, addr_type);

      if (p_eir_remote_name) {

        if (remote_name_len > BD_NAME_LEN + 1 ||

            (remote_name_len == BD_NAME_LEN + 1 &&

             p_eir_remote_name[BD_NAME_LEN] != '\0')) {

          LOG_INFO("%s dropping invalid packet - device name too long: %d",

                   __func__, remote_name_len);

          return;

        }

        bt_bdname_t bdname;

        memcpy(bdname.name, p_eir_remote_name, remote_name_len);

        if (remote_name_len < BD_NAME_LEN + 1)

          bdname.name[remote_name_len] = '\0';

        LOG_VERBOSE("%s BLE device name=%s len=%d dev_type=%d", __func__,

                    bdname.name, remote_name_len, device_type);

        btif_dm_update_ble_remote_properties(bd_addr, bdname.name, device_type);

      }

    }

  }

  dev_type = (bt_device_type_t)device_type;

  uint32_t remote_dev_type = 0;

  BTIF_STORAGE_FILL_PROPERTY(&properties, BT_PROPERTY_TYPE_OF_DEVICE,

    sizeof(remote_dev_type), &remote_dev_type);

  dev_type = (btif_storage_get_remote_device_property(&bd_addr, &properties) == BT_STATUS_SUCCESS) ?

    (bt_device_type_t)(remote_dev_type | device_type) : (bt_device_type_t)device_type;

  if ((remote_dev_type != dev_type) && (dev_type != 0)) {

    BTIF_TRACE_DEBUG("%s dev_type change 0x%x=>0x%x, update config",

          __func__, remote_dev_type, dev_type);

    BTIF_STORAGE_FILL_PROPERTY(&properties, BT_PROPERTY_TYPE_OF_DEVICE,

                               sizeof(dev_type), &dev_type);

    btif_storage_set_remote_device_property(&(bd_addr), &properties);

  }

  btif_storage_set_remote_addr_type(&bd_addr, addr_type);

  HAL_CBACK(bt_gatt_callbacks, scanner->scan_result_cb, ble_evt_type, addr_type,

            &bd_addr, ble_primary_phy, ble_secondary_phy, ble_advertising_sid,

            ble_tx_power, rssi, ble_periodic_adv_int, std::move(value),

            &original_bda);

}

void bta_scan_results_cb(tBTA_DM_SEARCH_EVT event, tBTA_DM_SEARCH* p_data) {

  if (event == BTA_DM_INQ_CMPL_EVT) {

    BTIF_TRACE_DEBUG("%s  BLE observe complete. Num Resp %d", __func__,

                     p_data->inq_cmpl.num_resps);

    return;

  }

  if (event != BTA_DM_INQ_RES_EVT) {

    BTIF_TRACE_WARNING("%s : Unknown event 0x%x", __func__, event);

    return;

  }

  vector<uint8_t> value;

  if (p_data->inq_res.p_eir) {

    value.insert(value.begin(), p_data->inq_res.p_eir,

                 p_data->inq_res.p_eir + p_data->inq_res.eir_len);

  }

  tBTA_DM_INQ_RES* r = &p_data->inq_res;

  do_in_jni_thread(

      Bind(bta_scan_results_cb_impl, r->bd_addr, r->device_type, r->rssi,

           r->ble_addr_type, r->ble_evt_type, r->ble_primary_phy,

           r->ble_secondary_phy, r->ble_advertising_sid, r->ble_tx_power,

           r->ble_periodic_adv_int, std::move(value), r->original_bda));

}

void bta_track_adv_event_cb(tBTM_BLE_TRACK_ADV_DATA* p_track_adv_data) {

  btgatt_track_adv_info_t* btif_scan_track_cb = new btgatt_track_adv_info_t;

  BTIF_TRACE_DEBUG("%s", __func__);

  btif_gatt_move_track_adv_data(btif_scan_track_cb,

                                (btgatt_track_adv_info_t*)p_track_adv_data);

  SCAN_CBACK_IN_JNI(track_adv_event_cb, Owned(btif_scan_track_cb));

}

void bta_cback(tBTA_GATTC_EVT, tBTA_GATTC*) {}

class BleScannerInterfaceImpl : public BleScannerInterface {

  ~BleScannerInterfaceImpl() override{};

  void RegisterScanner(const bluetooth::Uuid& app_uuid,

                       RegisterCallback cb) override {

    do_in_main_thread(FROM_HERE,

                      Bind(

                          [](RegisterCallback cb) {

                            BTA_GATTC_AppRegister(

                                bta_cback,

                                jni_thread_wrapper(FROM_HERE, std::move(cb)),

                                false);

                          },

                          std::move(cb)));

  }

  void Unregister(int scanner_id) override {

    do_in_main_thread(FROM_HERE, Bind(&BTA_GATTC_AppDeregister, scanner_id));

  }

  void Scan(bool start) override {

    do_in_jni_thread(Bind(

        [](bool start) {

          if (!start) {

            do_in_main_thread(FROM_HERE,

                              Bind(&BTA_DmBleObserve, false, 0, nullptr));

            return;

          }

          btif_address_cache_init();

          do_in_main_thread(

              FROM_HERE, Bind(&BTA_DmBleObserve, true, 0, bta_scan_results_cb));

        },

        start));

  }

  void ScanFilterParamSetup(

      uint8_t client_if, uint8_t action, uint8_t filt_index,

      std::unique_ptr<btgatt_filt_param_setup_t> filt_param,

      FilterParamSetupCallback cb) override {

    BTIF_TRACE_DEBUG("%s", __func__);

    if (filt_param && filt_param->dely_mode == 1) {

      do_in_main_thread(

          FROM_HERE, base::Bind(BTM_BleTrackAdvertiser, bta_track_adv_event_cb,

                                client_if));

    }

    do_in_main_thread(FROM_HERE,

                      base::Bind(&BTM_BleAdvFilterParamSetup,

                                 static_cast<tBTM_BLE_SCAN_COND_OP>(action),

                                 filt_index, base::Passed(&filt_param),

                                 jni_thread_wrapper(FROM_HERE, std::move(cb))));

  }

  void ScanFilterAdd(int filter_index, std::vector<ApcfCommand> filters,

                     FilterConfigCallback cb) override {

    BTIF_TRACE_DEBUG("%s: %d", __func__, filter_index);

    do_in_main_thread(

        FROM_HERE,

        base::Bind(

            &BTM_LE_PF_set, filter_index, std::move(filters),

            jni_thread_wrapper(

                FROM_HERE,

                Bind(std::move(cb),

                     0 /*TODO: this used to be filter type, unused ?*/))));

  }

  void ScanFilterClear(int filter_index, FilterConfigCallback cb) override {

    BTIF_TRACE_DEBUG("%s: filter_index: %d", __func__, filter_index);

    do_in_main_thread(

        FROM_HERE, base::Bind(&BTM_LE_PF_clear, filter_index,

                              jni_thread_wrapper(

                                  FROM_HERE, Bind(cb, BTM_BLE_PF_TYPE_ALL))));

  }

  void ScanFilterEnable(bool enable, EnableCallback cb) override {

    BTIF_TRACE_DEBUG("%s: enable: %d", __func__, enable);

    uint8_t action = enable ? 1 : 0;

    do_in_main_thread(FROM_HERE,

                      base::Bind(&BTM_BleEnableDisableFilterFeature, action,

                                 jni_thread_wrapper(FROM_HERE, std::move(cb))));

  }

  void SetScanParameters(int scanner_id, int scan_interval, int scan_window,

                         Callback cb) override {

    do_in_main_thread(

        FROM_HERE, base::Bind(&BTM_BleSetScanParams, scan_interval, scan_window,

                              BTM_BLE_SCAN_MODE_ACTI,

                              jni_thread_wrapper(FROM_HERE, std::move(cb))));

  }

  void BatchscanConfigStorage(int client_if, int batch_scan_full_max,

                              int batch_scan_trunc_max,

                              int batch_scan_notify_threshold,

                              Callback cb) override {

    do_in_main_thread(

        FROM_HERE,

        base::Bind(&BTM_BleSetStorageConfig, (uint8_t)batch_scan_full_max,

                   (uint8_t)batch_scan_trunc_max,

                   (uint8_t)batch_scan_notify_threshold,

                   jni_thread_wrapper(FROM_HERE, cb),

                   bta_batch_scan_threshold_cb, (tBTM_BLE_REF_VALUE)client_if));

  }

  void BatchscanEnable(int scan_mode, int scan_interval, int scan_window,

                       int addr_type, int discard_rule, Callback cb) override {

    do_in_main_thread(

        FROM_HERE, base::Bind(&BTM_BleEnableBatchScan, scan_mode, scan_interval,

                              scan_window, discard_rule,

                              static_cast<tBLE_ADDR_TYPE>(addr_type),

                              jni_thread_wrapper(FROM_HERE, cb)));

  }

  void BatchscanDisable(Callback cb) override {

    do_in_main_thread(FROM_HERE, base::Bind(&BTM_BleDisableBatchScan,

                                            jni_thread_wrapper(FROM_HERE, cb)));

  }

  void BatchscanReadReports(int client_if, int scan_mode) override {

    do_in_main_thread(

        FROM_HERE,

        base::Bind(&BTM_BleReadScanReports, (tBLE_SCAN_MODE)scan_mode,

                   Bind(bta_batch_scan_reports_cb, client_if)));

  }

  void StartSync(uint8_t sid, RawAddress address, uint16_t skip,

                 uint16_t timeout, int reg_id) override {

    const controller_t* controller = controller_get_interface();

    if (!controller->supports_ble_periodic_advertising_sync_transfer_sender()) {

      uint8_t status_no_resource = 2;

      callbacks_->OnPeriodicSyncStarted(reg_id, status_no_resource, -1, sid, 1,

                                        address, 0, 0);

      return;

    }

    StartSyncCb start_sync_cb =

        base::Bind(&ScanningCallbacks::OnPeriodicSyncStarted,

                   base::Unretained(callbacks_), reg_id);

    SyncReportCb sync_report_cb = base::Bind(

        &ScanningCallbacks::OnPeriodicSyncReport, base::Unretained(callbacks_));

    SyncLostCb sync_lost_cb = base::Bind(&ScanningCallbacks::OnPeriodicSyncLost,

                                         base::Unretained(callbacks_));

    BigInfoReportCb biginfo_report_cb = base::Bind(&ScanningCallbacks::OnBigInfoReport,

                                         base::Unretained(callbacks_));

    do_in_main_thread(

        FROM_HERE,

        base::Bind(&BTM_BleStartPeriodicSync, sid, address, skip, timeout,

                   jni_thread_wrapper(FROM_HERE, std::move(start_sync_cb)),

                   jni_thread_wrapper(FROM_HERE, std::move(sync_report_cb)),

                   jni_thread_wrapper(FROM_HERE, std::move(sync_lost_cb)),

                   jni_thread_wrapper(FROM_HERE, std::move(biginfo_report_cb))));

  }

  void StopSync(uint16_t handle) override {

    LOG_DEBUG("handle: %d", handle);

    const controller_t* controller = controller_get_interface();

    if (!controller->supports_ble_periodic_advertising_sync_transfer_sender()) {

      LOG_ERROR("PAST not supported by controller");

      return;

    }

    do_in_main_thread(FROM_HERE, base::Bind(&BTM_BleStopPeriodicSync, handle));

  }

  void RegisterCallbacks(ScanningCallbacks* callbacks) override {

    callbacks_ = callbacks;

  }

  void CancelCreateSync(uint8_t sid, RawAddress address) override {

    const controller_t* controller = controller_get_interface();

    if (!controller->supports_ble_periodic_advertising_sync_transfer_sender()) {

      LOG_ERROR("PAST not supported by controller");

      return;

    }

    do_in_main_thread(FROM_HERE,

                      base::Bind(&BTM_BleCancelPeriodicSync, sid, address));

  }

  void TransferSync(RawAddress address, uint16_t service_data,

                    uint16_t sync_handle, int pa_source) override {

    LOG_DEBUG("address:%s", ADDRESS_TO_LOGGABLE_CSTR(address));

    const controller_t* controller = controller_get_interface();

    if (!controller->supports_ble_periodic_advertising_sync_transfer_sender()) {

      uint8_t status_no_resource = 2;

      LOG_ERROR("PAST not supported by controller");

      callbacks_->OnPeriodicSyncTransferred(pa_source, status_no_resource,

                                            address);

      return;

    }

    SyncTransferCb sync_transfer_cb =

        base::Bind(&ScanningCallbacks::OnPeriodicSyncTransferred,

                   base::Unretained(callbacks_), pa_source);

    do_in_main_thread(

        FROM_HERE,

        base::Bind(&BTM_BlePeriodicSyncTransfer, address, service_data,

                   sync_handle,

                   jni_thread_wrapper(FROM_HERE, std::move(sync_transfer_cb))));

  }

  void TransferSetInfo(RawAddress address, uint16_t service_data,

                       uint8_t adv_handle, int pa_source) override {

    LOG_DEBUG("address: %s", ADDRESS_TO_LOGGABLE_CSTR(address));

    const controller_t* controller = controller_get_interface();

    if (!controller->supports_ble_periodic_advertising_sync_transfer_sender()) {

      uint8_t status_no_resource = 2;

      LOG_ERROR(" PAST not supported by controller");

      callbacks_->OnPeriodicSyncTransferred(pa_source, status_no_resource,

                                            address);

      return;

    }

    SyncTransferCb sync_transfer_cb =

        base::Bind(&ScanningCallbacks::OnPeriodicSyncTransferred,

                   base::Unretained(callbacks_), pa_source);

    do_in_main_thread(

        FROM_HERE,

        base::Bind(&BTM_BlePeriodicSyncSetInfo, address, service_data,

                   adv_handle,

                   jni_thread_wrapper(FROM_HERE, std::move(sync_transfer_cb))));

  }

  void SyncTxParameters(RawAddress addr, uint8_t mode, uint16_t skip,

                        uint16_t timeout, int reg_id) override {

    LOG_DEBUG("address: %s", ADDRESS_TO_LOGGABLE_CSTR(addr));

    const controller_t* controller = controller_get_interface();

    if (!controller->supports_ble_periodic_advertising_sync_transfer_sender()) {

      uint8_t status_no_resource = 2;

      LOG_ERROR(" PAST not supported by controller");

      callbacks_->OnPeriodicSyncStarted(reg_id, status_no_resource, -1, -1, 1,

                                        addr, 0, 0);

      return;

    }

    StartSyncCb start_sync_cb =

        base::Bind(&ScanningCallbacks::OnPeriodicSyncStarted,

                   base::Unretained(callbacks_), reg_id);

    do_in_main_thread(

        FROM_HERE,

        base::Bind(&BTM_BlePeriodicSyncTxParameters, addr, mode, skip, timeout,

                   jni_thread_wrapper(FROM_HERE, std::move(start_sync_cb))));

  }

  ScanningCallbacks* callbacks_ = nullptr;

};

}  // namespace

BleScannerInterface* get_ble_scanner_instance() {

  LOG_INFO("Use gd le scanner");

  return bluetooth::shim::get_ble_scanner_instance();

}