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_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_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_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 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 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_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 get_idle_time_callback(bt_bdaddr_t *bd_addr, bthh_status_t hh_status, int idle_time) {
jbyteArray addr;
CHECK_CALLBACK_ENV
if (hh_status != BTHH_OK) {
ALOGE("BTHH Status is not OK!");
checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);
return;
}
addr = sCallbackEnv->NewByteArray(sizeof(bt_bdaddr_t));
if (!addr) {
ALOGE("Fail to new jbyteArray bd addr for get protocal mode callback");
checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);
return;
}
sCallbackEnv->SetByteArrayRegion(addr, 0, sizeof(bt_bdaddr_t), (jbyte *) bd_addr);
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onGetIdleTime, addr, (jint) idle_time);
checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);
sCallbackEnv->DeleteLocalRef(addr);
}
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 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 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__);
}
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);
}
// Propagate the message up to Java layer.
void propagateCecCommand(const cec_message_t& message) {
jint srcAddr = message.initiator;
jint dstAddr = message.destination;
JNIEnv* env = AndroidRuntime::getJNIEnv();
jbyteArray body = env->NewByteArray(message.length);
const jbyte* bodyPtr = reinterpret_cast<const jbyte *>(message.body);
env->SetByteArrayRegion(body, 0, message.length, bodyPtr);
env->CallVoidMethod(mController->getCallbacksObj(),
gHdmiCecControllerClassInfo.handleIncomingCecCommand, srcAddr,
dstAddr, body);
env->DeleteLocalRef(body);
checkAndClearExceptionFromCallback(env, __FUNCTION__);
}
static void location_callback(UlpLocation* location)
{
JNIEnv* env = android::AndroidRuntime::getJNIEnv();
jbyteArray byteArray = NULL;
if (location->rawDataSize > 0) {
byteArray = env->NewByteArray(location->rawDataSize);
ALOG_ASSERT(byteArray, "Native could not create new byte[]");
env->SetByteArrayRegion(byteArray, 0, location->rawDataSize, (const jbyte *) location->rawData );
}
jstring java_string_map_url = NULL;
ALOGD ("Location CB invoked");
if ((location->gpsLocation.flags & GPS_LOCATION_HAS_MAP_URL) == GPS_LOCATION_HAS_MAP_URL) {
java_string_map_url = env->NewStringUTF(location->map_url);
}
jstring java_string_map_index = NULL;
if ((location->gpsLocation.flags & GPS_LOCATION_HAS_MAP_INDEX) == GPS_LOCATION_HAS_MAP_INDEX) {
char uuid_string_buf [UUID_STRING_LENGTH];
convert_uuid_from_byte_array_to_string (location->map_index, uuid_string_buf);
java_string_map_index = env->NewStringUTF(uuid_string_buf);
}
env->CallVoidMethod(mCallbacksObj, method_reportLocation, location->gpsLocation.flags,
(jdouble)location->gpsLocation.latitude, (jdouble)location->gpsLocation.longitude,
(jdouble)location->gpsLocation.altitude, (jfloat)location->gpsLocation.speed,
(jfloat)location->gpsLocation.bearing, (jfloat)location->gpsLocation.accuracy,
(jlong)location->gpsLocation.timestamp, location->position_source,
byteArray, (jboolean)location->is_indoor, (jfloat)location->floor_number,
java_string_map_url, java_string_map_index);
if (byteArray!= NULL) {
env->DeleteLocalRef(byteArray);
}
if (java_string_map_url != NULL) {
env->DeleteLocalRef(java_string_map_url);
}
if (java_string_map_index != NULL) {
env->DeleteLocalRef(java_string_map_index);
}
checkAndClearExceptionFromCallback(env, __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__);
}
virtual void onDisplayConnected(const sp<ISurfaceTexture>& surfaceTexture,
uint32_t width, uint32_t height, uint32_t flags) {
JNIEnv* env = AndroidRuntime::getJNIEnv();
jobject surfaceObj = android_view_Surface_createFromISurfaceTexture(env, surfaceTexture);
if (surfaceObj == NULL) {
ALOGE("Could not create Surface from surface texture %p provided by media server.",
surfaceTexture.get());
return;
}
env->CallVoidMethod(mRemoteDisplayObjGlobal,
gRemoteDisplayClassInfo.notifyDisplayConnected,
surfaceObj, width, height, flags);
env->DeleteLocalRef(surfaceObj);
checkAndClearExceptionFromCallback(env, "notifyDisplayConnected");
}
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_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__);
}
// PVD Status callback from ULPNative
static void pvd_callback (UlpPVDStatus status, void* venueInfo,
int venueInfoLen)
{
JNIEnv* env = android::AndroidRuntime::getJNIEnv();
ALOGD ("PVD CB invoked, status = %d, len = %d", status, venueInfoLen);
jbyteArray byteArray = NULL;
if (venueInfoLen > 0 && venueInfo != NULL) {
byteArray = env->NewByteArray(venueInfoLen);
ALOG_ASSERT(byteArray, "Native could not create new byte[]");
env->SetByteArrayRegion(byteArray, 0, venueInfoLen, (const jbyte *) venueInfo);
}
env->CallVoidMethod(mCallbacksObj, method_reportPVDStatus, (jint) status,
byteArray);
if (byteArray!= NULL) {
env->DeleteLocalRef(byteArray);
}
checkAndClearExceptionFromCallback(env, __FUNCTION__);
}
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);
if (sJniCallbacksObj) {
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 bond_state_changed_callback(bt_status_t status, bt_bdaddr_t *bd_addr,
bt_bond_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_bondStateChangeCallback, (jint) status,
addr, (jint)state);
checkAndClearExceptionFromCallback(callbackEnv, __FUNCTION__);
callbackEnv->DeleteLocalRef(addr);
}
void android_server_PowerManagerService_userActivity(nsecs_t eventTime, int32_t eventType) {
if (gPowerManagerServiceObj) {
// Throttle calls into user activity by event type.
// We're a little conservative about argument checking here in case the caller
// passes in bad data which could corrupt system state.
if (eventType >= 0 && eventType <= POWER_MANAGER_LAST_EVENT) {
nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
if (eventTime > now) {
eventTime = now;
}
if (gLastEventTime[eventType] + MIN_TIME_BETWEEN_USERACTIVITIES > eventTime) {
return;
}
gLastEventTime[eventType] = eventTime;
}
JNIEnv* env = AndroidRuntime::getJNIEnv();
env->CallVoidMethod(gPowerManagerServiceObj, gPowerManagerServiceClassInfo.userActivity,
nanoseconds_to_milliseconds(eventTime), false, eventType, false);
checkAndClearExceptionFromCallback(env, "userActivity");
}
}
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 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__);
}
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 status_callback(GpsStatus* status)
{
JNIEnv* env = AndroidRuntime::getJNIEnv();
env->CallVoidMethod(mCallbacksObj, method_reportStatus, status->status);
checkAndClearExceptionFromCallback(env, __FUNCTION__);
}
static void xtra_download_request_callback()
{
JNIEnv* env = AndroidRuntime::getJNIEnv();
env->CallVoidMethod(mCallbacksObj, method_xtraDownloadRequest);
checkAndClearExceptionFromCallback(env, __FUNCTION__);
}