1 /*
2 * Copyright (C) 2016-2017 The Linux Foundation
3 * Copyright (C) 2012 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 #define LOG_TAG "BluetoothServiceJni"
19 #include <dlfcn.h>
20 #include <errno.h>
21 #include <fcntl.h>
22 #include <hardware/bluetooth.h>
23 #include <nativehelper/JNIPlatformHelp.h>
24 #include <pthread.h>
25 #include <string.h>
26 #include <sys/prctl.h>
27 #include <sys/stat.h>
28
29 #include <shared_mutex>
30
31 #include "com_android_bluetooth.h"
32 #include "hardware/bt_sock.h"
33 #include "os/logging/log_redaction.h"
34 #include "utils/Log.h"
35 #include "utils/misc.h"
36
37 using bluetooth::Uuid;
38 #ifndef DYNAMIC_LOAD_BLUETOOTH
39 extern bt_interface_t bluetoothInterface;
40 #endif
41
42 namespace android {
43 // Both
44
45 #define TRANSPORT_AUTO 0
46 #define TRANSPORT_BREDR 1
47 #define TRANSPORT_LE 2
48
49 #define BLE_ADDR_PUBLIC 0x00
50 #define BLE_ADDR_RANDOM 0x01
51
52 const jint INVALID_FD = -1;
53
54 static jmethodID method_oobDataReceivedCallback;
55 static jmethodID method_stateChangeCallback;
56 static jmethodID method_adapterPropertyChangedCallback;
57 static jmethodID method_devicePropertyChangedCallback;
58 static jmethodID method_deviceFoundCallback;
59 static jmethodID method_pinRequestCallback;
60 static jmethodID method_sspRequestCallback;
61 static jmethodID method_bondStateChangeCallback;
62 static jmethodID method_addressConsolidateCallback;
63 static jmethodID method_leAddressAssociateCallback;
64 static jmethodID method_aclStateChangeCallback;
65 static jmethodID method_discoveryStateChangeCallback;
66 static jmethodID method_linkQualityReportCallback;
67 static jmethodID method_switchBufferSizeCallback;
68 static jmethodID method_switchCodecCallback;
69 static jmethodID method_setWakeAlarm;
70 static jmethodID method_acquireWakeLock;
71 static jmethodID method_releaseWakeLock;
72 static jmethodID method_energyInfo;
73
74 static struct {
75 jclass clazz;
76 jmethodID constructor;
77 } android_bluetooth_UidTraffic;
78
79 static const bt_interface_t* sBluetoothInterface = NULL;
80 static const btsock_interface_t* sBluetoothSocketInterface = NULL;
81 static JavaVM* vm = NULL;
82 static JNIEnv* callbackEnv = NULL;
83 static pthread_t sCallbackThread;
84 static bool sHaveCallbackThread;
85
86 static jobject sJniAdapterServiceObj;
87 static jobject sJniCallbacksObj;
88 static std::shared_timed_mutex jniObjMutex;
89 static jfieldID sJniCallbacksField;
90
getBluetoothInterface()91 const bt_interface_t* getBluetoothInterface() { return sBluetoothInterface; }
92
getCallbackEnv()93 JNIEnv* getCallbackEnv() { return callbackEnv; }
94
isCallbackThread()95 bool isCallbackThread() {
96 return sHaveCallbackThread && pthread_equal(sCallbackThread, pthread_self());
97 }
98
adapter_state_change_callback(bt_state_t status)99 static void adapter_state_change_callback(bt_state_t status) {
100 std::shared_lock<std::shared_timed_mutex> lock(jniObjMutex);
101 if (!sJniCallbacksObj) {
102 ALOGE("%s, JNI obj is null. Failed to call JNI callback", __func__);
103 return;
104 }
105
106 CallbackEnv sCallbackEnv(__func__);
107 if (!sCallbackEnv.valid()) return;
108 ALOGV("%s: Status is: %d", __func__, status);
109
110 sCallbackEnv->CallVoidMethod(sJniCallbacksObj, method_stateChangeCallback,
111 (jint)status);
112 }
113
get_properties(int num_properties,bt_property_t * properties,jintArray * types,jobjectArray * props)114 static int get_properties(int num_properties, bt_property_t* properties,
115 jintArray* types, jobjectArray* props) {
116 for (int i = 0; i < num_properties; i++) {
117 ScopedLocalRef<jbyteArray> propVal(
118 callbackEnv, callbackEnv->NewByteArray(properties[i].len));
119 if (!propVal.get()) {
120 ALOGE("Error while allocation of array in %s", __func__);
121 return -1;
122 }
123
124 callbackEnv->SetByteArrayRegion(propVal.get(), 0, properties[i].len,
125 (jbyte*)properties[i].val);
126 callbackEnv->SetObjectArrayElement(*props, i, propVal.get());
127 callbackEnv->SetIntArrayRegion(*types, i, 1, (jint*)&properties[i].type);
128 }
129 return 0;
130 }
131
adapter_properties_callback(bt_status_t status,int num_properties,bt_property_t * properties)132 static void adapter_properties_callback(bt_status_t status, int num_properties,
133 bt_property_t* properties) {
134 std::shared_lock<std::shared_timed_mutex> lock(jniObjMutex);
135 if (!sJniCallbacksObj) {
136 ALOGE("%s, JNI obj is null. Failed to call JNI callback", __func__);
137 return;
138 }
139
140 CallbackEnv sCallbackEnv(__func__);
141 if (!sCallbackEnv.valid()) return;
142
143 ALOGV("%s: Status is: %d, Properties: %d", __func__, status, num_properties);
144
145 if (status != BT_STATUS_SUCCESS) {
146 ALOGE("%s: Status %d is incorrect", __func__, status);
147 return;
148 }
149
150 ScopedLocalRef<jbyteArray> val(
151 sCallbackEnv.get(),
152 (jbyteArray)sCallbackEnv->NewByteArray(num_properties));
153 if (!val.get()) {
154 ALOGE("%s: Error allocating byteArray", __func__);
155 return;
156 }
157
158 ScopedLocalRef<jclass> mclass(sCallbackEnv.get(),
159 sCallbackEnv->GetObjectClass(val.get()));
160
161 /* (BT) Initialize the jobjectArray and jintArray here itself and send the
162 initialized array pointers alone to get_properties */
163
164 ScopedLocalRef<jobjectArray> props(
165 sCallbackEnv.get(),
166 sCallbackEnv->NewObjectArray(num_properties, mclass.get(), NULL));
167 if (!props.get()) {
168 ALOGE("%s: Error allocating object Array for properties", __func__);
169 return;
170 }
171
172 ScopedLocalRef<jintArray> types(
173 sCallbackEnv.get(), (jintArray)sCallbackEnv->NewIntArray(num_properties));
174 if (!types.get()) {
175 ALOGE("%s: Error allocating int Array for values", __func__);
176 return;
177 }
178
179 jintArray typesPtr = types.get();
180 jobjectArray propsPtr = props.get();
181 if (get_properties(num_properties, properties, &typesPtr, &propsPtr) < 0) {
182 return;
183 }
184
185 sCallbackEnv->CallVoidMethod(sJniCallbacksObj,
186 method_adapterPropertyChangedCallback,
187 types.get(), props.get());
188 }
189
remote_device_properties_callback(bt_status_t status,RawAddress * bd_addr,int num_properties,bt_property_t * properties)190 static void remote_device_properties_callback(bt_status_t status,
191 RawAddress* bd_addr,
192 int num_properties,
193 bt_property_t* properties) {
194 std::shared_lock<std::shared_timed_mutex> lock(jniObjMutex);
195 if (!sJniCallbacksObj) {
196 ALOGE("%s, JNI obj is null. Failed to call JNI callback", __func__);
197 return;
198 }
199
200 CallbackEnv sCallbackEnv(__func__);
201 if (!sCallbackEnv.valid()) return;
202
203 ALOGV("%s: Status is: %d, Properties: %d", __func__, status, num_properties);
204
205 if (status != BT_STATUS_SUCCESS) {
206 ALOGE("%s: Status %d is incorrect", __func__, status);
207 return;
208 }
209
210 ScopedLocalRef<jbyteArray> val(
211 sCallbackEnv.get(),
212 (jbyteArray)sCallbackEnv->NewByteArray(num_properties));
213 if (!val.get()) {
214 ALOGE("%s: Error allocating byteArray", __func__);
215 return;
216 }
217
218 ScopedLocalRef<jclass> mclass(sCallbackEnv.get(),
219 sCallbackEnv->GetObjectClass(val.get()));
220
221 /* Initialize the jobjectArray and jintArray here itself and send the
222 initialized array pointers alone to get_properties */
223
224 ScopedLocalRef<jobjectArray> props(
225 sCallbackEnv.get(),
226 sCallbackEnv->NewObjectArray(num_properties, mclass.get(), NULL));
227 if (!props.get()) {
228 ALOGE("%s: Error allocating object Array for properties", __func__);
229 return;
230 }
231
232 ScopedLocalRef<jintArray> types(
233 sCallbackEnv.get(), (jintArray)sCallbackEnv->NewIntArray(num_properties));
234 if (!types.get()) {
235 ALOGE("%s: Error allocating int Array for values", __func__);
236 return;
237 }
238
239 ScopedLocalRef<jbyteArray> addr(
240 sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
241 if (!addr.get()) {
242 ALOGE("Error while allocation byte array in %s", __func__);
243 return;
244 }
245
246 sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
247 (jbyte*)bd_addr);
248
249 jintArray typesPtr = types.get();
250 jobjectArray propsPtr = props.get();
251 if (get_properties(num_properties, properties, &typesPtr, &propsPtr) < 0) {
252 return;
253 }
254
255 sCallbackEnv->CallVoidMethod(sJniCallbacksObj,
256 method_devicePropertyChangedCallback, addr.get(),
257 types.get(), props.get());
258 }
259
device_found_callback(int num_properties,bt_property_t * properties)260 static void device_found_callback(int num_properties,
261 bt_property_t* properties) {
262 std::shared_lock<std::shared_timed_mutex> lock(jniObjMutex);
263 if (!sJniCallbacksObj) {
264 ALOGE("%s, JNI obj is null. Failed to call JNI callback", __func__);
265 return;
266 }
267
268 CallbackEnv sCallbackEnv(__func__);
269 if (!sCallbackEnv.valid()) return;
270
271 ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), NULL);
272 int addr_index;
273 for (int i = 0; i < num_properties; i++) {
274 if (properties[i].type == BT_PROPERTY_BDADDR) {
275 addr.reset(sCallbackEnv->NewByteArray(properties[i].len));
276 if (!addr.get()) {
277 ALOGE("Address is NULL (unable to allocate) in %s", __func__);
278 return;
279 }
280 sCallbackEnv->SetByteArrayRegion(addr.get(), 0, properties[i].len,
281 (jbyte*)properties[i].val);
282 addr_index = i;
283 }
284 }
285 if (!addr.get()) {
286 ALOGE("Address is NULL in %s", __func__);
287 return;
288 }
289
290 ALOGV("%s: Properties: %d, Address: %s", __func__, num_properties,
291 (const char*)properties[addr_index].val);
292
293 remote_device_properties_callback(BT_STATUS_SUCCESS,
294 (RawAddress*)properties[addr_index].val,
295 num_properties, properties);
296
297 sCallbackEnv->CallVoidMethod(sJniCallbacksObj, method_deviceFoundCallback,
298 addr.get());
299 }
300
bond_state_changed_callback(bt_status_t status,RawAddress * bd_addr,bt_bond_state_t state,int fail_reason)301 static void bond_state_changed_callback(bt_status_t status, RawAddress* bd_addr,
302 bt_bond_state_t state,
303 int fail_reason) {
304 std::shared_lock<std::shared_timed_mutex> lock(jniObjMutex);
305 if (!sJniCallbacksObj) {
306 ALOGE("%s, JNI obj is null. Failed to call JNI callback", __func__);
307 return;
308 }
309
310 CallbackEnv sCallbackEnv(__func__);
311 if (!sCallbackEnv.valid()) return;
312
313 if (!bd_addr) {
314 ALOGE("Address is null in %s", __func__);
315 return;
316 }
317
318 ScopedLocalRef<jbyteArray> addr(
319 sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
320 if (!addr.get()) {
321 ALOGE("Address allocation failed in %s", __func__);
322 return;
323 }
324 sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
325 (jbyte*)bd_addr);
326
327 sCallbackEnv->CallVoidMethod(sJniCallbacksObj, method_bondStateChangeCallback,
328 (jint)status, addr.get(), (jint)state,
329 (jint)fail_reason);
330 }
331
address_consolidate_callback(RawAddress * main_bd_addr,RawAddress * secondary_bd_addr)332 static void address_consolidate_callback(RawAddress* main_bd_addr,
333 RawAddress* secondary_bd_addr) {
334 std::shared_lock<std::shared_timed_mutex> lock(jniObjMutex);
335 if (!sJniCallbacksObj) {
336 ALOGE("%s, JNI obj is null. Failed to call JNI callback", __func__);
337 return;
338 }
339
340 CallbackEnv sCallbackEnv(__func__);
341
342 ScopedLocalRef<jbyteArray> main_addr(
343 sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
344 if (!main_addr.get()) {
345 ALOGE("Address allocation failed in %s", __func__);
346 return;
347 }
348 sCallbackEnv->SetByteArrayRegion(main_addr.get(), 0, sizeof(RawAddress),
349 (jbyte*)main_bd_addr);
350
351 ScopedLocalRef<jbyteArray> secondary_addr(
352 sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
353 if (!secondary_addr.get()) {
354 ALOGE("Address allocation failed in %s", __func__);
355 return;
356 }
357
358 sCallbackEnv->SetByteArrayRegion(secondary_addr.get(), 0, sizeof(RawAddress),
359 (jbyte*)secondary_bd_addr);
360
361 sCallbackEnv->CallVoidMethod(sJniCallbacksObj,
362 method_addressConsolidateCallback,
363 main_addr.get(), secondary_addr.get());
364 }
365
le_address_associate_callback(RawAddress * main_bd_addr,RawAddress * secondary_bd_addr)366 static void le_address_associate_callback(RawAddress* main_bd_addr,
367 RawAddress* secondary_bd_addr) {
368 std::shared_lock<std::shared_timed_mutex> lock(jniObjMutex);
369 if (!sJniCallbacksObj) {
370 ALOGE("%s, JNI obj is null. Failed to call JNI callback", __func__);
371 return;
372 }
373
374 CallbackEnv sCallbackEnv(__func__);
375
376 ScopedLocalRef<jbyteArray> main_addr(
377 sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
378 if (!main_addr.get()) {
379 ALOGE("Address allocation failed in %s", __func__);
380 return;
381 }
382 sCallbackEnv->SetByteArrayRegion(main_addr.get(), 0, sizeof(RawAddress),
383 (jbyte*)main_bd_addr);
384
385 ScopedLocalRef<jbyteArray> secondary_addr(
386 sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
387 if (!secondary_addr.get()) {
388 ALOGE("Address allocation failed in %s", __func__);
389 return;
390 }
391
392 sCallbackEnv->SetByteArrayRegion(secondary_addr.get(), 0, sizeof(RawAddress),
393 (jbyte*)secondary_bd_addr);
394
395 sCallbackEnv->CallVoidMethod(sJniCallbacksObj,
396 method_leAddressAssociateCallback,
397 main_addr.get(), secondary_addr.get());
398 }
399
acl_state_changed_callback(bt_status_t status,RawAddress * bd_addr,bt_acl_state_t state,int transport_link_type,bt_hci_error_code_t hci_reason,bt_conn_direction_t direction,uint16_t acl_handle)400 static void acl_state_changed_callback(bt_status_t status, RawAddress* bd_addr,
401 bt_acl_state_t state,
402 int transport_link_type,
403 bt_hci_error_code_t hci_reason,
404 bt_conn_direction_t direction,
405 uint16_t acl_handle) {
406 if (!bd_addr) {
407 ALOGE("Address is null in %s", __func__);
408 return;
409 }
410
411 std::shared_lock<std::shared_timed_mutex> lock(jniObjMutex);
412 if (!sJniCallbacksObj) {
413 ALOGE("%s, JNI obj is null. Failed to call JNI callback", __func__);
414 return;
415 }
416
417 CallbackEnv sCallbackEnv(__func__);
418 if (!sCallbackEnv.valid()) return;
419
420 ScopedLocalRef<jbyteArray> addr(
421 sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
422 if (!addr.get()) {
423 ALOGE("Address allocation failed in %s", __func__);
424 return;
425 }
426 sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
427 (jbyte*)bd_addr);
428
429 sCallbackEnv->CallVoidMethod(sJniCallbacksObj, method_aclStateChangeCallback,
430 (jint)status, addr.get(), (jint)state,
431 (jint)transport_link_type, (jint)hci_reason,
432 (jint)acl_handle);
433 }
434
discovery_state_changed_callback(bt_discovery_state_t state)435 static void discovery_state_changed_callback(bt_discovery_state_t state) {
436 std::shared_lock<std::shared_timed_mutex> lock(jniObjMutex);
437 if (!sJniCallbacksObj) {
438 ALOGE("%s, JNI obj is null. Failed to call JNI callback", __func__);
439 return;
440 }
441
442 CallbackEnv sCallbackEnv(__func__);
443 if (!sCallbackEnv.valid()) return;
444
445 ALOGV("%s: DiscoveryState:%d ", __func__, state);
446
447 sCallbackEnv->CallVoidMethod(
448 sJniCallbacksObj, method_discoveryStateChangeCallback, (jint)state);
449 }
450
pin_request_callback(RawAddress * bd_addr,bt_bdname_t * bdname,uint32_t cod,bool min_16_digits)451 static void pin_request_callback(RawAddress* bd_addr, bt_bdname_t* bdname,
452 uint32_t cod, bool min_16_digits) {
453 if (!bd_addr) {
454 ALOGE("Address is null in %s", __func__);
455 return;
456 }
457
458 std::shared_lock<std::shared_timed_mutex> lock(jniObjMutex);
459 if (!sJniCallbacksObj) {
460 ALOGE("%s, JNI obj is null. Failed to call JNI callback", __func__);
461 return;
462 }
463
464 CallbackEnv sCallbackEnv(__func__);
465 if (!sCallbackEnv.valid()) return;
466
467 ScopedLocalRef<jbyteArray> addr(
468 sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
469 if (!addr.get()) {
470 ALOGE("Error while allocating in: %s", __func__);
471 return;
472 }
473
474 sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
475 (jbyte*)bd_addr);
476
477 ScopedLocalRef<jbyteArray> devname(
478 sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(bt_bdname_t)));
479 if (!devname.get()) {
480 ALOGE("Error while allocating in: %s", __func__);
481 return;
482 }
483
484 sCallbackEnv->SetByteArrayRegion(devname.get(), 0, sizeof(bt_bdname_t),
485 (jbyte*)bdname);
486
487 sCallbackEnv->CallVoidMethod(sJniCallbacksObj, method_pinRequestCallback,
488 addr.get(), devname.get(), cod, min_16_digits);
489 }
490
ssp_request_callback(RawAddress * bd_addr,bt_bdname_t * bdname,uint32_t cod,bt_ssp_variant_t pairing_variant,uint32_t pass_key)491 static void ssp_request_callback(RawAddress* bd_addr, bt_bdname_t* bdname,
492 uint32_t cod, bt_ssp_variant_t pairing_variant,
493 uint32_t pass_key) {
494 if (!bd_addr) {
495 ALOGE("Address is null in %s", __func__);
496 return;
497 }
498
499 std::shared_lock<std::shared_timed_mutex> lock(jniObjMutex);
500 if (!sJniCallbacksObj) {
501 ALOGE("%s, JNI obj is null. Failed to call JNI callback", __func__);
502 return;
503 }
504
505 CallbackEnv sCallbackEnv(__func__);
506 if (!sCallbackEnv.valid()) return;
507
508 ScopedLocalRef<jbyteArray> addr(
509 sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
510 if (!addr.get()) {
511 ALOGE("Error while allocating in: %s", __func__);
512 return;
513 }
514
515 sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
516 (jbyte*)bd_addr);
517
518 ScopedLocalRef<jbyteArray> devname(
519 sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(bt_bdname_t)));
520 if (!devname.get()) {
521 ALOGE("Error while allocating in: %s", __func__);
522 return;
523 }
524
525 sCallbackEnv->SetByteArrayRegion(devname.get(), 0, sizeof(bt_bdname_t),
526 (jbyte*)bdname);
527
528 sCallbackEnv->CallVoidMethod(sJniCallbacksObj, method_sspRequestCallback,
529 addr.get(), devname.get(), cod,
530 (jint)pairing_variant, pass_key);
531 }
532
createClassicOobDataObject(JNIEnv * env,bt_oob_data_t oob_data)533 static jobject createClassicOobDataObject(JNIEnv* env, bt_oob_data_t oob_data) {
534 ALOGV("%s", __func__);
535 jclass classicBuilderClass =
536 env->FindClass("android/bluetooth/OobData$ClassicBuilder");
537
538 jbyteArray confirmationHash = env->NewByteArray(OOB_C_SIZE);
539 env->SetByteArrayRegion(confirmationHash, 0, OOB_C_SIZE,
540 reinterpret_cast<jbyte*>(oob_data.c));
541
542 jbyteArray oobDataLength = env->NewByteArray(OOB_DATA_LEN_SIZE);
543 env->SetByteArrayRegion(oobDataLength, 0, OOB_DATA_LEN_SIZE,
544 reinterpret_cast<jbyte*>(oob_data.oob_data_length));
545
546 jbyteArray address = env->NewByteArray(OOB_ADDRESS_SIZE);
547 env->SetByteArrayRegion(address, 0, OOB_ADDRESS_SIZE,
548 reinterpret_cast<jbyte*>(oob_data.address));
549
550 jmethodID classicBuilderConstructor =
551 env->GetMethodID(classicBuilderClass, "<init>", "([B[B[B)V");
552
553 jobject oobDataClassicBuilder =
554 env->NewObject(classicBuilderClass, classicBuilderConstructor,
555 confirmationHash, oobDataLength, address);
556
557 jmethodID setRMethod =
558 env->GetMethodID(classicBuilderClass, "setRandomizerHash",
559 "([B)Landroid/bluetooth/OobData$ClassicBuilder;");
560 jbyteArray randomizerHash = env->NewByteArray(OOB_R_SIZE);
561 env->SetByteArrayRegion(randomizerHash, 0, OOB_R_SIZE,
562 reinterpret_cast<jbyte*>(oob_data.r));
563
564 oobDataClassicBuilder =
565 env->CallObjectMethod(oobDataClassicBuilder, setRMethod, randomizerHash);
566
567 jmethodID setNameMethod =
568 env->GetMethodID(classicBuilderClass, "setDeviceName",
569 "([B)Landroid/bluetooth/OobData$ClassicBuilder;");
570
571 int name_char_count = 0;
572 for (int i = 0; i < OOB_NAME_MAX_SIZE; i++) {
573 if (oob_data.device_name[i] == 0) {
574 name_char_count = i;
575 break;
576 }
577 }
578
579 jbyteArray deviceName = env->NewByteArray(name_char_count);
580 env->SetByteArrayRegion(deviceName, 0, name_char_count,
581 reinterpret_cast<jbyte*>(oob_data.device_name));
582
583 oobDataClassicBuilder =
584 env->CallObjectMethod(oobDataClassicBuilder, setNameMethod, deviceName);
585
586 jmethodID buildMethod = env->GetMethodID(classicBuilderClass, "build",
587 "()Landroid/bluetooth/OobData;");
588
589 return env->CallObjectMethod(oobDataClassicBuilder, buildMethod);
590 }
591
createLeOobDataObject(JNIEnv * env,bt_oob_data_t oob_data)592 static jobject createLeOobDataObject(JNIEnv* env, bt_oob_data_t oob_data) {
593 ALOGV("%s", __func__);
594
595 jclass leBuilderClass = env->FindClass("android/bluetooth/OobData$LeBuilder");
596
597 jbyteArray confirmationHash = env->NewByteArray(OOB_C_SIZE);
598 env->SetByteArrayRegion(confirmationHash, 0, OOB_C_SIZE,
599 reinterpret_cast<jbyte*>(oob_data.c));
600
601 jbyteArray address = env->NewByteArray(OOB_ADDRESS_SIZE);
602 env->SetByteArrayRegion(address, 0, OOB_ADDRESS_SIZE,
603 reinterpret_cast<jbyte*>(oob_data.address));
604
605 jint le_role = (jint)oob_data.le_device_role;
606
607 jmethodID leBuilderConstructor =
608 env->GetMethodID(leBuilderClass, "<init>", "([B[BI)V");
609
610 jobject oobDataLeBuilder = env->NewObject(
611 leBuilderClass, leBuilderConstructor, confirmationHash, address, le_role);
612
613 jmethodID setRMethod =
614 env->GetMethodID(leBuilderClass, "setRandomizerHash",
615 "([B)Landroid/bluetooth/OobData$LeBuilder;");
616 jbyteArray randomizerHash = env->NewByteArray(OOB_R_SIZE);
617 env->SetByteArrayRegion(randomizerHash, 0, OOB_R_SIZE,
618 reinterpret_cast<jbyte*>(oob_data.r));
619
620 oobDataLeBuilder =
621 env->CallObjectMethod(oobDataLeBuilder, setRMethod, randomizerHash);
622
623 jmethodID setNameMethod =
624 env->GetMethodID(leBuilderClass, "setDeviceName",
625 "([B)Landroid/bluetooth/OobData$LeBuilder;");
626
627 int name_char_count = 0;
628 for (int i = 0; i < OOB_NAME_MAX_SIZE; i++) {
629 if (oob_data.device_name[i] == 0) {
630 name_char_count = i;
631 break;
632 }
633 }
634
635 jbyteArray deviceName = env->NewByteArray(name_char_count);
636 env->SetByteArrayRegion(deviceName, 0, name_char_count,
637 reinterpret_cast<jbyte*>(oob_data.device_name));
638
639 oobDataLeBuilder =
640 env->CallObjectMethod(oobDataLeBuilder, setNameMethod, deviceName);
641
642 jmethodID buildMethod = env->GetMethodID(leBuilderClass, "build",
643 "()Landroid/bluetooth/OobData;");
644
645 return env->CallObjectMethod(oobDataLeBuilder, buildMethod);
646 }
647
generate_local_oob_data_callback(tBT_TRANSPORT transport,bt_oob_data_t oob_data)648 static void generate_local_oob_data_callback(tBT_TRANSPORT transport,
649 bt_oob_data_t oob_data) {
650 ALOGV("%s", __func__);
651
652 std::shared_lock<std::shared_timed_mutex> lock(jniObjMutex);
653 if (!sJniCallbacksObj) {
654 ALOGE("%s, JNI obj is null. Failed to call JNI callback", __func__);
655 return;
656 }
657
658 CallbackEnv sCallbackEnv(__func__);
659 if (!sCallbackEnv.valid()) return;
660
661 if (transport == TRANSPORT_BREDR) {
662 sCallbackEnv->CallVoidMethod(
663 sJniCallbacksObj, method_oobDataReceivedCallback, (jint)transport,
664 ((oob_data.is_valid)
665 ? createClassicOobDataObject(sCallbackEnv.get(), oob_data)
666 : nullptr));
667 } else if (transport == TRANSPORT_LE) {
668 sCallbackEnv->CallVoidMethod(
669 sJniCallbacksObj, method_oobDataReceivedCallback, (jint)transport,
670 ((oob_data.is_valid)
671 ? createLeOobDataObject(sCallbackEnv.get(), oob_data)
672 : nullptr));
673 } else {
674 // TRANSPORT_AUTO is a concept, however, the host stack doesn't fully
675 // implement it So passing it from the java layer is currently useless until
676 // the implementation and concept of TRANSPORT_AUTO is fleshed out.
677 ALOGE("TRANSPORT: %d not implemented", transport);
678 sCallbackEnv->CallVoidMethod(sJniCallbacksObj,
679 method_oobDataReceivedCallback,
680 (jint)transport, nullptr);
681 }
682 }
683
link_quality_report_callback(uint64_t timestamp,int report_id,int rssi,int snr,int retransmission_count,int packets_not_receive_count,int negative_acknowledgement_count)684 static void link_quality_report_callback(
685 uint64_t timestamp, int report_id, int rssi, int snr,
686 int retransmission_count, int packets_not_receive_count,
687 int negative_acknowledgement_count) {
688 std::shared_lock<std::shared_timed_mutex> lock(jniObjMutex);
689 if (!sJniCallbacksObj) {
690 ALOGE("%s, JNI obj is null. Failed to call JNI callback", __func__);
691 return;
692 }
693
694 CallbackEnv sCallbackEnv(__func__);
695 if (!sCallbackEnv.valid()) return;
696
697 ALOGV("%s: LinkQualityReportCallback: %d %d %d %d %d %d", __func__,
698 report_id, rssi, snr, retransmission_count, packets_not_receive_count,
699 negative_acknowledgement_count);
700
701 sCallbackEnv->CallVoidMethod(
702 sJniCallbacksObj, method_linkQualityReportCallback,
703 (jlong)timestamp, (jint)report_id, (jint)rssi, (jint)snr,
704 (jint)retransmission_count, (jint)packets_not_receive_count,
705 (jint)negative_acknowledgement_count);
706 }
707
switch_buffer_size_callback(bool is_low_latency_buffer_size)708 static void switch_buffer_size_callback(bool is_low_latency_buffer_size) {
709 std::shared_lock<std::shared_timed_mutex> lock(jniObjMutex);
710 if (!sJniCallbacksObj) {
711 ALOGE("%s, JNI obj is null. Failed to call JNI callback", __func__);
712 return;
713 }
714
715 CallbackEnv sCallbackEnv(__func__);
716 if (!sCallbackEnv.valid()) return;
717
718 ALOGV("%s: SwitchBufferSizeCallback: %s", __func__,
719 is_low_latency_buffer_size ? "true" : "false");
720
721 sCallbackEnv->CallVoidMethod(
722 sJniCallbacksObj, method_switchBufferSizeCallback,
723 (jboolean)is_low_latency_buffer_size);
724 }
725
switch_codec_callback(bool is_low_latency_buffer_size)726 static void switch_codec_callback(bool is_low_latency_buffer_size) {
727 std::shared_lock<std::shared_timed_mutex> lock(jniObjMutex);
728 if (!sJniCallbacksObj) {
729 ALOGE("%s, JNI obj is null. Failed to call JNI callback", __func__);
730 return;
731 }
732
733 CallbackEnv sCallbackEnv(__func__);
734 if (!sCallbackEnv.valid()) return;
735
736 ALOGV("%s: SwitchCodecCallback: %s", __func__,
737 is_low_latency_buffer_size ? "true" : "false");
738
739 sCallbackEnv->CallVoidMethod(sJniCallbacksObj, method_switchCodecCallback,
740 (jboolean)is_low_latency_buffer_size);
741 }
742
le_rand_callback(uint64_t random)743 static void le_rand_callback(uint64_t random) {
744 // Android doesn't support the LeRand API.
745 }
746
callback_thread_event(bt_cb_thread_evt event)747 static void callback_thread_event(bt_cb_thread_evt event) {
748 if (event == ASSOCIATE_JVM) {
749 JavaVMAttachArgs args;
750 char name[] = "BT Service Callback Thread";
751 args.version = JNI_VERSION_1_6;
752 args.name = name;
753 args.group = NULL;
754 vm->AttachCurrentThread(&callbackEnv, &args);
755 sHaveCallbackThread = true;
756 sCallbackThread = pthread_self();
757 ALOGV("Callback thread attached: %p", callbackEnv);
758 } else if (event == DISASSOCIATE_JVM) {
759 if (!isCallbackThread()) {
760 ALOGE("Callback: '%s' is not called on the correct thread", __func__);
761 return;
762 }
763 vm->DetachCurrentThread();
764 sHaveCallbackThread = false;
765 callbackEnv = NULL;
766 }
767 }
768
energy_info_recv_callback(bt_activity_energy_info * p_energy_info,bt_uid_traffic_t * uid_data)769 static void energy_info_recv_callback(bt_activity_energy_info* p_energy_info,
770 bt_uid_traffic_t* uid_data) {
771 std::shared_lock<std::shared_timed_mutex> lock(jniObjMutex);
772 if (!sJniAdapterServiceObj) {
773 ALOGE("%s, JNI obj is null. Failed to call JNI callback", __func__);
774 return;
775 }
776
777 CallbackEnv sCallbackEnv(__func__);
778 if (!sCallbackEnv.valid()) return;
779
780 jsize len = 0;
781 for (bt_uid_traffic_t* data = uid_data; data->app_uid != -1; data++) {
782 len++;
783 }
784
785 ScopedLocalRef<jobjectArray> array(
786 sCallbackEnv.get(), sCallbackEnv->NewObjectArray(
787 len, android_bluetooth_UidTraffic.clazz, NULL));
788 jsize i = 0;
789 for (bt_uid_traffic_t* data = uid_data; data->app_uid != -1; data++) {
790 ScopedLocalRef<jobject> uidObj(
791 sCallbackEnv.get(),
792 sCallbackEnv->NewObject(android_bluetooth_UidTraffic.clazz,
793 android_bluetooth_UidTraffic.constructor,
794 (jint)data->app_uid, (jlong)data->rx_bytes,
795 (jlong)data->tx_bytes));
796 sCallbackEnv->SetObjectArrayElement(array.get(), i++, uidObj.get());
797 }
798
799 sCallbackEnv->CallVoidMethod(
800 sJniAdapterServiceObj, method_energyInfo, p_energy_info->status,
801 p_energy_info->ctrl_state, p_energy_info->tx_time, p_energy_info->rx_time,
802 p_energy_info->idle_time, p_energy_info->energy_used, array.get());
803 }
804
805 static bt_callbacks_t sBluetoothCallbacks = {sizeof(sBluetoothCallbacks),
806 adapter_state_change_callback,
807 adapter_properties_callback,
808 remote_device_properties_callback,
809 device_found_callback,
810 discovery_state_changed_callback,
811 pin_request_callback,
812 ssp_request_callback,
813 bond_state_changed_callback,
814 address_consolidate_callback,
815 le_address_associate_callback,
816 acl_state_changed_callback,
817 callback_thread_event,
818 energy_info_recv_callback,
819 link_quality_report_callback,
820 generate_local_oob_data_callback,
821 switch_buffer_size_callback,
822 switch_codec_callback,
823 le_rand_callback};
824
825 // The callback to call when the wake alarm fires.
826 static alarm_cb sAlarmCallback;
827
828 // The data to pass to the wake alarm callback.
829 static void* sAlarmCallbackData;
830
831 class JNIThreadAttacher {
832 public:
JNIThreadAttacher(JavaVM * vm)833 JNIThreadAttacher(JavaVM* vm) : vm_(vm), env_(nullptr) {
834 status_ = vm_->GetEnv((void**)&env_, JNI_VERSION_1_6);
835
836 if (status_ != JNI_OK && status_ != JNI_EDETACHED) {
837 ALOGE(
838 "JNIThreadAttacher: unable to get environment for JNI CALL, "
839 "status: %d",
840 status_);
841 env_ = nullptr;
842 return;
843 }
844
845 if (status_ == JNI_EDETACHED) {
846 char name[17] = {0};
847 if (prctl(PR_GET_NAME, (unsigned long)name) != 0) {
848 ALOGE(
849 "JNIThreadAttacher: unable to grab previous thread name, error: %s",
850 strerror(errno));
851 env_ = nullptr;
852 return;
853 }
854
855 JavaVMAttachArgs args = {
856 .version = JNI_VERSION_1_6, .name = name, .group = nullptr};
857 if (vm_->AttachCurrentThread(&env_, &args) != 0) {
858 ALOGE("JNIThreadAttacher: unable to attach thread to VM");
859 env_ = nullptr;
860 return;
861 }
862 }
863 }
864
~JNIThreadAttacher()865 ~JNIThreadAttacher() {
866 if (status_ == JNI_EDETACHED) vm_->DetachCurrentThread();
867 }
868
getEnv()869 JNIEnv* getEnv() { return env_; }
870
871 private:
872 JavaVM* vm_;
873 JNIEnv* env_;
874 jint status_;
875 };
876
set_wake_alarm_callout(uint64_t delay_millis,bool should_wake,alarm_cb cb,void * data)877 static bool set_wake_alarm_callout(uint64_t delay_millis, bool should_wake,
878 alarm_cb cb, void* data) {
879 std::shared_lock<std::shared_timed_mutex> lock(jniObjMutex);
880 if (!sJniAdapterServiceObj) {
881 ALOGE("%s, JNI obj is null. Failed to call JNI callback", __func__);
882 return false;
883 }
884
885 JNIThreadAttacher attacher(vm);
886 JNIEnv* env = attacher.getEnv();
887
888 if (env == nullptr) {
889 ALOGE("%s: Unable to get JNI Env", __func__);
890 return false;
891 }
892
893 sAlarmCallback = cb;
894 sAlarmCallbackData = data;
895
896 jboolean jshould_wake = should_wake ? JNI_TRUE : JNI_FALSE;
897 jboolean ret =
898 env->CallBooleanMethod(sJniAdapterServiceObj, method_setWakeAlarm,
899 (jlong)delay_millis, jshould_wake);
900 if (!ret) {
901 sAlarmCallback = NULL;
902 sAlarmCallbackData = NULL;
903 }
904
905 return (ret == JNI_TRUE);
906 }
907
acquire_wake_lock_callout(const char * lock_name)908 static int acquire_wake_lock_callout(const char* lock_name) {
909 std::shared_lock<std::shared_timed_mutex> lock(jniObjMutex);
910 if (!sJniAdapterServiceObj) {
911 ALOGE("%s, JNI obj is null. Failed to call JNI callback", __func__);
912 return BT_STATUS_NOT_READY;
913 }
914
915 JNIThreadAttacher attacher(vm);
916 JNIEnv* env = attacher.getEnv();
917
918 if (env == nullptr) {
919 ALOGE("%s: Unable to get JNI Env", __func__);
920 return BT_STATUS_JNI_THREAD_ATTACH_ERROR;
921 }
922
923 jint ret = BT_STATUS_SUCCESS;
924 {
925 ScopedLocalRef<jstring> lock_name_jni(env, env->NewStringUTF(lock_name));
926 if (lock_name_jni.get()) {
927 bool acquired = env->CallBooleanMethod(
928 sJniAdapterServiceObj, method_acquireWakeLock, lock_name_jni.get());
929 if (!acquired) ret = BT_STATUS_WAKELOCK_ERROR;
930 } else {
931 ALOGE("%s unable to allocate string: %s", __func__, lock_name);
932 ret = BT_STATUS_NOMEM;
933 }
934 }
935
936 return ret;
937 }
938
release_wake_lock_callout(const char * lock_name)939 static int release_wake_lock_callout(const char* lock_name) {
940 std::shared_lock<std::shared_timed_mutex> lock(jniObjMutex);
941 if (!sJniAdapterServiceObj) {
942 ALOGE("%s, JNI obj is null. Failed to call JNI callback", __func__);
943 return BT_STATUS_NOT_READY;
944 }
945
946 JNIThreadAttacher attacher(vm);
947 JNIEnv* env = attacher.getEnv();
948
949 if (env == nullptr) {
950 ALOGE("%s: Unable to get JNI Env", __func__);
951 return BT_STATUS_JNI_THREAD_ATTACH_ERROR;
952 }
953
954 jint ret = BT_STATUS_SUCCESS;
955 {
956 ScopedLocalRef<jstring> lock_name_jni(env, env->NewStringUTF(lock_name));
957 if (lock_name_jni.get()) {
958 bool released = env->CallBooleanMethod(
959 sJniAdapterServiceObj, method_releaseWakeLock, lock_name_jni.get());
960 if (!released) ret = BT_STATUS_WAKELOCK_ERROR;
961 } else {
962 ALOGE("%s unable to allocate string: %s", __func__, lock_name);
963 ret = BT_STATUS_NOMEM;
964 }
965 }
966
967 return ret;
968 }
969
970 // Called by Java code when alarm is fired. A wake lock is held by the caller
971 // over the duration of this callback.
alarmFiredNative(JNIEnv * env,jobject obj)972 static void alarmFiredNative(JNIEnv* env, jobject obj) {
973 if (sAlarmCallback) {
974 sAlarmCallback(sAlarmCallbackData);
975 } else {
976 ALOGE("%s() - Alarm fired with callback not set!", __func__);
977 }
978 }
979
980 static bt_os_callouts_t sBluetoothOsCallouts = {
981 sizeof(sBluetoothOsCallouts), set_wake_alarm_callout,
982 acquire_wake_lock_callout, release_wake_lock_callout,
983 };
984
hal_util_load_bt_library(const bt_interface_t ** interface)985 int hal_util_load_bt_library(const bt_interface_t** interface) {
986 #ifndef DYNAMIC_LOAD_BLUETOOTH
987 *interface = &bluetoothInterface;
988 return 0;
989 #else
990 const char* sym = BLUETOOTH_INTERFACE_STRING;
991 bt_interface_t* itf = nullptr;
992
993 // The library name is not set by default, so the preset library name is used.
994 void* handle = dlopen("libbluetooth.so", RTLD_NOW);
995 if (!handle) {
996 const char* err_str = dlerror();
997 ALOGE("%s: failed to load Bluetooth library, error=%s", __func__,
998 err_str ? err_str : "error unknown");
999 goto error;
1000 }
1001
1002 // Get the address of the bt_interface_t.
1003 itf = (bt_interface_t*)dlsym(handle, sym);
1004 if (!itf) {
1005 ALOGE("%s: failed to load symbol from Bluetooth library %s", __func__, sym);
1006 goto error;
1007 }
1008
1009 // Success.
1010 ALOGI("%s: loaded Bluetooth library successfully", __func__);
1011 *interface = itf;
1012 return 0;
1013
1014 error:
1015 *interface = NULL;
1016 if (handle) dlclose(handle);
1017
1018 return -EINVAL;
1019 #endif
1020 }
1021
classInitNative(JNIEnv * env,jclass clazz)1022 static void classInitNative(JNIEnv* env, jclass clazz) {
1023 jclass jniUidTrafficClass = env->FindClass("android/bluetooth/UidTraffic");
1024 android_bluetooth_UidTraffic.constructor =
1025 env->GetMethodID(jniUidTrafficClass, "<init>", "(IJJ)V");
1026
1027 jclass jniCallbackClass =
1028 env->FindClass("com/android/bluetooth/btservice/JniCallbacks");
1029 sJniCallbacksField = env->GetFieldID(
1030 clazz, "mJniCallbacks", "Lcom/android/bluetooth/btservice/JniCallbacks;");
1031
1032 method_oobDataReceivedCallback =
1033 env->GetMethodID(jniCallbackClass, "oobDataReceivedCallback",
1034 "(ILandroid/bluetooth/OobData;)V");
1035
1036 method_stateChangeCallback =
1037 env->GetMethodID(jniCallbackClass, "stateChangeCallback", "(I)V");
1038
1039 method_adapterPropertyChangedCallback = env->GetMethodID(
1040 jniCallbackClass, "adapterPropertyChangedCallback", "([I[[B)V");
1041 method_discoveryStateChangeCallback = env->GetMethodID(
1042 jniCallbackClass, "discoveryStateChangeCallback", "(I)V");
1043
1044 method_devicePropertyChangedCallback = env->GetMethodID(
1045 jniCallbackClass, "devicePropertyChangedCallback", "([B[I[[B)V");
1046 method_deviceFoundCallback =
1047 env->GetMethodID(jniCallbackClass, "deviceFoundCallback", "([B)V");
1048 method_pinRequestCallback =
1049 env->GetMethodID(jniCallbackClass, "pinRequestCallback", "([B[BIZ)V");
1050 method_sspRequestCallback =
1051 env->GetMethodID(jniCallbackClass, "sspRequestCallback", "([B[BIII)V");
1052
1053 method_bondStateChangeCallback =
1054 env->GetMethodID(jniCallbackClass, "bondStateChangeCallback", "(I[BII)V");
1055
1056 method_addressConsolidateCallback = env->GetMethodID(
1057 jniCallbackClass, "addressConsolidateCallback", "([B[B)V");
1058
1059 method_leAddressAssociateCallback = env->GetMethodID(
1060 jniCallbackClass, "leAddressAssociateCallback", "([B[B)V");
1061
1062 method_aclStateChangeCallback = env->GetMethodID(
1063 jniCallbackClass, "aclStateChangeCallback", "(I[BIIII)V");
1064
1065 method_linkQualityReportCallback = env->GetMethodID(
1066 jniCallbackClass, "linkQualityReportCallback", "(JIIIIII)V");
1067
1068 method_switchBufferSizeCallback =
1069 env->GetMethodID(jniCallbackClass, "switchBufferSizeCallback", "(Z)V");
1070
1071 method_switchCodecCallback =
1072 env->GetMethodID(jniCallbackClass, "switchCodecCallback", "(Z)V");
1073
1074 method_setWakeAlarm = env->GetMethodID(clazz, "setWakeAlarm", "(JZ)Z");
1075 method_acquireWakeLock =
1076 env->GetMethodID(clazz, "acquireWakeLock", "(Ljava/lang/String;)Z");
1077 method_releaseWakeLock =
1078 env->GetMethodID(clazz, "releaseWakeLock", "(Ljava/lang/String;)Z");
1079 method_energyInfo = env->GetMethodID(
1080 clazz, "energyInfoCallback", "(IIJJJJ[Landroid/bluetooth/UidTraffic;)V");
1081
1082 if (env->GetJavaVM(&vm) != JNI_OK) {
1083 ALOGE("Could not get JavaVM");
1084 }
1085
1086 if (hal_util_load_bt_library((bt_interface_t const**)&sBluetoothInterface)) {
1087 ALOGE("No Bluetooth Library found");
1088 }
1089 }
1090
initNative(JNIEnv * env,jobject obj,jboolean isGuest,jboolean isCommonCriteriaMode,int configCompareResult,jobjectArray initFlags,jboolean isAtvDevice,jstring userDataDirectory)1091 static bool initNative(JNIEnv* env, jobject obj, jboolean isGuest,
1092 jboolean isCommonCriteriaMode, int configCompareResult,
1093 jobjectArray initFlags, jboolean isAtvDevice,
1094 jstring userDataDirectory) {
1095 std::unique_lock<std::shared_timed_mutex> lock(jniObjMutex);
1096
1097 ALOGV("%s", __func__);
1098
1099 android_bluetooth_UidTraffic.clazz =
1100 (jclass)env->NewGlobalRef(env->FindClass("android/bluetooth/UidTraffic"));
1101
1102 sJniAdapterServiceObj = env->NewGlobalRef(obj);
1103 sJniCallbacksObj =
1104 env->NewGlobalRef(env->GetObjectField(obj, sJniCallbacksField));
1105
1106 if (!sBluetoothInterface) {
1107 return JNI_FALSE;
1108 }
1109
1110 int flagCount = env->GetArrayLength(initFlags);
1111 jstring* flagObjs = new jstring[flagCount];
1112 const char** flags = nullptr;
1113 if (flagCount > 0) {
1114 flags = new const char*[flagCount + 1];
1115 flags[flagCount] = nullptr;
1116 }
1117
1118 for (int i = 0; i < flagCount; i++) {
1119 flagObjs[i] = (jstring)env->GetObjectArrayElement(initFlags, i);
1120 flags[i] = env->GetStringUTFChars(flagObjs[i], NULL);
1121 }
1122
1123 const char* user_data_directory =
1124 env->GetStringUTFChars(userDataDirectory, NULL);
1125
1126 int ret = sBluetoothInterface->init(
1127 &sBluetoothCallbacks, isGuest == JNI_TRUE ? 1 : 0,
1128 isCommonCriteriaMode == JNI_TRUE ? 1 : 0, configCompareResult, flags,
1129 isAtvDevice == JNI_TRUE ? 1 : 0, user_data_directory);
1130
1131 env->ReleaseStringUTFChars(userDataDirectory, user_data_directory);
1132
1133 for (int i = 0; i < flagCount; i++) {
1134 env->ReleaseStringUTFChars(flagObjs[i], flags[i]);
1135 }
1136
1137 delete[] flags;
1138 delete[] flagObjs;
1139
1140 if (ret != BT_STATUS_SUCCESS) {
1141 ALOGE("Error while setting the callbacks: %d\n", ret);
1142 sBluetoothInterface = NULL;
1143 return JNI_FALSE;
1144 }
1145 ret = sBluetoothInterface->set_os_callouts(&sBluetoothOsCallouts);
1146 if (ret != BT_STATUS_SUCCESS) {
1147 ALOGE("Error while setting Bluetooth callouts: %d\n", ret);
1148 sBluetoothInterface->cleanup();
1149 sBluetoothInterface = NULL;
1150 return JNI_FALSE;
1151 }
1152
1153 sBluetoothSocketInterface =
1154 (btsock_interface_t*)sBluetoothInterface->get_profile_interface(
1155 BT_PROFILE_SOCKETS_ID);
1156 if (sBluetoothSocketInterface == NULL) {
1157 ALOGE("Error getting socket interface");
1158 }
1159
1160 return JNI_TRUE;
1161 }
1162
cleanupNative(JNIEnv * env,jobject obj)1163 static bool cleanupNative(JNIEnv* env, jobject obj) {
1164 std::unique_lock<std::shared_timed_mutex> lock(jniObjMutex);
1165
1166 ALOGV("%s", __func__);
1167
1168 if (!sBluetoothInterface) return JNI_FALSE;
1169
1170 sBluetoothInterface->cleanup();
1171 ALOGI("%s: return from cleanup", __func__);
1172
1173 if (sJniCallbacksObj) {
1174 env->DeleteGlobalRef(sJniCallbacksObj);
1175 sJniCallbacksObj = NULL;
1176 }
1177
1178 if (sJniAdapterServiceObj) {
1179 env->DeleteGlobalRef(sJniAdapterServiceObj);
1180 sJniAdapterServiceObj = NULL;
1181 }
1182
1183 if (android_bluetooth_UidTraffic.clazz) {
1184 env->DeleteGlobalRef(android_bluetooth_UidTraffic.clazz);
1185 android_bluetooth_UidTraffic.clazz = NULL;
1186 }
1187 return JNI_TRUE;
1188 }
1189
enableNative(JNIEnv * env,jobject obj)1190 static jboolean enableNative(JNIEnv* env, jobject obj) {
1191 ALOGV("%s", __func__);
1192
1193 if (!sBluetoothInterface) return JNI_FALSE;
1194 int ret = sBluetoothInterface->enable();
1195 return (ret == BT_STATUS_SUCCESS || ret == BT_STATUS_DONE) ? JNI_TRUE
1196 : JNI_FALSE;
1197 }
1198
disableNative(JNIEnv * env,jobject obj)1199 static jboolean disableNative(JNIEnv* env, jobject obj) {
1200 ALOGV("%s", __func__);
1201
1202 if (!sBluetoothInterface) return JNI_FALSE;
1203
1204 int ret = sBluetoothInterface->disable();
1205 /* Retrun JNI_FALSE only when BTIF explicitly reports
1206 BT_STATUS_FAIL. It is fine for the BT_STATUS_NOT_READY
1207 case which indicates that stack had not been enabled.
1208 */
1209 return (ret == BT_STATUS_FAIL) ? JNI_FALSE : JNI_TRUE;
1210 }
1211
startDiscoveryNative(JNIEnv * env,jobject obj)1212 static jboolean startDiscoveryNative(JNIEnv* env, jobject obj) {
1213 ALOGV("%s", __func__);
1214
1215 if (!sBluetoothInterface) return JNI_FALSE;
1216
1217 int ret = sBluetoothInterface->start_discovery();
1218 return (ret == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
1219 }
1220
cancelDiscoveryNative(JNIEnv * env,jobject obj)1221 static jboolean cancelDiscoveryNative(JNIEnv* env, jobject obj) {
1222 ALOGV("%s", __func__);
1223
1224 if (!sBluetoothInterface) return JNI_FALSE;
1225
1226 int ret = sBluetoothInterface->cancel_discovery();
1227 return (ret == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
1228 }
1229
createBondNative(JNIEnv * env,jobject obj,jbyteArray address,jint addrType,jint transport)1230 static jboolean createBondNative(JNIEnv* env, jobject obj, jbyteArray address,
1231 jint addrType, jint transport) {
1232 ALOGV("%s", __func__);
1233
1234 if (!sBluetoothInterface) return JNI_FALSE;
1235
1236 jbyte* addr = env->GetByteArrayElements(address, NULL);
1237 if (addr == NULL) {
1238 jniThrowIOException(env, EINVAL);
1239 return JNI_FALSE;
1240 }
1241
1242 uint8_t addr_type = (uint8_t)addrType;
1243 int ret = BT_STATUS_SUCCESS;
1244 if (addr_type == BLE_ADDR_RANDOM) {
1245 ret = sBluetoothInterface->create_bond_le((RawAddress*)addr, addr_type);
1246 } else {
1247 ret = sBluetoothInterface->create_bond((RawAddress*)addr, transport);
1248 }
1249
1250 if (ret != BT_STATUS_SUCCESS) {
1251 ALOGW("%s: Failed to initiate bonding. Status = %d", __func__, ret);
1252 }
1253
1254 env->ReleaseByteArrayElements(address, addr, 0);
1255 return (ret == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
1256 }
1257
callByteArrayGetter(JNIEnv * env,jobject object,const char * className,const char * methodName)1258 static jbyteArray callByteArrayGetter(JNIEnv* env, jobject object,
1259 const char* className,
1260 const char* methodName) {
1261 jclass myClass = env->FindClass(className);
1262 jmethodID myMethod = env->GetMethodID(myClass, methodName, "()[B");
1263 return (jbyteArray)env->CallObjectMethod(object, myMethod);
1264 }
1265
callIntGetter(JNIEnv * env,jobject object,const char * className,const char * methodName)1266 static jint callIntGetter(JNIEnv* env, jobject object, const char* className,
1267 const char* methodName) {
1268 jclass myClass = env->FindClass(className);
1269 jmethodID myMethod = env->GetMethodID(myClass, methodName, "()I");
1270 return env->CallIntMethod(object, myMethod);
1271 }
1272
set_data(JNIEnv * env,bt_oob_data_t & oob_data,jobject oobData,jint transport)1273 static jboolean set_data(JNIEnv* env, bt_oob_data_t& oob_data, jobject oobData,
1274 jint transport) {
1275 // Need both arguments to be non NULL
1276 if (oobData == NULL) {
1277 ALOGE("%s: oobData is null! Nothing to do.", __func__);
1278 return JNI_FALSE;
1279 }
1280
1281 memset(&oob_data, 0, sizeof(oob_data));
1282
1283 jbyteArray address = callByteArrayGetter(
1284 env, oobData, "android/bluetooth/OobData", "getDeviceAddressWithType");
1285
1286 // Check the data
1287 int len = env->GetArrayLength(address);
1288 if (len != OOB_ADDRESS_SIZE) {
1289 ALOGE("%s: addressBytes must be 7 bytes in length (address plus type) 6+1!",
1290 __func__);
1291 jniThrowIOException(env, EINVAL);
1292 return JNI_FALSE;
1293 }
1294
1295 // Convert the address from byte[]
1296 jbyte* addressBytes = env->GetByteArrayElements(address, NULL);
1297 if (addressBytes == NULL) {
1298 ALOGE("%s: addressBytes cannot be null!", __func__);
1299 jniThrowIOException(env, EINVAL);
1300 return JNI_FALSE;
1301 }
1302 memcpy(oob_data.address, addressBytes, len);
1303
1304 // Get the device name byte[] java object
1305 jbyteArray deviceName = callByteArrayGetter(
1306 env, oobData, "android/bluetooth/OobData", "getDeviceName");
1307
1308 // Optional
1309 // Convert it to a jbyte* and copy it to the struct
1310 jbyte* deviceNameBytes = NULL;
1311 if (deviceName != NULL) {
1312 deviceNameBytes = env->GetByteArrayElements(deviceName, NULL);
1313 int len = env->GetArrayLength(deviceName);
1314 if (len > OOB_NAME_MAX_SIZE) {
1315 ALOGI(
1316 "%s: wrong length of deviceName, should be empty or less than or "
1317 "equal to %d bytes.",
1318 __func__, OOB_NAME_MAX_SIZE);
1319 jniThrowIOException(env, EINVAL);
1320 env->ReleaseByteArrayElements(deviceName, deviceNameBytes, 0);
1321 return JNI_FALSE;
1322 }
1323 memcpy(oob_data.device_name, deviceNameBytes, len);
1324 env->ReleaseByteArrayElements(deviceName, deviceNameBytes, 0);
1325 }
1326 // Used by both classic and LE
1327 jbyteArray confirmation = callByteArrayGetter(
1328 env, oobData, "android/bluetooth/OobData", "getConfirmationHash");
1329 if (confirmation == NULL) {
1330 ALOGE("%s: confirmation cannot be null!", __func__);
1331 jniThrowIOException(env, EINVAL);
1332 return JNI_FALSE;
1333 }
1334
1335 // Confirmation is mandatory
1336 jbyte* confirmationBytes = NULL;
1337 confirmationBytes = env->GetByteArrayElements(confirmation, NULL);
1338 len = env->GetArrayLength(confirmation);
1339 if (confirmationBytes == NULL || len != OOB_C_SIZE) {
1340 ALOGI(
1341 "%s: wrong length of Confirmation, should be empty or %d "
1342 "bytes.",
1343 __func__, OOB_C_SIZE);
1344 jniThrowIOException(env, EINVAL);
1345 env->ReleaseByteArrayElements(confirmation, confirmationBytes, 0);
1346 return JNI_FALSE;
1347 }
1348 memcpy(oob_data.c, confirmationBytes, len);
1349 env->ReleaseByteArrayElements(confirmation, confirmationBytes, 0);
1350
1351 // Random is supposedly optional according to the specification
1352 jbyteArray randomizer = callByteArrayGetter(
1353 env, oobData, "android/bluetooth/OobData", "getRandomizerHash");
1354 jbyte* randomizerBytes = NULL;
1355 if (randomizer != NULL) {
1356 randomizerBytes = env->GetByteArrayElements(randomizer, NULL);
1357 int len = env->GetArrayLength(randomizer);
1358 if (randomizerBytes == NULL || len != OOB_R_SIZE) {
1359 ALOGI("%s: wrong length of Random, should be empty or %d bytes.",
1360 __func__, OOB_R_SIZE);
1361 jniThrowIOException(env, EINVAL);
1362 env->ReleaseByteArrayElements(randomizer, randomizerBytes, 0);
1363 return JNI_FALSE;
1364 }
1365 memcpy(oob_data.r, randomizerBytes, len);
1366 env->ReleaseByteArrayElements(randomizer, randomizerBytes, 0);
1367 }
1368
1369 // Transport specific data fetching/setting
1370 if (transport == TRANSPORT_BREDR) {
1371 // Classic
1372 // Not optional
1373 jbyteArray oobDataLength = callByteArrayGetter(
1374 env, oobData, "android/bluetooth/OobData", "getClassicLength");
1375 jbyte* oobDataLengthBytes = NULL;
1376 if (oobDataLength == NULL ||
1377 env->GetArrayLength(oobDataLength) != OOB_DATA_LEN_SIZE) {
1378 ALOGI("%s: wrong length of oobDataLength, should be empty or %d bytes.",
1379 __func__, OOB_DATA_LEN_SIZE);
1380 jniThrowIOException(env, EINVAL);
1381 env->ReleaseByteArrayElements(oobDataLength, oobDataLengthBytes, 0);
1382 return JNI_FALSE;
1383 }
1384
1385 oobDataLengthBytes = env->GetByteArrayElements(oobDataLength, NULL);
1386 memcpy(oob_data.oob_data_length, oobDataLengthBytes, OOB_DATA_LEN_SIZE);
1387 env->ReleaseByteArrayElements(oobDataLength, oobDataLengthBytes, 0);
1388
1389 // Optional
1390 jbyteArray classOfDevice = callByteArrayGetter(
1391 env, oobData, "android/bluetooth/OobData", "getClassOfDevice");
1392 jbyte* classOfDeviceBytes = NULL;
1393 if (classOfDevice != NULL) {
1394 classOfDeviceBytes = env->GetByteArrayElements(classOfDevice, NULL);
1395 int len = env->GetArrayLength(classOfDevice);
1396 if (len != OOB_COD_SIZE) {
1397 ALOGI("%s: wrong length of classOfDevice, should be empty or %d bytes.",
1398 __func__, OOB_COD_SIZE);
1399 jniThrowIOException(env, EINVAL);
1400 env->ReleaseByteArrayElements(classOfDevice, classOfDeviceBytes, 0);
1401 return JNI_FALSE;
1402 }
1403 memcpy(oob_data.class_of_device, classOfDeviceBytes, len);
1404 env->ReleaseByteArrayElements(classOfDevice, classOfDeviceBytes, 0);
1405 }
1406 } else if (transport == TRANSPORT_LE) {
1407 // LE
1408 jbyteArray temporaryKey = callByteArrayGetter(
1409 env, oobData, "android/bluetooth/OobData", "getLeTemporaryKey");
1410 jbyte* temporaryKeyBytes = NULL;
1411 if (temporaryKey != NULL) {
1412 temporaryKeyBytes = env->GetByteArrayElements(temporaryKey, NULL);
1413 int len = env->GetArrayLength(temporaryKey);
1414 if (len != OOB_TK_SIZE) {
1415 ALOGI("%s: wrong length of temporaryKey, should be empty or %d bytes.",
1416 __func__, OOB_TK_SIZE);
1417 jniThrowIOException(env, EINVAL);
1418 env->ReleaseByteArrayElements(temporaryKey, temporaryKeyBytes, 0);
1419 return JNI_FALSE;
1420 }
1421 memcpy(oob_data.sm_tk, temporaryKeyBytes, len);
1422 env->ReleaseByteArrayElements(temporaryKey, temporaryKeyBytes, 0);
1423 }
1424
1425 jbyteArray leAppearance = callByteArrayGetter(
1426 env, oobData, "android/bluetooth/OobData", "getLeAppearance");
1427 jbyte* leAppearanceBytes = NULL;
1428 if (leAppearance != NULL) {
1429 leAppearanceBytes = env->GetByteArrayElements(leAppearance, NULL);
1430 int len = env->GetArrayLength(leAppearance);
1431 if (len != OOB_LE_APPEARANCE_SIZE) {
1432 ALOGI("%s: wrong length of leAppearance, should be empty or %d bytes.",
1433 __func__, OOB_LE_APPEARANCE_SIZE);
1434 jniThrowIOException(env, EINVAL);
1435 env->ReleaseByteArrayElements(leAppearance, leAppearanceBytes, 0);
1436 return JNI_FALSE;
1437 }
1438 memcpy(oob_data.le_appearance, leAppearanceBytes, len);
1439 env->ReleaseByteArrayElements(leAppearance, leAppearanceBytes, 0);
1440 }
1441
1442 jint leRole = callIntGetter(env, oobData, "android/bluetooth/OobData",
1443 "getLeDeviceRole");
1444 oob_data.le_device_role = leRole;
1445
1446 jint leFlag =
1447 callIntGetter(env, oobData, "android/bluetooth/OobData", "getLeFlags");
1448 oob_data.le_flags = leFlag;
1449 }
1450 return JNI_TRUE;
1451 }
1452
generateLocalOobDataNative(JNIEnv * env,jobject obj,jint transport)1453 static void generateLocalOobDataNative(JNIEnv* env, jobject obj,
1454 jint transport) {
1455 // No BT interface? Can't do anything.
1456 if (!sBluetoothInterface) return;
1457
1458 if (sBluetoothInterface->generate_local_oob_data(transport) !=
1459 BT_STATUS_SUCCESS) {
1460 ALOGE("%s: Call to generate_local_oob_data failed!", __func__);
1461 bt_oob_data_t oob_data;
1462 oob_data.is_valid = false;
1463 generate_local_oob_data_callback(transport, oob_data);
1464 }
1465 }
1466
createBondOutOfBandNative(JNIEnv * env,jobject obj,jbyteArray address,jint transport,jobject p192Data,jobject p256Data)1467 static jboolean createBondOutOfBandNative(JNIEnv* env, jobject obj,
1468 jbyteArray address, jint transport,
1469 jobject p192Data, jobject p256Data) {
1470 // No BT interface? Can't do anything.
1471 if (!sBluetoothInterface) return JNI_FALSE;
1472
1473 // No data? Can't do anything
1474 if (p192Data == NULL && p256Data == NULL) {
1475 ALOGE("%s: All OOB Data are null! Nothing to do.", __func__);
1476 jniThrowIOException(env, EINVAL);
1477 return JNI_FALSE;
1478 }
1479
1480 // This address is already reversed which is why its being passed...
1481 // In the future we want to remove this and just reverse the address
1482 // for the oobdata in the host stack.
1483 if (address == NULL) {
1484 ALOGE("%s: Address cannot be null! Nothing to do.", __func__);
1485 jniThrowIOException(env, EINVAL);
1486 return JNI_FALSE;
1487 }
1488
1489 // Check the data
1490 int len = env->GetArrayLength(address);
1491 if (len != 6) {
1492 ALOGE("%s: addressBytes must be 6 bytes in length (address plus type) 6+1!",
1493 __func__);
1494 jniThrowIOException(env, EINVAL);
1495 return JNI_FALSE;
1496 }
1497
1498 jbyte* addr = env->GetByteArrayElements(address, NULL);
1499 if (addr == NULL) {
1500 jniThrowIOException(env, EINVAL);
1501 return JNI_FALSE;
1502 }
1503
1504 // Convert P192 data from Java POJO to C Struct
1505 bt_oob_data_t p192_data;
1506 if (p192Data != NULL) {
1507 if (set_data(env, p192_data, p192Data, transport) == JNI_FALSE) {
1508 jniThrowIOException(env, EINVAL);
1509 return JNI_FALSE;
1510 }
1511 }
1512
1513 // Convert P256 data from Java POJO to C Struct
1514 bt_oob_data_t p256_data;
1515 if (p256Data != NULL) {
1516 if (set_data(env, p256_data, p256Data, transport) == JNI_FALSE) {
1517 jniThrowIOException(env, EINVAL);
1518 return JNI_FALSE;
1519 }
1520 }
1521
1522 return ((sBluetoothInterface->create_bond_out_of_band(
1523 (RawAddress*)addr, transport, &p192_data, &p256_data)) ==
1524 BT_STATUS_SUCCESS)
1525 ? JNI_TRUE
1526 : JNI_FALSE;
1527 }
1528
removeBondNative(JNIEnv * env,jobject obj,jbyteArray address)1529 static jboolean removeBondNative(JNIEnv* env, jobject obj, jbyteArray address) {
1530 ALOGV("%s", __func__);
1531
1532 if (!sBluetoothInterface) return JNI_FALSE;
1533
1534 jbyte* addr = env->GetByteArrayElements(address, NULL);
1535 if (addr == NULL) {
1536 jniThrowIOException(env, EINVAL);
1537 return JNI_FALSE;
1538 }
1539
1540 int ret = sBluetoothInterface->remove_bond((RawAddress*)addr);
1541 env->ReleaseByteArrayElements(address, addr, 0);
1542
1543 return (ret == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
1544 }
1545
cancelBondNative(JNIEnv * env,jobject obj,jbyteArray address)1546 static jboolean cancelBondNative(JNIEnv* env, jobject obj, jbyteArray address) {
1547 ALOGV("%s", __func__);
1548
1549 if (!sBluetoothInterface) return JNI_FALSE;
1550
1551 jbyte* addr = env->GetByteArrayElements(address, NULL);
1552 if (addr == NULL) {
1553 jniThrowIOException(env, EINVAL);
1554 return JNI_FALSE;
1555 }
1556
1557 int ret = sBluetoothInterface->cancel_bond((RawAddress*)addr);
1558 env->ReleaseByteArrayElements(address, addr, 0);
1559 return (ret == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
1560 }
1561
getConnectionStateNative(JNIEnv * env,jobject obj,jbyteArray address)1562 static int getConnectionStateNative(JNIEnv* env, jobject obj,
1563 jbyteArray address) {
1564 ALOGV("%s", __func__);
1565 if (!sBluetoothInterface) return JNI_FALSE;
1566
1567 jbyte* addr = env->GetByteArrayElements(address, NULL);
1568 if (addr == NULL) {
1569 jniThrowIOException(env, EINVAL);
1570 return JNI_FALSE;
1571 }
1572
1573 int ret = sBluetoothInterface->get_connection_state((RawAddress*)addr);
1574 env->ReleaseByteArrayElements(address, addr, 0);
1575
1576 return ret;
1577 }
1578
pinReplyNative(JNIEnv * env,jobject obj,jbyteArray address,jboolean accept,jint len,jbyteArray pinArray)1579 static jboolean pinReplyNative(JNIEnv* env, jobject obj, jbyteArray address,
1580 jboolean accept, jint len, jbyteArray pinArray) {
1581 ALOGV("%s", __func__);
1582
1583 if (!sBluetoothInterface) return JNI_FALSE;
1584
1585 jbyte* addr = env->GetByteArrayElements(address, NULL);
1586 if (addr == NULL) {
1587 jniThrowIOException(env, EINVAL);
1588 return JNI_FALSE;
1589 }
1590
1591 jbyte* pinPtr = NULL;
1592 if (accept) {
1593 pinPtr = env->GetByteArrayElements(pinArray, NULL);
1594 if (pinPtr == NULL) {
1595 jniThrowIOException(env, EINVAL);
1596 env->ReleaseByteArrayElements(address, addr, 0);
1597 return JNI_FALSE;
1598 }
1599 }
1600
1601 int ret = sBluetoothInterface->pin_reply((RawAddress*)addr, accept, len,
1602 (bt_pin_code_t*)pinPtr);
1603 env->ReleaseByteArrayElements(address, addr, 0);
1604 env->ReleaseByteArrayElements(pinArray, pinPtr, 0);
1605
1606 return (ret == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
1607 }
1608
sspReplyNative(JNIEnv * env,jobject obj,jbyteArray address,jint type,jboolean accept,jint passkey)1609 static jboolean sspReplyNative(JNIEnv* env, jobject obj, jbyteArray address,
1610 jint type, jboolean accept, jint passkey) {
1611 ALOGV("%s", __func__);
1612
1613 if (!sBluetoothInterface) return JNI_FALSE;
1614
1615 jbyte* addr = env->GetByteArrayElements(address, NULL);
1616 if (addr == NULL) {
1617 jniThrowIOException(env, EINVAL);
1618 return JNI_FALSE;
1619 }
1620
1621 int ret = sBluetoothInterface->ssp_reply(
1622 (RawAddress*)addr, (bt_ssp_variant_t)type, accept, passkey);
1623 env->ReleaseByteArrayElements(address, addr, 0);
1624
1625 return (ret == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
1626 }
1627
setAdapterPropertyNative(JNIEnv * env,jobject obj,jint type,jbyteArray value)1628 static jboolean setAdapterPropertyNative(JNIEnv* env, jobject obj, jint type,
1629 jbyteArray value) {
1630 ALOGV("%s", __func__);
1631
1632 if (!sBluetoothInterface) return JNI_FALSE;
1633
1634 jbyte* val = env->GetByteArrayElements(value, NULL);
1635 bt_property_t prop;
1636 prop.type = (bt_property_type_t)type;
1637 prop.len = env->GetArrayLength(value);
1638 prop.val = val;
1639
1640 int ret = sBluetoothInterface->set_adapter_property(&prop);
1641 env->ReleaseByteArrayElements(value, val, 0);
1642
1643 return (ret == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
1644 }
1645
getAdapterPropertiesNative(JNIEnv * env,jobject obj)1646 static jboolean getAdapterPropertiesNative(JNIEnv* env, jobject obj) {
1647 ALOGV("%s", __func__);
1648
1649 if (!sBluetoothInterface) return JNI_FALSE;
1650
1651 int ret = sBluetoothInterface->get_adapter_properties();
1652 return (ret == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
1653 }
1654
getAdapterPropertyNative(JNIEnv * env,jobject obj,jint type)1655 static jboolean getAdapterPropertyNative(JNIEnv* env, jobject obj, jint type) {
1656 ALOGV("%s", __func__);
1657
1658 if (!sBluetoothInterface) return JNI_FALSE;
1659
1660 int ret = sBluetoothInterface->get_adapter_property((bt_property_type_t)type);
1661 return (ret == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
1662 }
1663
getDevicePropertyNative(JNIEnv * env,jobject obj,jbyteArray address,jint type)1664 static jboolean getDevicePropertyNative(JNIEnv* env, jobject obj,
1665 jbyteArray address, jint type) {
1666 ALOGV("%s", __func__);
1667
1668 if (!sBluetoothInterface) return JNI_FALSE;
1669
1670 jbyte* addr = env->GetByteArrayElements(address, NULL);
1671 if (addr == NULL) {
1672 jniThrowIOException(env, EINVAL);
1673 return JNI_FALSE;
1674 }
1675
1676 int ret = sBluetoothInterface->get_remote_device_property(
1677 (RawAddress*)addr, (bt_property_type_t)type);
1678 env->ReleaseByteArrayElements(address, addr, 0);
1679 return (ret == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
1680 }
1681
setDevicePropertyNative(JNIEnv * env,jobject obj,jbyteArray address,jint type,jbyteArray value)1682 static jboolean setDevicePropertyNative(JNIEnv* env, jobject obj,
1683 jbyteArray address, jint type,
1684 jbyteArray value) {
1685 ALOGV("%s", __func__);
1686
1687 if (!sBluetoothInterface) return JNI_FALSE;
1688
1689 jbyte* val = env->GetByteArrayElements(value, NULL);
1690 if (val == NULL) {
1691 jniThrowIOException(env, EINVAL);
1692 return JNI_FALSE;
1693 }
1694
1695 jbyte* addr = env->GetByteArrayElements(address, NULL);
1696 if (addr == NULL) {
1697 env->ReleaseByteArrayElements(value, val, 0);
1698 jniThrowIOException(env, EINVAL);
1699 return JNI_FALSE;
1700 }
1701
1702 bt_property_t prop;
1703 prop.type = (bt_property_type_t)type;
1704 prop.len = env->GetArrayLength(value);
1705 prop.val = val;
1706
1707 int ret =
1708 sBluetoothInterface->set_remote_device_property((RawAddress*)addr, &prop);
1709 env->ReleaseByteArrayElements(value, val, 0);
1710 env->ReleaseByteArrayElements(address, addr, 0);
1711
1712 return (ret == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
1713 }
1714
getRemoteServicesNative(JNIEnv * env,jobject obj,jbyteArray address,jint transport)1715 static jboolean getRemoteServicesNative(JNIEnv* env, jobject obj,
1716 jbyteArray address, jint transport) {
1717 ALOGV("%s", __func__);
1718
1719 if (!sBluetoothInterface) return JNI_FALSE;
1720
1721 jbyte* addr = addr = env->GetByteArrayElements(address, NULL);
1722 if (addr == NULL) {
1723 jniThrowIOException(env, EINVAL);
1724 return JNI_FALSE;
1725 }
1726
1727 int ret =
1728 sBluetoothInterface->get_remote_services((RawAddress*)addr, transport);
1729 env->ReleaseByteArrayElements(address, addr, 0);
1730 return (ret == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
1731 }
1732
readEnergyInfo()1733 static int readEnergyInfo() {
1734 ALOGV("%s", __func__);
1735
1736 if (!sBluetoothInterface) return JNI_FALSE;
1737 int ret = sBluetoothInterface->read_energy_info();
1738 return (ret == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
1739 }
1740
dumpNative(JNIEnv * env,jobject obj,jobject fdObj,jobjectArray argArray)1741 static void dumpNative(JNIEnv* env, jobject obj, jobject fdObj,
1742 jobjectArray argArray) {
1743 ALOGV("%s", __func__);
1744 if (!sBluetoothInterface) return;
1745
1746 int fd = jniGetFDFromFileDescriptor(env, fdObj);
1747 if (fd < 0) return;
1748
1749 int numArgs = env->GetArrayLength(argArray);
1750
1751 jstring* argObjs = new jstring[numArgs];
1752 const char** args = nullptr;
1753 if (numArgs > 0) {
1754 args = new const char*[numArgs + 1];
1755 args[numArgs] = nullptr;
1756 }
1757
1758 for (int i = 0; i < numArgs; i++) {
1759 argObjs[i] = (jstring)env->GetObjectArrayElement(argArray, i);
1760 args[i] = env->GetStringUTFChars(argObjs[i], NULL);
1761 }
1762
1763 sBluetoothInterface->dump(fd, args);
1764
1765 for (int i = 0; i < numArgs; i++) {
1766 env->ReleaseStringUTFChars(argObjs[i], args[i]);
1767 }
1768
1769 delete[] args;
1770 delete[] argObjs;
1771 }
1772
dumpMetricsNative(JNIEnv * env,jobject obj)1773 static jbyteArray dumpMetricsNative(JNIEnv* env, jobject obj) {
1774 ALOGI("%s", __func__);
1775 if (!sBluetoothInterface) return env->NewByteArray(0);
1776
1777 std::string output;
1778 sBluetoothInterface->dumpMetrics(&output);
1779 jsize output_size = output.size() * sizeof(char);
1780 jbyteArray output_bytes = env->NewByteArray(output_size);
1781 env->SetByteArrayRegion(output_bytes, 0, output_size,
1782 (const jbyte*)output.data());
1783 return output_bytes;
1784 }
1785
factoryResetNative(JNIEnv * env,jobject obj)1786 static jboolean factoryResetNative(JNIEnv* env, jobject obj) {
1787 ALOGV("%s", __func__);
1788 if (!sBluetoothInterface) return JNI_FALSE;
1789 int ret = sBluetoothInterface->config_clear();
1790 return (ret == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
1791 }
1792
obfuscateAddressNative(JNIEnv * env,jobject obj,jbyteArray address)1793 static jbyteArray obfuscateAddressNative(JNIEnv* env, jobject obj,
1794 jbyteArray address) {
1795 ALOGV("%s", __func__);
1796 if (!sBluetoothInterface) return env->NewByteArray(0);
1797 jbyte* addr = env->GetByteArrayElements(address, nullptr);
1798 if (addr == nullptr) {
1799 jniThrowIOException(env, EINVAL);
1800 return env->NewByteArray(0);
1801 }
1802 RawAddress addr_obj = {};
1803 addr_obj.FromOctets((uint8_t*)addr);
1804 std::string output = sBluetoothInterface->obfuscate_address(addr_obj);
1805 jsize output_size = output.size() * sizeof(char);
1806 jbyteArray output_bytes = env->NewByteArray(output_size);
1807 env->SetByteArrayRegion(output_bytes, 0, output_size,
1808 (const jbyte*)output.data());
1809 return output_bytes;
1810 }
1811
setBufferLengthMillisNative(JNIEnv * env,jobject obj,jint codec,jint size)1812 static jboolean setBufferLengthMillisNative(JNIEnv* env, jobject obj,
1813 jint codec, jint size) {
1814 ALOGV("%s", __func__);
1815
1816 if (!sBluetoothInterface) return JNI_FALSE;
1817
1818 int ret = sBluetoothInterface->set_dynamic_audio_buffer_size(codec, size);
1819 return (ret == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
1820 }
1821
connectSocketNative(JNIEnv * env,jobject obj,jbyteArray address,jint type,jbyteArray uuid,jint port,jint flag,jint callingUid)1822 static jint connectSocketNative(JNIEnv* env, jobject obj, jbyteArray address,
1823 jint type, jbyteArray uuid, jint port,
1824 jint flag, jint callingUid) {
1825 int socket_fd = INVALID_FD;
1826 jbyte* addr = nullptr;
1827 jbyte* uuidBytes = nullptr;
1828 Uuid btUuid;
1829
1830 if (!sBluetoothSocketInterface) {
1831 goto done;
1832 }
1833 addr = env->GetByteArrayElements(address, nullptr);
1834 uuidBytes = env->GetByteArrayElements(uuid, nullptr);
1835 if (addr == nullptr || uuidBytes == nullptr) {
1836 jniThrowIOException(env, EINVAL);
1837 goto done;
1838 }
1839
1840 btUuid = Uuid::From128BitBE((uint8_t*)uuidBytes);
1841 if (sBluetoothSocketInterface->connect((RawAddress*)addr, (btsock_type_t)type,
1842 &btUuid, port, &socket_fd, flag,
1843 callingUid) != BT_STATUS_SUCCESS) {
1844 socket_fd = INVALID_FD;
1845 }
1846
1847 done:
1848 if (addr) env->ReleaseByteArrayElements(address, addr, 0);
1849 if (uuidBytes) env->ReleaseByteArrayElements(uuid, uuidBytes, 0);
1850 return socket_fd;
1851 }
1852
createSocketChannelNative(JNIEnv * env,jobject obj,jint type,jstring serviceName,jbyteArray uuid,jint port,jint flag,jint callingUid)1853 static jint createSocketChannelNative(JNIEnv* env, jobject obj, jint type,
1854 jstring serviceName, jbyteArray uuid,
1855 jint port, jint flag, jint callingUid) {
1856 int socket_fd = INVALID_FD;
1857 jbyte* uuidBytes = nullptr;
1858 Uuid btUuid;
1859 const char* nativeServiceName = nullptr;
1860
1861 if (!sBluetoothSocketInterface) {
1862 goto done;
1863 }
1864 uuidBytes = env->GetByteArrayElements(uuid, nullptr);
1865 if (serviceName != nullptr) {
1866 nativeServiceName = env->GetStringUTFChars(serviceName, nullptr);
1867 }
1868 if (uuidBytes == nullptr) {
1869 jniThrowIOException(env, EINVAL);
1870 goto done;
1871 }
1872 btUuid = Uuid::From128BitBE((uint8_t*)uuidBytes);
1873
1874 if (sBluetoothSocketInterface->listen((btsock_type_t)type, nativeServiceName,
1875 &btUuid, port, &socket_fd, flag,
1876 callingUid) != BT_STATUS_SUCCESS) {
1877 socket_fd = INVALID_FD;
1878 }
1879
1880 done:
1881 if (uuidBytes) env->ReleaseByteArrayElements(uuid, uuidBytes, 0);
1882 if (nativeServiceName)
1883 env->ReleaseStringUTFChars(serviceName, nativeServiceName);
1884 return socket_fd;
1885 }
1886
requestMaximumTxDataLengthNative(JNIEnv * env,jobject obj,jbyteArray address)1887 static void requestMaximumTxDataLengthNative(JNIEnv* env, jobject obj,
1888 jbyteArray address) {
1889 if (!sBluetoothSocketInterface) {
1890 return;
1891 }
1892 jbyte* addr = env->GetByteArrayElements(address, nullptr);
1893 if (addr == nullptr) {
1894 jniThrowIOException(env, EINVAL);
1895 return;
1896 }
1897
1898 RawAddress addressVar = *(RawAddress*)addr;
1899 sBluetoothSocketInterface->request_max_tx_data_length(addressVar);
1900 env->ReleaseByteArrayElements(address, addr, 1);
1901 }
1902
getMetricIdNative(JNIEnv * env,jobject obj,jbyteArray address)1903 static int getMetricIdNative(JNIEnv* env, jobject obj, jbyteArray address) {
1904 ALOGV("%s", __func__);
1905 if (!sBluetoothInterface) return 0; // 0 is invalid id
1906 jbyte* addr = env->GetByteArrayElements(address, nullptr);
1907 if (addr == nullptr) {
1908 jniThrowIOException(env, EINVAL);
1909 return 0;
1910 }
1911 RawAddress addr_obj = {};
1912 addr_obj.FromOctets((uint8_t*)addr);
1913 return sBluetoothInterface->get_metric_id(addr_obj);
1914 }
1915
allowLowLatencyAudioNative(JNIEnv * env,jobject obj,jboolean allowed,jbyteArray address)1916 static jboolean allowLowLatencyAudioNative(JNIEnv* env, jobject obj,
1917 jboolean allowed,
1918 jbyteArray address) {
1919 ALOGV("%s", __func__);
1920 if (!sBluetoothInterface) return false;
1921 jbyte* addr = env->GetByteArrayElements(address, nullptr);
1922 if (addr == nullptr) {
1923 jniThrowIOException(env, EINVAL);
1924 return false;
1925 }
1926
1927 RawAddress addr_obj = {};
1928 addr_obj.FromOctets((uint8_t*)addr);
1929 sBluetoothInterface->allow_low_latency_audio(allowed, addr_obj);
1930 return true;
1931 }
1932
metadataChangedNative(JNIEnv * env,jobject obj,jbyteArray address,jint key,jbyteArray value)1933 static void metadataChangedNative(JNIEnv* env, jobject obj, jbyteArray address,
1934 jint key, jbyteArray value) {
1935 ALOGV("%s", __func__);
1936 if (!sBluetoothInterface) return;
1937 jbyte* addr = env->GetByteArrayElements(address, nullptr);
1938 if (addr == nullptr) {
1939 jniThrowIOException(env, EINVAL);
1940 return;
1941 }
1942 RawAddress addr_obj = {};
1943 addr_obj.FromOctets((uint8_t*)addr);
1944
1945 if (value == NULL) {
1946 ALOGE("metadataChangedNative() ignoring NULL array");
1947 return;
1948 }
1949
1950 uint16_t len = (uint16_t)env->GetArrayLength(value);
1951 jbyte* p_value = env->GetByteArrayElements(value, NULL);
1952 if (p_value == NULL) return;
1953
1954 std::vector<uint8_t> val_vec(reinterpret_cast<uint8_t*>(p_value),
1955 reinterpret_cast<uint8_t*>(p_value + len));
1956 env->ReleaseByteArrayElements(value, p_value, 0);
1957
1958 sBluetoothInterface->metadata_changed(addr_obj, key, std::move(val_vec));
1959 return;
1960 }
1961
isLogRedactionEnabled(JNIEnv * env,jobject obj)1962 static jboolean isLogRedactionEnabled(JNIEnv* env, jobject obj) {
1963 ALOGV("%s", __func__);
1964 return bluetooth::os::should_log_be_redacted();
1965 }
1966
interopMatchAddrNative(JNIEnv * env,jclass clazz,jstring feature_name,jstring address)1967 static jboolean interopMatchAddrNative(JNIEnv* env, jclass clazz,
1968 jstring feature_name, jstring address) {
1969 ALOGV("%s", __func__);
1970
1971 if (!sBluetoothInterface) {
1972 ALOGW("%s: sBluetoothInterface is null.", __func__);
1973 return JNI_FALSE;
1974 }
1975
1976 const char* tmp_addr = env->GetStringUTFChars(address, NULL);
1977 if (!tmp_addr) {
1978 ALOGW("%s: address is null.", __func__);
1979 return JNI_FALSE;
1980 }
1981 RawAddress bdaddr;
1982 bool success = RawAddress::FromString(tmp_addr, bdaddr);
1983
1984 env->ReleaseStringUTFChars(address, tmp_addr);
1985
1986 if (!success) {
1987 ALOGW("%s: address is invalid.", __func__);
1988 return JNI_FALSE;
1989 }
1990
1991 const char* feature_name_str = env->GetStringUTFChars(feature_name, NULL);
1992 if (!feature_name_str) {
1993 ALOGW("%s: feature name is null.", __func__);
1994 return JNI_FALSE;
1995 }
1996
1997 bool matched =
1998 sBluetoothInterface->interop_match_addr(feature_name_str, &bdaddr);
1999 env->ReleaseStringUTFChars(feature_name, feature_name_str);
2000
2001 return matched ? JNI_TRUE : JNI_FALSE;
2002 }
2003
interopMatchNameNative(JNIEnv * env,jclass clazz,jstring feature_name,jstring name)2004 static jboolean interopMatchNameNative(JNIEnv* env, jclass clazz,
2005 jstring feature_name, jstring name) {
2006 ALOGV("%s", __func__);
2007
2008 if (!sBluetoothInterface) {
2009 ALOGW("%s: sBluetoothInterface is null.", __func__);
2010 return JNI_FALSE;
2011 }
2012
2013 const char* feature_name_str = env->GetStringUTFChars(feature_name, NULL);
2014 if (!feature_name_str) {
2015 ALOGW("%s: feature name is null.", __func__);
2016 return JNI_FALSE;
2017 }
2018
2019 const char* name_str = env->GetStringUTFChars(name, NULL);
2020 if (!name_str) {
2021 ALOGW("%s: name is null.", __func__);
2022 env->ReleaseStringUTFChars(feature_name, feature_name_str);
2023 return JNI_FALSE;
2024 }
2025
2026 bool matched =
2027 sBluetoothInterface->interop_match_name(feature_name_str, name_str);
2028 env->ReleaseStringUTFChars(feature_name, feature_name_str);
2029 env->ReleaseStringUTFChars(name, name_str);
2030
2031 return matched ? JNI_TRUE : JNI_FALSE;
2032 }
2033
interopMatchAddrOrNameNative(JNIEnv * env,jclass clazz,jstring feature_name,jstring address)2034 static jboolean interopMatchAddrOrNameNative(JNIEnv* env, jclass clazz,
2035 jstring feature_name,
2036 jstring address) {
2037 ALOGV("%s", __func__);
2038
2039 if (!sBluetoothInterface) {
2040 ALOGW("%s: sBluetoothInterface is null.", __func__);
2041 return JNI_FALSE;
2042 }
2043
2044 const char* tmp_addr = env->GetStringUTFChars(address, NULL);
2045 if (!tmp_addr) {
2046 ALOGW("%s: address is null.", __func__);
2047 return JNI_FALSE;
2048 }
2049 RawAddress bdaddr;
2050 bool success = RawAddress::FromString(tmp_addr, bdaddr);
2051
2052 env->ReleaseStringUTFChars(address, tmp_addr);
2053
2054 if (!success) {
2055 ALOGW("%s: address is invalid.", __func__);
2056 return JNI_FALSE;
2057 }
2058
2059 const char* feature_name_str = env->GetStringUTFChars(feature_name, NULL);
2060 if (!feature_name_str) {
2061 ALOGW("%s: feature name is null.", __func__);
2062 return JNI_FALSE;
2063 }
2064
2065 bool matched = sBluetoothInterface->interop_match_addr_or_name(
2066 feature_name_str, &bdaddr);
2067 env->ReleaseStringUTFChars(feature_name, feature_name_str);
2068
2069 return matched ? JNI_TRUE : JNI_FALSE;
2070 }
2071
interopDatabaseAddRemoveAddrNative(JNIEnv * env,jclass clazz,jboolean do_add,jstring feature_name,jstring address,jint length)2072 static void interopDatabaseAddRemoveAddrNative(JNIEnv* env, jclass clazz,
2073 jboolean do_add,
2074 jstring feature_name,
2075 jstring address, jint length) {
2076 ALOGV("%s", __func__);
2077
2078 if (!sBluetoothInterface) {
2079 ALOGW("%s: sBluetoothInterface is null.", __func__);
2080 return;
2081 }
2082
2083 if ((do_add == JNI_TRUE) && (length <= 0 || length > 6)) {
2084 ALOGE("%s: address length %d is invalid, valid length is [1,6]", __func__,
2085 length);
2086 return;
2087 }
2088
2089 const char* tmp_addr = env->GetStringUTFChars(address, NULL);
2090 if (!tmp_addr) {
2091 ALOGW("%s: address is null.", __func__);
2092 return;
2093 }
2094 RawAddress bdaddr;
2095 bool success = RawAddress::FromString(tmp_addr, bdaddr);
2096
2097 env->ReleaseStringUTFChars(address, tmp_addr);
2098
2099 if (!success) {
2100 ALOGW("%s: address is invalid.", __func__);
2101 return;
2102 }
2103
2104 const char* feature_name_str = env->GetStringUTFChars(feature_name, NULL);
2105 if (!feature_name_str) {
2106 ALOGW("%s: feature name is null.", __func__);
2107 return;
2108 }
2109
2110 sBluetoothInterface->interop_database_add_remove_addr(
2111 (do_add == JNI_TRUE), feature_name_str, &bdaddr, (int)length);
2112
2113 env->ReleaseStringUTFChars(feature_name, feature_name_str);
2114 }
2115
interopDatabaseAddRemoveNameNative(JNIEnv * env,jclass clazz,jboolean do_add,jstring feature_name,jstring name)2116 static void interopDatabaseAddRemoveNameNative(JNIEnv* env, jclass clazz,
2117 jboolean do_add,
2118 jstring feature_name,
2119 jstring name) {
2120 ALOGV("%s", __func__);
2121
2122 if (!sBluetoothInterface) {
2123 ALOGW("%s: sBluetoothInterface is null.", __func__);
2124 return;
2125 }
2126
2127 const char* feature_name_str = env->GetStringUTFChars(feature_name, NULL);
2128 if (!feature_name_str) {
2129 ALOGW("%s: feature name is null.", __func__);
2130 return;
2131 }
2132
2133 const char* name_str = env->GetStringUTFChars(name, NULL);
2134 if (!name_str) {
2135 ALOGW("%s: name is null.", __func__);
2136 env->ReleaseStringUTFChars(feature_name, feature_name_str);
2137 return;
2138 }
2139
2140 sBluetoothInterface->interop_database_add_remove_name(
2141 (do_add == JNI_TRUE), feature_name_str, name_str);
2142
2143 env->ReleaseStringUTFChars(feature_name, feature_name_str);
2144 env->ReleaseStringUTFChars(name, name_str);
2145 }
2146
getRemotePbapPceVersionNative(JNIEnv * env,jobject obj,jstring address)2147 static int getRemotePbapPceVersionNative(JNIEnv* env, jobject obj,
2148 jstring address) {
2149 ALOGV("%s", __func__);
2150
2151 if (!sBluetoothInterface) return JNI_FALSE;
2152
2153 const char* tmp_addr = env->GetStringUTFChars(address, NULL);
2154 if (!tmp_addr) {
2155 ALOGW("%s: address is null.", __func__);
2156 return JNI_FALSE;
2157 }
2158
2159 RawAddress bdaddr;
2160 bool success = RawAddress::FromString(tmp_addr, bdaddr);
2161
2162 env->ReleaseStringUTFChars(address, tmp_addr);
2163
2164 if (!success) {
2165 ALOGW("%s: address is invalid.", __func__);
2166 return JNI_FALSE;
2167 }
2168
2169 return sBluetoothInterface->get_remote_pbap_pce_version(&bdaddr);
2170 }
2171
pbapPseDynamicVersionUpgradeIsEnabledNative(JNIEnv * env,jobject obj)2172 static jboolean pbapPseDynamicVersionUpgradeIsEnabledNative(JNIEnv* env,
2173 jobject obj) {
2174 ALOGV("%s", __func__);
2175
2176 if (!sBluetoothInterface) return JNI_FALSE;
2177
2178 return sBluetoothInterface->pbap_pse_dynamic_version_upgrade_is_enabled()
2179 ? JNI_TRUE
2180 : JNI_FALSE;
2181 }
2182
2183 static JNINativeMethod sMethods[] = {
2184 /* name, signature, funcPtr */
2185 {"classInitNative", "()V", (void*)classInitNative},
2186 {"initNative", "(ZZI[Ljava/lang/String;ZLjava/lang/String;)Z",
2187 (void*)initNative},
2188 {"cleanupNative", "()V", (void*)cleanupNative},
2189 {"enableNative", "()Z", (void*)enableNative},
2190 {"disableNative", "()Z", (void*)disableNative},
2191 {"setAdapterPropertyNative", "(I[B)Z", (void*)setAdapterPropertyNative},
2192 {"getAdapterPropertiesNative", "()Z", (void*)getAdapterPropertiesNative},
2193 {"getAdapterPropertyNative", "(I)Z", (void*)getAdapterPropertyNative},
2194 {"getDevicePropertyNative", "([BI)Z", (void*)getDevicePropertyNative},
2195 {"setDevicePropertyNative", "([BI[B)Z", (void*)setDevicePropertyNative},
2196 {"startDiscoveryNative", "()Z", (void*)startDiscoveryNative},
2197 {"cancelDiscoveryNative", "()Z", (void*)cancelDiscoveryNative},
2198 {"createBondNative", "([BII)Z", (void*)createBondNative},
2199 {"createBondOutOfBandNative",
2200 "([BILandroid/bluetooth/OobData;Landroid/bluetooth/OobData;)Z",
2201 (void*)createBondOutOfBandNative},
2202 {"removeBondNative", "([B)Z", (void*)removeBondNative},
2203 {"cancelBondNative", "([B)Z", (void*)cancelBondNative},
2204 {"generateLocalOobDataNative", "(I)V", (void*)generateLocalOobDataNative},
2205 {"getConnectionStateNative", "([B)I", (void*)getConnectionStateNative},
2206 {"pinReplyNative", "([BZI[B)Z", (void*)pinReplyNative},
2207 {"sspReplyNative", "([BIZI)Z", (void*)sspReplyNative},
2208 {"getRemoteServicesNative", "([BI)Z", (void*)getRemoteServicesNative},
2209 {"alarmFiredNative", "()V", (void*)alarmFiredNative},
2210 {"readEnergyInfo", "()I", (void*)readEnergyInfo},
2211 {"dumpNative", "(Ljava/io/FileDescriptor;[Ljava/lang/String;)V",
2212 (void*)dumpNative},
2213 {"dumpMetricsNative", "()[B", (void*)dumpMetricsNative},
2214 {"factoryResetNative", "()Z", (void*)factoryResetNative},
2215 {"obfuscateAddressNative", "([B)[B", (void*)obfuscateAddressNative},
2216 {"setBufferLengthMillisNative", "(II)Z",
2217 (void*)setBufferLengthMillisNative},
2218 {"getMetricIdNative", "([B)I", (void*)getMetricIdNative},
2219 {"connectSocketNative", "([BI[BIII)I", (void*)connectSocketNative},
2220 {"createSocketChannelNative", "(ILjava/lang/String;[BIII)I",
2221 (void*)createSocketChannelNative},
2222 {"requestMaximumTxDataLengthNative", "([B)V",
2223 (void*)requestMaximumTxDataLengthNative},
2224 {"allowLowLatencyAudioNative", "(Z[B)Z", (void*)allowLowLatencyAudioNative},
2225 {"metadataChangedNative", "([BI[B)V", (void*)metadataChangedNative},
2226 {"isLogRedactionEnabled", "()Z", (void*)isLogRedactionEnabled},
2227 {"interopMatchAddrNative", "(Ljava/lang/String;Ljava/lang/String;)Z",
2228 (void*)interopMatchAddrNative},
2229 {"interopMatchNameNative", "(Ljava/lang/String;Ljava/lang/String;)Z",
2230 (void*)interopMatchNameNative},
2231 {"interopMatchAddrOrNameNative", "(Ljava/lang/String;Ljava/lang/String;)Z",
2232 (void*)interopMatchAddrOrNameNative},
2233 {"interopDatabaseAddRemoveAddrNative",
2234 "(ZLjava/lang/String;Ljava/lang/String;I)V",
2235 (void*)interopDatabaseAddRemoveAddrNative},
2236 {"interopDatabaseAddRemoveNameNative",
2237 "(ZLjava/lang/String;Ljava/lang/String;)V",
2238 (void*)interopDatabaseAddRemoveNameNative},
2239 {"getRemotePbapPceVersionNative", "(Ljava/lang/String;)I",
2240 (void*)getRemotePbapPceVersionNative},
2241 {"pbapPseDynamicVersionUpgradeIsEnabledNative", "()Z",
2242 (void*)pbapPseDynamicVersionUpgradeIsEnabledNative},
2243 };
2244
register_com_android_bluetooth_btservice_AdapterService(JNIEnv * env)2245 int register_com_android_bluetooth_btservice_AdapterService(JNIEnv* env) {
2246 return jniRegisterNativeMethods(
2247 env, "com/android/bluetooth/btservice/AdapterService", sMethods,
2248 NELEM(sMethods));
2249 }
2250
2251 } /* namespace android */
2252
2253 /*
2254 * JNI Initialization
2255 */
JNI_OnLoad(JavaVM * jvm,void * reserved)2256 jint JNI_OnLoad(JavaVM* jvm, void* reserved) {
2257 JNIEnv* e;
2258 int status;
2259
2260 ALOGV("Bluetooth Adapter Service : loading JNI\n");
2261
2262 // Check JNI version
2263 if (jvm->GetEnv((void**)&e, JNI_VERSION_1_6)) {
2264 ALOGE("JNI version mismatch error");
2265 return JNI_ERR;
2266 }
2267
2268 status = android::register_com_android_bluetooth_btservice_AdapterService(e);
2269 if (status < 0) {
2270 ALOGE("jni adapter service registration failure, status: %d", status);
2271 return JNI_ERR;
2272 }
2273
2274 status =
2275 android::register_com_android_bluetooth_btservice_activity_attribution(e);
2276 if (status < 0) {
2277 ALOGE("jni activity attribution registration failure: %d", status);
2278 return JNI_ERR;
2279 }
2280
2281 status =
2282 android::register_com_android_bluetooth_btservice_BluetoothKeystore(e);
2283 if (status < 0) {
2284 ALOGE("jni BluetoothKeyStore registration failure: %d", status);
2285 return JNI_ERR;
2286 }
2287
2288 status = android::register_com_android_bluetooth_hfp(e);
2289 if (status < 0) {
2290 ALOGE("jni hfp registration failure, status: %d", status);
2291 return JNI_ERR;
2292 }
2293
2294 status = android::register_com_android_bluetooth_hfpclient(e);
2295 if (status < 0) {
2296 ALOGE("jni hfp client registration failure, status: %d", status);
2297 return JNI_ERR;
2298 }
2299
2300 status = android::register_com_android_bluetooth_a2dp(e);
2301 if (status < 0) {
2302 ALOGE("jni a2dp source registration failure: %d", status);
2303 return JNI_ERR;
2304 }
2305
2306 status = android::register_com_android_bluetooth_a2dp_sink(e);
2307 if (status < 0) {
2308 ALOGE("jni a2dp sink registration failure: %d", status);
2309 return JNI_ERR;
2310 }
2311
2312 status = android::register_com_android_bluetooth_avrcp_target(e);
2313 if (status < 0) {
2314 ALOGE("jni new avrcp target registration failure: %d", status);
2315 }
2316
2317 status = android::register_com_android_bluetooth_avrcp_controller(e);
2318 if (status < 0) {
2319 ALOGE("jni avrcp controller registration failure: %d", status);
2320 return JNI_ERR;
2321 }
2322
2323 status = android::register_com_android_bluetooth_hid_host(e);
2324 if (status < 0) {
2325 ALOGE("jni hid registration failure: %d", status);
2326 return JNI_ERR;
2327 }
2328
2329 status = android::register_com_android_bluetooth_hid_device(e);
2330 if (status < 0) {
2331 ALOGE("jni hidd registration failure: %d", status);
2332 return JNI_ERR;
2333 }
2334
2335 status = android::register_com_android_bluetooth_pan(e);
2336 if (status < 0) {
2337 ALOGE("jni pan registration failure: %d", status);
2338 return JNI_ERR;
2339 }
2340
2341 status = android::register_com_android_bluetooth_gatt(e);
2342 if (status < 0) {
2343 ALOGE("jni gatt registration failure: %d", status);
2344 return JNI_ERR;
2345 }
2346
2347 status = android::register_com_android_bluetooth_sdp(e);
2348 if (status < 0) {
2349 ALOGE("jni sdp registration failure: %d", status);
2350 return JNI_ERR;
2351 }
2352
2353 status = android::register_com_android_bluetooth_hearing_aid(e);
2354 if (status < 0) {
2355 ALOGE("jni hearing aid registration failure: %d", status);
2356 return JNI_ERR;
2357 }
2358
2359 status = android::register_com_android_bluetooth_hap_client(e);
2360 if (status < 0) {
2361 ALOGE("jni le audio hearing access client registration failure: %d",
2362 status);
2363 return JNI_ERR;
2364 }
2365
2366 status = android::register_com_android_bluetooth_le_audio(e);
2367 if (status < 0) {
2368 ALOGE("jni le_audio registration failure: %d", status);
2369 return JNI_ERR;
2370 }
2371
2372 status = android::register_com_android_bluetooth_vc(e);
2373 if (status < 0) {
2374 ALOGE("jni vc registration failure: %d", status);
2375 return JNI_ERR;
2376 }
2377
2378 status = android::register_com_android_bluetooth_csip_set_coordinator(e);
2379 if (status < 0) {
2380 ALOGE("jni csis client registration failure: %d", status);
2381 return JNI_ERR;
2382 }
2383
2384 status =
2385 android::register_com_android_bluetooth_btservice_BluetoothQualityReport(
2386 e);
2387 if (status < 0) {
2388 ALOGE("jni bluetooth quality report registration failure: %d", status);
2389 return JNI_ERR;
2390 }
2391
2392 return JNI_VERSION_1_6;
2393 }
2394