/* * Copyright (C) 2013 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define LOG_TAG "BtGatt.JNI" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "com_android_bluetooth.h" #include "com_android_bluetooth_flags.h" #include "hardware/ble_advertiser.h" #include "hardware/ble_scanner.h" #include "hardware/bluetooth.h" #include "hardware/bt_common_types.h" #include "hardware/bt_gatt.h" #include "hardware/bt_gatt_client.h" #include "hardware/bt_gatt_server.h" #include "hardware/bt_gatt_types.h" #include "hardware/distance_measurement_interface.h" #include "main/shim/le_scanning_manager.h" #include "rust/cxx.h" #include "src/gatt/ffi.rs.h" #include "types/bluetooth/uuid.h" #include "types/raw_address.h" // TODO(b/369381361) Enfore -Wmissing-prototypes #pragma GCC diagnostic ignored "-Wmissing-prototypes" using bluetooth::Uuid; #define UUID_PARAMS(uuid) uuid_lsb(uuid), uuid_msb(uuid) static Uuid from_java_uuid(jlong uuid_msb, jlong uuid_lsb) { std::array uu; for (int i = 0; i < 8; i++) { uu[7 - i] = (uuid_msb >> (8 * i)) & 0xFF; uu[15 - i] = (uuid_lsb >> (8 * i)) & 0xFF; } return Uuid::From128BitBE(uu); } static uint64_t uuid_lsb(const Uuid& uuid) { uint64_t lsb = 0; auto uu = uuid.To128BitBE(); for (int i = 8; i <= 15; i++) { lsb <<= 8; lsb |= uu[i]; } return lsb; } static uint64_t uuid_msb(const Uuid& uuid) { uint64_t msb = 0; auto uu = uuid.To128BitBE(); for (int i = 0; i <= 7; i++) { msb <<= 8; msb |= uu[i]; } return msb; } static RawAddress str2addr(JNIEnv* env, jstring address) { RawAddress bd_addr; const char* c_address = env->GetStringUTFChars(address, NULL); if (!c_address) { return bd_addr; } RawAddress::FromString(std::string(c_address), bd_addr); env->ReleaseStringUTFChars(address, c_address); return bd_addr; } static jstring bdaddr2newjstr(JNIEnv* env, const RawAddress* bda) { char c_address[32]; snprintf(c_address, sizeof(c_address), "%02X:%02X:%02X:%02X:%02X:%02X", bda->address[0], bda->address[1], bda->address[2], bda->address[3], bda->address[4], bda->address[5]); return env->NewStringUTF(c_address); } static std::vector toVector(JNIEnv* env, jbyteArray ba) { jbyte* data_data = env->GetByteArrayElements(ba, NULL); uint16_t data_len = (uint16_t)env->GetArrayLength(ba); std::vector data_vec(data_data, data_data + data_len); env->ReleaseByteArrayElements(ba, data_data, JNI_ABORT); return data_vec; } namespace android { /** * Client callback methods */ static jmethodID method_onClientRegistered; static jmethodID method_onConnected; static jmethodID method_onDisconnected; static jmethodID method_onReadCharacteristic; static jmethodID method_onWriteCharacteristic; static jmethodID method_onExecuteCompleted; static jmethodID method_onSearchCompleted; static jmethodID method_onReadDescriptor; static jmethodID method_onWriteDescriptor; static jmethodID method_onNotify; static jmethodID method_onRegisterForNotifications; static jmethodID method_onReadRemoteRssi; static jmethodID method_onConfigureMTU; static jmethodID method_onClientCongestion; static jmethodID method_getSampleGattDbElement; static jmethodID method_onGetGattDb; static jmethodID method_onClientPhyUpdate; static jmethodID method_onClientPhyRead; static jmethodID method_onClientConnUpdate; static jmethodID method_onServiceChanged; static jmethodID method_onClientSubrateChange; /** * Server callback methods */ static jmethodID method_onServerRegistered; static jmethodID method_onClientConnected; static jmethodID method_onServiceAdded; static jmethodID method_onServiceStopped; static jmethodID method_onServiceDeleted; static jmethodID method_onResponseSendCompleted; static jmethodID method_onServerReadCharacteristic; static jmethodID method_onServerReadDescriptor; static jmethodID method_onServerWriteCharacteristic; static jmethodID method_onServerWriteDescriptor; static jmethodID method_onExecuteWrite; static jmethodID method_onNotificationSent; static jmethodID method_onServerCongestion; static jmethodID method_onServerMtuChanged; static jmethodID method_onServerPhyUpdate; static jmethodID method_onServerPhyRead; static jmethodID method_onServerConnUpdate; static jmethodID method_onServerSubrateChange; /** * Advertiser callback methods */ static jmethodID method_onAdvertisingSetStarted; static jmethodID method_onOwnAddressRead; static jmethodID method_onAdvertisingEnabled; static jmethodID method_onAdvertisingDataSet; static jmethodID method_onScanResponseDataSet; static jmethodID method_onAdvertisingParametersUpdated; static jmethodID method_onPeriodicAdvertisingParametersUpdated; static jmethodID method_onPeriodicAdvertisingDataSet; static jmethodID method_onPeriodicAdvertisingEnabled; /** * Scanner callback methods */ static jmethodID method_onScannerRegistered; static jmethodID method_onScanResult; static jmethodID method_onScanFilterConfig; static jmethodID method_onScanFilterParamsConfigured; static jmethodID method_onScanFilterEnableDisabled; static jmethodID method_onBatchScanStorageConfigured; static jmethodID method_onBatchScanStartStopped; static jmethodID method_onBatchScanReports; static jmethodID method_onBatchScanThresholdCrossed; static jmethodID method_createOnTrackAdvFoundLostObject; static jmethodID method_onTrackAdvFoundLost; static jmethodID method_onScanParamSetupCompleted; static jmethodID method_onMsftAdvMonitorAdd; static jmethodID method_onMsftAdvMonitorRemove; static jmethodID method_onMsftAdvMonitorEnable; /** * Periodic scanner callback methods */ static jmethodID method_onSyncLost; static jmethodID method_onSyncReport; static jmethodID method_onSyncStarted; static jmethodID method_onSyncTransferredCallback; static jmethodID method_onBigInfoReport; /** * Distance Measurement callback methods */ static jmethodID method_onDistanceMeasurementStarted; static jmethodID method_onDistanceMeasurementStopped; static jmethodID method_onDistanceMeasurementResult; /** * Static variables */ static const btgatt_interface_t* sGattIf = NULL; /** Pointer to the LE scanner interface methods.*/ static BleScannerInterface* sScanner = NULL; static jobject mCallbacksObj = NULL; static jobject mScanCallbacksObj = NULL; static jobject mAdvertiseCallbacksObj = NULL; static jobject mPeriodicScanCallbacksObj = NULL; static jobject mDistanceMeasurementCallbacksObj = NULL; static std::shared_mutex callbacks_mutex; /** * BTA client callbacks */ void btgattc_register_app_cb(int status, int clientIf, const Uuid& app_uuid) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onClientRegistered, status, clientIf, UUID_PARAMS(app_uuid)); } void btgattc_scan_result_cb(uint16_t event_type, uint8_t addr_type, RawAddress* bda, uint8_t primary_phy, uint8_t secondary_phy, uint8_t advertising_sid, int8_t tx_power, int8_t rssi, uint16_t periodic_adv_int, std::vector adv_data, RawAddress* original_bda) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mScanCallbacksObj) { return; } ScopedLocalRef address(sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), bda)); ScopedLocalRef jb(sCallbackEnv.get(), sCallbackEnv->NewByteArray(adv_data.size())); sCallbackEnv->SetByteArrayRegion(jb.get(), 0, adv_data.size(), (jbyte*)adv_data.data()); ScopedLocalRef original_address(sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), original_bda)); sCallbackEnv->CallVoidMethod(mScanCallbacksObj, method_onScanResult, event_type, addr_type, address.get(), primary_phy, secondary_phy, advertising_sid, tx_power, rssi, periodic_adv_int, jb.get(), original_address.get()); } void btgattc_open_cb(int conn_id, int status, int clientIf, const RawAddress& bda) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } ScopedLocalRef address(sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), &bda)); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onConnected, clientIf, conn_id, status, address.get()); } void btgattc_close_cb(int conn_id, int status, int clientIf, const RawAddress& bda) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } ScopedLocalRef address(sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), &bda)); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onDisconnected, clientIf, conn_id, status, address.get()); } void btgattc_search_complete_cb(int conn_id, int status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onSearchCompleted, conn_id, status); } void btgattc_register_for_notification_cb(int conn_id, int registered, int status, uint16_t handle) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onRegisterForNotifications, conn_id, status, registered, handle); } void btgattc_notify_cb(int conn_id, const btgatt_notify_params_t& p_data) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } ScopedLocalRef address(sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), &p_data.bda)); ScopedLocalRef jb(sCallbackEnv.get(), sCallbackEnv->NewByteArray(p_data.len)); sCallbackEnv->SetByteArrayRegion(jb.get(), 0, p_data.len, (jbyte*)p_data.value); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onNotify, conn_id, address.get(), p_data.handle, p_data.is_notify, jb.get()); } void btgattc_read_characteristic_cb(int conn_id, int status, const btgatt_read_params_t& p_data) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } ScopedLocalRef jb(sCallbackEnv.get(), NULL); if (status == 0) { // Success jb.reset(sCallbackEnv->NewByteArray(p_data.value.len)); sCallbackEnv->SetByteArrayRegion(jb.get(), 0, p_data.value.len, (jbyte*)p_data.value.value); } else { uint8_t value = 0; jb.reset(sCallbackEnv->NewByteArray(1)); sCallbackEnv->SetByteArrayRegion(jb.get(), 0, 1, (jbyte*)&value); } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onReadCharacteristic, conn_id, status, p_data.handle, jb.get()); } void btgattc_write_characteristic_cb(int conn_id, int status, uint16_t handle, uint16_t len, const uint8_t* value) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } ScopedLocalRef jb(sCallbackEnv.get(), NULL); jb.reset(sCallbackEnv->NewByteArray(len)); sCallbackEnv->SetByteArrayRegion(jb.get(), 0, len, (jbyte*)value); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onWriteCharacteristic, conn_id, status, handle, jb.get()); } void btgattc_execute_write_cb(int conn_id, int status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onExecuteCompleted, conn_id, status); } void btgattc_read_descriptor_cb(int conn_id, int status, const btgatt_read_params_t& p_data) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } ScopedLocalRef jb(sCallbackEnv.get(), NULL); if (p_data.value.len != 0) { jb.reset(sCallbackEnv->NewByteArray(p_data.value.len)); sCallbackEnv->SetByteArrayRegion(jb.get(), 0, p_data.value.len, (jbyte*)p_data.value.value); } else { jb.reset(sCallbackEnv->NewByteArray(1)); } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onReadDescriptor, conn_id, status, p_data.handle, jb.get()); } void btgattc_write_descriptor_cb(int conn_id, int status, uint16_t handle, uint16_t len, const uint8_t* value) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } ScopedLocalRef jb(sCallbackEnv.get(), NULL); jb.reset(sCallbackEnv->NewByteArray(len)); sCallbackEnv->SetByteArrayRegion(jb.get(), 0, len, (jbyte*)value); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onWriteDescriptor, conn_id, status, handle, jb.get()); } void btgattc_remote_rssi_cb(int client_if, const RawAddress& bda, int rssi, int status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } ScopedLocalRef address(sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), &bda)); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onReadRemoteRssi, client_if, address.get(), rssi, status); } void btgattc_configure_mtu_cb(int conn_id, int status, int mtu) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onConfigureMTU, conn_id, status, mtu); } void btgattc_congestion_cb(int conn_id, bool congested) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onClientCongestion, conn_id, congested); } void btgattc_batchscan_reports_cb(int client_if, int status, int report_format, int num_records, std::vector data) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mScanCallbacksObj) { return; } ScopedLocalRef jb(sCallbackEnv.get(), sCallbackEnv->NewByteArray(data.size())); sCallbackEnv->SetByteArrayRegion(jb.get(), 0, data.size(), (jbyte*)data.data()); sCallbackEnv->CallVoidMethod(mScanCallbacksObj, method_onBatchScanReports, status, client_if, report_format, num_records, jb.get()); } void btgattc_batchscan_threshold_cb(int client_if) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mScanCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mScanCallbacksObj, method_onBatchScanThresholdCrossed, client_if); } void btgattc_track_adv_event_cb(btgatt_track_adv_info_t* p_adv_track_info) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mScanCallbacksObj) { return; } ScopedLocalRef address(sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), &p_adv_track_info->bd_addr)); ScopedLocalRef jb_adv_pkt(sCallbackEnv.get(), sCallbackEnv->NewByteArray(p_adv_track_info->adv_pkt_len)); ScopedLocalRef jb_scan_rsp( sCallbackEnv.get(), sCallbackEnv->NewByteArray(p_adv_track_info->scan_rsp_len)); sCallbackEnv->SetByteArrayRegion(jb_adv_pkt.get(), 0, p_adv_track_info->adv_pkt_len, (jbyte*)p_adv_track_info->p_adv_pkt_data); sCallbackEnv->SetByteArrayRegion(jb_scan_rsp.get(), 0, p_adv_track_info->scan_rsp_len, (jbyte*)p_adv_track_info->p_scan_rsp_data); ScopedLocalRef trackadv_obj( sCallbackEnv.get(), sCallbackEnv->CallObjectMethod( mScanCallbacksObj, method_createOnTrackAdvFoundLostObject, p_adv_track_info->client_if, p_adv_track_info->adv_pkt_len, jb_adv_pkt.get(), p_adv_track_info->scan_rsp_len, jb_scan_rsp.get(), p_adv_track_info->filt_index, p_adv_track_info->advertiser_state, p_adv_track_info->advertiser_info_present, address.get(), p_adv_track_info->addr_type, p_adv_track_info->tx_power, p_adv_track_info->rssi_value, p_adv_track_info->time_stamp)); if (NULL != trackadv_obj.get()) { sCallbackEnv->CallVoidMethod(mScanCallbacksObj, method_onTrackAdvFoundLost, trackadv_obj.get()); } } void fillGattDbElementArray(JNIEnv* env, jobject* array, const btgatt_db_element_t* db, int count) { // Because JNI uses a different class loader in the callback context, we // cannot simply get the class. // As a workaround, we have to make sure we obtain an object of the class // first, as this will cause // class loader to load it. ScopedLocalRef objectForClass( env, env->CallObjectMethod(mCallbacksObj, method_getSampleGattDbElement)); ScopedLocalRef gattDbElementClazz(env, env->GetObjectClass(objectForClass.get())); jmethodID gattDbElementConstructor = env->GetMethodID(gattDbElementClazz.get(), "", "()V"); jmethodID arrayAdd; const JNIJavaMethod javaMethods[] = { {"add", "(Ljava/lang/Object;)Z", &arrayAdd}, }; GET_JAVA_METHODS(env, "java/util/ArrayList", javaMethods); jmethodID uuidConstructor; const JNIJavaMethod javaUuidMethods[] = { {"", "(JJ)V", &uuidConstructor}, }; GET_JAVA_METHODS(env, "java/util/UUID", javaUuidMethods); for (int i = 0; i < count; i++) { const btgatt_db_element_t& curr = db[i]; ScopedLocalRef element( env, env->NewObject(gattDbElementClazz.get(), gattDbElementConstructor)); jfieldID fid = env->GetFieldID(gattDbElementClazz.get(), "id", "I"); env->SetIntField(element.get(), fid, curr.id); fid = env->GetFieldID(gattDbElementClazz.get(), "attributeHandle", "I"); env->SetIntField(element.get(), fid, curr.attribute_handle); ScopedLocalRef uuidClazz(env, env->FindClass("java/util/UUID")); ScopedLocalRef uuid(env, env->NewObject(uuidClazz.get(), uuidConstructor, uuid_msb(curr.uuid), uuid_lsb(curr.uuid))); fid = env->GetFieldID(gattDbElementClazz.get(), "uuid", "Ljava/util/UUID;"); env->SetObjectField(element.get(), fid, uuid.get()); fid = env->GetFieldID(gattDbElementClazz.get(), "type", "I"); env->SetIntField(element.get(), fid, curr.type); fid = env->GetFieldID(gattDbElementClazz.get(), "attributeHandle", "I"); env->SetIntField(element.get(), fid, curr.attribute_handle); fid = env->GetFieldID(gattDbElementClazz.get(), "startHandle", "I"); env->SetIntField(element.get(), fid, curr.start_handle); fid = env->GetFieldID(gattDbElementClazz.get(), "endHandle", "I"); env->SetIntField(element.get(), fid, curr.end_handle); fid = env->GetFieldID(gattDbElementClazz.get(), "properties", "I"); env->SetIntField(element.get(), fid, curr.properties); env->CallBooleanMethod(*array, arrayAdd, element.get()); } } void btgattc_get_gatt_db_cb(int conn_id, const btgatt_db_element_t* db, int count) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } jclass arrayListclazz = sCallbackEnv->FindClass("java/util/ArrayList"); ScopedLocalRef array( sCallbackEnv.get(), sCallbackEnv->NewObject(arrayListclazz, sCallbackEnv->GetMethodID(arrayListclazz, "", "()V"))); jobject arrayPtr = array.get(); fillGattDbElementArray(sCallbackEnv.get(), &arrayPtr, db, count); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onGetGattDb, conn_id, array.get()); } void btgattc_phy_updated_cb(int conn_id, uint8_t tx_phy, uint8_t rx_phy, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onClientPhyUpdate, conn_id, tx_phy, rx_phy, status); } void btgattc_conn_updated_cb(int conn_id, uint16_t interval, uint16_t latency, uint16_t timeout, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onClientConnUpdate, conn_id, interval, latency, timeout, status); } void btgattc_service_changed_cb(int conn_id) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServiceChanged, conn_id); } void btgattc_subrate_change_cb(int conn_id, uint16_t subrate_factor, uint16_t latency, uint16_t cont_num, uint16_t timeout, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onClientSubrateChange, conn_id, subrate_factor, latency, cont_num, timeout, status); } static const btgatt_scanner_callbacks_t sGattScannerCallbacks = { btgattc_scan_result_cb, btgattc_batchscan_reports_cb, btgattc_batchscan_threshold_cb, btgattc_track_adv_event_cb, }; static const btgatt_client_callbacks_t sGattClientCallbacks = { btgattc_register_app_cb, btgattc_open_cb, btgattc_close_cb, btgattc_search_complete_cb, btgattc_register_for_notification_cb, btgattc_notify_cb, btgattc_read_characteristic_cb, btgattc_write_characteristic_cb, btgattc_read_descriptor_cb, btgattc_write_descriptor_cb, btgattc_execute_write_cb, btgattc_remote_rssi_cb, btgattc_configure_mtu_cb, btgattc_congestion_cb, btgattc_get_gatt_db_cb, NULL, /* services_removed_cb */ NULL, /* services_added_cb */ btgattc_phy_updated_cb, btgattc_conn_updated_cb, btgattc_service_changed_cb, btgattc_subrate_change_cb, }; /** * BTA server callbacks */ void btgatts_register_app_cb(int status, int server_if, const Uuid& uuid) { bluetooth::gatt::open_server(server_if); std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServerRegistered, status, server_if, UUID_PARAMS(uuid)); } void btgatts_connection_cb(int conn_id, int server_if, int connected, const RawAddress& bda) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } ScopedLocalRef address(sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), &bda)); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onClientConnected, address.get(), connected, conn_id, server_if); } void btgatts_service_added_cb(int status, int server_if, const btgatt_db_element_t* service, size_t service_count) { // mirror the database in rust, now that it's created. if (status == 0x00 /* SUCCESS */) { auto service_records = rust::Vec(); for (size_t i = 0; i != service_count; ++i) { auto& curr_service = service[i]; service_records.push_back(bluetooth::gatt::GattRecord{ curr_service.uuid, (bluetooth::gatt::GattRecordType)curr_service.type, curr_service.attribute_handle, curr_service.properties, curr_service.extended_properties, curr_service.permissions}); } bluetooth::gatt::add_service(server_if, std::move(service_records)); } std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } jclass arrayListclazz = sCallbackEnv->FindClass("java/util/ArrayList"); ScopedLocalRef array( sCallbackEnv.get(), sCallbackEnv->NewObject(arrayListclazz, sCallbackEnv->GetMethodID(arrayListclazz, "", "()V"))); jobject arrayPtr = array.get(); fillGattDbElementArray(sCallbackEnv.get(), &arrayPtr, service, service_count); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServiceAdded, status, server_if, array.get()); } void btgatts_service_stopped_cb(int status, int server_if, int srvc_handle) { bluetooth::gatt::remove_service(server_if, srvc_handle); std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServiceStopped, status, server_if, srvc_handle); } void btgatts_service_deleted_cb(int status, int server_if, int srvc_handle) { bluetooth::gatt::remove_service(server_if, srvc_handle); std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServiceDeleted, status, server_if, srvc_handle); } void btgatts_request_read_characteristic_cb(int conn_id, int trans_id, const RawAddress& bda, int attr_handle, int offset, bool is_long) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } ScopedLocalRef address(sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), &bda)); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServerReadCharacteristic, address.get(), conn_id, trans_id, attr_handle, offset, is_long); } void btgatts_request_read_descriptor_cb(int conn_id, int trans_id, const RawAddress& bda, int attr_handle, int offset, bool is_long) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } ScopedLocalRef address(sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), &bda)); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServerReadDescriptor, address.get(), conn_id, trans_id, attr_handle, offset, is_long); } void btgatts_request_write_characteristic_cb(int conn_id, int trans_id, const RawAddress& bda, int attr_handle, int offset, bool need_rsp, bool is_prep, const uint8_t* value, size_t length) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } ScopedLocalRef address(sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), &bda)); ScopedLocalRef val(sCallbackEnv.get(), sCallbackEnv->NewByteArray(length)); if (val.get()) { sCallbackEnv->SetByteArrayRegion(val.get(), 0, length, (jbyte*)value); } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServerWriteCharacteristic, address.get(), conn_id, trans_id, attr_handle, offset, length, need_rsp, is_prep, val.get()); } void btgatts_request_write_descriptor_cb(int conn_id, int trans_id, const RawAddress& bda, int attr_handle, int offset, bool need_rsp, bool is_prep, const uint8_t* value, size_t length) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } ScopedLocalRef address(sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), &bda)); ScopedLocalRef val(sCallbackEnv.get(), sCallbackEnv->NewByteArray(length)); if (val.get()) { sCallbackEnv->SetByteArrayRegion(val.get(), 0, length, (jbyte*)value); } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServerWriteDescriptor, address.get(), conn_id, trans_id, attr_handle, offset, length, need_rsp, is_prep, val.get()); } void btgatts_request_exec_write_cb(int conn_id, int trans_id, const RawAddress& bda, int exec_write) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } ScopedLocalRef address(sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), &bda)); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onExecuteWrite, address.get(), conn_id, trans_id, exec_write); } void btgatts_response_confirmation_cb(int status, int handle) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onResponseSendCompleted, status, handle); } void btgatts_indication_sent_cb(int conn_id, int status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onNotificationSent, conn_id, status); } void btgatts_congestion_cb(int conn_id, bool congested) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServerCongestion, conn_id, congested); } void btgatts_mtu_changed_cb(int conn_id, int mtu) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServerMtuChanged, conn_id, mtu); } void btgatts_phy_updated_cb(int conn_id, uint8_t tx_phy, uint8_t rx_phy, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServerPhyUpdate, conn_id, tx_phy, rx_phy, status); } void btgatts_conn_updated_cb(int conn_id, uint16_t interval, uint16_t latency, uint16_t timeout, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServerConnUpdate, conn_id, interval, latency, timeout, status); } void btgatts_subrate_change_cb(int conn_id, uint16_t subrate_factor, uint16_t latency, uint16_t cont_num, uint16_t timeout, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServerSubrateChange, conn_id, subrate_factor, latency, cont_num, timeout, status); } static const btgatt_server_callbacks_t sGattServerCallbacks = { btgatts_register_app_cb, btgatts_connection_cb, btgatts_service_added_cb, btgatts_service_stopped_cb, btgatts_service_deleted_cb, btgatts_request_read_characteristic_cb, btgatts_request_read_descriptor_cb, btgatts_request_write_characteristic_cb, btgatts_request_write_descriptor_cb, btgatts_request_exec_write_cb, btgatts_response_confirmation_cb, btgatts_indication_sent_cb, btgatts_congestion_cb, btgatts_mtu_changed_cb, btgatts_phy_updated_cb, btgatts_conn_updated_cb, btgatts_subrate_change_cb, }; /** * GATT callbacks */ static const btgatt_callbacks_t sGattCallbacks = { sizeof(btgatt_callbacks_t), &sGattClientCallbacks, &sGattServerCallbacks, &sGattScannerCallbacks, }; class JniAdvertisingCallbacks : AdvertisingCallbacks { public: static AdvertisingCallbacks* GetInstance() { static AdvertisingCallbacks* instance = new JniAdvertisingCallbacks(); return instance; } void OnAdvertisingSetStarted(int reg_id, uint8_t advertiser_id, int8_t tx_power, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || mAdvertiseCallbacksObj == NULL) { return; } sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj, method_onAdvertisingSetStarted, reg_id, advertiser_id, tx_power, status); } void OnAdvertisingEnabled(uint8_t advertiser_id, bool enable, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || mAdvertiseCallbacksObj == NULL) { return; } sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj, method_onAdvertisingEnabled, advertiser_id, enable, status); } void OnAdvertisingDataSet(uint8_t advertiser_id, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || mAdvertiseCallbacksObj == NULL) { return; } sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj, method_onAdvertisingDataSet, advertiser_id, status); } void OnScanResponseDataSet(uint8_t advertiser_id, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || mAdvertiseCallbacksObj == NULL) { return; } sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj, method_onScanResponseDataSet, advertiser_id, status); } void OnAdvertisingParametersUpdated(uint8_t advertiser_id, int8_t tx_power, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || mAdvertiseCallbacksObj == NULL) { return; } sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj, method_onAdvertisingParametersUpdated, advertiser_id, tx_power, status); } void OnPeriodicAdvertisingParametersUpdated(uint8_t advertiser_id, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || mAdvertiseCallbacksObj == NULL) { return; } sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj, method_onPeriodicAdvertisingParametersUpdated, advertiser_id, status); } void OnPeriodicAdvertisingDataSet(uint8_t advertiser_id, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || mAdvertiseCallbacksObj == NULL) { return; } sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj, method_onPeriodicAdvertisingDataSet, advertiser_id, status); } void OnPeriodicAdvertisingEnabled(uint8_t advertiser_id, bool enable, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || mAdvertiseCallbacksObj == NULL) { return; } sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj, method_onPeriodicAdvertisingEnabled, advertiser_id, enable, status); } void OnOwnAddressRead(uint8_t advertiser_id, uint8_t address_type, RawAddress address) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || mAdvertiseCallbacksObj == NULL) { return; } ScopedLocalRef addr(sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), &address)); sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj, method_onOwnAddressRead, advertiser_id, address_type, addr.get()); } }; class JniScanningCallbacks : ScanningCallbacks { public: static ScanningCallbacks* GetInstance() { static ScanningCallbacks* instance = new JniScanningCallbacks(); return instance; } void OnScannerRegistered(const Uuid app_uuid, uint8_t scannerId, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mScanCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mScanCallbacksObj, method_onScannerRegistered, status, scannerId, UUID_PARAMS(app_uuid)); } void OnSetScannerParameterComplete(uint8_t scannerId, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mScanCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mScanCallbacksObj, method_onScanParamSetupCompleted, status, scannerId); } void OnScanResult(uint16_t event_type, uint8_t addr_type, RawAddress bda, uint8_t primary_phy, uint8_t secondary_phy, uint8_t advertising_sid, int8_t tx_power, int8_t rssi, uint16_t periodic_adv_int, std::vector adv_data) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mScanCallbacksObj) { return; } ScopedLocalRef address(sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), &bda)); ScopedLocalRef jb(sCallbackEnv.get(), sCallbackEnv->NewByteArray(adv_data.size())); sCallbackEnv->SetByteArrayRegion(jb.get(), 0, adv_data.size(), (jbyte*)adv_data.data()); // TODO(optedoblivion): Figure out original address for here, use empty // for now // length of data + '\0' char empty_address[18] = "00:00:00:00:00:00"; ScopedLocalRef fake_address(sCallbackEnv.get(), sCallbackEnv->NewStringUTF(empty_address)); sCallbackEnv->CallVoidMethod(mScanCallbacksObj, method_onScanResult, event_type, addr_type, address.get(), primary_phy, secondary_phy, advertising_sid, tx_power, rssi, periodic_adv_int, jb.get(), fake_address.get()); } void OnTrackAdvFoundLost(AdvertisingTrackInfo track_info) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mScanCallbacksObj) { log::error("sCallbackEnv not valid or no mScanCallbacksObj."); return; } ScopedLocalRef address( sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), &track_info.advertiser_address)); ScopedLocalRef jb_adv_pkt(sCallbackEnv.get(), sCallbackEnv->NewByteArray(track_info.adv_packet_len)); ScopedLocalRef jb_scan_rsp( sCallbackEnv.get(), sCallbackEnv->NewByteArray(track_info.scan_response_len)); sCallbackEnv->SetByteArrayRegion(jb_adv_pkt.get(), 0, track_info.adv_packet_len, (jbyte*)track_info.adv_packet.data()); sCallbackEnv->SetByteArrayRegion(jb_scan_rsp.get(), 0, track_info.scan_response_len, (jbyte*)track_info.scan_response.data()); ScopedLocalRef trackadv_obj( sCallbackEnv.get(), sCallbackEnv->CallObjectMethod( mScanCallbacksObj, method_createOnTrackAdvFoundLostObject, track_info.scanner_id, track_info.adv_packet_len, jb_adv_pkt.get(), track_info.scan_response_len, jb_scan_rsp.get(), track_info.filter_index, track_info.advertiser_state, track_info.advertiser_info_present, address.get(), track_info.advertiser_address_type, track_info.tx_power, track_info.rssi, track_info.time_stamp)); if (NULL != trackadv_obj.get()) { sCallbackEnv->CallVoidMethod(mScanCallbacksObj, method_onTrackAdvFoundLost, trackadv_obj.get()); } } void OnBatchScanReports(int client_if, int status, int report_format, int num_records, std::vector data) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mScanCallbacksObj) { return; } ScopedLocalRef jb(sCallbackEnv.get(), sCallbackEnv->NewByteArray(data.size())); sCallbackEnv->SetByteArrayRegion(jb.get(), 0, data.size(), (jbyte*)data.data()); sCallbackEnv->CallVoidMethod(mScanCallbacksObj, method_onBatchScanReports, status, client_if, report_format, num_records, jb.get()); } void OnBatchScanThresholdCrossed(int client_if) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mScanCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mScanCallbacksObj, method_onBatchScanThresholdCrossed, client_if); } void OnPeriodicSyncStarted(int reg_id, uint8_t status, uint16_t sync_handle, uint8_t sid, uint8_t address_type, RawAddress address, uint8_t phy, uint16_t interval) override { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid()) { return; } if (!mPeriodicScanCallbacksObj) { log::error("mPeriodicScanCallbacksObj is NULL. Return."); return; } ScopedLocalRef addr(sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), &address)); sCallbackEnv->CallVoidMethod(mPeriodicScanCallbacksObj, method_onSyncStarted, reg_id, sync_handle, sid, address_type, addr.get(), phy, interval, status); } void OnPeriodicSyncReport(uint16_t sync_handle, int8_t tx_power, int8_t rssi, uint8_t data_status, std::vector data) override { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mPeriodicScanCallbacksObj) { return; } ScopedLocalRef jb(sCallbackEnv.get(), sCallbackEnv->NewByteArray(data.size())); sCallbackEnv->SetByteArrayRegion(jb.get(), 0, data.size(), (jbyte*)data.data()); sCallbackEnv->CallVoidMethod(mPeriodicScanCallbacksObj, method_onSyncReport, sync_handle, tx_power, rssi, data_status, jb.get()); } void OnPeriodicSyncLost(uint16_t sync_handle) override { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mPeriodicScanCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mPeriodicScanCallbacksObj, method_onSyncLost, sync_handle); } void OnPeriodicSyncTransferred(int pa_source, uint8_t status, RawAddress address) override { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid()) { return; } if (!mPeriodicScanCallbacksObj) { log::error("mPeriodicScanCallbacksObj is NULL. Return."); return; } ScopedLocalRef addr(sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), &address)); sCallbackEnv->CallVoidMethod(mPeriodicScanCallbacksObj, method_onSyncTransferredCallback, pa_source, status, addr.get()); } void OnBigInfoReport(uint16_t sync_handle, bool encrypted) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid()) { return; } if (!mPeriodicScanCallbacksObj) { log::error("mPeriodicScanCallbacksObj is NULL. Return."); return; } sCallbackEnv->CallVoidMethod(mPeriodicScanCallbacksObj, method_onBigInfoReport, sync_handle, encrypted); } }; class JniDistanceMeasurementCallbacks : DistanceMeasurementCallbacks { public: static DistanceMeasurementCallbacks* GetInstance() { static DistanceMeasurementCallbacks* instance = new JniDistanceMeasurementCallbacks(); return instance; } void OnDistanceMeasurementStarted(RawAddress address, uint8_t method) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mDistanceMeasurementCallbacksObj) { return; } ScopedLocalRef addr(sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), &address)); sCallbackEnv->CallVoidMethod(mDistanceMeasurementCallbacksObj, method_onDistanceMeasurementStarted, addr.get(), method); } void OnDistanceMeasurementStopped(RawAddress address, uint8_t reason, uint8_t method) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mDistanceMeasurementCallbacksObj) { return; } ScopedLocalRef addr(sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), &address)); sCallbackEnv->CallVoidMethod(mDistanceMeasurementCallbacksObj, method_onDistanceMeasurementStopped, addr.get(), reason, method); } void OnDistanceMeasurementResult(RawAddress address, uint32_t centimeter, uint32_t error_centimeter, int azimuth_angle, int error_azimuth_angle, int altitude_angle, int error_altitude_angle, uint64_t elapsedRealtimeNanos, int8_t confidence_level, uint8_t method) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mDistanceMeasurementCallbacksObj) { return; } ScopedLocalRef addr(sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), &address)); sCallbackEnv->CallVoidMethod( mDistanceMeasurementCallbacksObj, method_onDistanceMeasurementResult, addr.get(), centimeter, error_centimeter, azimuth_angle, error_azimuth_angle, altitude_angle, error_altitude_angle, elapsedRealtimeNanos, confidence_level, method); } }; /** * Native function definitions */ static const bt_interface_t* btIf; static void initializeNative(JNIEnv* env, jobject object) { std::unique_lock lock(callbacks_mutex); if (btIf) { return; } btIf = getBluetoothInterface(); if (btIf == NULL) { log::error("Bluetooth module is not loaded"); return; } if (sGattIf != NULL) { log::warn("Cleaning up Bluetooth GATT Interface before initializing..."); sGattIf->cleanup(); sGattIf = NULL; } if (mCallbacksObj != NULL) { log::warn("Cleaning up Bluetooth GATT callback object"); env->DeleteGlobalRef(mCallbacksObj); mCallbacksObj = NULL; } sGattIf = (btgatt_interface_t*)btIf->get_profile_interface(BT_PROFILE_GATT_ID); if (sGattIf == NULL) { log::error("Failed to get Bluetooth GATT Interface"); return; } bt_status_t status = sGattIf->init(&sGattCallbacks); if (status != BT_STATUS_SUCCESS) { log::error("Failed to initialize Bluetooth GATT, status: {}", bt_status_text(status)); sGattIf = NULL; return; } if (com::android::bluetooth::flags::scan_manager_refactor()) { log::info("Starting rust module"); btIf->start_rust_module(); } sGattIf->advertiser->RegisterCallbacks(JniAdvertisingCallbacks::GetInstance()); sGattIf->distance_measurement_manager->RegisterDistanceMeasurementCallbacks( JniDistanceMeasurementCallbacks::GetInstance()); mCallbacksObj = env->NewGlobalRef(object); } static void cleanupNative(JNIEnv* env, jobject /* object */) { std::unique_lock lock(callbacks_mutex); if (!btIf) { return; } if (com::android::bluetooth::flags::scan_manager_refactor()) { log::info("Stopping rust module"); btIf->stop_rust_module(); } if (sGattIf != NULL) { sGattIf->cleanup(); sGattIf = NULL; } if (mCallbacksObj != NULL) { env->DeleteGlobalRef(mCallbacksObj); mCallbacksObj = NULL; } btIf = NULL; } /** * Native Client functions */ static int gattClientGetDeviceTypeNative(JNIEnv* env, jobject /* object */, jstring address) { if (!sGattIf) { return 0; } return sGattIf->client->get_device_type(str2addr(env, address)); } static void gattClientRegisterAppNative(JNIEnv* /* env */, jobject /* object */, jlong app_uuid_lsb, jlong app_uuid_msb, jboolean eatt_support) { if (!sGattIf) { return; } Uuid uuid = from_java_uuid(app_uuid_msb, app_uuid_lsb); sGattIf->client->register_client(uuid, eatt_support); } static void gattClientUnregisterAppNative(JNIEnv* /* env */, jobject /* object */, jint clientIf) { if (!sGattIf) { return; } sGattIf->client->unregister_client(clientIf); } void btgattc_register_scanner_cb(const Uuid& app_uuid, uint8_t scannerId, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mScanCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mScanCallbacksObj, method_onScannerRegistered, status, scannerId, UUID_PARAMS(app_uuid)); } static void registerScannerNative(JNIEnv* /* env */, jobject /* object */, jlong app_uuid_lsb, jlong app_uuid_msb) { if (!sScanner) { return; } Uuid uuid = from_java_uuid(app_uuid_msb, app_uuid_lsb); sScanner->RegisterScanner(uuid, base::Bind(&btgattc_register_scanner_cb, uuid)); } static void unregisterScannerNative(JNIEnv* /* env */, jobject /* object */, jint scanner_id) { if (!sScanner) { return; } sScanner->Unregister(scanner_id); } static void gattClientScanNative(JNIEnv* /* env */, jobject /* object */, jboolean start) { if (!sScanner) { return; } sScanner->Scan(start); } static void gattClientConnectNative(JNIEnv* env, jobject /* object */, jint clientif, jstring address, jint addressType, jboolean isDirect, jint transport, jboolean opportunistic, jint initiating_phys, jint preferred_mtu) { if (!sGattIf) { return; } sGattIf->client->connect(clientif, str2addr(env, address), addressType, isDirect, transport, opportunistic, initiating_phys, preferred_mtu); } static void gattClientDisconnectNative(JNIEnv* env, jobject /* object */, jint clientIf, jstring address, jint conn_id) { if (!sGattIf) { return; } sGattIf->client->disconnect(clientIf, str2addr(env, address), conn_id); } static void gattClientSetPreferredPhyNative(JNIEnv* env, jobject /* object */, jint /* clientIf */, jstring address, jint tx_phy, jint rx_phy, jint phy_options) { if (!sGattIf) { return; } sGattIf->client->set_preferred_phy(str2addr(env, address), tx_phy, rx_phy, phy_options); } static void readClientPhyCb(uint8_t clientIf, RawAddress bda, uint8_t tx_phy, uint8_t rx_phy, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } ScopedLocalRef address(sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), &bda)); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onClientPhyRead, clientIf, address.get(), tx_phy, rx_phy, status); } static void gattClientReadPhyNative(JNIEnv* env, jobject /* object */, jint clientIf, jstring address) { if (!sGattIf) { return; } RawAddress bda = str2addr(env, address); sGattIf->client->read_phy(bda, base::Bind(&readClientPhyCb, clientIf, bda)); } static void gattClientRefreshNative(JNIEnv* env, jobject /* object */, jint clientIf, jstring address) { if (!sGattIf) { return; } sGattIf->client->refresh(clientIf, str2addr(env, address)); } static void gattClientSearchServiceNative(JNIEnv* /* env */, jobject /* object */, jint conn_id, jboolean search_all, jlong service_uuid_lsb, jlong service_uuid_msb) { if (!sGattIf) { return; } Uuid uuid = from_java_uuid(service_uuid_msb, service_uuid_lsb); sGattIf->client->search_service(conn_id, search_all ? 0 : &uuid); } static void gattClientDiscoverServiceByUuidNative(JNIEnv* /* env */, jobject /* object */, jint conn_id, jlong service_uuid_lsb, jlong service_uuid_msb) { if (!sGattIf) { return; } Uuid uuid = from_java_uuid(service_uuid_msb, service_uuid_lsb); sGattIf->client->btif_gattc_discover_service_by_uuid(conn_id, uuid); } static void gattClientGetGattDbNative(JNIEnv* /* env */, jobject /* object */, jint conn_id) { if (!sGattIf) { return; } sGattIf->client->get_gatt_db(conn_id); } static void gattClientReadCharacteristicNative(JNIEnv* /* env */, jobject /* object */, jint conn_id, jint handle, jint authReq) { if (!sGattIf) { return; } sGattIf->client->read_characteristic(conn_id, handle, authReq); } static void gattClientReadUsingCharacteristicUuidNative(JNIEnv* /* env */, jobject /* object */, jint conn_id, jlong uuid_lsb, jlong uuid_msb, jint s_handle, jint e_handle, jint authReq) { if (!sGattIf) { return; } Uuid uuid = from_java_uuid(uuid_msb, uuid_lsb); sGattIf->client->read_using_characteristic_uuid(conn_id, uuid, s_handle, e_handle, authReq); } static void gattClientReadDescriptorNative(JNIEnv* /* env */, jobject /* object */, jint conn_id, jint handle, jint authReq) { if (!sGattIf) { return; } sGattIf->client->read_descriptor(conn_id, handle, authReq); } static void gattClientWriteCharacteristicNative(JNIEnv* env, jobject /* object */, jint conn_id, jint handle, jint write_type, jint auth_req, jbyteArray value) { if (!sGattIf) { return; } if (value == NULL) { log::warn("gattClientWriteCharacteristicNative() ignoring NULL array"); return; } uint16_t len = (uint16_t)env->GetArrayLength(value); jbyte* p_value = env->GetByteArrayElements(value, NULL); if (p_value == NULL) { return; } sGattIf->client->write_characteristic(conn_id, handle, write_type, auth_req, reinterpret_cast(p_value), len); env->ReleaseByteArrayElements(value, p_value, 0); } static void gattClientExecuteWriteNative(JNIEnv* /* env */, jobject /* object */, jint conn_id, jboolean execute) { if (!sGattIf) { return; } sGattIf->client->execute_write(conn_id, execute ? 1 : 0); } static void gattClientWriteDescriptorNative(JNIEnv* env, jobject /* object */, jint conn_id, jint handle, jint auth_req, jbyteArray value) { if (!sGattIf) { return; } if (value == NULL) { log::warn("gattClientWriteDescriptorNative() ignoring NULL array"); return; } uint16_t len = (uint16_t)env->GetArrayLength(value); jbyte* p_value = env->GetByteArrayElements(value, NULL); if (p_value == NULL) { return; } sGattIf->client->write_descriptor(conn_id, handle, auth_req, reinterpret_cast(p_value), len); env->ReleaseByteArrayElements(value, p_value, 0); } static void gattClientRegisterForNotificationsNative(JNIEnv* env, jobject /* object */, jint clientIf, jstring address, jint handle, jboolean enable) { if (!sGattIf) { return; } RawAddress bd_addr = str2addr(env, address); if (enable) { sGattIf->client->register_for_notification(clientIf, bd_addr, handle); } else { sGattIf->client->deregister_for_notification(clientIf, bd_addr, handle); } } static void gattClientReadRemoteRssiNative(JNIEnv* env, jobject /* object */, jint clientif, jstring address) { if (!sGattIf) { return; } sGattIf->client->read_remote_rssi(clientif, str2addr(env, address)); } void set_scan_params_cmpl_cb(int client_if, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mScanCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mScanCallbacksObj, method_onScanParamSetupCompleted, status, client_if); } static void gattSetScanParametersNative(JNIEnv* /* env */, jobject /* object */, jint client_if, jint scan_interval_unit, jint scan_window_unit, jint scan_phy) { if (!sScanner) { return; } sScanner->SetScanParameters(client_if, /* use active scan */ 0x01, scan_interval_unit, scan_window_unit, scan_phy, base::Bind(&set_scan_params_cmpl_cb, client_if)); } void scan_filter_param_cb(uint8_t client_if, uint8_t avbl_space, uint8_t action, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mScanCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mScanCallbacksObj, method_onScanFilterParamsConfigured, action, status, client_if, avbl_space); } static void gattClientScanFilterParamAddNative(JNIEnv* env, jobject /* object */, jobject params) { if (!sScanner) { return; } const int add_scan_filter_params_action = 0; auto filt_params = std::make_unique(); jmethodID methodId = 0; ScopedLocalRef filtparam(env, env->GetObjectClass(params)); methodId = env->GetMethodID(filtparam.get(), "getClientIf", "()I"); uint8_t client_if = env->CallIntMethod(params, methodId); methodId = env->GetMethodID(filtparam.get(), "getFiltIndex", "()I"); uint8_t filt_index = env->CallIntMethod(params, methodId); methodId = env->GetMethodID(filtparam.get(), "getFeatSeln", "()I"); filt_params->feat_seln = env->CallIntMethod(params, methodId); methodId = env->GetMethodID(filtparam.get(), "getListLogicType", "()I"); filt_params->list_logic_type = env->CallIntMethod(params, methodId); methodId = env->GetMethodID(filtparam.get(), "getFiltLogicType", "()I"); filt_params->filt_logic_type = env->CallIntMethod(params, methodId); methodId = env->GetMethodID(filtparam.get(), "getDelyMode", "()I"); filt_params->dely_mode = env->CallIntMethod(params, methodId); methodId = env->GetMethodID(filtparam.get(), "getFoundTimeout", "()I"); filt_params->found_timeout = env->CallIntMethod(params, methodId); methodId = env->GetMethodID(filtparam.get(), "getLostTimeout", "()I"); filt_params->lost_timeout = env->CallIntMethod(params, methodId); methodId = env->GetMethodID(filtparam.get(), "getFoundTimeOutCnt", "()I"); filt_params->found_timeout_cnt = env->CallIntMethod(params, methodId); methodId = env->GetMethodID(filtparam.get(), "getNumOfTrackEntries", "()I"); filt_params->num_of_tracking_entries = env->CallIntMethod(params, methodId); methodId = env->GetMethodID(filtparam.get(), "getRSSIHighValue", "()I"); filt_params->rssi_high_thres = env->CallIntMethod(params, methodId); methodId = env->GetMethodID(filtparam.get(), "getRSSILowValue", "()I"); filt_params->rssi_low_thres = env->CallIntMethod(params, methodId); sScanner->ScanFilterParamSetup(client_if, add_scan_filter_params_action, filt_index, std::move(filt_params), base::Bind(&scan_filter_param_cb, client_if)); } static void gattClientScanFilterParamDeleteNative(JNIEnv* /* env */, jobject /* object */, jint client_if, jint filt_index) { if (!sScanner) { return; } const int delete_scan_filter_params_action = 1; sScanner->ScanFilterParamSetup(client_if, delete_scan_filter_params_action, filt_index, nullptr, base::Bind(&scan_filter_param_cb, client_if)); } static void gattClientScanFilterParamClearAllNative(JNIEnv* /* env */, jobject /* object */, jint client_if) { if (!sScanner) { return; } const int clear_scan_filter_params_action = 2; sScanner->ScanFilterParamSetup(client_if, clear_scan_filter_params_action, 0 /* index, unused */, nullptr, base::Bind(&scan_filter_param_cb, client_if)); } static void scan_filter_cfg_cb(uint8_t client_if, uint8_t filt_type, uint8_t avbl_space, uint8_t action, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mScanCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mScanCallbacksObj, method_onScanFilterConfig, action, status, client_if, filt_type, avbl_space); } static void gattClientScanFilterAddNative(JNIEnv* env, jobject /* object */, jint client_if, jobjectArray filters, jint filter_index) { if (!sScanner) { return; } jmethodID uuidGetMsb; jmethodID uuidGetLsb; const JNIJavaMethod javaMethods[] = { {"getMostSignificantBits", "()J", &uuidGetMsb}, {"getLeastSignificantBits", "()J", &uuidGetLsb}, }; GET_JAVA_METHODS(env, "java/util/UUID", javaMethods); std::vector native_filters; int numFilters = env->GetArrayLength(filters); if (numFilters == 0) { sScanner->ScanFilterAdd(filter_index, std::move(native_filters), base::Bind(&scan_filter_cfg_cb, client_if)); return; } jclass entryClazz = env->GetObjectClass(env->GetObjectArrayElement(filters, 0)); jfieldID typeFid = env->GetFieldID(entryClazz, "type", "B"); jfieldID addressFid = env->GetFieldID(entryClazz, "address", "Ljava/lang/String;"); jfieldID addrTypeFid = env->GetFieldID(entryClazz, "addr_type", "B"); jfieldID irkTypeFid = env->GetFieldID(entryClazz, "irk", "[B"); jfieldID uuidFid = env->GetFieldID(entryClazz, "uuid", "Ljava/util/UUID;"); jfieldID uuidMaskFid = env->GetFieldID(entryClazz, "uuid_mask", "Ljava/util/UUID;"); jfieldID nameFid = env->GetFieldID(entryClazz, "name", "Ljava/lang/String;"); jfieldID companyFid = env->GetFieldID(entryClazz, "company", "I"); jfieldID companyMaskFid = env->GetFieldID(entryClazz, "company_mask", "I"); jfieldID adTypeFid = env->GetFieldID(entryClazz, "ad_type", "I"); jfieldID dataFid = env->GetFieldID(entryClazz, "data", "[B"); jfieldID dataMaskFid = env->GetFieldID(entryClazz, "data_mask", "[B"); jfieldID orgFid = env->GetFieldID(entryClazz, "org_id", "I"); jfieldID TDSFlagsFid = env->GetFieldID(entryClazz, "tds_flags", "I"); jfieldID TDSFlagsMaskFid = env->GetFieldID(entryClazz, "tds_flags_mask", "I"); jfieldID metaDataTypeFid = env->GetFieldID(entryClazz, "meta_data_type", "I"); jfieldID metaDataFid = env->GetFieldID(entryClazz, "meta_data", "[B"); for (int i = 0; i < numFilters; ++i) { ApcfCommand curr{}; ScopedLocalRef current(env, env->GetObjectArrayElement(filters, i)); curr.type = env->GetByteField(current.get(), typeFid); ScopedLocalRef address(env, (jstring)env->GetObjectField(current.get(), addressFid)); if (address.get() != NULL) { curr.address = str2addr(env, address.get()); } curr.addr_type = env->GetByteField(current.get(), addrTypeFid); ScopedLocalRef irkByteArray( env, (jbyteArray)env->GetObjectField(current.get(), irkTypeFid)); if (irkByteArray.get() != nullptr) { int len = env->GetArrayLength(irkByteArray.get()); // IRK is 128 bits or 16 octets, set the bytes or zero it out if (len != 16) { log::error("Invalid IRK length '{}'; expected 16", len); jniThrowIOException(env, EINVAL); return; } jbyte* irkBytes = env->GetByteArrayElements(irkByteArray.get(), NULL); if (irkBytes == NULL) { jniThrowIOException(env, EINVAL); return; } for (int j = 0; j < len; j++) { curr.irk[j] = irkBytes[j]; } } ScopedLocalRef uuid(env, env->GetObjectField(current.get(), uuidFid)); if (uuid.get() != NULL) { jlong uuid_msb = env->CallLongMethod(uuid.get(), uuidGetMsb); jlong uuid_lsb = env->CallLongMethod(uuid.get(), uuidGetLsb); curr.uuid = from_java_uuid(uuid_msb, uuid_lsb); } ScopedLocalRef uuid_mask(env, env->GetObjectField(current.get(), uuidMaskFid)); if (uuid.get() != NULL) { jlong uuid_msb = env->CallLongMethod(uuid_mask.get(), uuidGetMsb); jlong uuid_lsb = env->CallLongMethod(uuid_mask.get(), uuidGetLsb); curr.uuid_mask = from_java_uuid(uuid_msb, uuid_lsb); } ScopedLocalRef name(env, (jstring)env->GetObjectField(current.get(), nameFid)); if (name.get() != NULL) { const char* c_name = env->GetStringUTFChars(name.get(), NULL); if (c_name != NULL && strlen(c_name) != 0) { curr.name = std::vector(c_name, c_name + strlen(c_name)); env->ReleaseStringUTFChars(name.get(), c_name); } } curr.company = env->GetIntField(current.get(), companyFid); curr.company_mask = env->GetIntField(current.get(), companyMaskFid); curr.ad_type = env->GetIntField(current.get(), adTypeFid); ScopedLocalRef data(env, (jbyteArray)env->GetObjectField(current.get(), dataFid)); if (data.get() != NULL) { jbyte* data_array = env->GetByteArrayElements(data.get(), 0); int data_len = env->GetArrayLength(data.get()); if (data_array && data_len) { curr.data = std::vector(data_array, data_array + data_len); env->ReleaseByteArrayElements(data.get(), data_array, JNI_ABORT); } } ScopedLocalRef data_mask( env, (jbyteArray)env->GetObjectField(current.get(), dataMaskFid)); if (data_mask.get() != NULL) { jbyte* data_array = env->GetByteArrayElements(data_mask.get(), 0); int data_len = env->GetArrayLength(data_mask.get()); if (data_array && data_len) { curr.data_mask = std::vector(data_array, data_array + data_len); env->ReleaseByteArrayElements(data_mask.get(), data_array, JNI_ABORT); } } curr.org_id = env->GetIntField(current.get(), orgFid); curr.tds_flags = env->GetIntField(current.get(), TDSFlagsFid); curr.tds_flags_mask = env->GetIntField(current.get(), TDSFlagsMaskFid); curr.meta_data_type = env->GetIntField(current.get(), metaDataTypeFid); ScopedLocalRef meta_data( env, (jbyteArray)env->GetObjectField(current.get(), metaDataFid)); if (meta_data.get() != NULL) { jbyte* data_array = env->GetByteArrayElements(meta_data.get(), 0); int data_len = env->GetArrayLength(meta_data.get()); if (data_array && data_len) { curr.meta_data = std::vector(data_array, data_array + data_len); env->ReleaseByteArrayElements(meta_data.get(), data_array, JNI_ABORT); } } native_filters.push_back(curr); } sScanner->ScanFilterAdd(filter_index, std::move(native_filters), base::Bind(&scan_filter_cfg_cb, client_if)); } static void gattClientScanFilterClearNative(JNIEnv* /* env */, jobject /* object */, jint client_if, jint filt_index) { if (!sScanner) { return; } sScanner->ScanFilterClear(filt_index, base::Bind(&scan_filter_cfg_cb, client_if)); } void scan_enable_cb(uint8_t client_if, uint8_t action, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mScanCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mScanCallbacksObj, method_onScanFilterEnableDisabled, action, status, client_if); } static void gattClientScanFilterEnableNative(JNIEnv* /* env */, jobject /* object */, jint client_if, jboolean enable) { if (!sScanner) { return; } sScanner->ScanFilterEnable(enable, base::Bind(&scan_enable_cb, client_if)); } void msft_monitor_add_cb(int filter_index, uint8_t monitor_handle, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mScanCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mScanCallbacksObj, method_onMsftAdvMonitorAdd, filter_index, monitor_handle, status); } void msft_monitor_remove_cb(int filter_index, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mScanCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mScanCallbacksObj, method_onMsftAdvMonitorRemove, filter_index, status); } void msft_monitor_enable_cb(uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mScanCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mScanCallbacksObj, method_onMsftAdvMonitorEnable, status); } static bool gattClientIsMsftSupportedNative(JNIEnv* /* env */, jobject /* object */) { return sScanner && sScanner->IsMsftSupported(); } static void gattClientMsftAdvMonitorAddNative(JNIEnv* env, jobject /* object*/, jobject msft_adv_monitor, jobjectArray msft_adv_monitor_patterns, jobject msft_adv_monitor_address, jint filter_index) { if (!sScanner) { return; } jclass msftAdvMonitorClazz = env->GetObjectClass(msft_adv_monitor); jfieldID rssiThresholdHighFid = env->GetFieldID(msftAdvMonitorClazz, "rssi_threshold_high", "B"); jfieldID rssiThresholdLowFid = env->GetFieldID(msftAdvMonitorClazz, "rssi_threshold_low", "B"); jfieldID rssiThresholdLowTimeIntervalFid = env->GetFieldID(msftAdvMonitorClazz, "rssi_threshold_low_time_interval", "B"); jfieldID rssiSamplingPeriodFid = env->GetFieldID(msftAdvMonitorClazz, "rssi_sampling_period", "B"); jfieldID conditionTypeFid = env->GetFieldID(msftAdvMonitorClazz, "condition_type", "B"); jclass msftAdvMonitorAddressClazz = env->GetObjectClass(msft_adv_monitor_address); jfieldID addrTypeFid = env->GetFieldID(msftAdvMonitorAddressClazz, "addr_type", "B"); jfieldID bdAddrFid = env->GetFieldID(msftAdvMonitorAddressClazz, "bd_addr", "Ljava/lang/String;"); MsftAdvMonitor native_msft_adv_monitor{}; ScopedLocalRef msft_adv_monitor_object(env, msft_adv_monitor); native_msft_adv_monitor.rssi_threshold_high = env->GetByteField(msft_adv_monitor_object.get(), rssiThresholdHighFid); native_msft_adv_monitor.rssi_threshold_low = env->GetByteField(msft_adv_monitor_object.get(), rssiThresholdLowFid); native_msft_adv_monitor.rssi_threshold_low_time_interval = env->GetByteField(msft_adv_monitor_object.get(), rssiThresholdLowTimeIntervalFid); native_msft_adv_monitor.rssi_sampling_period = env->GetByteField(msft_adv_monitor_object.get(), rssiSamplingPeriodFid); native_msft_adv_monitor.condition_type = env->GetByteField(msft_adv_monitor_object.get(), conditionTypeFid); MsftAdvMonitorAddress native_msft_adv_monitor_address{}; ScopedLocalRef msft_adv_monitor_address_object(env, msftAdvMonitorAddressClazz); native_msft_adv_monitor_address.addr_type = env->GetByteField(msft_adv_monitor_address_object.get(), addrTypeFid); native_msft_adv_monitor_address.bd_addr = str2addr( env, (jstring)env->GetObjectField(msft_adv_monitor_address_object.get(), bdAddrFid)); native_msft_adv_monitor.addr_info = native_msft_adv_monitor_address; int numPatterns = env->GetArrayLength(msft_adv_monitor_patterns); if (numPatterns == 0) { sScanner->MsftAdvMonitorAdd(std::move(native_msft_adv_monitor), base::Bind(&msft_monitor_add_cb, filter_index)); return; } jclass msftAdvMonitorPatternClazz = env->GetObjectClass(env->GetObjectArrayElement(msft_adv_monitor_patterns, 0)); jfieldID adTypeFid = env->GetFieldID(msftAdvMonitorPatternClazz, "ad_type", "B"); jfieldID startByteFid = env->GetFieldID(msftAdvMonitorPatternClazz, "start_byte", "B"); jfieldID patternFid = env->GetFieldID(msftAdvMonitorPatternClazz, "pattern", "[B"); std::vector patterns; for (int i = 0; i < numPatterns; i++) { MsftAdvMonitorPattern native_msft_adv_monitor_pattern{}; ScopedLocalRef msft_adv_monitor_pattern_object( env, env->GetObjectArrayElement(msft_adv_monitor_patterns, i)); native_msft_adv_monitor_pattern.ad_type = env->GetByteField(msft_adv_monitor_pattern_object.get(), adTypeFid); native_msft_adv_monitor_pattern.start_byte = env->GetByteField(msft_adv_monitor_pattern_object.get(), startByteFid); ScopedLocalRef patternByteArray( env, (jbyteArray)env->GetObjectField(msft_adv_monitor_pattern_object.get(), patternFid)); if (patternByteArray.get() != nullptr) { jbyte* patternBytes = env->GetByteArrayElements(patternByteArray.get(), NULL); if (patternBytes == NULL) { jniThrowIOException(env, EINVAL); return; } for (int j = 0; j < env->GetArrayLength(patternByteArray.get()); j++) { native_msft_adv_monitor_pattern.pattern.push_back(patternBytes[j]); } } patterns.push_back(native_msft_adv_monitor_pattern); } native_msft_adv_monitor.patterns = patterns; sScanner->MsftAdvMonitorAdd(std::move(native_msft_adv_monitor), base::Bind(&msft_monitor_add_cb, filter_index)); } static void gattClientMsftAdvMonitorRemoveNative(JNIEnv* /* env */, jobject /* object */, int filter_index, int monitor_handle) { if (!sScanner) { return; } sScanner->MsftAdvMonitorRemove(monitor_handle, base::Bind(&msft_monitor_remove_cb, filter_index)); } static void gattClientMsftAdvMonitorEnableNative(JNIEnv* /* env */, jobject /* object */, jboolean enable) { if (!sScanner) { return; } sScanner->MsftAdvMonitorEnable(enable, base::Bind(&msft_monitor_enable_cb)); } static void gattClientConfigureMTUNative(JNIEnv* /* env */, jobject /* object */, jint conn_id, jint mtu) { if (!sGattIf) { return; } sGattIf->client->configure_mtu(conn_id, mtu); } static void gattConnectionParameterUpdateNative(JNIEnv* env, jobject /* object */, jint /* client_if */, jstring address, jint min_interval, jint max_interval, jint latency, jint timeout, jint min_ce_len, jint max_ce_len) { if (!sGattIf) { return; } sGattIf->client->conn_parameter_update(str2addr(env, address), min_interval, max_interval, latency, timeout, (uint16_t)min_ce_len, (uint16_t)max_ce_len); } static void gattSubrateRequestNative(JNIEnv* env, jobject /* object */, jint /* client_if */, jstring address, jint subrate_min, jint subrate_max, jint max_latency, jint cont_num, jint sup_timeout) { if (!sGattIf) { return; } sGattIf->client->subrate_request(str2addr(env, address), subrate_min, subrate_max, max_latency, cont_num, sup_timeout); } void batchscan_cfg_storage_cb(uint8_t client_if, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mScanCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mScanCallbacksObj, method_onBatchScanStorageConfigured, status, client_if); } static void gattClientConfigBatchScanStorageNative(JNIEnv* /* env */, jobject /* object */, jint client_if, jint max_full_reports_percent, jint max_trunc_reports_percent, jint notify_threshold_level_percent) { if (!sScanner) { return; } sScanner->BatchscanConfigStorage(client_if, max_full_reports_percent, max_trunc_reports_percent, notify_threshold_level_percent, base::Bind(&batchscan_cfg_storage_cb, client_if)); } void batchscan_enable_cb(uint8_t client_if, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mScanCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mScanCallbacksObj, method_onBatchScanStartStopped, 0 /* unused */, status, client_if); } static void gattClientStartBatchScanNative(JNIEnv* /* env */, jobject /* object */, jint client_if, jint scan_mode, jint scan_interval_unit, jint scan_window_unit, jint addr_type, jint discard_rule) { if (!sScanner) { return; } sScanner->BatchscanEnable(scan_mode, scan_interval_unit, scan_window_unit, addr_type, discard_rule, base::Bind(&batchscan_enable_cb, client_if)); } static void gattClientStopBatchScanNative(JNIEnv* /* env */, jobject /* object */, jint client_if) { if (!sScanner) { return; } sScanner->BatchscanDisable(base::Bind(&batchscan_enable_cb, client_if)); } static void gattClientReadScanReportsNative(JNIEnv* /* env */, jobject /* object */, jint client_if, jint scan_type) { if (!sScanner) { return; } sScanner->BatchscanReadReports(client_if, scan_type); } /** * Native server functions */ static void gattServerRegisterAppNative(JNIEnv* /* env */, jobject /* object */, jlong app_uuid_lsb, jlong app_uuid_msb, jboolean eatt_support) { if (!sGattIf) { return; } Uuid uuid = from_java_uuid(app_uuid_msb, app_uuid_lsb); sGattIf->server->register_server(uuid, eatt_support); } static void gattServerUnregisterAppNative(JNIEnv* /* env */, jobject /* object */, jint serverIf) { if (!sGattIf) { return; } bluetooth::gatt::close_server(serverIf); sGattIf->server->unregister_server(serverIf); } static void gattServerConnectNative(JNIEnv* env, jobject /* object */, jint server_if, jstring address, jint addr_type, jboolean is_direct, jint transport) { if (!sGattIf) { return; } RawAddress bd_addr = str2addr(env, address); sGattIf->server->connect(server_if, bd_addr, addr_type, is_direct, transport); } static void gattServerDisconnectNative(JNIEnv* env, jobject /* object */, jint serverIf, jstring address, jint conn_id) { if (!sGattIf) { return; } sGattIf->server->disconnect(serverIf, str2addr(env, address), conn_id); } static void gattServerSetPreferredPhyNative(JNIEnv* env, jobject /* object */, jint /* serverIf */, jstring address, jint tx_phy, jint rx_phy, jint phy_options) { if (!sGattIf) { return; } RawAddress bda = str2addr(env, address); sGattIf->server->set_preferred_phy(bda, tx_phy, rx_phy, phy_options); } static void readServerPhyCb(uint8_t serverIf, RawAddress bda, uint8_t tx_phy, uint8_t rx_phy, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mCallbacksObj) { return; } ScopedLocalRef address(sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), &bda)); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServerPhyRead, serverIf, address.get(), tx_phy, rx_phy, status); } static void gattServerReadPhyNative(JNIEnv* env, jobject /* object */, jint serverIf, jstring address) { if (!sGattIf) { return; } RawAddress bda = str2addr(env, address); sGattIf->server->read_phy(bda, base::Bind(&readServerPhyCb, serverIf, bda)); } static void gattServerAddServiceNative(JNIEnv* env, jobject /* object */, jint server_if, jobject gatt_db_elements) { if (!sGattIf) { return; } jmethodID arrayGet; jmethodID arraySize; const JNIJavaMethod javaListMethods[] = { {"get", "(I)Ljava/lang/Object;", &arrayGet}, {"size", "()I", &arraySize}, }; GET_JAVA_METHODS(env, "java/util/List", javaListMethods); int count = env->CallIntMethod(gatt_db_elements, arraySize); std::vector db; jmethodID uuidGetMsb; jmethodID uuidGetLsb; const JNIJavaMethod javaUuidMethods[] = { {"getMostSignificantBits", "()J", &uuidGetMsb}, {"getLeastSignificantBits", "()J", &uuidGetLsb}, }; GET_JAVA_METHODS(env, "java/util/UUID", javaUuidMethods); jobject objectForClass = env->CallObjectMethod(mCallbacksObj, method_getSampleGattDbElement); jclass gattDbElementClazz = env->GetObjectClass(objectForClass); for (int i = 0; i < count; i++) { btgatt_db_element_t curr; jint index = i; ScopedLocalRef element(env, env->CallObjectMethod(gatt_db_elements, arrayGet, index)); jfieldID fid; fid = env->GetFieldID(gattDbElementClazz, "id", "I"); curr.id = env->GetIntField(element.get(), fid); fid = env->GetFieldID(gattDbElementClazz, "uuid", "Ljava/util/UUID;"); ScopedLocalRef uuid(env, env->GetObjectField(element.get(), fid)); if (uuid.get() != NULL) { jlong uuid_msb = env->CallLongMethod(uuid.get(), uuidGetMsb); jlong uuid_lsb = env->CallLongMethod(uuid.get(), uuidGetLsb); curr.uuid = from_java_uuid(uuid_msb, uuid_lsb); } fid = env->GetFieldID(gattDbElementClazz, "type", "I"); curr.type = (bt_gatt_db_attribute_type_t)env->GetIntField(element.get(), fid); fid = env->GetFieldID(gattDbElementClazz, "attributeHandle", "I"); curr.attribute_handle = env->GetIntField(element.get(), fid); fid = env->GetFieldID(gattDbElementClazz, "startHandle", "I"); curr.start_handle = env->GetIntField(element.get(), fid); fid = env->GetFieldID(gattDbElementClazz, "endHandle", "I"); curr.end_handle = env->GetIntField(element.get(), fid); fid = env->GetFieldID(gattDbElementClazz, "properties", "I"); curr.properties = env->GetIntField(element.get(), fid); fid = env->GetFieldID(gattDbElementClazz, "permissions", "I"); curr.permissions = env->GetIntField(element.get(), fid); db.push_back(curr); } sGattIf->server->add_service(server_if, db.data(), db.size()); } static void gattServerStopServiceNative(JNIEnv* /* env */, jobject /* object */, jint server_if, jint svc_handle) { if (!sGattIf) { return; } sGattIf->server->stop_service(server_if, svc_handle); } static void gattServerDeleteServiceNative(JNIEnv* /* env */, jobject /* object */, jint server_if, jint svc_handle) { if (!sGattIf) { return; } sGattIf->server->delete_service(server_if, svc_handle); } static void gattServerSendIndicationNative(JNIEnv* env, jobject /* object */, jint server_if, jint attr_handle, jint conn_id, jbyteArray val) { if (!sGattIf) { return; } jbyte* array = env->GetByteArrayElements(val, 0); int val_len = env->GetArrayLength(val); if (bluetooth::gatt::is_connection_isolated(conn_id)) { auto data = ::rust::Slice((uint8_t*)array, val_len); bluetooth::gatt::send_indication(server_if, attr_handle, conn_id, data); } else { sGattIf->server->send_indication(server_if, attr_handle, conn_id, /*confirm*/ 1, (uint8_t*)array, val_len); } env->ReleaseByteArrayElements(val, array, JNI_ABORT); } static void gattServerSendNotificationNative(JNIEnv* env, jobject /* object */, jint server_if, jint attr_handle, jint conn_id, jbyteArray val) { if (!sGattIf) { return; } jbyte* array = env->GetByteArrayElements(val, 0); int val_len = env->GetArrayLength(val); sGattIf->server->send_indication(server_if, attr_handle, conn_id, /*confirm*/ 0, (uint8_t*)array, val_len); env->ReleaseByteArrayElements(val, array, JNI_ABORT); } static void gattServerSendResponseNative(JNIEnv* env, jobject /* object */, jint server_if, jint conn_id, jint trans_id, jint status, jint handle, jint offset, jbyteArray val, jint auth_req) { if (!sGattIf) { return; } btgatt_response_t response; response.attr_value.handle = handle; response.attr_value.auth_req = auth_req; response.attr_value.offset = offset; response.attr_value.len = 0; if (val != NULL) { if (env->GetArrayLength(val) < GATT_MAX_ATTR_LEN) { response.attr_value.len = (uint16_t)env->GetArrayLength(val); } else { response.attr_value.len = GATT_MAX_ATTR_LEN; } jbyte* array = env->GetByteArrayElements(val, 0); for (int i = 0; i != response.attr_value.len; ++i) { response.attr_value.value[i] = (uint8_t)array[i]; } env->ReleaseByteArrayElements(val, array, JNI_ABORT); } if (bluetooth::gatt::is_connection_isolated(conn_id)) { auto data = ::rust::Slice(response.attr_value.value, response.attr_value.len); bluetooth::gatt::send_response(server_if, conn_id, trans_id, status, data); } else { sGattIf->server->send_response(conn_id, trans_id, status, response); } } static void advertiseInitializeNative(JNIEnv* env, jobject object) { std::unique_lock lock(callbacks_mutex); if (mAdvertiseCallbacksObj != NULL) { log::warn("Cleaning up Advertise callback object"); env->DeleteGlobalRef(mAdvertiseCallbacksObj); mAdvertiseCallbacksObj = NULL; } mAdvertiseCallbacksObj = env->NewGlobalRef(object); } static void advertiseCleanupNative(JNIEnv* env, jobject /* object */) { std::unique_lock lock(callbacks_mutex); if (mAdvertiseCallbacksObj != NULL) { env->DeleteGlobalRef(mAdvertiseCallbacksObj); mAdvertiseCallbacksObj = NULL; } } static uint32_t INTERVAL_MAX = 0xFFFFFF; // Always give controller 31.25ms difference between min and max static uint32_t INTERVAL_DELTA = 50; static AdvertiseParameters parseParams(JNIEnv* env, jobject i) { AdvertiseParameters p; jclass clazz = env->GetObjectClass(i); jmethodID methodId; methodId = env->GetMethodID(clazz, "isConnectable", "()Z"); jboolean isConnectable = env->CallBooleanMethod(i, methodId); methodId = env->GetMethodID(clazz, "isDiscoverable", "()Z"); jboolean isDiscoverable = env->CallBooleanMethod(i, methodId); methodId = env->GetMethodID(clazz, "isScannable", "()Z"); jboolean isScannable = env->CallBooleanMethod(i, methodId); methodId = env->GetMethodID(clazz, "isLegacy", "()Z"); jboolean isLegacy = env->CallBooleanMethod(i, methodId); methodId = env->GetMethodID(clazz, "isAnonymous", "()Z"); jboolean isAnonymous = env->CallBooleanMethod(i, methodId); methodId = env->GetMethodID(clazz, "includeTxPower", "()Z"); jboolean includeTxPower = env->CallBooleanMethod(i, methodId); methodId = env->GetMethodID(clazz, "getPrimaryPhy", "()I"); uint8_t primaryPhy = env->CallIntMethod(i, methodId); methodId = env->GetMethodID(clazz, "getSecondaryPhy", "()I"); uint8_t secondaryPhy = env->CallIntMethod(i, methodId); methodId = env->GetMethodID(clazz, "getInterval", "()I"); uint32_t interval = env->CallIntMethod(i, methodId); methodId = env->GetMethodID(clazz, "getTxPowerLevel", "()I"); int8_t txPowerLevel = env->CallIntMethod(i, methodId); methodId = env->GetMethodID(clazz, "getOwnAddressType", "()I"); int8_t ownAddressType = env->CallIntMethod(i, methodId); methodId = env->GetMethodID(clazz, "isDirected", "()Z"); jboolean isDirected = env->CallBooleanMethod(i, methodId); methodId = env->GetMethodID(clazz, "isHighDutyCycle", "()Z"); jboolean isHighDutyCycle = env->CallBooleanMethod(i, methodId); methodId = env->GetMethodID(clazz, "getPeerAddress", "()Ljava/lang/String;"); jstring peerAddress = (jstring)env->CallObjectMethod(i, methodId); methodId = env->GetMethodID(clazz, "getPeerAddressType", "()I"); int8_t peerAddressType = env->CallIntMethod(i, methodId); uint16_t props = 0; if (isConnectable) { props |= 0x01; } if (isScannable) { props |= 0x02; } if (isDirected) { props |= 0x04; } if (isHighDutyCycle) { props |= 0x08; } if (isLegacy) { props |= 0x10; } if (isAnonymous) { props |= 0x20; } if (includeTxPower) { props |= 0x40; } if (interval > INTERVAL_MAX - INTERVAL_DELTA) { interval = INTERVAL_MAX - INTERVAL_DELTA; } p.advertising_event_properties = props; p.min_interval = interval; p.max_interval = interval + INTERVAL_DELTA; p.channel_map = 0x07; /* all channels */ p.tx_power = txPowerLevel; p.primary_advertising_phy = primaryPhy; p.secondary_advertising_phy = secondaryPhy; p.scan_request_notification_enable = false; p.own_address_type = ownAddressType; p.peer_address = str2addr(env, peerAddress); p.peer_address_type = peerAddressType; p.discoverable = isDiscoverable; return p; } static PeriodicAdvertisingParameters parsePeriodicParams(JNIEnv* env, jobject i) { PeriodicAdvertisingParameters p; if (i == NULL) { p.enable = false; return p; } jclass clazz = env->GetObjectClass(i); jmethodID methodId; methodId = env->GetMethodID(clazz, "getIncludeTxPower", "()Z"); jboolean includeTxPower = env->CallBooleanMethod(i, methodId); methodId = env->GetMethodID(clazz, "getInterval", "()I"); uint16_t interval = env->CallIntMethod(i, methodId); p.enable = true; p.include_adi = true; p.min_interval = interval; p.max_interval = interval + 16; /* 20ms difference betwen min and max */ uint16_t props = 0; if (includeTxPower) { props |= 0x40; } p.periodic_advertising_properties = props; return p; } static void ble_advertising_set_started_cb(int reg_id, int server_if, uint8_t advertiser_id, int8_t tx_power, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mAdvertiseCallbacksObj) { return; } // tie advertiser ID to server_if, once the advertisement has started if (status == 0 /* AdvertisingCallback::AdvertisingStatus::SUCCESS */ && server_if != 0) { bluetooth::gatt::associate_server_with_advertiser(server_if, advertiser_id); } sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj, method_onAdvertisingSetStarted, reg_id, advertiser_id, tx_power, status); } static void ble_advertising_set_timeout_cb(uint8_t advertiser_id, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mAdvertiseCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj, method_onAdvertisingEnabled, advertiser_id, false, status); } static void startAdvertisingSetNative(JNIEnv* env, jobject /* object */, jobject parameters, jbyteArray adv_data, jbyteArray scan_resp, jobject periodic_parameters, jbyteArray periodic_data, jint duration, jint maxExtAdvEvents, jint reg_id, jint server_if) { if (!sGattIf) { return; } jbyte* scan_resp_data = env->GetByteArrayElements(scan_resp, NULL); uint16_t scan_resp_len = (uint16_t)env->GetArrayLength(scan_resp); std::vector scan_resp_vec(scan_resp_data, scan_resp_data + scan_resp_len); env->ReleaseByteArrayElements(scan_resp, scan_resp_data, JNI_ABORT); AdvertiseParameters params = parseParams(env, parameters); PeriodicAdvertisingParameters periodicParams = parsePeriodicParams(env, periodic_parameters); jbyte* adv_data_data = env->GetByteArrayElements(adv_data, NULL); uint16_t adv_data_len = (uint16_t)env->GetArrayLength(adv_data); std::vector data_vec(adv_data_data, adv_data_data + adv_data_len); env->ReleaseByteArrayElements(adv_data, adv_data_data, JNI_ABORT); jbyte* periodic_data_data = env->GetByteArrayElements(periodic_data, NULL); uint16_t periodic_data_len = (uint16_t)env->GetArrayLength(periodic_data); std::vector periodic_data_vec(periodic_data_data, periodic_data_data + periodic_data_len); env->ReleaseByteArrayElements(periodic_data, periodic_data_data, JNI_ABORT); sGattIf->advertiser->StartAdvertisingSet( kAdvertiserClientIdJni, reg_id, base::Bind(&ble_advertising_set_started_cb, reg_id, server_if), params, data_vec, scan_resp_vec, periodicParams, periodic_data_vec, duration, maxExtAdvEvents, base::Bind(ble_advertising_set_timeout_cb)); } static void stopAdvertisingSetNative(JNIEnv* /* env */, jobject /* object */, jint advertiser_id) { if (!sGattIf) { return; } bluetooth::gatt::clear_advertiser(advertiser_id); sGattIf->advertiser->Unregister(advertiser_id); } static void getOwnAddressCb(uint8_t advertiser_id, uint8_t address_type, RawAddress address) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mAdvertiseCallbacksObj) { return; } ScopedLocalRef addr(sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), &address)); sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj, method_onOwnAddressRead, advertiser_id, address_type, addr.get()); } static void getOwnAddressNative(JNIEnv* /* env */, jobject /* object */, jint advertiser_id) { if (!sGattIf) { return; } sGattIf->advertiser->GetOwnAddress(advertiser_id, base::Bind(&getOwnAddressCb, advertiser_id)); } static void callJniCallback(jmethodID method, uint8_t advertiser_id, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mAdvertiseCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj, method, advertiser_id, status); } static void enableSetCb(uint8_t advertiser_id, bool enable, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mAdvertiseCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj, method_onAdvertisingEnabled, advertiser_id, enable, status); } static void enableAdvertisingSetNative(JNIEnv* /* env */, jobject /* object */, jint advertiser_id, jboolean enable, jint duration, jint maxExtAdvEvents) { if (!sGattIf) { return; } sGattIf->advertiser->Enable(advertiser_id, enable, base::Bind(&enableSetCb, advertiser_id, enable), duration, maxExtAdvEvents, base::Bind(&enableSetCb, advertiser_id, false)); } static void setAdvertisingDataNative(JNIEnv* env, jobject /* object */, jint advertiser_id, jbyteArray data) { if (!sGattIf) { return; } sGattIf->advertiser->SetData( advertiser_id, false, toVector(env, data), base::Bind(&callJniCallback, method_onAdvertisingDataSet, advertiser_id)); } static void setScanResponseDataNative(JNIEnv* env, jobject /* object */, jint advertiser_id, jbyteArray data) { if (!sGattIf) { return; } sGattIf->advertiser->SetData( advertiser_id, true, toVector(env, data), base::Bind(&callJniCallback, method_onScanResponseDataSet, advertiser_id)); } static void setAdvertisingParametersNativeCb(uint8_t advertiser_id, uint8_t status, int8_t tx_power) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mAdvertiseCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj, method_onAdvertisingParametersUpdated, advertiser_id, tx_power, status); } static void setAdvertisingParametersNative(JNIEnv* env, jobject /* object */, jint advertiser_id, jobject parameters) { if (!sGattIf) { return; } AdvertiseParameters params = parseParams(env, parameters); sGattIf->advertiser->SetParameters(advertiser_id, params, base::Bind(&setAdvertisingParametersNativeCb, advertiser_id)); } static void setPeriodicAdvertisingParametersNative(JNIEnv* env, jobject /* object */, jint advertiser_id, jobject periodic_parameters) { if (!sGattIf) { return; } PeriodicAdvertisingParameters periodicParams = parsePeriodicParams(env, periodic_parameters); sGattIf->advertiser->SetPeriodicAdvertisingParameters( advertiser_id, periodicParams, base::Bind(&callJniCallback, method_onPeriodicAdvertisingParametersUpdated, advertiser_id)); } static void setPeriodicAdvertisingDataNative(JNIEnv* env, jobject /* object */, jint advertiser_id, jbyteArray data) { if (!sGattIf) { return; } sGattIf->advertiser->SetPeriodicAdvertisingData( advertiser_id, toVector(env, data), base::Bind(&callJniCallback, method_onPeriodicAdvertisingDataSet, advertiser_id)); } static void enablePeriodicSetCb(uint8_t advertiser_id, bool enable, uint8_t status) { std::shared_lock lock(callbacks_mutex); CallbackEnv sCallbackEnv(__func__); if (!sCallbackEnv.valid() || !mAdvertiseCallbacksObj) { return; } sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj, method_onPeriodicAdvertisingEnabled, advertiser_id, enable, status); } static void setPeriodicAdvertisingEnableNative(JNIEnv* /* env */, jobject /* object */, jint advertiser_id, jboolean enable) { if (!sGattIf) { return; } sGattIf->advertiser->SetPeriodicAdvertisingEnable( advertiser_id, enable, true /*include_adi*/, base::Bind(&enablePeriodicSetCb, advertiser_id, enable)); } static void periodicScanInitializeNative(JNIEnv* env, jobject object) { std::unique_lock lock(callbacks_mutex); if (mPeriodicScanCallbacksObj != NULL) { log::warn("Cleaning up periodic scan callback object"); env->DeleteGlobalRef(mPeriodicScanCallbacksObj); mPeriodicScanCallbacksObj = NULL; } mPeriodicScanCallbacksObj = env->NewGlobalRef(object); } static void periodicScanCleanupNative(JNIEnv* env, jobject /* object */) { std::unique_lock lock(callbacks_mutex); if (mPeriodicScanCallbacksObj != NULL) { env->DeleteGlobalRef(mPeriodicScanCallbacksObj); mPeriodicScanCallbacksObj = NULL; } } static void scanInitializeNative(JNIEnv* env, jobject object) { std::unique_lock lock(callbacks_mutex); sScanner = bluetooth::shim::get_ble_scanner_instance(); sScanner->RegisterCallbacks(JniScanningCallbacks::GetInstance()); if (mScanCallbacksObj != NULL) { log::warn("Cleaning up scan callback object"); env->DeleteGlobalRef(mScanCallbacksObj); mScanCallbacksObj = NULL; } mScanCallbacksObj = env->NewGlobalRef(object); } static void scanCleanupNative(JNIEnv* env, jobject /* object */) { std::unique_lock lock(callbacks_mutex); if (mScanCallbacksObj != NULL) { env->DeleteGlobalRef(mScanCallbacksObj); mScanCallbacksObj = NULL; } if (sScanner != NULL) { sScanner = NULL; } } static void startSyncNative(JNIEnv* env, jobject /* object */, jint sid, jstring address, jint skip, jint timeout, jint reg_id) { if (!sScanner) { return; } sScanner->StartSync(sid, str2addr(env, address), skip, timeout, reg_id); } static void stopSyncNative(JNIEnv* /* env */, jobject /* object */, jint sync_handle) { if (!sScanner) { return; } sScanner->StopSync(sync_handle); } static void cancelSyncNative(JNIEnv* env, jobject /* object */, jint sid, jstring address) { if (!sScanner) { return; } sScanner->CancelCreateSync(sid, str2addr(env, address)); } static void syncTransferNative(JNIEnv* env, jobject /* object */, jint pa_source, jstring addr, jint service_data, jint sync_handle) { if (!sScanner) { return; } sScanner->TransferSync(str2addr(env, addr), service_data, sync_handle, pa_source); } static void transferSetInfoNative(JNIEnv* env, jobject /* object */, jint pa_source, jstring addr, jint service_data, jint adv_handle) { if (!sScanner) { return; } sScanner->TransferSetInfo(str2addr(env, addr), service_data, adv_handle, pa_source); } static void gattTestNative(JNIEnv* env, jobject /* object */, jint command, jlong uuid1_lsb, jlong uuid1_msb, jstring bda1, jint p1, jint p2, jint p3, jint p4, jint p5) { if (!sGattIf) { return; } RawAddress bt_bda1 = str2addr(env, bda1); Uuid uuid1 = from_java_uuid(uuid1_msb, uuid1_lsb); btgatt_test_params_t params; params.bda1 = &bt_bda1; params.uuid1 = &uuid1; params.u1 = p1; params.u2 = p2; params.u3 = p3; params.u4 = p4; params.u5 = p5; sGattIf->client->test_command(command, params); } static void distanceMeasurementInitializeNative(JNIEnv* env, jobject object) { std::unique_lock lock(callbacks_mutex); if (mDistanceMeasurementCallbacksObj != NULL) { log::warn("Cleaning up Advertise callback object"); env->DeleteGlobalRef(mDistanceMeasurementCallbacksObj); mDistanceMeasurementCallbacksObj = NULL; } mDistanceMeasurementCallbacksObj = env->NewGlobalRef(object); } static void distanceMeasurementCleanupNative(JNIEnv* env, jobject /* object */) { std::unique_lock lock(callbacks_mutex); if (mDistanceMeasurementCallbacksObj != NULL) { env->DeleteGlobalRef(mDistanceMeasurementCallbacksObj); mDistanceMeasurementCallbacksObj = NULL; } } static void startDistanceMeasurementNative(JNIEnv* env, jobject /* object */, jstring address, jint interval, jint method) { if (!sGattIf) { return; } sGattIf->distance_measurement_manager->StartDistanceMeasurement(str2addr(env, address), interval, method); } static void stopDistanceMeasurementNative(JNIEnv* env, jobject /* object */, jstring address, jint method) { if (!sGattIf) { return; } sGattIf->distance_measurement_manager->StopDistanceMeasurement(str2addr(env, address), method); } /** * JNI function definitions */ // JNI functions defined in ScanNativeInterface class. static int register_com_android_bluetooth_gatt_scan(JNIEnv* env) { const JNINativeMethod methods[] = { {"initializeNative", "()V", (void*)scanInitializeNative}, {"cleanupNative", "()V", (void*)scanCleanupNative}, {"registerScannerNative", "(JJ)V", (void*)registerScannerNative}, {"unregisterScannerNative", "(I)V", (void*)unregisterScannerNative}, {"gattClientScanNative", "(Z)V", (void*)gattClientScanNative}, // Batch scan JNI functions. {"gattClientConfigBatchScanStorageNative", "(IIII)V", (void*)gattClientConfigBatchScanStorageNative}, {"gattClientStartBatchScanNative", "(IIIIII)V", (void*)gattClientStartBatchScanNative}, {"gattClientStopBatchScanNative", "(I)V", (void*)gattClientStopBatchScanNative}, {"gattClientReadScanReportsNative", "(II)V", (void*)gattClientReadScanReportsNative}, // Scan filter JNI functions. {"gattClientScanFilterParamAddNative", "(Lcom/android/bluetooth/gatt/FilterParams;)V", (void*)gattClientScanFilterParamAddNative}, {"gattClientScanFilterParamDeleteNative", "(II)V", (void*)gattClientScanFilterParamDeleteNative}, {"gattClientScanFilterParamClearAllNative", "(I)V", (void*)gattClientScanFilterParamClearAllNative}, {"gattClientScanFilterAddNative", "(I[Lcom/android/bluetooth/le_scan/ScanFilterQueue$Entry;I)V", (void*)gattClientScanFilterAddNative}, {"gattClientScanFilterClearNative", "(II)V", (void*)gattClientScanFilterClearNative}, {"gattClientScanFilterEnableNative", "(IZ)V", (void*)gattClientScanFilterEnableNative}, {"gattSetScanParametersNative", "(IIII)V", (void*)gattSetScanParametersNative}, // MSFT HCI Extension functions. {"gattClientIsMsftSupportedNative", "()Z", (bool*)gattClientIsMsftSupportedNative}, {"gattClientMsftAdvMonitorAddNative", "(Lcom/android/bluetooth/le_scan/MsftAdvMonitor$Monitor;[Lcom/android/bluetooth/le_scan/" "MsftAdvMonitor$Pattern;Lcom/android/bluetooth/le_scan/MsftAdvMonitor$Address;I)V", (void*)gattClientMsftAdvMonitorAddNative}, {"gattClientMsftAdvMonitorRemoveNative", "(II)V", (void*)gattClientMsftAdvMonitorRemoveNative}, {"gattClientMsftAdvMonitorEnableNative", "(Z)V", (void*)gattClientMsftAdvMonitorEnableNative}, }; const int result = REGISTER_NATIVE_METHODS( env, "com/android/bluetooth/le_scan/ScanNativeInterface", methods); if (result != 0) { return result; } const JNIJavaMethod javaMethods[] = { // Client callbacks {"onScannerRegistered", "(IIJJ)V", &method_onScannerRegistered}, {"onScanResult", "(IILjava/lang/String;IIIIII[BLjava/lang/String;)V", &method_onScanResult}, {"onScanFilterConfig", "(IIIII)V", &method_onScanFilterConfig}, {"onScanFilterParamsConfigured", "(IIII)V", &method_onScanFilterParamsConfigured}, {"onScanFilterEnableDisabled", "(III)V", &method_onScanFilterEnableDisabled}, {"onBatchScanStorageConfigured", "(II)V", &method_onBatchScanStorageConfigured}, {"onBatchScanStartStopped", "(III)V", &method_onBatchScanStartStopped}, {"onBatchScanReports", "(IIII[B)V", &method_onBatchScanReports}, {"onBatchScanThresholdCrossed", "(I)V", &method_onBatchScanThresholdCrossed}, {"createOnTrackAdvFoundLostObject", "(II[BI[BIIILjava/lang/String;IIII)" "Lcom/android/bluetooth/le_scan/AdvtFilterOnFoundOnLostInfo;", &method_createOnTrackAdvFoundLostObject}, {"onTrackAdvFoundLost", "(Lcom/android/bluetooth/le_scan/AdvtFilterOnFoundOnLostInfo;)V", &method_onTrackAdvFoundLost}, {"onScanParamSetupCompleted", "(II)V", &method_onScanParamSetupCompleted}, {"onMsftAdvMonitorAdd", "(III)V", &method_onMsftAdvMonitorAdd}, {"onMsftAdvMonitorRemove", "(II)V", &method_onMsftAdvMonitorRemove}, {"onMsftAdvMonitorEnable", "(I)V", &method_onMsftAdvMonitorEnable}, }; GET_JAVA_METHODS(env, "com/android/bluetooth/le_scan/ScanNativeInterface", javaMethods); return 0; } // JNI functions defined in AdvertiseManagerNativeInterface class. static int register_com_android_bluetooth_gatt_advertise_manager(JNIEnv* env) { const JNINativeMethod methods[] = { {"initializeNative", "()V", (void*)advertiseInitializeNative}, {"cleanupNative", "()V", (void*)advertiseCleanupNative}, {"startAdvertisingSetNative", "(Landroid/bluetooth/le/AdvertisingSetParameters;" "[B[BLandroid/bluetooth/le/PeriodicAdvertisingParameters;[BIIII)V", (void*)startAdvertisingSetNative}, {"stopAdvertisingSetNative", "(I)V", (void*)stopAdvertisingSetNative}, {"getOwnAddressNative", "(I)V", (void*)getOwnAddressNative}, {"enableAdvertisingSetNative", "(IZII)V", (void*)enableAdvertisingSetNative}, {"setAdvertisingDataNative", "(I[B)V", (void*)setAdvertisingDataNative}, {"setScanResponseDataNative", "(I[B)V", (void*)setScanResponseDataNative}, {"setAdvertisingParametersNative", "(ILandroid/bluetooth/le/AdvertisingSetParameters;)V", (void*)setAdvertisingParametersNative}, {"setPeriodicAdvertisingParametersNative", "(ILandroid/bluetooth/le/PeriodicAdvertisingParameters;)V", (void*)setPeriodicAdvertisingParametersNative}, {"setPeriodicAdvertisingDataNative", "(I[B)V", (void*)setPeriodicAdvertisingDataNative}, {"setPeriodicAdvertisingEnableNative", "(IZ)V", (void*)setPeriodicAdvertisingEnableNative}, }; const int result = REGISTER_NATIVE_METHODS( env, "com/android/bluetooth/gatt/AdvertiseManagerNativeInterface", methods); if (result != 0) { return result; } const JNIJavaMethod javaMethods[] = { {"onAdvertisingSetStarted", "(IIII)V", &method_onAdvertisingSetStarted}, {"onOwnAddressRead", "(IILjava/lang/String;)V", &method_onOwnAddressRead}, {"onAdvertisingEnabled", "(IZI)V", &method_onAdvertisingEnabled}, {"onAdvertisingDataSet", "(II)V", &method_onAdvertisingDataSet}, {"onScanResponseDataSet", "(II)V", &method_onScanResponseDataSet}, {"onAdvertisingParametersUpdated", "(III)V", &method_onAdvertisingParametersUpdated}, {"onPeriodicAdvertisingParametersUpdated", "(II)V", &method_onPeriodicAdvertisingParametersUpdated}, {"onPeriodicAdvertisingDataSet", "(II)V", &method_onPeriodicAdvertisingDataSet}, {"onPeriodicAdvertisingEnabled", "(IZI)V", &method_onPeriodicAdvertisingEnabled}, }; GET_JAVA_METHODS(env, "com/android/bluetooth/gatt/AdvertiseManagerNativeInterface", javaMethods); return 0; } // JNI functions defined in PeriodicScanNativeInterface class. static int register_com_android_bluetooth_gatt_periodic_scan(JNIEnv* env) { const JNINativeMethod methods[] = { {"initializeNative", "()V", (void*)periodicScanInitializeNative}, {"cleanupNative", "()V", (void*)periodicScanCleanupNative}, {"startSyncNative", "(ILjava/lang/String;III)V", (void*)startSyncNative}, {"stopSyncNative", "(I)V", (void*)stopSyncNative}, {"cancelSyncNative", "(ILjava/lang/String;)V", (void*)cancelSyncNative}, {"syncTransferNative", "(ILjava/lang/String;II)V", (void*)syncTransferNative}, {"transferSetInfoNative", "(ILjava/lang/String;II)V", (void*)transferSetInfoNative}, }; const int result = REGISTER_NATIVE_METHODS( env, "com/android/bluetooth/le_scan/PeriodicScanNativeInterface", methods); if (result != 0) { return result; } const JNIJavaMethod javaMethods[] = { {"onSyncStarted", "(IIIILjava/lang/String;III)V", &method_onSyncStarted}, {"onSyncReport", "(IIII[B)V", &method_onSyncReport}, {"onSyncLost", "(I)V", &method_onSyncLost}, {"onSyncTransferredCallback", "(IILjava/lang/String;)V", &method_onSyncTransferredCallback}, {"onBigInfoReport", "(IZ)V", &method_onBigInfoReport}, }; GET_JAVA_METHODS(env, "com/android/bluetooth/le_scan/PeriodicScanNativeInterface", javaMethods); return 0; } // JNI functions defined in DistanceMeasurementNativeInterface class. static int register_com_android_bluetooth_gatt_distance_measurement(JNIEnv* env) { const JNINativeMethod methods[] = { {"initializeNative", "()V", (void*)distanceMeasurementInitializeNative}, {"cleanupNative", "()V", (void*)distanceMeasurementCleanupNative}, {"startDistanceMeasurementNative", "(Ljava/lang/String;II)V", (void*)startDistanceMeasurementNative}, {"stopDistanceMeasurementNative", "(Ljava/lang/String;I)V", (void*)stopDistanceMeasurementNative}, }; const int result = REGISTER_NATIVE_METHODS( env, "com/android/bluetooth/gatt/DistanceMeasurementNativeInterface", methods); if (result != 0) { return result; } const JNIJavaMethod javaMethods[] = { {"onDistanceMeasurementStarted", "(Ljava/lang/String;I)V", &method_onDistanceMeasurementStarted}, {"onDistanceMeasurementStopped", "(Ljava/lang/String;II)V", &method_onDistanceMeasurementStopped}, {"onDistanceMeasurementResult", "(Ljava/lang/String;IIIIIIJII)V", &method_onDistanceMeasurementResult}, }; GET_JAVA_METHODS(env, "com/android/bluetooth/gatt/DistanceMeasurementNativeInterface", javaMethods); return 0; } // JNI functions defined in GattNativeInterface class. static int register_com_android_bluetooth_gatt_(JNIEnv* env) { const JNINativeMethod methods[] = { {"initializeNative", "()V", (void*)initializeNative}, {"cleanupNative", "()V", (void*)cleanupNative}, {"gattClientGetDeviceTypeNative", "(Ljava/lang/String;)I", (void*)gattClientGetDeviceTypeNative}, {"gattClientRegisterAppNative", "(JJZ)V", (void*)gattClientRegisterAppNative}, {"gattClientUnregisterAppNative", "(I)V", (void*)gattClientUnregisterAppNative}, {"gattClientConnectNative", "(ILjava/lang/String;IZIZII)V", (void*)gattClientConnectNative}, {"gattClientDisconnectNative", "(ILjava/lang/String;I)V", (void*)gattClientDisconnectNative}, {"gattClientSetPreferredPhyNative", "(ILjava/lang/String;III)V", (void*)gattClientSetPreferredPhyNative}, {"gattClientReadPhyNative", "(ILjava/lang/String;)V", (void*)gattClientReadPhyNative}, {"gattClientRefreshNative", "(ILjava/lang/String;)V", (void*)gattClientRefreshNative}, {"gattClientSearchServiceNative", "(IZJJ)V", (void*)gattClientSearchServiceNative}, {"gattClientDiscoverServiceByUuidNative", "(IJJ)V", (void*)gattClientDiscoverServiceByUuidNative}, {"gattClientGetGattDbNative", "(I)V", (void*)gattClientGetGattDbNative}, {"gattClientReadCharacteristicNative", "(III)V", (void*)gattClientReadCharacteristicNative}, {"gattClientReadUsingCharacteristicUuidNative", "(IJJIII)V", (void*)gattClientReadUsingCharacteristicUuidNative}, {"gattClientReadDescriptorNative", "(III)V", (void*)gattClientReadDescriptorNative}, {"gattClientWriteCharacteristicNative", "(IIII[B)V", (void*)gattClientWriteCharacteristicNative}, {"gattClientWriteDescriptorNative", "(III[B)V", (void*)gattClientWriteDescriptorNative}, {"gattClientExecuteWriteNative", "(IZ)V", (void*)gattClientExecuteWriteNative}, {"gattClientRegisterForNotificationsNative", "(ILjava/lang/String;IZ)V", (void*)gattClientRegisterForNotificationsNative}, {"gattClientReadRemoteRssiNative", "(ILjava/lang/String;)V", (void*)gattClientReadRemoteRssiNative}, {"gattClientConfigureMTUNative", "(II)V", (void*)gattClientConfigureMTUNative}, {"gattConnectionParameterUpdateNative", "(ILjava/lang/String;IIIIII)V", (void*)gattConnectionParameterUpdateNative}, {"gattServerRegisterAppNative", "(JJZ)V", (void*)gattServerRegisterAppNative}, {"gattServerUnregisterAppNative", "(I)V", (void*)gattServerUnregisterAppNative}, {"gattServerConnectNative", "(ILjava/lang/String;IZI)V", (void*)gattServerConnectNative}, {"gattServerDisconnectNative", "(ILjava/lang/String;I)V", (void*)gattServerDisconnectNative}, {"gattServerSetPreferredPhyNative", "(ILjava/lang/String;III)V", (void*)gattServerSetPreferredPhyNative}, {"gattServerReadPhyNative", "(ILjava/lang/String;)V", (void*)gattServerReadPhyNative}, {"gattServerAddServiceNative", "(ILjava/util/List;)V", (void*)gattServerAddServiceNative}, {"gattServerStopServiceNative", "(II)V", (void*)gattServerStopServiceNative}, {"gattServerDeleteServiceNative", "(II)V", (void*)gattServerDeleteServiceNative}, {"gattServerSendIndicationNative", "(III[B)V", (void*)gattServerSendIndicationNative}, {"gattServerSendNotificationNative", "(III[B)V", (void*)gattServerSendNotificationNative}, {"gattServerSendResponseNative", "(IIIIII[BI)V", (void*)gattServerSendResponseNative}, {"gattSubrateRequestNative", "(ILjava/lang/String;IIIII)V", (void*)gattSubrateRequestNative}, {"gattTestNative", "(IJJLjava/lang/String;IIIII)V", (void*)gattTestNative}, }; const int result = REGISTER_NATIVE_METHODS(env, "com/android/bluetooth/gatt/GattNativeInterface", methods); if (result != 0) { return result; } const JNIJavaMethod javaMethods[] = { // Client callbacks {"onClientRegistered", "(IIJJ)V", &method_onClientRegistered}, {"onConnected", "(IIILjava/lang/String;)V", &method_onConnected}, {"onDisconnected", "(IIILjava/lang/String;)V", &method_onDisconnected}, {"onReadCharacteristic", "(III[B)V", &method_onReadCharacteristic}, {"onWriteCharacteristic", "(III[B)V", &method_onWriteCharacteristic}, {"onExecuteCompleted", "(II)V", &method_onExecuteCompleted}, {"onSearchCompleted", "(II)V", &method_onSearchCompleted}, {"onReadDescriptor", "(III[B)V", &method_onReadDescriptor}, {"onWriteDescriptor", "(III[B)V", &method_onWriteDescriptor}, {"onNotify", "(ILjava/lang/String;IZ[B)V", &method_onNotify}, {"onRegisterForNotifications", "(IIII)V", &method_onRegisterForNotifications}, {"onReadRemoteRssi", "(ILjava/lang/String;II)V", &method_onReadRemoteRssi}, {"onConfigureMTU", "(III)V", &method_onConfigureMTU}, {"onClientCongestion", "(IZ)V", &method_onClientCongestion}, {"getSampleGattDbElement", "()Lcom/android/bluetooth/gatt/GattDbElement;", &method_getSampleGattDbElement}, {"onGetGattDb", "(ILjava/util/List;)V", &method_onGetGattDb}, {"onClientPhyRead", "(ILjava/lang/String;III)V", &method_onClientPhyRead}, {"onClientPhyUpdate", "(IIII)V", &method_onClientPhyUpdate}, {"onClientConnUpdate", "(IIIII)V", &method_onClientConnUpdate}, {"onServiceChanged", "(I)V", &method_onServiceChanged}, {"onClientSubrateChange", "(IIIIII)V", &method_onClientSubrateChange}, // Server callbacks {"onServerRegistered", "(IIJJ)V", &method_onServerRegistered}, {"onClientConnected", "(Ljava/lang/String;ZII)V", &method_onClientConnected}, {"onServiceAdded", "(IILjava/util/List;)V", &method_onServiceAdded}, {"onServiceStopped", "(III)V", &method_onServiceStopped}, {"onServiceDeleted", "(III)V", &method_onServiceDeleted}, {"onResponseSendCompleted", "(II)V", &method_onResponseSendCompleted}, {"onServerReadCharacteristic", "(Ljava/lang/String;IIIIZ)V", &method_onServerReadCharacteristic}, {"onServerReadDescriptor", "(Ljava/lang/String;IIIIZ)V", &method_onServerReadDescriptor}, {"onServerWriteCharacteristic", "(Ljava/lang/String;IIIIIZZ[B)V", &method_onServerWriteCharacteristic}, {"onServerWriteDescriptor", "(Ljava/lang/String;IIIIIZZ[B)V", &method_onServerWriteDescriptor}, {"onExecuteWrite", "(Ljava/lang/String;III)V", &method_onExecuteWrite}, {"onNotificationSent", "(II)V", &method_onNotificationSent}, {"onServerCongestion", "(IZ)V", &method_onServerCongestion}, {"onMtuChanged", "(II)V", &method_onServerMtuChanged}, {"onServerPhyRead", "(ILjava/lang/String;III)V", &method_onServerPhyRead}, {"onServerPhyUpdate", "(IIII)V", &method_onServerPhyUpdate}, {"onServerConnUpdate", "(IIIII)V", &method_onServerConnUpdate}, {"onServerSubrateChange", "(IIIIII)V", &method_onServerSubrateChange}, }; GET_JAVA_METHODS(env, "com/android/bluetooth/gatt/GattNativeInterface", javaMethods); return 0; } int register_com_android_bluetooth_gatt(JNIEnv* env) { const std::array, 5> register_fns = { register_com_android_bluetooth_gatt_scan, register_com_android_bluetooth_gatt_advertise_manager, register_com_android_bluetooth_gatt_periodic_scan, register_com_android_bluetooth_gatt_distance_measurement, register_com_android_bluetooth_gatt_, }; for (const auto& fn : register_fns) { const int result = fn(env); if (result != 0) { return result; } } return 0; } } // namespace android