static void acl_state_changed_callback(bt_status_t status, bt_bdaddr_t *bd_addr, bt_acl_state_t state) { jbyteArray addr; int i; if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } if (!bd_addr) { ALOGE("Address is null in %s", __FUNCTION__); return; } addr = callbackEnv->NewByteArray(sizeof(bt_bdaddr_t)); if (addr == NULL) { ALOGE("Address allocation failed in %s", __FUNCTION__); return; } callbackEnv->SetByteArrayRegion(addr, 0, sizeof(bt_bdaddr_t), (jbyte *)bd_addr); callbackEnv->CallVoidMethod(sJniCallbacksObj, method_aclStateChangeCallback, (jint) status, addr, (jint)state); checkAndClearExceptionFromCallback(callbackEnv, __FUNCTION__); callbackEnv->DeleteLocalRef(addr); }
static void btavrcp_set_playerapp_setting_value_callback(btrc_player_settings_t *attr) { jbyteArray attrs_ids; jbyteArray attrs_value; ALOGI("%s", __FUNCTION__); if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } attrs_ids = (jbyteArray)sCallbackEnv->NewByteArray(attr->num_attr); if (!attrs_ids) { ALOGE("Fail to new jintArray for attrs"); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); return; } sCallbackEnv->SetByteArrayRegion(attrs_ids, 0, attr->num_attr, (jbyte *)attr->attr_ids); attrs_value = (jbyteArray)sCallbackEnv->NewByteArray(attr->num_attr); if (!attrs_value) { ALOGE("Fail to new jintArray for attrs"); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); return; } sCallbackEnv->SetByteArrayRegion(attrs_value, 0, attr->num_attr, (jbyte *)attr->attr_values); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_setPlayerAppSetting, (jbyte)attr->num_attr, attrs_ids ,attrs_value ); sCallbackEnv->DeleteLocalRef(attrs_ids); sCallbackEnv->DeleteLocalRef(attrs_value); }
static void btavrcp_get_playstatus_rsp_callback(bt_bdaddr_t *bd_addr, int param_len, uint8_t* play_status_rsp,uint8_t rsp_type) { jbyteArray addr; jbyteArray supported_val; ALOGI("%s", __FUNCTION__); if (!checkCallbackThread()) { \ ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); \ return; \ } addr = sCallbackEnv->NewByteArray(sizeof(bt_bdaddr_t)); supported_val = sCallbackEnv->NewByteArray(param_len); if ((!addr)||(!supported_val)) { ALOGE("Fail to get new array "); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); return; } sCallbackEnv->SetByteArrayRegion(addr, 0, sizeof(bt_bdaddr_t), (jbyte*) bd_addr); sCallbackEnv->SetByteArrayRegion(supported_val, 0, (param_len), (jbyte*)(play_status_rsp)); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_handleGetPlayStatus, addr, (jint)param_len, supported_val, (jbyte)rsp_type); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); sCallbackEnv->DeleteLocalRef(addr); sCallbackEnv->DeleteLocalRef(supported_val); }
static void ssp_request_callback(bt_bdaddr_t *bd_addr, bt_bdname_t *bdname, uint32_t cod, bt_ssp_variant_t pairing_variant, uint32_t pass_key) { jbyteArray addr, devname; if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } if (!bd_addr) { ALOGE("Address is null in %s", __FUNCTION__); return; } addr = callbackEnv->NewByteArray(sizeof(bt_bdaddr_t)); if (addr == NULL) goto Fail; callbackEnv->SetByteArrayRegion(addr, 0, sizeof(bt_bdaddr_t), (jbyte *)bd_addr); devname = callbackEnv->NewByteArray(sizeof(bt_bdname_t)); if (devname == NULL) goto Fail; callbackEnv->SetByteArrayRegion(devname, 0, sizeof(bt_bdname_t), (jbyte*)bdname); callbackEnv->CallVoidMethod(sJniCallbacksObj, method_sspRequestCallback, addr, devname, cod, (jint) pairing_variant, pass_key); checkAndClearExceptionFromCallback(callbackEnv, __FUNCTION__); callbackEnv->DeleteLocalRef(addr); callbackEnv->DeleteLocalRef(devname); return; Fail: if (addr) callbackEnv->DeleteLocalRef(addr); if (devname) callbackEnv->DeleteLocalRef(devname); ALOGE("Error while allocating in: %s", __FUNCTION__); }
static void btavrcp_current_player_app_setting_rsp_callback(bt_bdaddr_t *bd_addr, uint8_t* supported_ids,uint8_t* supported_values, uint8_t num_attrib, uint8_t rsp_type) { jbyteArray addr; jbyteArray supported_attrib_ids; jbyteArray supported_val; ALOGI("%s", __FUNCTION__); if (!checkCallbackThread()) { \ ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); \ return; \ } addr = sCallbackEnv->NewByteArray(sizeof(bt_bdaddr_t)); supported_val = sCallbackEnv->NewByteArray(num_attrib); supported_attrib_ids = sCallbackEnv->NewByteArray(num_attrib); if ((!addr)||(!supported_val)) { ALOGE("Fail to get new array "); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); return; } sCallbackEnv->SetByteArrayRegion(addr, 0, sizeof(bt_bdaddr_t), (jbyte*) bd_addr); sCallbackEnv->SetByteArrayRegion(supported_val, 0, (num_attrib), (jbyte*)(supported_values)); sCallbackEnv->SetByteArrayRegion(supported_attrib_ids, 0, (num_attrib), (jbyte*)(supported_ids)); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_handleCurrentPlayerApplicationSettingsResponse,addr,supported_attrib_ids, supported_val, (jbyte)num_attrib, (jbyte)rsp_type); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); sCallbackEnv->DeleteLocalRef(addr); sCallbackEnv->DeleteLocalRef(supported_val); sCallbackEnv->DeleteLocalRef(supported_attrib_ids); }
static void btavrcp_getcap_rsp_callback(bt_bdaddr_t *bd_addr, int cap_id, uint32_t* supported_values, int num_supported, uint8_t rsp_type) { jbyteArray addr; jintArray supported_val = NULL; ALOGI("%s", __FUNCTION__); if (!checkCallbackThread()) { \ ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); \ return; \ } addr = sCallbackEnv->NewByteArray(sizeof(bt_bdaddr_t)); supported_val = sCallbackEnv->NewIntArray(num_supported); if ((!addr)||(!supported_val)) { ALOGE("Fail to get new array "); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); return; } sCallbackEnv->SetByteArrayRegion(addr, 0, sizeof(bt_bdaddr_t), (jbyte*) bd_addr); sCallbackEnv->SetIntArrayRegion(supported_val, 0, (num_supported), (jint*)(supported_values)); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_handleGetCapabilitiesResponse, addr, (jint)cap_id,supported_val, (jint)num_supported, (jbyte)rsp_type); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); sCallbackEnv->DeleteLocalRef(addr); sCallbackEnv->DeleteLocalRef(supported_val); }
static void btavrcp_get_player_attribute_id_callback() { ALOGI("%s", __FUNCTION__); if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } sCallbackEnv->CallVoidMethod(mCallbacksObj,method_onListPlayerAttributeRequest ); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); }
static void btavrcp_get_player_seeting_value_callback(btrc_player_attr_t player_att) { ALOGI("%s", __FUNCTION__); if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } sCallbackEnv->CallVoidMethod(mCallbacksObj ,method_onListPlayerAttributeValues , (jbyte)player_att ); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); }
static void btavrcp_get_play_status_callback() { ALOGI("%s", __FUNCTION__); if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_getPlayStatus); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); }
static void adapter_state_change_callback(bt_state_t status) { if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } ALOGV("%s: Status is: %d", __FUNCTION__, status); callbackEnv->CallVoidMethod(sJniCallbacksObj, method_stateChangeCallback, (jint)status); checkAndClearExceptionFromCallback(callbackEnv, __FUNCTION__); }
static void btavrcp_passthrough_command_callback(int id, int pressed) { ALOGI("%s", __FUNCTION__); if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_handlePassthroughCmd, (jint)id, (jint)pressed); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); }
static void btavrcp_register_notification_callback(btrc_event_id_t event_id, uint32_t param) { ALOGI("%s", __FUNCTION__); if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_registerNotification, (jint)event_id, (jint)param); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); }
static void btavrcp_volume_change_callback(uint8_t volume, uint8_t ctype) { ALOGI("%s", __FUNCTION__); if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_volumeChangeCallback, (jint)volume, (jint)ctype); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); }
static void energy_info_recv_callback(bt_activity_energy_info *p_energy_info) { if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } callbackEnv->CallVoidMethod(sJniAdapterServiceObj, method_energyInfo, p_energy_info->status, p_energy_info->ctrl_state, p_energy_info->tx_time, p_energy_info->rx_time, p_energy_info->idle_time, p_energy_info->energy_used); checkAndClearExceptionFromCallback(callbackEnv, __FUNCTION__); }
static void btavrcp_set_addressed_player_callback(uint32_t player_id) { ALOGI("%s", __FUNCTION__); ALOGI("player id: %d", player_id); if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_setAddressedPlayer, (jint)player_id); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); }
static void discovery_state_changed_callback(bt_discovery_state_t state) { jbyteArray addr; if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } ALOGV("%s: DiscoveryState:%d ", __FUNCTION__, state); callbackEnv->CallVoidMethod(sJniCallbacksObj, method_discoveryStateChangeCallback, (jint)state); checkAndClearExceptionFromCallback(callbackEnv, __FUNCTION__); }
void le_lpp_rssi_threshold_evt_callbacks(bt_bdaddr_t *bda, int evt_type, int rssi) { char c_address[32] = {0}; if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } 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]); jstring address = qccallbackEnv->NewStringUTF(c_address); qccallbackEnv->CallVoidMethod(qcJniCallbacksObj, method_onLeLppRssiThresholdEvent, address, evt_type, rssi); qccallbackEnv->DeleteLocalRef(address); checkAndClearExceptionFromCallback(qccallbackEnv, __FUNCTION__); }
static void callback_thread_event(bt_cb_thread_evt event) { JavaVM* vm = AndroidRuntime::getJavaVM(); if (event == ASSOCIATE_JVM) { JavaVMAttachArgs args; char name[] = "BT Service Callback Thread"; args.version = JNI_VERSION_1_6; args.name = name; args.group = NULL; vm->AttachCurrentThread(&callbackEnv, &args); ALOGV("Callback thread attached: %p", callbackEnv); } else if (event == DISASSOCIATE_JVM) { if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } vm->DetachCurrentThread(); } }
static void btavrcp_getPlayer_app_attribute_text(uint8_t num , btrc_player_attr_t *att) { jbyteArray attrs; ALOGI("%s", __FUNCTION__); if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } attrs = (jbyteArray)sCallbackEnv->NewByteArray(num); if (!attrs) { ALOGE("Fail to new jintArray for attrs"); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); return; } sCallbackEnv->SetByteArrayRegion(attrs, 0, num, (jbyte *)att); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_getplayerattribute_text,(jbyte) num ,attrs ); sCallbackEnv->DeleteLocalRef(attrs); }
static void btavrcp_getPlayer_app_value_text(uint8_t attr_id , uint8_t num_val , uint8_t *value) { jbyteArray Attr_Value ; ALOGI("%s", __FUNCTION__); if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } Attr_Value = (jbyteArray)sCallbackEnv->NewByteArray(num_val); if (!Attr_Value) { ALOGE("Fail to new jintArray for attrs"); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); return; } sCallbackEnv->SetByteArrayRegion(Attr_Value, 0, num_val, (jbyte *)value); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_getplayervalue_text,(jbyte) attr_id, (jbyte) num_val , Attr_Value ); sCallbackEnv->DeleteLocalRef(Attr_Value); }
static void btavrcp_get_element_attr_response_callback(uint8_t num_attr, btrc_element_attr_val_t *p_attrs){ int i; jint attrs_temp[num_attr]; jintArray attrs; jobjectArray values; ALOGI("%s", __FUNCTION__); ALOGI("num_attr: %d", num_attr); if (!checkCallbackThread()) { \ ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); \ return; \ } attrs = (jintArray)sCallbackEnv->NewIntArray(num_attr); if (!attrs) { ALOGE("Fail to new jintArray for attrs"); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); return; } values = (jobjectArray)sCallbackEnv->NewObjectArray(num_attr, sCallbackEnv->FindClass("java/lang/String"), NULL); if (!values) { ALOGE("Fail to new jobjectArray for values"); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); return; } for (i=0; i<num_attr; i++){ attrs_temp[i] = p_attrs[i].attr_id; sCallbackEnv->SetObjectArrayElement(values, i, sCallbackEnv->NewStringUTF((char *)p_attrs[i].text)); } sCallbackEnv->SetIntArrayRegion(attrs, 0, num_attr, attrs_temp); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onGetElementAttrRsp, (jint) num_attr, attrs, values); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); sCallbackEnv->DeleteLocalRef(attrs); sCallbackEnv->DeleteLocalRef(values); }
static void btavrcp_remote_features_callback(bt_bdaddr_t* bd_addr, btrc_remote_features_t features) { ALOGI("%s", __FUNCTION__); jbyteArray addr; if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } addr = sCallbackEnv->NewByteArray(sizeof(bt_bdaddr_t)); if (!addr) { ALOGE("Fail to new jbyteArray bd addr for connection state"); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); return; } sCallbackEnv->SetByteArrayRegion(addr, 0, sizeof(bt_bdaddr_t), (jbyte*) bd_addr); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_getRcFeatures, addr, (jint)features); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); sCallbackEnv->DeleteLocalRef(addr); }
static void btavrcp_get_folder_items_callback(btrc_browse_folderitem_t scope , btrc_getfolderitem_t *param) { jint start = param->start_item; jint end = param->end_item; jint size = param->size; ALOGI("%s", __FUNCTION__); ALOGI("scope: %d", scope); ALOGI("start entry: %d", start); ALOGI("end entry: %d", end); ALOGI("size: %d", size); if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } sCallbackEnv->CallVoidMethod(mCallbacksObj, method_getFolderItems, (jbyte)scope, start, end, size); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); }
static void btavrcp_get_element_attr_callback(uint8_t num_attr, btrc_media_attr_t *p_attrs) { jintArray attrs; ALOGI("%s", __FUNCTION__); if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } attrs = (jintArray)sCallbackEnv->NewIntArray(num_attr); if (!attrs) { ALOGE("Fail to new jintArray for attrs"); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); return; } sCallbackEnv->SetIntArrayRegion(attrs, 0, num_attr, (jint *)p_attrs); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_getElementAttr, (jbyte)num_attr, attrs); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); sCallbackEnv->DeleteLocalRef(attrs); }
static void btavrcp_register_notification_absvol_callback(bt_bdaddr_t *bd_addr) { jbyteArray addr; ALOGI("%s", __FUNCTION__); if (!checkCallbackThread()) { \ ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); \ return; \ } addr = sCallbackEnv->NewByteArray(sizeof(bt_bdaddr_t)); if ((!addr)) { ALOGE("Fail to get new array "); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); return; } sCallbackEnv->SetByteArrayRegion(addr, 0, sizeof(bt_bdaddr_t), (jbyte*)bd_addr); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_handleRegisterNotificationAbsVol, addr); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); sCallbackEnv->DeleteLocalRef(addr); }
static void btavrcp_set_player_app_setting_rsp_callback(bt_bdaddr_t *bd_addr,uint8_t rsp_type) { jbyteArray addr; ALOGI("%s", __FUNCTION__); if (!checkCallbackThread()) { \ ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); \ return; \ } addr = sCallbackEnv->NewByteArray(sizeof(bt_bdaddr_t)); if ((!addr)) { ALOGE("Fail to get new array "); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); return; } sCallbackEnv->SetByteArrayRegion(addr, 0, sizeof(bt_bdaddr_t), (jbyte*) bd_addr); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_handleSetPlayerApplicationResponse, addr,(jbyte)rsp_type); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); sCallbackEnv->DeleteLocalRef(addr); }
static void btavrcp_connection_state_callback(bool state, bt_bdaddr_t* bd_addr) { jbyteArray addr; ALOGI("%s", __FUNCTION__); ALOGI("conn state: %d", state); if (!checkCallbackThread()) { \ ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); \ return; \ } addr = sCallbackEnv->NewByteArray(sizeof(bt_bdaddr_t)); if (!addr) { ALOGE("Fail to new jbyteArray bd addr for connection state"); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); return; } sCallbackEnv->SetByteArrayRegion(addr, 0, sizeof(bt_bdaddr_t), (jbyte*) bd_addr); sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onConnectionStateChanged, (jboolean) state, addr); checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__); sCallbackEnv->DeleteLocalRef(addr); }
static void remote_mas_instances_callback(bt_status_t status, bt_bdaddr_t *bd_addr, int num_instances, btmce_mas_instance_t *instances) { if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } ALOGV("%s: Status is: %d, Instances: %d", __FUNCTION__, status, num_instances); if (status != BT_STATUS_SUCCESS) { ALOGE("%s: Status %d is incorrect", __FUNCTION__, status); return; } callbackEnv->PushLocalFrame(ADDITIONAL_NREFS); jbyteArray addr = NULL; jobjectArray a_name = NULL; jintArray a_scn = NULL; jintArray a_masid = NULL; jintArray a_msgtype = NULL; jclass mclass; mclass = callbackEnv->FindClass("java/lang/String"); addr = callbackEnv->NewByteArray(sizeof(bt_bdaddr_t)); if (addr == NULL) goto clean; callbackEnv->SetByteArrayRegion(addr, 0, sizeof(bt_bdaddr_t), (jbyte*)bd_addr); a_name = callbackEnv->NewObjectArray(num_instances, mclass, NULL); if (a_name == NULL) goto clean; a_scn = callbackEnv->NewIntArray(num_instances); if (a_scn == NULL) goto clean; a_masid = callbackEnv->NewIntArray(num_instances); if (a_masid == NULL) goto clean; a_msgtype = callbackEnv->NewIntArray(num_instances); if (a_msgtype == NULL) goto clean; for (int i = 0; i < num_instances; i++) { jstring name = callbackEnv->NewStringUTF(instances[i].p_name); callbackEnv->SetObjectArrayElement(a_name, i, name); callbackEnv->SetIntArrayRegion(a_scn, i, 1, &instances[i].scn); callbackEnv->SetIntArrayRegion(a_masid, i, 1, &instances[i].id); callbackEnv->SetIntArrayRegion(a_msgtype, i, 1, &instances[i].msg_types); callbackEnv->DeleteLocalRef(name); } callbackEnv->CallVoidMethod(sJniCallbacksObj, method_deviceMasInstancesFoundCallback, (jint) status, addr, a_name, a_scn, a_masid, a_msgtype); checkAndClearExceptionFromCallback(callbackEnv, __FUNCTION__); clean: if (addr != NULL) callbackEnv->DeleteLocalRef(addr); if (a_name != NULL) callbackEnv->DeleteLocalRef(a_name); if (a_scn != NULL) callbackEnv->DeleteLocalRef(a_scn); if (a_masid != NULL) callbackEnv->DeleteLocalRef(a_masid); if (a_msgtype != NULL) callbackEnv->DeleteLocalRef(a_msgtype); callbackEnv->PopLocalFrame(NULL); }
static void adapter_properties_callback(bt_status_t status, int num_properties, bt_property_t *properties) { jobjectArray props; jintArray types; jbyteArray val; jclass mclass; if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } ALOGV("%s: Status is: %d, Properties: %d", __FUNCTION__, status, num_properties); if (status != BT_STATUS_SUCCESS) { ALOGE("%s: Status %d is incorrect", __FUNCTION__, status); return; } val = (jbyteArray) callbackEnv->NewByteArray(num_properties); if (val == NULL) { ALOGE("%s: Error allocating byteArray", __FUNCTION__); return; } mclass = callbackEnv->GetObjectClass(val); /* (BT) Initialize the jobjectArray and jintArray here itself and send the initialized array pointers alone to get_properties */ props = callbackEnv->NewObjectArray(num_properties, mclass, NULL); if (props == NULL) { ALOGE("%s: Error allocating object Array for properties", __FUNCTION__); return; } types = (jintArray)callbackEnv->NewIntArray(num_properties); if (types == NULL) { ALOGE("%s: Error allocating int Array for values", __FUNCTION__); return; } // Delete the reference to val and mclass callbackEnv->DeleteLocalRef(mclass); callbackEnv->DeleteLocalRef(val); if (get_properties(num_properties, properties, &types, &props) < 0) { if (props) callbackEnv->DeleteLocalRef(props); if (types) callbackEnv->DeleteLocalRef(types); return; } callbackEnv->CallVoidMethod(sJniCallbacksObj, method_adapterPropertyChangedCallback, types, props); checkAndClearExceptionFromCallback(callbackEnv, __FUNCTION__); callbackEnv->DeleteLocalRef(props); callbackEnv->DeleteLocalRef(types); return; }
static void remote_device_properties_callback(bt_status_t status, bt_bdaddr_t *bd_addr, int num_properties, bt_property_t *properties) { if (!checkCallbackThread()) { ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); return; } ALOGV("%s: Status is: %d, Properties: %d", __FUNCTION__, status, num_properties); if (status != BT_STATUS_SUCCESS) { ALOGE("%s: Status %d is incorrect", __FUNCTION__, status); return; } callbackEnv->PushLocalFrame(ADDITIONAL_NREFS); jobjectArray props; jbyteArray addr; jintArray types; jbyteArray val; jclass mclass; val = (jbyteArray) callbackEnv->NewByteArray(num_properties); if (val == NULL) { ALOGE("%s: Error allocating byteArray", __FUNCTION__); return; } mclass = callbackEnv->GetObjectClass(val); /* Initialize the jobjectArray and jintArray here itself and send the initialized array pointers alone to get_properties */ props = callbackEnv->NewObjectArray(num_properties, mclass, NULL); if (props == NULL) { ALOGE("%s: Error allocating object Array for properties", __FUNCTION__); return; } types = (jintArray)callbackEnv->NewIntArray(num_properties); if (types == NULL) { ALOGE("%s: Error allocating int Array for values", __FUNCTION__); return; } // Delete the reference to val and mclass callbackEnv->DeleteLocalRef(mclass); callbackEnv->DeleteLocalRef(val); addr = callbackEnv->NewByteArray(sizeof(bt_bdaddr_t)); if (addr == NULL) goto Fail; if (addr) callbackEnv->SetByteArrayRegion(addr, 0, sizeof(bt_bdaddr_t), (jbyte*)bd_addr); if (get_properties(num_properties, properties, &types, &props) < 0) { if (props) callbackEnv->DeleteLocalRef(props); if (types) callbackEnv->DeleteLocalRef(types); callbackEnv->PopLocalFrame(NULL); return; } callbackEnv->CallVoidMethod(sJniCallbacksObj, method_devicePropertyChangedCallback, addr, types, props); checkAndClearExceptionFromCallback(callbackEnv, __FUNCTION__); callbackEnv->DeleteLocalRef(props); callbackEnv->DeleteLocalRef(types); callbackEnv->DeleteLocalRef(addr); callbackEnv->PopLocalFrame(NULL); return; Fail: ALOGE("Error while allocation byte array in %s", __FUNCTION__); }