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__);
}
