frameworks/base/core/jni/android_server_BluetoothEventLoop.cpp

   1 /*
   2 ** Copyright 2008, The Android Open Source Project
   3 **
   4 ** Licensed under the Apache License, Version 2.0 (the "License");
   5 ** you may not use this file except in compliance with the License.
   6 ** You may obtain a copy of the License at
   7 **
   8 **     http://www.apache.org/licenses/LICENSE-2.0
   9 **
  10 ** Unless required by applicable law or agreed to in writing, software
  11 ** distributed under the License is distributed on an "AS IS" BASIS,
  12 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 ** See the License for the specific language governing permissions and
  14 ** limitations under the License.
  15 */
  16
  17 #define LOG_TAG "BluetoothEventLoop.cpp"
  18
  19 #include "android_bluetooth_common.h"
  20 #include "android_runtime/AndroidRuntime.h"
  21 #include "cutils/sockets.h"
  22 #include "JNIHelp.h"
  23 #include "jni.h"
  24 #include "utils/Log.h"
  25 #include "utils/misc.h"
  26
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <stdlib.h>
  30 #include <errno.h>
  31 #include <unistd.h>
  32
  33 #ifdef HAVE_BLUETOOTH
  34 #include <dbus/dbus.h>
  35 #endif
  36
  37 namespace android {
  38
  39 #define CREATE_DEVICE_ALREADY_EXISTS 1
  40 #define CREATE_DEVICE_SUCCESS 0
  41 #define CREATE_DEVICE_FAILED -1
  42
  43 #ifdef HAVE_BLUETOOTH
  44 static jfieldID field_mNativeData;
  45
  46 static jmethodID method_onPropertyChanged;
  47 static jmethodID method_onDevicePropertyChanged;
  48 static jmethodID method_onDeviceFound;
  49 static jmethodID method_onDeviceDisappeared;
  50 static jmethodID method_onDeviceCreated;
  51 static jmethodID method_onDeviceRemoved;
  52 static jmethodID method_onDeviceDisconnectRequested;
  53
  54 static jmethodID method_onCreatePairedDeviceResult;
  55 static jmethodID method_onCreateDeviceResult;
  56 static jmethodID method_onDiscoverServicesResult;
  57 static jmethodID method_onGetDeviceServiceChannelResult;
  58
  59 static jmethodID method_onRequestPinCode;
  60 static jmethodID method_onRequestPasskey;
  61 static jmethodID method_onRequestPasskeyConfirmation;
  62 static jmethodID method_onRequestPairingConsent;
  63 static jmethodID method_onDisplayPasskey;
  64 static jmethodID method_onRequestOobData;
  65 static jmethodID method_onAgentOutOfBandDataAvailable;
  66 static jmethodID method_onAgentAuthorize;
  67 static jmethodID method_onAgentCancel;
  68
  69 typedef event_loop_native_data_t native_data_t;
  70
  71 #define EVENT_LOOP_REFS 10
  72
  73 static inline native_data_t * get_native_data(JNIEnv *env, jobject object) {
  74     return (native_data_t *)(env->GetIntField(object,
  75                                                  field_mNativeData));
  76 }
  77
  78 native_data_t *get_EventLoop_native_data(JNIEnv *env, jobject object) {
  79     return get_native_data(env, object);
  80 }
  81
  82 #endif
  83 static void classInitNative(JNIEnv* env, jclass clazz) {
  84     LOGV(__FUNCTION__);
  85
  86 #ifdef HAVE_BLUETOOTH
  87     method_onPropertyChanged = env->GetMethodID(clazz, "onPropertyChanged",
  88                                                 "([Ljava/lang/String;)V");
  89     method_onDevicePropertyChanged = env->GetMethodID(clazz,
  90                                                       "onDevicePropertyChanged",
  91                                                       "(Ljava/lang/String;[Ljava/lang/String;)V");
  92     method_onDeviceFound = env->GetMethodID(clazz, "onDeviceFound",
  93                                             "(Ljava/lang/String;[Ljava/lang/String;)V");
  94     method_onDeviceDisappeared = env->GetMethodID(clazz, "onDeviceDisappeared",
  95                                                   "(Ljava/lang/String;)V");
  96     method_onDeviceCreated = env->GetMethodID(clazz, "onDeviceCreated", "(Ljava/lang/String;)V");
  97     method_onDeviceRemoved = env->GetMethodID(clazz, "onDeviceRemoved", "(Ljava/lang/String;)V");
  98     method_onDeviceDisconnectRequested = env->GetMethodID(clazz, "onDeviceDisconnectRequested",
  99                                                         "(Ljava/lang/String;)V");
 100
 101     method_onCreatePairedDeviceResult = env->GetMethodID(clazz, "onCreatePairedDeviceResult",
 102                                                          "(Ljava/lang/String;I)V");
 103     method_onCreateDeviceResult = env->GetMethodID(clazz, "onCreateDeviceResult",
 104                                                          "(Ljava/lang/String;I)V");
 105     method_onDiscoverServicesResult = env->GetMethodID(clazz, "onDiscoverServicesResult",
 106                                                          "(Ljava/lang/String;Z)V");
 107
 108     method_onAgentAuthorize = env->GetMethodID(clazz, "onAgentAuthorize",
 109                                                "(Ljava/lang/String;Ljava/lang/String;)Z");
 110     method_onAgentOutOfBandDataAvailable = env->GetMethodID(clazz, "onAgentOutOfBandDataAvailable",
 111                                                "(Ljava/lang/String;)Z");
 112     method_onAgentCancel = env->GetMethodID(clazz, "onAgentCancel", "()V");
 113     method_onRequestPinCode = env->GetMethodID(clazz, "onRequestPinCode",
 114                                                "(Ljava/lang/String;I)V");
 115     method_onRequestPasskey = env->GetMethodID(clazz, "onRequestPasskey",
 116                                                "(Ljava/lang/String;I)V");
 117     method_onRequestPasskeyConfirmation = env->GetMethodID(clazz, "onRequestPasskeyConfirmation",
 118                                                "(Ljava/lang/String;II)V");
 119     method_onRequestPairingConsent = env->GetMethodID(clazz, "onRequestPairingConsent",
 120                                                "(Ljava/lang/String;I)V");
 121     method_onDisplayPasskey = env->GetMethodID(clazz, "onDisplayPasskey",
 122                                                "(Ljava/lang/String;II)V");
 123     method_onRequestOobData = env->GetMethodID(clazz, "onRequestOobData",
 124                                                "(Ljava/lang/String;I)V");
 125
 126     field_mNativeData = env->GetFieldID(clazz, "mNativeData", "I");
 127 #endif
 128 }
 129
 130 static void initializeNativeDataNative(JNIEnv* env, jobject object) {
 131     LOGV(__FUNCTION__);
 132 #ifdef HAVE_BLUETOOTH
 133     native_data_t *nat = (native_data_t *)calloc(1, sizeof(native_data_t));
 134     if (NULL == nat) {
 135         LOGE("%s: out of memory!", __FUNCTION__);
 136         return;
 137     }
 138     memset(nat, 0, sizeof(native_data_t));
 139
 140     pthread_mutex_init(&(nat->thread_mutex), NULL);
 141
 142     env->SetIntField(object, field_mNativeData, (jint)nat);
 143
 144     {
 145         DBusError err;
 146         dbus_error_init(&err);
 147         dbus_threads_init_default();
 148         nat->conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
 149         if (dbus_error_is_set(&err)) {
 150             LOGE("%s: Could not get onto the system bus!", __FUNCTION__);
 151             dbus_error_free(&err);
 152         }
 153         dbus_connection_set_exit_on_disconnect(nat->conn, FALSE);
 154     }
 155 #endif
 156 }
 157
 158 static void cleanupNativeDataNative(JNIEnv* env, jobject object) {
 159     LOGV(__FUNCTION__);
 160 #ifdef HAVE_BLUETOOTH
 161     native_data_t *nat =
 162             (native_data_t *)env->GetIntField(object, field_mNativeData);
 163
 164     pthread_mutex_destroy(&(nat->thread_mutex));
 165
 166     if (nat) {
 167         free(nat);
 168     }
 169 #endif
 170 }
 171
 172 #ifdef HAVE_BLUETOOTH
 173 static DBusHandlerResult event_filter(DBusConnection *conn, DBusMessage *msg,
 174                                       void *data);
 175 DBusHandlerResult agent_event_filter(DBusConnection *conn,
 176                                      DBusMessage *msg,
 177                                      void *data);
 178 static int register_agent(native_data_t *nat,
 179                           const char *agent_path, const char *capabilities);
 180
 181 static const DBusObjectPathVTable agent_vtable = {
 182     NULL, agent_event_filter, NULL, NULL, NULL, NULL
 183 };
 184
 185 static unsigned int unix_events_to_dbus_flags(short events) {
 186     return (events & DBUS_WATCH_READABLE ? POLLIN : 0) |
 187            (events & DBUS_WATCH_WRITABLE ? POLLOUT : 0) |
 188            (events & DBUS_WATCH_ERROR ? POLLERR : 0) |
 189            (events & DBUS_WATCH_HANGUP ? POLLHUP : 0);
 190 }
 191
 192 static short dbus_flags_to_unix_events(unsigned int flags) {
 193     return (flags & POLLIN ? DBUS_WATCH_READABLE : 0) |
 194            (flags & POLLOUT ? DBUS_WATCH_WRITABLE : 0) |
 195            (flags & POLLERR ? DBUS_WATCH_ERROR : 0) |
 196            (flags & POLLHUP ? DBUS_WATCH_HANGUP : 0);
 197 }
 198
 199 static jboolean setUpEventLoop(native_data_t *nat) {
 200     LOGV(__FUNCTION__);
 201
 202     if (nat != NULL && nat->conn != NULL) {
 203         dbus_threads_init_default();
 204         DBusError err;
 205         dbus_error_init(&err);
 206
 207         // Add a filter for all incoming messages
 208         if (!dbus_connection_add_filter(nat->conn, event_filter, nat, NULL)){
 209             return JNI_FALSE;
 210         }
 211
 212         // Set which messages will be processed by this dbus connection
 213         dbus_bus_add_match(nat->conn,
 214                 "type='signal',interface='org.freedesktop.DBus'",
 215                 &err);
 216         if (dbus_error_is_set(&err)) {
 217             LOG_AND_FREE_DBUS_ERROR(&err);
 218             return JNI_FALSE;
 219         }
 220         dbus_bus_add_match(nat->conn,
 221                 "type='signal',interface='"BLUEZ_DBUS_BASE_IFC".Adapter'",
 222                 &err);
 223         if (dbus_error_is_set(&err)) {
 224             LOG_AND_FREE_DBUS_ERROR(&err);
 225             return JNI_FALSE;
 226         }
 227         dbus_bus_add_match(nat->conn,
 228                 "type='signal',interface='"BLUEZ_DBUS_BASE_IFC".Device'",
 229                 &err);
 230         if (dbus_error_is_set(&err)) {
 231             LOG_AND_FREE_DBUS_ERROR(&err);
 232             return JNI_FALSE;
 233         }
 234         dbus_bus_add_match(nat->conn,
 235                 "type='signal',interface='org.bluez.AudioSink'",
 236                 &err);
 237         if (dbus_error_is_set(&err)) {
 238             LOG_AND_FREE_DBUS_ERROR(&err);
 239             return JNI_FALSE;
 240         }
 241
 242         const char *agent_path = "/android/bluetooth/agent";
 243         const char *capabilities = "DisplayYesNo";
 244         if (register_agent(nat, agent_path, capabilities) < 0) {
 245             dbus_connection_unregister_object_path (nat->conn, agent_path);
 246             return JNI_FALSE;
 247         }
 248         return JNI_TRUE;
 249     }
 250     return JNI_FALSE;
 251 }
 252
 253
 254 const char * get_adapter_path(DBusConnection *conn) {
 255     DBusMessage *msg = NULL, *reply = NULL;
 256     DBusError err;
 257     const char *device_path = NULL;
 258     int attempt = 0;
 259
 260     for (attempt = 0; attempt < 1000 && reply == NULL; attempt ++) {
 261         msg = dbus_message_new_method_call("org.bluez", "/",
 262               "org.bluez.Manager", "DefaultAdapter");
 263         if (!msg) {
 264             LOGE("%s: Can't allocate new method call for get_adapter_path!",
 265                   __FUNCTION__);
 266             return NULL;
 267         }
 268         dbus_message_append_args(msg, DBUS_TYPE_INVALID);
 269         dbus_error_init(&err);
 270         reply = dbus_connection_send_with_reply_and_block(conn, msg, -1, &err);
 271
 272         if (!reply) {
 273             if (dbus_error_is_set(&err)) {
 274                 if (dbus_error_has_name(&err,
 275                     "org.freedesktop.DBus.Error.ServiceUnknown")) {
 276                     // bluetoothd is still down, retry
 277                     LOG_AND_FREE_DBUS_ERROR(&err);
 278                     usleep(10000);  // 10 ms
 279                     continue;
 280                 } else {
 281                     // Some other error we weren't expecting
 282                     LOG_AND_FREE_DBUS_ERROR(&err);
 283                 }
 284             }
 285             goto failed;
 286         }
 287     }
 288     if (attempt == 1000) {
 289         LOGE("Time out while trying to get Adapter path, is bluetoothd up ?");
 290         goto failed;
 291     }
 292
 293     if (!dbus_message_get_args(reply, &err, DBUS_TYPE_OBJECT_PATH,
 294                                &device_path, DBUS_TYPE_INVALID)
 295                                || !device_path){
 296         if (dbus_error_is_set(&err)) {
 297             LOG_AND_FREE_DBUS_ERROR(&err);
 298         }
 299         goto failed;
 300     }
 301     dbus_message_unref(msg);
 302     return device_path;
 303
 304 failed:
 305     dbus_message_unref(msg);
 306     return NULL;
 307 }
 308
 309 static int register_agent(native_data_t *nat,
 310                           const char * agent_path, const char * capabilities)
 311 {
 312     DBusMessage *msg, *reply;
 313     DBusError err;
 314     bool oob = TRUE;
 315
 316     if (!dbus_connection_register_object_path(nat->conn, agent_path,
 317             &agent_vtable, nat)) {
 318         LOGE("%s: Can't register object path %s for agent!",
 319               __FUNCTION__, agent_path);
 320         return -1;
 321     }
 322
 323     nat->adapter = get_adapter_path(nat->conn);
 324     if (nat->adapter == NULL) {
 325         return -1;
 326     }
 327     msg = dbus_message_new_method_call("org.bluez", nat->adapter,
 328           "org.bluez.Adapter", "RegisterAgent");
 329     if (!msg) {
 330         LOGE("%s: Can't allocate new method call for agent!",
 331               __FUNCTION__);
 332         return -1;
 333     }
 334     dbus_message_append_args(msg, DBUS_TYPE_OBJECT_PATH, &agent_path,
 335                              DBUS_TYPE_STRING, &capabilities,
 336                              DBUS_TYPE_BOOLEAN, &oob,
 337                              DBUS_TYPE_INVALID);
 338
 339     dbus_error_init(&err);
 340     reply = dbus_connection_send_with_reply_and_block(nat->conn, msg, -1, &err);
 341     dbus_message_unref(msg);
 342
 343     if (!reply) {
 344         LOGE("%s: Can't register agent!", __FUNCTION__);
 345         if (dbus_error_is_set(&err)) {
 346             LOG_AND_FREE_DBUS_ERROR(&err);
 347         }
 348         return -1;
 349     }
 350
 351     dbus_message_unref(reply);
 352     dbus_connection_flush(nat->conn);
 353
 354     return 0;
 355 }
 356
 357 static void tearDownEventLoop(native_data_t *nat) {
 358     LOGV(__FUNCTION__);
 359     if (nat != NULL && nat->conn != NULL) {
 360
 361         DBusMessage *msg, *reply;
 362         DBusError err;
 363         dbus_error_init(&err);
 364         const char * agent_path = "/android/bluetooth/agent";
 365
 366         msg = dbus_message_new_method_call("org.bluez",
 367                                            nat->adapter,
 368                                            "org.bluez.Adapter",
 369                                            "UnregisterAgent");
 370         if (msg != NULL) {
 371             dbus_message_append_args(msg, DBUS_TYPE_OBJECT_PATH, &agent_path,
 372                                      DBUS_TYPE_INVALID);
 373             reply = dbus_connection_send_with_reply_and_block(nat->conn,
 374                                                               msg, -1, &err);
 375
 376             if (!reply) {
 377                 if (dbus_error_is_set(&err)) {
 378                     LOG_AND_FREE_DBUS_ERROR(&err);
 379                     dbus_error_free(&err);
 380                 }
 381             } else {
 382                 dbus_message_unref(reply);
 383             }
 384             dbus_message_unref(msg);
 385         } else {
 386              LOGE("%s: Can't create new method call!", __FUNCTION__);
 387         }
 388
 389         dbus_connection_flush(nat->conn);
 390         dbus_connection_unregister_object_path(nat->conn, agent_path);
 391
 392         dbus_bus_remove_match(nat->conn,
 393                 "type='signal',interface='org.bluez.AudioSink'",
 394                 &err);
 395         if (dbus_error_is_set(&err)) {
 396             LOG_AND_FREE_DBUS_ERROR(&err);
 397         }
 398         dbus_bus_remove_match(nat->conn,
 399                 "type='signal',interface='org.bluez.Device'",
 400                 &err);
 401         if (dbus_error_is_set(&err)) {
 402             LOG_AND_FREE_DBUS_ERROR(&err);
 403         }
 404         dbus_bus_remove_match(nat->conn,
 405                 "type='signal',interface='org.bluez.audio.Manager'",
 406                 &err);
 407         if (dbus_error_is_set(&err)) {
 408             LOG_AND_FREE_DBUS_ERROR(&err);
 409         }
 410         dbus_bus_remove_match(nat->conn,
 411                 "type='signal',interface='"BLUEZ_DBUS_BASE_IFC".Adapter'",
 412                 &err);
 413         if (dbus_error_is_set(&err)) {
 414             LOG_AND_FREE_DBUS_ERROR(&err);
 415         }
 416         dbus_bus_remove_match(nat->conn,
 417                 "type='signal',interface='org.freedesktop.DBus'",
 418                 &err);
 419         if (dbus_error_is_set(&err)) {
 420             LOG_AND_FREE_DBUS_ERROR(&err);
 421         }
 422
 423         dbus_connection_remove_filter(nat->conn, event_filter, nat);
 424     }
 425 }
 426
 427
 428 #define EVENT_LOOP_EXIT 1
 429 #define EVENT_LOOP_ADD  2
 430 #define EVENT_LOOP_REMOVE 3
 431
 432 dbus_bool_t dbusAddWatch(DBusWatch *watch, void *data) {
 433     native_data_t *nat = (native_data_t *)data;
 434
 435     if (dbus_watch_get_enabled(watch)) {
 436         // note that we can't just send the watch and inspect it later
 437         // because we may get a removeWatch call before this data is reacted
 438         // to by our eventloop and remove this watch..  reading the add first
 439         // and then inspecting the recently deceased watch would be bad.
 440         char control = EVENT_LOOP_ADD;
 441         write(nat->controlFdW, &control, sizeof(char));
 442
 443         int fd = dbus_watch_get_fd(watch);
 444         write(nat->controlFdW, &fd, sizeof(int));
 445
 446         unsigned int flags = dbus_watch_get_flags(watch);
 447         write(nat->controlFdW, &flags, sizeof(unsigned int));
 448
 449         write(nat->controlFdW, &watch, sizeof(DBusWatch*));
 450     }
 451     return true;
 452 }
 453
 454 void dbusRemoveWatch(DBusWatch *watch, void *data) {
 455     native_data_t *nat = (native_data_t *)data;
 456
 457     char control = EVENT_LOOP_REMOVE;
 458     write(nat->controlFdW, &control, sizeof(char));
 459
 460     int fd = dbus_watch_get_fd(watch);
 461     write(nat->controlFdW, &fd, sizeof(int));
 462
 463     unsigned int flags = dbus_watch_get_flags(watch);
 464     write(nat->controlFdW, &flags, sizeof(unsigned int));
 465 }
 466
 467 void dbusToggleWatch(DBusWatch *watch, void *data) {
 468     if (dbus_watch_get_enabled(watch)) {
 469         dbusAddWatch(watch, data);
 470     } else {
 471         dbusRemoveWatch(watch, data);
 472     }
 473 }
 474
 475 static void handleWatchAdd(native_data_t *nat) {
 476     DBusWatch *watch;
 477     int newFD;
 478     unsigned int flags;
 479
 480     read(nat->controlFdR, &newFD, sizeof(int));
 481     read(nat->controlFdR, &flags, sizeof(unsigned int));
 482     read(nat->controlFdR, &watch, sizeof(DBusWatch *));
 483     short events = dbus_flags_to_unix_events(flags);
 484
 485     for (int y = 0; y<nat->pollMemberCount; y++) {
 486         if ((nat->pollData[y].fd == newFD) &&
 487                 (nat->pollData[y].events == events)) {
 488             LOGV("DBusWatch duplicate add");
 489             return;
 490         }
 491     }
 492     if (nat->pollMemberCount == nat->pollDataSize) {
 493         LOGV("Bluetooth EventLoop poll struct growing");
 494         struct pollfd *temp = (struct pollfd *)malloc(
 495                 sizeof(struct pollfd) * (nat->pollMemberCount+1));
 496         if (!temp) {
 497             return;
 498         }
 499         memcpy(temp, nat->pollData, sizeof(struct pollfd) *
 500                 nat->pollMemberCount);
 501         free(nat->pollData);
 502         nat->pollData = temp;
 503         DBusWatch **temp2 = (DBusWatch **)malloc(sizeof(DBusWatch *) *
 504                 (nat->pollMemberCount+1));
 505         if (!temp2) {
 506             return;
 507         }
 508         memcpy(temp2, nat->watchData, sizeof(DBusWatch *) *
 509                 nat->pollMemberCount);
 510         free(nat->watchData);
 511         nat->watchData = temp2;
 512         nat->pollDataSize++;
 513     }
 514     nat->pollData[nat->pollMemberCount].fd = newFD;
 515     nat->pollData[nat->pollMemberCount].revents = 0;
 516     nat->pollData[nat->pollMemberCount].events = events;
 517     nat->watchData[nat->pollMemberCount] = watch;
 518     nat->pollMemberCount++;
 519 }
 520
 521 static void handleWatchRemove(native_data_t *nat) {
 522     int removeFD;
 523     unsigned int flags;
 524
 525     read(nat->controlFdR, &removeFD, sizeof(int));
 526     read(nat->controlFdR, &flags, sizeof(unsigned int));
 527     short events = dbus_flags_to_unix_events(flags);
 528
 529     for (int y = 0; y < nat->pollMemberCount; y++) {
 530         if ((nat->pollData[y].fd == removeFD) &&
 531                 (nat->pollData[y].events == events)) {
 532             int newCount = --nat->pollMemberCount;
 533             // copy the last live member over this one
 534             nat->pollData[y].fd = nat->pollData[newCount].fd;
 535             nat->pollData[y].events = nat->pollData[newCount].events;
 536             nat->pollData[y].revents = nat->pollData[newCount].revents;
 537             nat->watchData[y] = nat->watchData[newCount];
 538             return;
 539         }
 540     }
 541     LOGW("WatchRemove given with unknown watch");
 542 }
 543
 544 static void *eventLoopMain(void *ptr) {
 545     native_data_t *nat = (native_data_t *)ptr;
 546     JNIEnv *env;
 547
 548     JavaVMAttachArgs args;
 549     char name[] = "BT EventLoop";
 550     args.version = nat->envVer;
 551     args.name = name;
 552     args.group = NULL;
 553
 554     nat->vm->AttachCurrentThread(&env, &args);
 555
 556     dbus_connection_set_watch_functions(nat->conn, dbusAddWatch,
 557             dbusRemoveWatch, dbusToggleWatch, ptr, NULL);
 558
 559     nat->running = true;
 560
 561     while (1) {
 562         for (int i = 0; i < nat->pollMemberCount; i++) {
 563             if (!nat->pollData[i].revents) {
 564                 continue;
 565             }
 566             if (nat->pollData[i].fd == nat->controlFdR) {
 567                 char data;
 568                 while (recv(nat->controlFdR, &data, sizeof(char), MSG_DONTWAIT)
 569                         != -1) {
 570                     switch (data) {
 571                     case EVENT_LOOP_EXIT:
 572                     {
 573                         dbus_connection_set_watch_functions(nat->conn,
 574                                 NULL, NULL, NULL, NULL, NULL);
 575                         tearDownEventLoop(nat);
 576                         nat->vm->DetachCurrentThread();
 577
 578                         int fd = nat->controlFdR;
 579                         nat->controlFdR = 0;
 580                         close(fd);
 581                         return NULL;
 582                     }
 583                     case EVENT_LOOP_ADD:
 584                     {
 585                         handleWatchAdd(nat);
 586                         break;
 587                     }
 588                     case EVENT_LOOP_REMOVE:
 589                     {
 590                         handleWatchRemove(nat);
 591                         break;
 592                     }
 593                     }
 594                 }
 595             } else {
 596                 short events = nat->pollData[i].revents;
 597                 unsigned int flags = unix_events_to_dbus_flags(events);
 598                 dbus_watch_handle(nat->watchData[i], flags);
 599                 nat->pollData[i].revents = 0;
 600                 // can only do one - it may have caused a 'remove'
 601                 break;
 602             }
 603         }
 604         while (dbus_connection_dispatch(nat->conn) ==
 605                 DBUS_DISPATCH_DATA_REMAINS) {
 606         }
 607
 608         poll(nat->pollData, nat->pollMemberCount, -1);
 609     }
 610 }
 611 #endif // HAVE_BLUETOOTH
 612
 613 static jboolean startEventLoopNative(JNIEnv *env, jobject object) {
 614     jboolean result = JNI_FALSE;
 615 #ifdef HAVE_BLUETOOTH
 616     event_loop_native_data_t *nat = get_native_data(env, object);
 617
 618     pthread_mutex_lock(&(nat->thread_mutex));
 619
 620     nat->running = false;
 621
 622     if (nat->pollData) {
 623         LOGW("trying to start EventLoop a second time!");
 624         pthread_mutex_unlock( &(nat->thread_mutex) );
 625         return JNI_FALSE;
 626     }
 627
 628     nat->pollData = (struct pollfd *)malloc(sizeof(struct pollfd) *
 629             DEFAULT_INITIAL_POLLFD_COUNT);
 630     if (!nat->pollData) {
 631         LOGE("out of memory error starting EventLoop!");
 632         goto done;
 633     }
 634
 635     nat->watchData = (DBusWatch **)malloc(sizeof(DBusWatch *) *
 636             DEFAULT_INITIAL_POLLFD_COUNT);
 637     if (!nat->watchData) {
 638         LOGE("out of memory error starting EventLoop!");
 639         goto done;
 640     }
 641
 642     memset(nat->pollData, 0, sizeof(struct pollfd) *
 643             DEFAULT_INITIAL_POLLFD_COUNT);
 644     memset(nat->watchData, 0, sizeof(DBusWatch *) *
 645             DEFAULT_INITIAL_POLLFD_COUNT);
 646     nat->pollDataSize = DEFAULT_INITIAL_POLLFD_COUNT;
 647     nat->pollMemberCount = 1;
 648
 649     if (socketpair(AF_LOCAL, SOCK_STREAM, 0, &(nat->controlFdR))) {
 650         LOGE("Error getting BT control socket");
 651         goto done;
 652     }
 653     nat->pollData[0].fd = nat->controlFdR;
 654     nat->pollData[0].events = POLLIN;
 655
 656     env->GetJavaVM( &(nat->vm) );
 657     nat->envVer = env->GetVersion();
 658
 659     nat->me = env->NewGlobalRef(object);
 660
 661     if (setUpEventLoop(nat) != JNI_TRUE) {
 662         LOGE("failure setting up Event Loop!");
 663         goto done;
 664     }
 665
 666     pthread_create(&(nat->thread), NULL, eventLoopMain, nat);
 667     result = JNI_TRUE;
 668
 669 done:
 670     if (JNI_FALSE == result) {
 671         if (nat->controlFdW) {
 672             close(nat->controlFdW);
 673             nat->controlFdW = 0;
 674         }
 675         if (nat->controlFdR) {
 676             close(nat->controlFdR);
 677             nat->controlFdR = 0;
 678         }
 679         if (nat->me) env->DeleteGlobalRef(nat->me);
 680         nat->me = NULL;
 681         if (nat->pollData) free(nat->pollData);
 682         nat->pollData = NULL;
 683         if (nat->watchData) free(nat->watchData);
 684         nat->watchData = NULL;
 685         nat->pollDataSize = 0;
 686         nat->pollMemberCount = 0;
 687     }
 688
 689     pthread_mutex_unlock(&(nat->thread_mutex));
 690 #endif // HAVE_BLUETOOTH
 691     return result;
 692 }
 693
 694 static void stopEventLoopNative(JNIEnv *env, jobject object) {
 695 #ifdef HAVE_BLUETOOTH
 696     native_data_t *nat = get_native_data(env, object);
 697
 698     pthread_mutex_lock(&(nat->thread_mutex));
 699     if (nat->pollData) {
 700         char data = EVENT_LOOP_EXIT;
 701         ssize_t t = write(nat->controlFdW, &data, sizeof(char));
 702         void *ret;
 703         pthread_join(nat->thread, &ret);
 704
 705         env->DeleteGlobalRef(nat->me);
 706         nat->me = NULL;
 707         free(nat->pollData);
 708         nat->pollData = NULL;
 709         free(nat->watchData);
 710         nat->watchData = NULL;
 711         nat->pollDataSize = 0;
 712         nat->pollMemberCount = 0;
 713
 714         int fd = nat->controlFdW;
 715         nat->controlFdW = 0;
 716         close(fd);
 717     }
 718     nat->running = false;
 719     pthread_mutex_unlock(&(nat->thread_mutex));
 720 #endif // HAVE_BLUETOOTH
 721 }
 722
 723 static jboolean isEventLoopRunningNative(JNIEnv *env, jobject object) {
 724     jboolean result = JNI_FALSE;
 725 #ifdef HAVE_BLUETOOTH
 726     native_data_t *nat = get_native_data(env, object);
 727
 728     pthread_mutex_lock(&(nat->thread_mutex));
 729     if (nat->running) {
 730         result = JNI_TRUE;
 731     }
 732     pthread_mutex_unlock(&(nat->thread_mutex));
 733
 734 #endif // HAVE_BLUETOOTH
 735     return result;
 736 }
 737
 738 #ifdef HAVE_BLUETOOTH
 739 extern DBusHandlerResult a2dp_event_filter(DBusMessage *msg, JNIEnv *env);
 740
 741 // Called by dbus during WaitForAndDispatchEventNative()
 742 static DBusHandlerResult event_filter(DBusConnection *conn, DBusMessage *msg,
 743                                       void *data) {
 744     native_data_t *nat;
 745     JNIEnv *env;
 746     DBusError err;
 747     DBusHandlerResult ret;
 748
 749     dbus_error_init(&err);
 750
 751     nat = (native_data_t *)data;
 752     nat->vm->GetEnv((void**)&env, nat->envVer);
 753     if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL) {
 754         LOGV("%s: not interested (not a signal).", __FUNCTION__);
 755         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 756     }
 757
 758     LOGE("%s: Received signal %s:%s from %s", __FUNCTION__,
 759         dbus_message_get_interface(msg), dbus_message_get_member(msg),
 760         dbus_message_get_path(msg));
 761
 762     env->PushLocalFrame(EVENT_LOOP_REFS);
 763     if (dbus_message_is_signal(msg,
 764                                "org.bluez.Adapter",
 765                                "DeviceFound")) {
 766         char *c_address;
 767         DBusMessageIter iter;
 768         jobjectArray str_array = NULL;
 769         if (dbus_message_iter_init(msg, &iter)) {
 770             dbus_message_iter_get_basic(&iter, &c_address);
 771             if (dbus_message_iter_next(&iter))
 772                 str_array =
 773                     parse_remote_device_properties(env, &iter);
 774         }
 775         if (str_array != NULL) {
 776             env->CallVoidMethod(nat->me,
 777                                 method_onDeviceFound,
 778                                 env->NewStringUTF(c_address),
 779                                 str_array);
 780         } else
 781             LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg);
 782         goto success;
 783     } else if (dbus_message_is_signal(msg,
 784                                      "org.bluez.Adapter",
 785                                      "DeviceDisappeared")) {
 786         char *c_address;
 787         if (dbus_message_get_args(msg, &err,
 788                                   DBUS_TYPE_STRING, &c_address,
 789                                   DBUS_TYPE_INVALID)) {
 790             LOGV("... address = %s", c_address);
 791             env->CallVoidMethod(nat->me, method_onDeviceDisappeared,
 792                                 env->NewStringUTF(c_address));
 793         } else LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg);
 794         goto success;
 795     } else if (dbus_message_is_signal(msg,
 796                                      "org.bluez.Adapter",
 797                                      "DeviceCreated")) {
 798         char *c_object_path;
 799         if (dbus_message_get_args(msg, &err,
 800                                   DBUS_TYPE_OBJECT_PATH, &c_object_path,
 801                                   DBUS_TYPE_INVALID)) {
 802             LOGV("... address = %s", c_object_path);
 803             env->CallVoidMethod(nat->me,
 804                                 method_onDeviceCreated,
 805                                 env->NewStringUTF(c_object_path));
 806         } else LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg);
 807         goto success;
 808     } else if (dbus_message_is_signal(msg,
 809                                      "org.bluez.Adapter",
 810                                      "DeviceRemoved")) {
 811         char *c_object_path;
 812         if (dbus_message_get_args(msg, &err,
 813                                  DBUS_TYPE_OBJECT_PATH, &c_object_path,
 814                                  DBUS_TYPE_INVALID)) {
 815            LOGV("... Object Path = %s", c_object_path);
 816            env->CallVoidMethod(nat->me,
 817                                method_onDeviceRemoved,
 818                                env->NewStringUTF(c_object_path));
 819         } else LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg);
 820         goto success;
 821     } else if (dbus_message_is_signal(msg,
 822                                       "org.bluez.Adapter",
 823                                       "PropertyChanged")) {
 824         jobjectArray str_array = parse_adapter_property_change(env, msg);
 825         if (str_array != NULL) {
 826             /* Check if bluetoothd has (re)started, if so update the path. */
 827             jstring property =(jstring) env->GetObjectArrayElement(str_array, 0);
 828             const char *c_property = env->GetStringUTFChars(property, NULL);
 829             if (!strncmp(c_property, "Powered", strlen("Powered"))) {
 830                 jstring value =
 831                     (jstring) env->GetObjectArrayElement(str_array, 1);
 832                 const char *c_value = env->GetStringUTFChars(value, NULL);
 833                 if (!strncmp(c_value, "true", strlen("true")))
 834                     nat->adapter = get_adapter_path(nat->conn);
 835                 env->ReleaseStringUTFChars(value, c_value);
 836             }
 837             env->ReleaseStringUTFChars(property, c_property);
 838
 839             env->CallVoidMethod(nat->me,
 840                               method_onPropertyChanged,
 841                               str_array);
 842         } else LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg);
 843         goto success;
 844     } else if (dbus_message_is_signal(msg,
 845                                       "org.bluez.Device",
 846                                       "PropertyChanged")) {
 847         jobjectArray str_array = parse_remote_device_property_change(env, msg);
 848         if (str_array != NULL) {
 849             const char *remote_device_path = dbus_message_get_path(msg);
 850             env->CallVoidMethod(nat->me,
 851                             method_onDevicePropertyChanged,
 852                             env->NewStringUTF(remote_device_path),
 853                             str_array);
 854         } else LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg);
 855         goto success;
 856     } else if (dbus_message_is_signal(msg,
 857                                       "org.bluez.Device",
 858                                       "DisconnectRequested")) {
 859         const char *remote_device_path = dbus_message_get_path(msg);
 860         env->CallVoidMethod(nat->me,
 861                             method_onDeviceDisconnectRequested,
 862                             env->NewStringUTF(remote_device_path));
 863         goto success;
 864     }
 865
 866     ret = a2dp_event_filter(msg, env);
 867     env->PopLocalFrame(NULL);
 868     return ret;
 869
 870 success:
 871     env->PopLocalFrame(NULL);
 872     return DBUS_HANDLER_RESULT_HANDLED;
 873 }
 874
 875 // Called by dbus during WaitForAndDispatchEventNative()
 876 DBusHandlerResult agent_event_filter(DBusConnection *conn,
 877                                      DBusMessage *msg, void *data) {
 878     native_data_t *nat = (native_data_t *)data;
 879     JNIEnv *env;
 880     if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_METHOD_CALL) {
 881         LOGV("%s: not interested (not a method call).", __FUNCTION__);
 882         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 883     }
 884     LOGI("%s: Received method %s:%s", __FUNCTION__,
 885          dbus_message_get_interface(msg), dbus_message_get_member(msg));
 886
 887     if (nat == NULL) return DBUS_HANDLER_RESULT_HANDLED;
 888
 889     nat->vm->GetEnv((void**)&env, nat->envVer);
 890     env->PushLocalFrame(EVENT_LOOP_REFS);
 891
 892     if (dbus_message_is_method_call(msg,
 893             "org.bluez.Agent", "Cancel")) {
 894         env->CallVoidMethod(nat->me, method_onAgentCancel);
 895         // reply
 896         DBusMessage *reply = dbus_message_new_method_return(msg);
 897         if (!reply) {
 898             LOGE("%s: Cannot create message reply\n", __FUNCTION__);
 899             goto failure;
 900         }
 901         dbus_connection_send(nat->conn, reply, NULL);
 902         dbus_message_unref(reply);
 903         goto success;
 904
 905     } else if (dbus_message_is_method_call(msg,
 906             "org.bluez.Agent", "Authorize")) {
 907         char *object_path;
 908         const char *uuid;
 909         if (!dbus_message_get_args(msg, NULL,
 910                                    DBUS_TYPE_OBJECT_PATH, &object_path,
 911                                    DBUS_TYPE_STRING, &uuid,
 912                                    DBUS_TYPE_INVALID)) {
 913             LOGE("%s: Invalid arguments for Authorize() method", __FUNCTION__);
 914             goto failure;
 915         }
 916
 917         LOGV("... object_path = %s", object_path);
 918         LOGV("... uuid = %s", uuid);
 919
 920         bool auth_granted =
 921             env->CallBooleanMethod(nat->me, method_onAgentAuthorize,
 922                 env->NewStringUTF(object_path), env->NewStringUTF(uuid));
 923
 924         // reply
 925         if (auth_granted) {
 926             DBusMessage *reply = dbus_message_new_method_return(msg);
 927             if (!reply) {
 928                 LOGE("%s: Cannot create message reply\n", __FUNCTION__);
 929                 goto failure;
 930             }
 931             dbus_connection_send(nat->conn, reply, NULL);
 932             dbus_message_unref(reply);
 933         } else {
 934             DBusMessage *reply = dbus_message_new_error(msg,
 935                     "org.bluez.Error.Rejected", "Authorization rejected");
 936             if (!reply) {
 937                 LOGE("%s: Cannot create message reply\n", __FUNCTION__);
 938                 goto failure;
 939             }
 940             dbus_connection_send(nat->conn, reply, NULL);
 941             dbus_message_unref(reply);
 942         }
 943         goto success;
 944     } else if (dbus_message_is_method_call(msg,
 945             "org.bluez.Agent", "OutOfBandAvailable")) {
 946         char *object_path;
 947         if (!dbus_message_get_args(msg, NULL,
 948                                    DBUS_TYPE_OBJECT_PATH, &object_path,
 949                                    DBUS_TYPE_INVALID)) {
 950             LOGE("%s: Invalid arguments for OutOfBandData available() method", __FUNCTION__);
 951             goto failure;
 952         }
 953
 954         LOGV("... object_path = %s", object_path);
 955
 956         bool available =
 957             env->CallBooleanMethod(nat->me, method_onAgentOutOfBandDataAvailable,
 958                 env->NewStringUTF(object_path));
 959
 960
 961         // reply
 962         if (available) {
 963             DBusMessage *reply = dbus_message_new_method_return(msg);
 964             if (!reply) {
 965                 LOGE("%s: Cannot create message reply\n", __FUNCTION__);
 966                 goto failure;
 967             }
 968             dbus_connection_send(nat->conn, reply, NULL);
 969             dbus_message_unref(reply);
 970         } else {
 971             DBusMessage *reply = dbus_message_new_error(msg,
 972                     "org.bluez.Error.DoesNotExist", "OutofBand data not available");
 973             if (!reply) {
 974                 LOGE("%s: Cannot create message reply\n", __FUNCTION__);
 975                 goto failure;
 976             }
 977             dbus_connection_send(nat->conn, reply, NULL);
 978             dbus_message_unref(reply);
 979         }
 980         goto success;
 981     } else if (dbus_message_is_method_call(msg,
 982             "org.bluez.Agent", "RequestPinCode")) {
 983         char *object_path;
 984         if (!dbus_message_get_args(msg, NULL,
 985                                    DBUS_TYPE_OBJECT_PATH, &object_path,
 986                                    DBUS_TYPE_INVALID)) {
 987             LOGE("%s: Invalid arguments for RequestPinCode() method", __FUNCTION__);
 988             goto failure;
 989         }
 990
 991         dbus_message_ref(msg);  // increment refcount because we pass to java
 992         env->CallVoidMethod(nat->me, method_onRequestPinCode,
 993                                        env->NewStringUTF(object_path),
 994                                        int(msg));
 995         goto success;
 996     } else if (dbus_message_is_method_call(msg,
 997             "org.bluez.Agent", "RequestPasskey")) {
 998         char *object_path;
 999         if (!dbus_message_get_args(msg, NULL,
1000                                    DBUS_TYPE_OBJECT_PATH, &object_path,
1001                                    DBUS_TYPE_INVALID)) {
1002             LOGE("%s: Invalid arguments for RequestPasskey() method", __FUNCTION__);
1003             goto failure;
1004         }
1005
1006         dbus_message_ref(msg);  // increment refcount because we pass to java
1007         env->CallVoidMethod(nat->me, method_onRequestPasskey,
1008                                        env->NewStringUTF(object_path),
1009                                        int(msg));
1010         goto success;
1011     } else if (dbus_message_is_method_call(msg,
1012             "org.bluez.Agent", "RequestOobData")) {
1013         char *object_path;
1014         if (!dbus_message_get_args(msg, NULL,
1015                                    DBUS_TYPE_OBJECT_PATH, &object_path,
1016                                    DBUS_TYPE_INVALID)) {
1017             LOGE("%s: Invalid arguments for RequestOobData() method", __FUNCTION__);
1018             goto failure;
1019         }
1020
1021         dbus_message_ref(msg);  // increment refcount because we pass to java
1022         env->CallVoidMethod(nat->me, method_onRequestOobData,
1023                                        env->NewStringUTF(object_path),
1024                                        int(msg));
1025         goto success;
1026     } else if (dbus_message_is_method_call(msg,
1027             "org.bluez.Agent", "DisplayPasskey")) {
1028         char *object_path;
1029         uint32_t passkey;
1030         if (!dbus_message_get_args(msg, NULL,
1031                                    DBUS_TYPE_OBJECT_PATH, &object_path,
1032                                    DBUS_TYPE_UINT32, &passkey,
1033                                    DBUS_TYPE_INVALID)) {
1034             LOGE("%s: Invalid arguments for RequestPasskey() method", __FUNCTION__);
1035             goto failure;
1036         }
1037
1038         dbus_message_ref(msg);  // increment refcount because we pass to java
1039         env->CallVoidMethod(nat->me, method_onDisplayPasskey,
1040                                        env->NewStringUTF(object_path),
1041                                        passkey,
1042                                        int(msg));
1043         goto success;
1044     } else if (dbus_message_is_method_call(msg,
1045             "org.bluez.Agent", "RequestConfirmation")) {
1046         char *object_path;
1047         uint32_t passkey;
1048         if (!dbus_message_get_args(msg, NULL,
1049                                    DBUS_TYPE_OBJECT_PATH, &object_path,
1050                                    DBUS_TYPE_UINT32, &passkey,
1051                                    DBUS_TYPE_INVALID)) {
1052             LOGE("%s: Invalid arguments for RequestConfirmation() method", __FUNCTION__);
1053             goto failure;
1054         }
1055
1056         dbus_message_ref(msg);  // increment refcount because we pass to java
1057         env->CallVoidMethod(nat->me, method_onRequestPasskeyConfirmation,
1058                                        env->NewStringUTF(object_path),
1059                                        passkey,
1060                                        int(msg));
1061         goto success;
1062     } else if (dbus_message_is_method_call(msg,
1063             "org.bluez.Agent", "RequestPairingConsent")) {
1064         char *object_path;
1065         if (!dbus_message_get_args(msg, NULL,
1066                                    DBUS_TYPE_OBJECT_PATH, &object_path,
1067                                    DBUS_TYPE_INVALID)) {
1068             LOGE("%s: Invalid arguments for RequestPairingConsent() method", __FUNCTION__);
1069             goto failure;
1070         }
1071
1072         dbus_message_ref(msg);  // increment refcount because we pass to java
1073         env->CallVoidMethod(nat->me, method_onRequestPairingConsent,
1074                                        env->NewStringUTF(object_path),
1075                                        int(msg));
1076         goto success;
1077     } else if (dbus_message_is_method_call(msg,
1078                   "org.bluez.Agent", "Release")) {
1079         // reply
1080         DBusMessage *reply = dbus_message_new_method_return(msg);
1081         if (!reply) {
1082             LOGE("%s: Cannot create message reply\n", __FUNCTION__);
1083             goto failure;
1084         }
1085         dbus_connection_send(nat->conn, reply, NULL);
1086         dbus_message_unref(reply);
1087         goto success;
1088     } else {
1089         LOGV("%s:%s is ignored", dbus_message_get_interface(msg), dbus_message_get_member(msg));
1090     }
1091
1092 failure:
1093     env->PopLocalFrame(NULL);
1094     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1095
1096 success:
1097     env->PopLocalFrame(NULL);
1098     return DBUS_HANDLER_RESULT_HANDLED;
1099
1100 }
1101 #endif
1102
1103
1104 #ifdef HAVE_BLUETOOTH
1105 //TODO: Unify result codes in a header
1106 #define BOND_RESULT_ERROR -1000
1107 #define BOND_RESULT_SUCCESS 0
1108 #define BOND_RESULT_AUTH_FAILED 1
1109 #define BOND_RESULT_AUTH_REJECTED 2
1110 #define BOND_RESULT_AUTH_CANCELED 3
1111 #define BOND_RESULT_REMOTE_DEVICE_DOWN 4
1112 #define BOND_RESULT_DISCOVERY_IN_PROGRESS 5
1113 #define BOND_RESULT_AUTH_TIMEOUT 6
1114 #define BOND_RESULT_REPEATED_ATTEMPTS 7
1115
1116 void onCreatePairedDeviceResult(DBusMessage *msg, void *user, void *n) {
1117     LOGV(__FUNCTION__);
1118
1119     native_data_t *nat = (native_data_t *)n;
1120     const char *address = (const char *)user;
1121     DBusError err;
1122     dbus_error_init(&err);
1123     JNIEnv *env;
1124     jstring addr;
1125
1126     nat->vm->GetEnv((void**)&env, nat->envVer);
1127
1128     LOGV("... address = %s", address);
1129
1130     jint result = BOND_RESULT_SUCCESS;
1131     if (dbus_set_error_from_message(&err, msg)) {
1132         if (!strcmp(err.name, BLUEZ_DBUS_BASE_IFC ".Error.AuthenticationFailed")) {
1133             // Pins did not match, or remote device did not respond to pin
1134             // request in time
1135             LOGV("... error = %s (%s)\n", err.name, err.message);
1136             result = BOND_RESULT_AUTH_FAILED;
1137         } else if (!strcmp(err.name, BLUEZ_DBUS_BASE_IFC ".Error.AuthenticationRejected")) {
1138             // We rejected pairing, or the remote side rejected pairing. This
1139             // happens if either side presses 'cancel' at the pairing dialog.
1140             LOGV("... error = %s (%s)\n", err.name, err.message);
1141             result = BOND_RESULT_AUTH_REJECTED;
1142         } else if (!strcmp(err.name, BLUEZ_DBUS_BASE_IFC ".Error.AuthenticationCanceled")) {
1143             // Not sure if this happens
1144             LOGV("... error = %s (%s)\n", err.name, err.message);
1145             result = BOND_RESULT_AUTH_CANCELED;
1146         } else if (!strcmp(err.name, BLUEZ_DBUS_BASE_IFC ".Error.ConnectionAttemptFailed")) {
1147             // Other device is not responding at all
1148             LOGV("... error = %s (%s)\n", err.name, err.message);
1149             result = BOND_RESULT_REMOTE_DEVICE_DOWN;
1150         } else if (!strcmp(err.name, BLUEZ_DBUS_BASE_IFC ".Error.AlreadyExists")) {
1151             // already bonded
1152             LOGV("... error = %s (%s)\n", err.name, err.message);
1153             result = BOND_RESULT_SUCCESS;
1154         } else if (!strcmp(err.name, BLUEZ_DBUS_BASE_IFC ".Error.InProgress") &&
1155                    !strcmp(err.message, "Bonding in progress")) {
1156             LOGV("... error = %s (%s)\n", err.name, err.message);
1157             goto done;
1158         } else if (!strcmp(err.name, BLUEZ_DBUS_BASE_IFC ".Error.InProgress") &&
1159                    !strcmp(err.message, "Discover in progress")) {
1160             LOGV("... error = %s (%s)\n", err.name, err.message);
1161             result = BOND_RESULT_DISCOVERY_IN_PROGRESS;
1162         } else if (!strcmp(err.name, BLUEZ_DBUS_BASE_IFC ".Error.RepeatedAttempts")) {
1163             LOGV("... error = %s (%s)\n", err.name, err.message);
1164             result = BOND_RESULT_REPEATED_ATTEMPTS;
1165         } else if (!strcmp(err.name, BLUEZ_DBUS_BASE_IFC ".Error.AuthenticationTimeout")) {
1166             LOGV("... error = %s (%s)\n", err.name, err.message);
1167             result = BOND_RESULT_AUTH_TIMEOUT;
1168         } else {
1169             LOGE("%s: D-Bus error: %s (%s)\n", __FUNCTION__, err.name, err.message);
1170             result = BOND_RESULT_ERROR;
1171         }
1172     }
1173
1174     addr = env->NewStringUTF(address);
1175     env->CallVoidMethod(nat->me,
1176                         method_onCreatePairedDeviceResult,
1177                         addr,
1178                         result);
1179     env->DeleteLocalRef(addr);
1180 done:
1181     dbus_error_free(&err);
1182     free(user);
1183 }
1184
1185 void onCreateDeviceResult(DBusMessage *msg, void *user, void *n) {
1186     LOGV(__FUNCTION__);
1187
1188     native_data_t *nat = (native_data_t *)n;
1189     const char *address= (const char *)user;
1190     DBusError err;
1191     dbus_error_init(&err);
1192     JNIEnv *env;
1193     nat->vm->GetEnv((void**)&env, nat->envVer);
1194
1195     LOGV("... Address = %s", address);
1196
1197     jint result = CREATE_DEVICE_SUCCESS;
1198     if (dbus_set_error_from_message(&err, msg)) {
1199         if (dbus_error_has_name(&err, "org.bluez.Error.AlreadyExists")) {
1200             result = CREATE_DEVICE_ALREADY_EXISTS;
1201         } else {
1202             result = CREATE_DEVICE_FAILED;
1203         }
1204         LOG_AND_FREE_DBUS_ERROR(&err);
1205     }
1206     jstring addr = env->NewStringUTF(address);
1207     env->CallVoidMethod(nat->me,
1208                         method_onCreateDeviceResult,
1209                         addr,
1210                         result);
1211     env->DeleteLocalRef(addr);
1212     free(user);
1213 }
1214
1215 void onDiscoverServicesResult(DBusMessage *msg, void *user, void *n) {
1216     LOGV(__FUNCTION__);
1217
1218     native_data_t *nat = (native_data_t *)n;
1219     const char *path = (const char *)user;
1220     DBusError err;
1221     dbus_error_init(&err);
1222     JNIEnv *env;
1223     nat->vm->GetEnv((void**)&env, nat->envVer);
1224
1225     LOGV("... Device Path = %s", path);
1226
1227     bool result = JNI_TRUE;
1228     if (dbus_set_error_from_message(&err, msg)) {
1229         LOG_AND_FREE_DBUS_ERROR(&err);
1230         result = JNI_FALSE;
1231     }
1232     jstring jPath = env->NewStringUTF(path);
1233     env->CallVoidMethod(nat->me,
1234                         method_onDiscoverServicesResult,
1235                         jPath,
1236                         result);
1237     env->DeleteLocalRef(jPath);
1238     free(user);
1239 }
1240
1241 void onGetDeviceServiceChannelResult(DBusMessage *msg, void *user, void *n) {
1242     LOGV(__FUNCTION__);
1243
1244     const char *address = (const char *) user;
1245     native_data_t *nat = (native_data_t *) n;
1246
1247     DBusError err;
1248     dbus_error_init(&err);
1249     JNIEnv *env;
1250     nat->vm->GetEnv((void**)&env, nat->envVer);
1251
1252     jint channel = -2;
1253
1254     LOGV("... address = %s", address);
1255
1256     if (dbus_set_error_from_message(&err, msg) ||
1257         !dbus_message_get_args(msg, &err,
1258                                DBUS_TYPE_INT32, &channel,
1259                                DBUS_TYPE_INVALID)) {
1260         LOGE("%s: D-Bus error: %s (%s)\n", __FUNCTION__, err.name, err.message);
1261         dbus_error_free(&err);
1262     }
1263
1264 done:
1265     jstring addr = env->NewStringUTF(address);
1266     env->CallVoidMethod(nat->me,
1267                         method_onGetDeviceServiceChannelResult,
1268                         addr,
1269                         channel);
1270     env->DeleteLocalRef(addr);
1271     free(user);
1272 }
1273 #endif
1274
1275 static JNINativeMethod sMethods[] = {
1276      /* name, signature, funcPtr */
1277     {"classInitNative", "()V", (void *)classInitNative},
1278     {"initializeNativeDataNative", "()V", (void *)initializeNativeDataNative},
1279     {"cleanupNativeDataNative", "()V", (void *)cleanupNativeDataNative},
1280     {"startEventLoopNative", "()V", (void *)startEventLoopNative},
1281     {"stopEventLoopNative", "()V", (void *)stopEventLoopNative},
1282     {"isEventLoopRunningNative", "()Z", (void *)isEventLoopRunningNative}
1283 };
1284
1285 int register_android_server_BluetoothEventLoop(JNIEnv *env) {
1286     return AndroidRuntime::registerNativeMethods(env,
1287             "android/server/BluetoothEventLoop", sMethods, NELEM(sMethods));
1288 }
1289
1290 } /* namespace android */