• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /******************************************************************************
2  *
3  *  Copyright 2016 The Android Open Source Project
4  *
5  *  Licensed under the Apache License, Version 2.0 (the "License");
6  *  you may not use this file except in compliance with the License.
7  *  You may obtain a copy of the License at:
8  *
9  *  http://www.apache.org/licenses/LICENSE-2.0
10  *
11  *  Unless required by applicable law or agreed to in writing, software
12  *  distributed under the License is distributed on an "AS IS" BASIS,
13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  *  See the License for the specific language governing permissions and
15  *  limitations under the License.
16  *
17  ******************************************************************************/
18 
19 #define LOG_TAG "bt_btif_scanner"
20 
21 #include <base/bind.h>
22 #include <base/threading/thread.h>
23 #include <errno.h>
24 #include <hardware/bluetooth.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <unordered_set>
29 #include "device/include/controller.h"
30 
31 #include "btif_common.h"
32 #include "btif_util.h"
33 
34 #include <hardware/bt_gatt.h>
35 
36 #include "advertise_data_parser.h"
37 #include "bta_api.h"
38 #include "bta_gatt_api.h"
39 #include "btif_config.h"
40 #include "btif_dm.h"
41 #include "btif_gatt.h"
42 #include "btif_gatt_util.h"
43 #include "btif_storage.h"
44 #include "osi/include/log.h"
45 #include "stack/include/btu.h"
46 #include "vendor_api.h"
47 
48 using base::Bind;
49 using base::Owned;
50 using std::vector;
51 using RegisterCallback = BleScannerInterface::RegisterCallback;
52 
53 extern const btgatt_callbacks_t* bt_gatt_callbacks;
54 
55 #define SCAN_CBACK_IN_JNI(P_CBACK, ...)                              \
56   do {                                                               \
57     if (bt_gatt_callbacks && bt_gatt_callbacks->scanner->P_CBACK) {  \
58       BTIF_TRACE_API("HAL bt_gatt_callbacks->client->%s", #P_CBACK); \
59       do_in_jni_thread(                                              \
60           Bind(bt_gatt_callbacks->scanner->P_CBACK, __VA_ARGS__));   \
61     } else {                                                         \
62       ASSERTC(0, "Callback is NULL", 0);                             \
63     }                                                                \
64   } while (0)
65 
66 namespace {
67 
68 // all access to this variable should be done on the jni thread
69 std::set<RawAddress> remote_bdaddr_cache;
70 std::queue<RawAddress> remote_bdaddr_cache_ordered;
71 const size_t remote_bdaddr_cache_max_size = 1024;
72 
btif_address_cache_add(const RawAddress & p_bda,uint8_t addr_type)73 void btif_address_cache_add(const RawAddress& p_bda, uint8_t addr_type) {
74   // Remove the oldest entries
75   while (remote_bdaddr_cache.size() >= remote_bdaddr_cache_max_size) {
76     const RawAddress& raw_address = remote_bdaddr_cache_ordered.front();
77     remote_bdaddr_cache.erase(raw_address);
78     remote_bdaddr_cache_ordered.pop();
79   }
80   remote_bdaddr_cache.insert(p_bda);
81   remote_bdaddr_cache_ordered.push(p_bda);
82 }
83 
btif_address_cache_find(const RawAddress & p_bda)84 bool btif_address_cache_find(const RawAddress& p_bda) {
85   return (remote_bdaddr_cache.find(p_bda) != remote_bdaddr_cache.end());
86 }
87 
btif_address_cache_init(void)88 void btif_address_cache_init(void) {
89   remote_bdaddr_cache.clear();
90   remote_bdaddr_cache_ordered = {};
91 }
92 
bta_batch_scan_threshold_cb(tBTM_BLE_REF_VALUE ref_value)93 void bta_batch_scan_threshold_cb(tBTM_BLE_REF_VALUE ref_value) {
94   SCAN_CBACK_IN_JNI(batchscan_threshold_cb, ref_value);
95 }
96 
bta_batch_scan_reports_cb(int client_id,tBTA_STATUS status,uint8_t report_format,uint8_t num_records,std::vector<uint8_t> data)97 void bta_batch_scan_reports_cb(int client_id, tBTA_STATUS status,
98                                uint8_t report_format, uint8_t num_records,
99                                std::vector<uint8_t> data) {
100   SCAN_CBACK_IN_JNI(batchscan_reports_cb, client_id, status, report_format,
101                     num_records, std::move(data));
102 }
103 
bta_scan_results_cb_impl(RawAddress bd_addr,tBT_DEVICE_TYPE device_type,int8_t rssi,uint8_t 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)104 void bta_scan_results_cb_impl(RawAddress bd_addr, tBT_DEVICE_TYPE device_type,
105                               int8_t rssi, uint8_t addr_type,
106                               uint16_t ble_evt_type, uint8_t ble_primary_phy,
107                               uint8_t ble_secondary_phy,
108                               uint8_t ble_advertising_sid, int8_t ble_tx_power,
109                               uint16_t ble_periodic_adv_int,
110                               vector<uint8_t> value) {
111   uint8_t remote_name_len;
112   bt_device_type_t dev_type;
113   bt_property_t properties;
114 
115   const uint8_t* p_eir_remote_name = AdvertiseDataParser::GetFieldByType(
116       value, BTM_EIR_COMPLETE_LOCAL_NAME_TYPE, &remote_name_len);
117 
118   if (p_eir_remote_name == NULL) {
119     p_eir_remote_name = AdvertiseDataParser::GetFieldByType(
120         value, BT_EIR_SHORTENED_LOCAL_NAME_TYPE, &remote_name_len);
121   }
122 
123   if ((addr_type != BLE_ADDR_RANDOM) || (p_eir_remote_name)) {
124     if (!btif_address_cache_find(bd_addr)) {
125       btif_address_cache_add(bd_addr, addr_type);
126 
127       if (p_eir_remote_name) {
128         if (remote_name_len > BD_NAME_LEN + 1 ||
129             (remote_name_len == BD_NAME_LEN + 1 &&
130              p_eir_remote_name[BD_NAME_LEN] != '\0')) {
131           LOG_INFO(LOG_TAG,
132                    "%s dropping invalid packet - device name too long: %d",
133                    __func__, remote_name_len);
134           return;
135         }
136 
137         bt_bdname_t bdname;
138         memcpy(bdname.name, p_eir_remote_name, remote_name_len);
139         if (remote_name_len < BD_NAME_LEN + 1)
140           bdname.name[remote_name_len] = '\0';
141 
142         LOG_VERBOSE(LOG_TAG, "%s BLE device name=%s len=%d dev_type=%d",
143                     __func__, bdname.name, remote_name_len, device_type);
144         btif_dm_update_ble_remote_properties(bd_addr, bdname.name, device_type);
145       }
146     }
147   }
148 
149   dev_type = (bt_device_type_t)device_type;
150   BTIF_STORAGE_FILL_PROPERTY(&properties, BT_PROPERTY_TYPE_OF_DEVICE,
151                              sizeof(dev_type), &dev_type);
152   btif_storage_set_remote_device_property(&(bd_addr), &properties);
153 
154   btif_storage_set_remote_addr_type(&bd_addr, addr_type);
155   HAL_CBACK(bt_gatt_callbacks, scanner->scan_result_cb, ble_evt_type, addr_type,
156             &bd_addr, ble_primary_phy, ble_secondary_phy, ble_advertising_sid,
157             ble_tx_power, rssi, ble_periodic_adv_int, std::move(value));
158 }
159 
bta_scan_results_cb(tBTA_DM_SEARCH_EVT event,tBTA_DM_SEARCH * p_data)160 void bta_scan_results_cb(tBTA_DM_SEARCH_EVT event, tBTA_DM_SEARCH* p_data) {
161   uint8_t len;
162 
163   if (event == BTA_DM_INQ_CMPL_EVT) {
164     BTIF_TRACE_DEBUG("%s  BLE observe complete. Num Resp %d", __func__,
165                      p_data->inq_cmpl.num_resps);
166     return;
167   }
168 
169   if (event != BTA_DM_INQ_RES_EVT) {
170     BTIF_TRACE_WARNING("%s : Unknown event 0x%x", __func__, event);
171     return;
172   }
173 
174   vector<uint8_t> value;
175   if (p_data->inq_res.p_eir) {
176     value.insert(value.begin(), p_data->inq_res.p_eir,
177                  p_data->inq_res.p_eir + p_data->inq_res.eir_len);
178 
179     if (AdvertiseDataParser::GetFieldByType(
180             value, BTM_EIR_COMPLETE_LOCAL_NAME_TYPE, &len)) {
181       p_data->inq_res.remt_name_not_required = true;
182     }
183   }
184 
185   tBTA_DM_INQ_RES* r = &p_data->inq_res;
186   do_in_jni_thread(Bind(bta_scan_results_cb_impl, r->bd_addr, r->device_type,
187                         r->rssi, r->ble_addr_type, r->ble_evt_type,
188                         r->ble_primary_phy, r->ble_secondary_phy,
189                         r->ble_advertising_sid, r->ble_tx_power,
190                         r->ble_periodic_adv_int, std::move(value)));
191 }
192 
bta_track_adv_event_cb(tBTM_BLE_TRACK_ADV_DATA * p_track_adv_data)193 void bta_track_adv_event_cb(tBTM_BLE_TRACK_ADV_DATA* p_track_adv_data) {
194   btgatt_track_adv_info_t* btif_scan_track_cb = new btgatt_track_adv_info_t;
195 
196   BTIF_TRACE_DEBUG("%s", __func__);
197   btif_gatt_move_track_adv_data(btif_scan_track_cb,
198                                 (btgatt_track_adv_info_t*)p_track_adv_data);
199 
200   SCAN_CBACK_IN_JNI(track_adv_event_cb, Owned(btif_scan_track_cb));
201 }
202 
bta_cback(tBTA_GATTC_EVT,tBTA_GATTC *)203 void bta_cback(tBTA_GATTC_EVT, tBTA_GATTC*) {}
204 
205 class BleScannerInterfaceImpl : public BleScannerInterface {
~BleScannerInterfaceImpl()206   ~BleScannerInterfaceImpl(){};
207 
RegisterScanner(RegisterCallback cb)208   void RegisterScanner(RegisterCallback cb) override {
209     do_in_main_thread(FROM_HERE,
210                       Bind(
211                           [](RegisterCallback cb) {
212                             BTA_GATTC_AppRegister(
213                                 bta_cback,
214                                 jni_thread_wrapper(FROM_HERE, std::move(cb)));
215                           },
216                           std::move(cb)));
217   }
218 
Unregister(int scanner_id)219   void Unregister(int scanner_id) override {
220     do_in_main_thread(FROM_HERE, Bind(&BTA_GATTC_AppDeregister, scanner_id));
221   }
222 
Scan(bool start)223   void Scan(bool start) override {
224     do_in_jni_thread(Bind(
225         [](bool start) {
226           if (!start) {
227             do_in_main_thread(FROM_HERE,
228                               Bind(&BTA_DmBleObserve, false, 0, nullptr));
229             return;
230           }
231 
232           btif_address_cache_init();
233           do_in_main_thread(
234               FROM_HERE, Bind(&BTA_DmBleObserve, true, 0, bta_scan_results_cb));
235         },
236         start));
237   }
238 
ScanFilterParamSetup(uint8_t client_if,uint8_t action,uint8_t filt_index,std::unique_ptr<btgatt_filt_param_setup_t> filt_param,FilterParamSetupCallback cb)239   void ScanFilterParamSetup(
240       uint8_t client_if, uint8_t action, uint8_t filt_index,
241       std::unique_ptr<btgatt_filt_param_setup_t> filt_param,
242       FilterParamSetupCallback cb) override {
243     BTIF_TRACE_DEBUG("%s", __func__);
244 
245     if (filt_param && filt_param->dely_mode == 1) {
246       do_in_main_thread(
247           FROM_HERE, base::Bind(BTM_BleTrackAdvertiser, bta_track_adv_event_cb,
248                                 client_if));
249     }
250 
251     do_in_main_thread(
252         FROM_HERE, base::Bind(&BTM_BleAdvFilterParamSetup, action, filt_index,
253                               base::Passed(&filt_param),
254                               jni_thread_wrapper(FROM_HERE, std::move(cb))));
255   }
256 
ScanFilterAdd(int filter_index,std::vector<ApcfCommand> filters,FilterConfigCallback cb)257   void ScanFilterAdd(int filter_index, std::vector<ApcfCommand> filters,
258                      FilterConfigCallback cb) override {
259     BTIF_TRACE_DEBUG("%s: %d", __func__, filter_index);
260 
261     do_in_main_thread(
262         FROM_HERE,
263         base::Bind(
264             &BTM_LE_PF_set, filter_index, std::move(filters),
265             jni_thread_wrapper(
266                 FROM_HERE,
267                 Bind(std::move(cb),
268                      0 /*TODO: this used to be filter type, unused ?*/))));
269   }
270 
ScanFilterClear(int filter_index,FilterConfigCallback cb)271   void ScanFilterClear(int filter_index, FilterConfigCallback cb) override {
272     BTIF_TRACE_DEBUG("%s: filter_index: %d", __func__, filter_index);
273     do_in_main_thread(
274         FROM_HERE, base::Bind(&BTM_LE_PF_clear, filter_index,
275                               jni_thread_wrapper(
276                                   FROM_HERE, Bind(cb, BTM_BLE_PF_TYPE_ALL))));
277   }
278 
ScanFilterEnable(bool enable,EnableCallback cb)279   void ScanFilterEnable(bool enable, EnableCallback cb) override {
280     BTIF_TRACE_DEBUG("%s: enable: %d", __func__, enable);
281 
282     uint8_t action = enable ? 1 : 0;
283     do_in_main_thread(FROM_HERE,
284                       base::Bind(&BTM_BleEnableDisableFilterFeature, action,
285                                  jni_thread_wrapper(FROM_HERE, std::move(cb))));
286   }
287 
SetScanParameters(int scan_interval,int scan_window,Callback cb)288   void SetScanParameters(int scan_interval, int scan_window,
289                          Callback cb) override {
290     do_in_main_thread(
291         FROM_HERE, base::Bind(&BTM_BleSetScanParams, scan_interval, scan_window,
292                               BTM_BLE_SCAN_MODE_ACTI,
293                               jni_thread_wrapper(FROM_HERE, std::move(cb))));
294   }
295 
BatchscanConfigStorage(int client_if,int batch_scan_full_max,int batch_scan_trunc_max,int batch_scan_notify_threshold,Callback cb)296   void BatchscanConfigStorage(int client_if, int batch_scan_full_max,
297                               int batch_scan_trunc_max,
298                               int batch_scan_notify_threshold,
299                               Callback cb) override {
300     do_in_main_thread(
301         FROM_HERE,
302         base::Bind(&BTM_BleSetStorageConfig, (uint8_t)batch_scan_full_max,
303                    (uint8_t)batch_scan_trunc_max,
304                    (uint8_t)batch_scan_notify_threshold,
305                    jni_thread_wrapper(FROM_HERE, cb),
306                    bta_batch_scan_threshold_cb, (tBTM_BLE_REF_VALUE)client_if));
307   }
308 
BatchscanEnable(int scan_mode,int scan_interval,int scan_window,int addr_type,int discard_rule,Callback cb)309   void BatchscanEnable(int scan_mode, int scan_interval, int scan_window,
310                        int addr_type, int discard_rule, Callback cb) override {
311     do_in_main_thread(
312         FROM_HERE, base::Bind(&BTM_BleEnableBatchScan, scan_mode, scan_interval,
313                               scan_window, discard_rule, addr_type,
314                               jni_thread_wrapper(FROM_HERE, cb)));
315   }
316 
BatchscanDisable(Callback cb)317   void BatchscanDisable(Callback cb) override {
318     do_in_main_thread(FROM_HERE, base::Bind(&BTM_BleDisableBatchScan,
319                                             jni_thread_wrapper(FROM_HERE, cb)));
320   }
321 
BatchscanReadReports(int client_if,int scan_mode)322   void BatchscanReadReports(int client_if, int scan_mode) override {
323     do_in_main_thread(FROM_HERE,
324                       base::Bind(&BTM_BleReadScanReports, (uint8_t)scan_mode,
325                                  Bind(bta_batch_scan_reports_cb, client_if)));
326   }
327 
StartSync(uint8_t sid,RawAddress address,uint16_t skip,uint16_t timeout,StartSyncCb start_cb,SyncReportCb report_cb,SyncLostCb lost_cb)328   void StartSync(uint8_t sid, RawAddress address, uint16_t skip,
329                  uint16_t timeout, StartSyncCb start_cb, SyncReportCb report_cb,
330                  SyncLostCb lost_cb) override {}
331 
StopSync(uint16_t handle)332   void StopSync(uint16_t handle) override {}
333 };
334 
335 BleScannerInterface* btLeScannerInstance = nullptr;
336 
337 }  // namespace
338 
get_ble_scanner_instance()339 BleScannerInterface* get_ble_scanner_instance() {
340   if (btLeScannerInstance == nullptr)
341     btLeScannerInstance = new BleScannerInterfaceImpl();
342 
343   return btLeScannerInstance;
344 }
345