static void disconnectNative(JNIEnv *env, jobject object, jstring path)
{
#ifdef HAVE_BLUETOOTH
LOGV("%s", __FUNCTION__);
native_data_t *nat = get_native_data(env, object);
if (nat) {
DBusMessage *msg, *reply;
DBusError err;
dbus_error_init(&err);
const char *c_path = env->GetStringUTFChars(path, NULL);
LOGE("%s c_path=%s",__FUNCTION__, c_path);
reply = dbus_func_args_timeout(env,
nat->conn, -1, c_path,
DBUS_DEVICE_IFACE, "GattClientDisconnect",
DBUS_TYPE_INVALID);
env->ReleaseStringUTFChars(path, c_path);
if (!reply) {
if (dbus_error_is_set(&err)) {
LOG_AND_FREE_DBUS_ERROR(&err);
} else
LOGE("DBus reply is NULL in function %s", __FUNCTION__);
LOGE("%s returning null for some reason", __FUNCTION__);
} else
dbus_message_unref(reply);
}
#endif
}
void onConnectSinkResult(DBusMessage *msg, void *user, void *n) {
LOGV(__FUNCTION__);
native_data_t *nat = (native_data_t *)n;
const char *path = (const char *)user;
DBusError err;
dbus_error_init(&err);
JNIEnv *env;
nat->vm->GetEnv((void**)&env, nat->envVer);
bool result = JNI_TRUE;
if (dbus_set_error_from_message(&err, msg)) {
LOG_AND_FREE_DBUS_ERROR(&err);
result = JNI_FALSE;
}
LOGV("... Device Path = %s, result = %d", path, result);
jstring jPath = env->NewStringUTF(path);
env->CallVoidMethod(nat->me,
method_onConnectSinkResult,
jPath,
result);
env->DeleteLocalRef(jPath);
free(user);
}
static jobjectArray getAdapterPropertiesNative(JNIEnv *env, jobject object) {
#ifdef HAVE_BLUETOOTH
LOGV(__FUNCTION__);
native_data_t *nat = get_native_data(env, object);
if (nat) {
DBusMessage *msg, *reply;
DBusError err;
dbus_error_init(&err);
reply = dbus_func_args_timeout(env,
nat->conn, -1, get_adapter_path(env, object),
DBUS_ADAPTER_IFACE, "GetProperties",
DBUS_TYPE_INVALID);
if (!reply) {
if (dbus_error_is_set(&err)) {
LOG_AND_FREE_DBUS_ERROR(&err);
} else
LOGE("DBus reply is NULL in function %s", __FUNCTION__);
return NULL;
}
env->PushLocalFrame(PROPERTIES_NREFS);
DBusMessageIter iter;
jobjectArray str_array = NULL;
if (dbus_message_iter_init(reply, &iter))
str_array = parse_adapter_properties(env, &iter);
dbus_message_unref(reply);
env->PopLocalFrame(NULL);
return str_array;
}
#endif
return NULL;
}
static int unregister_watcher(native_data_t *nat,
const char * watcher_path, const char *device_path)
{
#ifdef HAVE_BLUETOOTH
DBusMessage *msg, *reply;
DBusError err;
msg = dbus_message_new_method_call("org.bluez", device_path,
"org.bluez.Characteristic", "UnregisterCharacteristicsWatcher");
if (!msg) {
LOGE("%s: Can't allocate new method call for watcher!",
__FUNCTION__);
return -1;
}
dbus_message_append_args(msg, DBUS_TYPE_OBJECT_PATH, &watcher_path,
DBUS_TYPE_INVALID);
dbus_error_init(&err);
reply = dbus_connection_send_with_reply_and_block(nat->conn, msg, -1, &err);
dbus_message_unref(msg);
if (!reply) {
LOGE("%s: Can't register watcher!", __FUNCTION__);
if (dbus_error_is_set(&err)) {
LOG_AND_FREE_DBUS_ERROR(&err);
}
return -1;
}
dbus_message_unref(reply);
dbus_connection_flush(nat->conn);
#endif
return 0;
}
static jboolean cancelDeviceCreationNative(JNIEnv *env, jobject object,
jstring address) {
LOGV(__FUNCTION__);
jboolean result = JNI_FALSE;
#ifdef HAVE_BLUETOOTH
native_data_t *nat = get_native_data(env, object);
if (nat) {
const char *c_address = env->GetStringUTFChars(address, NULL);
DBusError err;
dbus_error_init(&err);
LOGV("... address = %s", c_address);
DBusMessage *reply =
dbus_func_args_timeout(env, nat->conn, -1,
get_adapter_path(env, object),
DBUS_ADAPTER_IFACE, "CancelDeviceCreation",
DBUS_TYPE_STRING, &c_address,
DBUS_TYPE_INVALID);
env->ReleaseStringUTFChars(address, c_address);
if (!reply) {
if (dbus_error_is_set(&err)) {
LOG_AND_FREE_DBUS_ERROR(&err);
} else
LOGE("DBus reply is NULL in function %s", __FUNCTION__);
return JNI_FALSE;
} else {
result = JNI_TRUE;
}
dbus_message_unref(reply);
}
#endif
return JNI_FALSE;
}
bool
DBusThread::SetUpEventLoop()
{
// If we already have a connection, exit
if (mConnection) {
return false;
}
dbus_threads_init_default();
DBusError err;
dbus_error_init(&err);
// If we can't establish a connection to dbus, nothing else will work
nsresult rv = EstablishDBusConnection();
if (NS_FAILED(rv)) {
NS_WARNING("Cannot create DBus Connection for DBus Thread!");
return false;
}
// Set which messages will be processed by this dbus connection.
// Since we are maintaining a single thread for all the DBus bluez
// signals we want, register all of them in this thread at startup.
// The event handler will sort the destinations out as needed.
for (uint32_t i = 0; i < ArrayLength(DBUS_SIGNALS); ++i) {
dbus_bus_add_match(mConnection,
DBUS_SIGNALS[i],
&err);
if (dbus_error_is_set(&err)) {
LOG_AND_FREE_DBUS_ERROR(&err);
return false;
}
}
return true;
}
void onStatusReply(DBusMessage *msg, void *user, void *n) {
LOGV(__FUNCTION__);
native_data_t *nat = (native_data_t *)n;
DBusError err;
dbus_error_init(&err);
if (dbus_set_error_from_message(&err, msg)) {
LOG_AND_FREE_DBUS_ERROR(&err);
}
}
static jboolean writeValueCommandNative(JNIEnv *env, jobject object, jstring path, jbyteArray buff)
{
#ifdef HAVE_BLUETOOTH
LOGV("%s", __FUNCTION__);
native_data_t *nat = get_native_data(env, object);
if (nat) {
DBusMessage *msg, *reply;
DBusError err;
dbus_error_init(&err);
jsize len = env->GetArrayLength(buff);
uint16_t offset = 0;
uint16_t timeout = 0;
const char *c_op = "WriteWithoutResponse";
jbyte *value = env->GetByteArrayElements(buff, NULL);
if (value == NULL)
return false;
const char *c_path = env->GetStringUTFChars(path, NULL);
LOGE("%s c_path=%s buff_len=%d",__FUNCTION__, c_path,len);
reply = dbus_func_args_timeout(env,
nat->conn, -1, c_path,
DBUS_CHAR_IFACE, "WriteValue",
DBUS_TYPE_ARRAY,DBUS_TYPE_BYTE, &value, len,
DBUS_TYPE_STRING, &c_op,
DBUS_TYPE_UINT16, &offset,
DBUS_TYPE_UINT16, &timeout,
DBUS_TYPE_INVALID);
env->ReleaseStringUTFChars(path, c_path);
env->ReleaseByteArrayElements(buff, value, 0);
if (!reply) {
if (dbus_error_is_set(&err)) {
LOG_AND_FREE_DBUS_ERROR(&err);
} else
LOGE("DBus reply is NULL in function %s", __FUNCTION__);
LOGE("%s returning null for some reason", __FUNCTION__);
return false;
}
dbus_message_unref(reply);
return true;
}
#endif
return false;
}
static jboolean setCharacteristicPropertyNative(JNIEnv *env, jobject object, jstring path, jstring property, void *value, jint type)
{
#ifdef HAVE_BLUETOOTH
LOGV("%s", __FUNCTION__);
native_data_t *nat = get_native_data(env, object);
if (nat) {
DBusMessage *msg;
DBusMessageIter iter;
DBusError err;
dbus_error_init(&err);
const char *c_path = env->GetStringUTFChars(path, NULL);
const char *c_key = env->GetStringUTFChars(property, NULL);
dbus_bool_t reply = JNI_FALSE;
LOGE("%s c_path=%s",__FUNCTION__, c_path);
msg = dbus_message_new_method_call(BLUEZ_DBUS_BASE_IFC,
c_path, DBUS_CHAR_IFACE, "SetProperty");
if (!msg) {
LOGE("%s: Can't allocate new method call for device SetProperty!", __FUNCTION__);
env->ReleaseStringUTFChars(path, c_path);
env->ReleaseStringUTFChars(property, c_key);
return JNI_FALSE;
}
dbus_message_append_args(msg, DBUS_TYPE_STRING, &c_key, DBUS_TYPE_INVALID);
dbus_message_iter_init_append(msg, &iter);
append_variant(&iter, type, value);
reply = dbus_connection_send_with_reply(nat->conn, msg, NULL, -1);
if (!reply) {
if (dbus_error_is_set(&err)) {
LOG_AND_FREE_DBUS_ERROR(&err);
} else {
LOGE("DBus reply is NULL in function %s", __FUNCTION__);
}
}
dbus_message_unref(msg);
env->ReleaseStringUTFChars(path, c_path);
env->ReleaseStringUTFChars(property, c_key);
return reply ? JNI_TRUE : JNI_FALSE;
}
#endif
return JNI_FALSE;
}
static jobjectArray discoverServiceCharacteristicsNative(JNIEnv *env,
jobject object, jstring path)
{
#ifdef HAVE_BLUETOOTH
LOGV("%s", __FUNCTION__);
native_data_t *nat = get_native_data(env, object);
if (nat) {
DBusMessage *msg, *reply;
DBusError err;
dbus_error_init(&err);
const char *c_path = env->GetStringUTFChars(path, NULL);
LOGE("%s c_path=%s",__FUNCTION__, c_path);
reply = dbus_func_args_timeout(env,
nat->conn, -1, c_path,
DBUS_CHAR_IFACE, "DiscoverCharacteristics",
DBUS_TYPE_INVALID);
env->ReleaseStringUTFChars(path, c_path);
if (!reply) {
if (dbus_error_is_set(&err)) {
LOG_AND_FREE_DBUS_ERROR(&err);
} else
LOGE("DBus reply is NULL in function %s", __FUNCTION__);
LOGE("%s returning null for some reason", __FUNCTION__);
return NULL;
}
env->PushLocalFrame(30);
DBusMessageIter iter;
jobjectArray str_array = NULL;
if (dbus_message_iter_init(reply, &iter)) {
str_array = dbus_returns_array_of_object_path(env,reply);
}
return (jobjectArray) env->PopLocalFrame(str_array);
}
#endif
return NULL;
}
static jboolean setAdapterPropertyNative(JNIEnv *env, jobject object, jstring key,
void *value, jint type) {
#ifdef HAVE_BLUETOOTH
LOGV(__FUNCTION__);
native_data_t *nat = get_native_data(env, object);
if (nat) {
DBusMessage *reply, *msg;
DBusMessageIter iter;
DBusError err;
const char *c_key = env->GetStringUTFChars(key, NULL);
dbus_error_init(&err);
msg = dbus_message_new_method_call(BLUEZ_DBUS_BASE_IFC,
get_adapter_path(env, object),
DBUS_ADAPTER_IFACE, "SetProperty");
if (!msg) {
LOGE("%s: Can't allocate new method call for GetProperties!",
__FUNCTION__);
env->ReleaseStringUTFChars(key, c_key);
return JNI_FALSE;
}
dbus_message_append_args(msg, DBUS_TYPE_STRING, &c_key, DBUS_TYPE_INVALID);
dbus_message_iter_init_append(msg, &iter);
append_variant(&iter, type, value);
reply = dbus_connection_send_with_reply_and_block(nat->conn, msg, -1, &err);
dbus_message_unref(msg);
env->ReleaseStringUTFChars(key, c_key);
if (!reply) {
if (dbus_error_is_set(&err)) {
LOG_AND_FREE_DBUS_ERROR(&err);
} else
LOGE("DBus reply is NULL in function %s", __FUNCTION__);
return JNI_FALSE;
}
return JNI_TRUE;
}
#endif
return JNI_FALSE;
}
bool
DBusThread::TearDownEventLoop()
{
MOZ_ASSERT(mConnection);
DBusError err;
dbus_error_init(&err);
for (uint32_t i = 0; i < ArrayLength(DBUS_SIGNALS); ++i) {
dbus_bus_remove_match(mConnection,
DBUS_SIGNALS[i],
&err);
if (dbus_error_is_set(&err)) {
LOG_AND_FREE_DBUS_ERROR(&err);
}
}
return true;
}
static jboolean readValueCommandNative(JNIEnv *env, jobject object, jstring path, jint offst)
{
#ifdef HAVE_BLUETOOTH
LOGV("%s", __FUNCTION__);
native_data_t *nat = get_native_data(env, object);
if (nat) {
DBusMessage *msg, *reply;
DBusError err;
dbus_error_init(&err);
uint16_t offset = 0; /* TODO : Do not ignore the offst function argument */
uint16_t timeout = 0;
const char *c_path = env->GetStringUTFChars(path, NULL);
LOGE("%s c_path=%s offset=%d",__FUNCTION__, c_path,offst);
reply = dbus_func_args_timeout(env,
nat->conn, -1, c_path,
DBUS_CHAR_IFACE, "ReadValue",
DBUS_TYPE_UINT16, &offset,
DBUS_TYPE_UINT16, &timeout,
DBUS_TYPE_INVALID);
env->ReleaseStringUTFChars(path, c_path);
if (!reply) {
if (dbus_error_is_set(&err)) {
LOG_AND_FREE_DBUS_ERROR(&err);
} else
LOGE("DBus reply is NULL in function %s", __FUNCTION__);
LOGE("%s returning null for some reason", __FUNCTION__);
return false;
}
dbus_message_unref(reply);
return true;
}
#endif
return false;
}
static jobjectArray getDevicePropertiesNative(JNIEnv *env, jobject object,
jstring path)
{
#ifdef HAVE_BLUETOOTH
LOGV(__FUNCTION__);
native_data_t *nat = get_native_data(env, object);
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,
DBUS_DEVICE_IFACE, "GetProperties",
DBUS_TYPE_INVALID);
env->ReleaseStringUTFChars(path, c_path);
if (!reply) {
if (dbus_error_is_set(&err)) {
LOG_AND_FREE_DBUS_ERROR(&err);
} else
LOGE("DBus reply is NULL in function %s", __FUNCTION__);
return NULL;
}
env->PushLocalFrame(PROPERTIES_NREFS);
DBusMessageIter iter;
jobjectArray str_array = NULL;
if (dbus_message_iter_init(reply, &iter))
str_array = parse_remote_device_properties(env, &iter);
dbus_message_unref(reply);
env->PopLocalFrame(NULL);
return str_array;
}
#endif
return NULL;
}
static jbyteArray readAdapterOutOfBandDataNative(JNIEnv *env, jobject object) {
LOGV(__FUNCTION__);
#ifdef HAVE_BLUETOOTH
native_data_t *nat = get_native_data(env, object);
DBusError err;
jbyte *hash, *randomizer;
jbyteArray byteArray = NULL;
int hash_len, r_len;
if (nat) {
DBusMessage *reply = dbus_func_args(env, nat->conn,
get_adapter_path(env, object),
DBUS_ADAPTER_IFACE, "ReadLocalOutOfBandData",
DBUS_TYPE_INVALID);
if (!reply) return NULL;
dbus_error_init(&err);
if (dbus_message_get_args(reply, &err,
DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &hash, &hash_len,
DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &randomizer, &r_len,
DBUS_TYPE_INVALID)) {
if (hash_len == 16 && r_len == 16) {
byteArray = env->NewByteArray(32);
if (byteArray) {
env->SetByteArrayRegion(byteArray, 0, 16, hash);
env->SetByteArrayRegion(byteArray, 16, 16, randomizer);
}
} else {
LOGE("readAdapterOutOfBandDataNative: Hash len = %d, R len = %d",
hash_len, r_len);
}
} else {
LOG_AND_FREE_DBUS_ERROR(&err);
}
dbus_message_unref(reply);
return byteArray;
}
#endif
return NULL;
}
