static jboolean stopDiscoveryNative(JNIEnv *env, jobject object) {
LOGV(__FUNCTION__);
#ifdef HAVE_BLUETOOTH
DBusMessage *msg = NULL;
DBusMessage *reply = NULL;
DBusError err;
const char *name;
native_data_t *nat;
jboolean ret = JNI_FALSE;
dbus_error_init(&err);
nat = get_native_data(env, object);
if (nat == NULL) {
goto done;
}
/* Compose the command */
msg = dbus_message_new_method_call(BLUEZ_DBUS_BASE_IFC,
get_adapter_path(env, object),
DBUS_ADAPTER_IFACE, "StopDiscovery");
if (msg == NULL) {
if (dbus_error_is_set(&err))
LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg);
goto done;
}
/* Send the command. */
reply = dbus_connection_send_with_reply_and_block(nat->conn, msg, -1, &err);
if (dbus_error_is_set(&err)) {
if(strncmp(err.name, BLUEZ_DBUS_BASE_IFC ".Error.NotAuthorized",
strlen(BLUEZ_DBUS_BASE_IFC ".Error.NotAuthorized")) == 0) {
// hcid sends this if there is no active discovery to cancel
LOGV("%s: There was no active discovery to cancel", __FUNCTION__);
dbus_error_free(&err);
} else {
LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg);
}
goto done;
}
ret = JNI_TRUE;
done:
if (msg) dbus_message_unref(msg);
if (reply) dbus_message_unref(reply);
return ret;
#else
return JNI_FALSE;
#endif
}
static jobjectArray getInputPropertiesNative(JNIEnv *env, jobject object,
jstring path) {
#ifdef HAVE_BLUETOOTH
LOGV(__FUNCTION__);
if (nat) {
DBusMessage *msg, *reply;
DBusError err;
dbus_error_init(&err);
const char *c_path = env->GetStringUTFChars(path, NULL);
reply = dbus_func_args_timeout(env,
nat->conn, -1, c_path,
"org.bluez.Input", "GetProperties",
DBUS_TYPE_INVALID);
env->ReleaseStringUTFChars(path, c_path);
if (!reply && dbus_error_is_set(&err)) {
LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, reply);
return NULL;
} else if (!reply) {
LOGV("DBus reply is NULL in function %s", __FUNCTION__);
return NULL;
}
DBusMessageIter iter;
if (dbus_message_iter_init(reply, &iter))
return parse_properties(env, &iter, (Properties *)&input_properties,
sizeof(input_properties) / sizeof(Properties));
}
#endif
return NULL;
}
jobjectArray dbus_returns_array_of_strings(JNIEnv *env, DBusMessage *reply) {
DBusError err;
char **list;
int i, len;
jobjectArray strArray = NULL;
dbus_error_init(&err);
if (dbus_message_get_args (reply,
&err,
DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
&list, &len,
DBUS_TYPE_INVALID)) {
jclass stringClass;
jstring classNameStr;
//LOGV("%s: there are %d elements in string array!", __FUNCTION__, len);
stringClass = env->FindClass("java/lang/String");
strArray = env->NewObjectArray(len, stringClass, NULL);
for (i = 0; i < len; i++) {
//LOGV("%s: array[%d] = [%s]", __FUNCTION__, i, list[i]);
env->SetObjectArrayElement(strArray, i,
env->NewStringUTF(list[i]));
}
} else {
LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, reply);
}
dbus_message_unref(reply);
return strArray;
}
static jboolean startDiscoveryNative(JNIEnv *env, jobject object) {
LOGV(__FUNCTION__);
#ifdef HAVE_BLUETOOTH
DBusMessage *msg = NULL;
DBusMessage *reply = NULL;
DBusError err;
const char *name;
jboolean ret = JNI_FALSE;
native_data_t *nat = get_native_data(env, object);
if (nat == NULL) {
goto done;
}
dbus_error_init(&err);
/* Compose the command */
msg = dbus_message_new_method_call(BLUEZ_DBUS_BASE_IFC,
get_adapter_path(env, object),
DBUS_ADAPTER_IFACE, "StartDiscovery");
if (msg == NULL) {
if (dbus_error_is_set(&err)) {
LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg);
}
goto done;
}
/* Send the command. */
reply = dbus_connection_send_with_reply_and_block(nat->conn, msg, -1, &err);
if (dbus_error_is_set(&err)) {
LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg);
ret = JNI_FALSE;
goto done;
}
ret = JNI_TRUE;
done:
if (reply) dbus_message_unref(reply);
if (msg) dbus_message_unref(msg);
return ret;
#else
return JNI_FALSE;
#endif
}
jint dbus_returns_uint32(JNIEnv *env, DBusMessage *reply) {
DBusError err;
jint ret = -1;
dbus_error_init(&err);
if (!dbus_message_get_args(reply, &err,
DBUS_TYPE_UINT32, &ret,
DBUS_TYPE_INVALID)) {
LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, reply);
}
dbus_message_unref(reply);
return ret;
}
int dbus_returns_int32(DBusMessage *reply)
{
DBusError err;
int32_t ret = -1;
dbus_error_init(&err);
if (!dbus_message_get_args(reply, &err,
DBUS_TYPE_INT32, &ret,
DBUS_TYPE_INVALID)) {
LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, reply);
}
return ret;
}
// If err is NULL, then any errors will be LOGE'd, and free'd and the reply
// will be NULL.
// If err is not NULL, then it is assumed that dbus_error_init was already
// called, and error's will be returned to the caller without logging. The
// return value is NULL iff an error was set. The client must free the error if
// set.
DBusMessage * dbus_func_args_timeout_valist(JNIEnv *env,
DBusConnection *conn,
int timeout_ms,
DBusError *err,
const char *path,
const char *ifc,
const char *func,
int first_arg_type,
va_list args) {
DBusMessage *msg = NULL, *reply = NULL;
const char *name;
bool return_error = (err != NULL);
if (!return_error) {
err = (DBusError*)malloc(sizeof(DBusError));
dbus_error_init(err);
}
/* Compose the command */
msg = dbus_message_new_method_call(BLUEZ_DBUS_BASE_IFC, path, ifc, func);
if (msg == NULL) {
LOGE("Could not allocate D-Bus message object!");
goto done;
}
/* append arguments */
if (!dbus_message_append_args_valist(msg, first_arg_type, args)) {
LOGE("Could not append argument to method call!");
goto done;
}
/* Make the call. */
reply = dbus_connection_send_with_reply_and_block(conn, msg, timeout_ms, err);
if (!return_error && dbus_error_is_set(err)) {
LOG_AND_FREE_DBUS_ERROR_WITH_MSG(err, msg);
}
done:
if (!return_error) {
free(err);
}
if (msg) dbus_message_unref(msg);
return reply;
}
jstring dbus_returns_string(JNIEnv *env, DBusMessage *reply) {
DBusError err;
jstring ret = NULL;
const char *name;
dbus_error_init(&err);
if (dbus_message_get_args(reply, &err,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_INVALID)) {
ret = env->NewStringUTF(name);
} else {
LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, reply);
}
dbus_message_unref(reply);
return ret;
}
jboolean dbus_returns_boolean(JNIEnv *env, DBusMessage *reply) {
DBusError err;
jboolean ret = JNI_FALSE;
dbus_bool_t val = FALSE;
dbus_error_init(&err);
/* Check the return value. */
if (dbus_message_get_args(reply, &err,
DBUS_TYPE_BOOLEAN, &val,
DBUS_TYPE_INVALID)) {
ret = val == TRUE ? JNI_TRUE : JNI_FALSE;
} else {
LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, reply);
}
dbus_message_unref(reply);
return ret;
}
jbyteArray dbus_returns_array_of_bytes(JNIEnv *env, DBusMessage *reply) {
DBusError err;
int i, len;
jbyte *list;
jbyteArray byteArray = NULL;
dbus_error_init(&err);
if (dbus_message_get_args(reply, &err,
DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &list, &len,
DBUS_TYPE_INVALID)) {
//LOGV("%s: there are %d elements in byte array!", __FUNCTION__, len);
byteArray = env->NewByteArray(len);
if (byteArray)
env->SetByteArrayRegion(byteArray, 0, len, list);
} else {
LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, reply);
}
dbus_message_unref(reply);
return byteArray;
}
DBusHandlerResult gattclient_event_filter(DBusMessage *msg, JNIEnv *env) {
DBusError err;
DBusHandlerResult ret;
DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
dbus_error_init(&err);
if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL) {
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
if (dbus_message_is_signal(msg,"org.bluez.Characteristic", "PropertyChanged")) {
LOGV("org.bluez.Characteristic.PropertyChanged");
jobjectArray str_array = parse_remote_characteristic_property_change(env, msg);
if (str_array != NULL) {
const char *remote_char_path = dbus_message_get_path(msg);
env->CallVoidMethod(gnat->me,
method_onCharacteristicPropertyChanged,
env->NewStringUTF(remote_char_path),
str_array);
} else LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg);
result = DBUS_HANDLER_RESULT_HANDLED;
} else {
LOGV("... ignored");
}
if (env->ExceptionCheck()) {
LOGE("VM Exception occurred while handling %s.%s (%s) in %s,"
" leaving for VM",
dbus_message_get_interface(msg), dbus_message_get_member(msg),
dbus_message_get_path(msg), __FUNCTION__);
}
return result;
}
DBusHandlerResult a2dp_event_filter(DBusMessage *msg, JNIEnv *env) {
DBusError err;
if (!nat) {
LOGV("... skipping %s\n", __FUNCTION__);
LOGV("... ignored\n");
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
dbus_error_init(&err);
if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL) {
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
if (dbus_message_is_signal(msg,
"org.bluez.audio.Manager",
"HeadsetCreated")) {
char *c_path;
if (dbus_message_get_args(msg, &err,
DBUS_TYPE_STRING, &c_path,
DBUS_TYPE_INVALID)) {
LOGV("... path = %s", c_path);
env->CallVoidMethod(nat->me,
method_onHeadsetCreated,
env->NewStringUTF(c_path));
} else LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg);
result = DBUS_HANDLER_RESULT_HANDLED;
} else if (dbus_message_is_signal(msg,
"org.bluez.audio.Manager",
"HeadsetRemoved")) {
char *c_path;
if (dbus_message_get_args(msg, &err,
DBUS_TYPE_STRING, &c_path,
DBUS_TYPE_INVALID)) {
LOGV("... path = %s", c_path);
env->CallVoidMethod(nat->me,
method_onHeadsetRemoved,
env->NewStringUTF(c_path));
} else LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg);
result = DBUS_HANDLER_RESULT_HANDLED;
} else if (dbus_message_is_signal(msg,
"org.bluez.audio.Sink",
"Connected")) {
const char *c_path = dbus_message_get_path(msg);
LOGV("... path = %s", c_path);
env->CallVoidMethod(nat->me,
method_onSinkConnected,
env->NewStringUTF(c_path));
result = DBUS_HANDLER_RESULT_HANDLED;
} else if (dbus_message_is_signal(msg,
"org.bluez.audio.Sink",
"Disconnected")) {
const char *c_path = dbus_message_get_path(msg);
LOGV("... path = %s", c_path);
env->CallVoidMethod(nat->me,
method_onSinkDisconnected,
env->NewStringUTF(c_path));
result = DBUS_HANDLER_RESULT_HANDLED;
} else if (dbus_message_is_signal(msg,
"org.bluez.audio.Sink",
"Playing")) {
const char *c_path = dbus_message_get_path(msg);
LOGV("... path = %s", c_path);
env->CallVoidMethod(nat->me,
method_onSinkPlaying,
env->NewStringUTF(c_path));
result = DBUS_HANDLER_RESULT_HANDLED;
} else if (dbus_message_is_signal(msg,
"org.bluez.audio.Sink",
"Stopped")) {
const char *c_path = dbus_message_get_path(msg);
LOGV("... path = %s", c_path);
env->CallVoidMethod(nat->me,
method_onSinkStopped,
env->NewStringUTF(c_path));
result = DBUS_HANDLER_RESULT_HANDLED;
}
if (result == DBUS_HANDLER_RESULT_NOT_YET_HANDLED) {
LOGV("... ignored");
}
if (env->ExceptionCheck()) {
LOGE("VM Exception occurred while handling %s.%s (%s) in %s,"
" leaving for VM",
dbus_message_get_interface(msg), dbus_message_get_member(msg),
dbus_message_get_path(msg), __FUNCTION__);
}
return result;
}
