diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index 7e0cdc2..cb5642d 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -394,5 +394,12 @@
                 android:name="android.accounts.AccountAuthenticator"
                 android:resource="@xml/authenticator" />
         </service>
+        <service
+            android:name = ".hid.HidDevService"
+            android:enabled="@bool/profile_supported_hidd">
+            <intent-filter>
+                <action android:name="android.bluetooth.IBluetoothHidDevice" />
+            </intent-filter>
+        </service>
     </application>
 </manifest>
diff --git a/jni/Android.mk b/jni/Android.mk
index fe5c482..971b614 100644
--- a/jni/Android.mk
+++ b/jni/Android.mk
@@ -11,6 +11,7 @@
     com_android_bluetooth_avrcp.cpp \
     com_android_bluetooth_avrcp_controller.cpp \
     com_android_bluetooth_hid.cpp \
+    com_android_bluetooth_hidd.cpp \
     com_android_bluetooth_hdp.cpp \
     com_android_bluetooth_pan.cpp \
     com_android_bluetooth_gatt.cpp \
diff --git a/jni/com_android_bluetooth.h b/jni/com_android_bluetooth.h
index e63eba5..77ef51d 100644
--- a/jni/com_android_bluetooth.h
+++ b/jni/com_android_bluetooth.h
@@ -84,6 +84,8 @@
 
 int register_com_android_bluetooth_hid(JNIEnv* env);
 
+int register_com_android_bluetooth_hidd(JNIEnv* env);
+
 int register_com_android_bluetooth_hdp(JNIEnv* env);
 
 int register_com_android_bluetooth_pan(JNIEnv* env);
diff --git a/jni/com_android_bluetooth_btservice_AdapterService.cpp b/jni/com_android_bluetooth_btservice_AdapterService.cpp
index 5f69601..bfc843d 100644
--- a/jni/com_android_bluetooth_btservice_AdapterService.cpp
+++ b/jni/com_android_bluetooth_btservice_AdapterService.cpp
@@ -1321,6 +1321,12 @@
     return JNI_ERR;
   }
 
+  status = android::register_com_android_bluetooth_hidd(e);
+  if (status < 0) {
+    ALOGE("jni hidd registration failure: %d", status);
+    return JNI_ERR;
+  }
+
   status = android::register_com_android_bluetooth_hdp(e);
   if (status < 0) {
     ALOGE("jni hdp registration failure: %d", status);
diff --git a/jni/com_android_bluetooth_hidd.cpp b/jni/com_android_bluetooth_hidd.cpp
new file mode 100644
index 0000000..9b19dd8
--- /dev/null
+++ b/jni/com_android_bluetooth_hidd.cpp
@@ -0,0 +1,504 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "BluetoothHidDevServiceJni"
+
+#define LOG_NDEBUG 0
+
+#define CHECK_CALLBACK_ENV                                                     \
+  if (!checkCallbackThread()) {                                                \
+    ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); \
+    return;                                                                    \
+  }
+
+#include "android_runtime/AndroidRuntime.h"
+#include "com_android_bluetooth.h"
+#include "hardware/bt_hd.h"
+#include "utils/Log.h"
+
+#include <string.h>
+
+namespace android {
+
+static jmethodID method_onApplicationStateChanged;
+static jmethodID method_onConnectStateChanged;
+static jmethodID method_onGetReport;
+static jmethodID method_onSetReport;
+static jmethodID method_onSetProtocol;
+static jmethodID method_onIntrData;
+static jmethodID method_onVirtualCableUnplug;
+
+static const bthd_interface_t* sHiddIf = NULL;
+static jobject mCallbacksObj = NULL;
+static JNIEnv* sCallbackEnv = NULL;
+
+static bool checkCallbackThread() {
+  sCallbackEnv = getCallbackEnv();
+
+  if (sCallbackEnv != AndroidRuntime::getJNIEnv() || sCallbackEnv == NULL) {
+    return false;
+  }
+
+  return true;
+}
+
+static void application_state_callback(bt_bdaddr_t* bd_addr,
+                                       bthd_application_state_t state) {
+  jboolean registered = JNI_FALSE;
+  jbyteArray addr;
+
+  CHECK_CALLBACK_ENV
+
+  if (state == BTHD_APP_STATE_REGISTERED) {
+    registered = JNI_TRUE;
+  }
+
+  if (bd_addr) {
+    addr = sCallbackEnv->NewByteArray(sizeof(bt_bdaddr_t));
+    if (!addr) {
+      ALOGE("%s: failed to allocate storage for bt_addr", __FUNCTION__);
+      return;
+    }
+    sCallbackEnv->SetByteArrayRegion(addr, 0, sizeof(bt_bdaddr_t),
+                                     (jbyte*)bd_addr);
+  } else {
+    addr = NULL;
+  }
+
+  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onApplicationStateChanged,
+                               addr, registered);
+
+  if (addr) {
+    sCallbackEnv->DeleteLocalRef(addr);
+  }
+}
+
+static void connection_state_callback(bt_bdaddr_t* bd_addr,
+                                      bthd_connection_state_t state) {
+  jbyteArray addr;
+
+  CHECK_CALLBACK_ENV
+
+  addr = sCallbackEnv->NewByteArray(sizeof(bt_bdaddr_t));
+  if (!addr) {
+    ALOGE("%s: failed to allocate storage for bt_addr", __FUNCTION__);
+    return;
+  }
+  sCallbackEnv->SetByteArrayRegion(addr, 0, sizeof(bt_bdaddr_t),
+                                   (jbyte*)bd_addr);
+
+  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onConnectStateChanged,
+                               addr, (jint)state);
+
+  sCallbackEnv->DeleteLocalRef(addr);
+}
+
+static void get_report_callback(uint8_t type, uint8_t id,
+                                uint16_t buffer_size) {
+  CHECK_CALLBACK_ENV
+
+  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onGetReport, type, id,
+                               buffer_size);
+}
+
+static void set_report_callback(uint8_t type, uint8_t id, uint16_t len,
+                                uint8_t* p_data) {
+  jbyteArray data;
+
+  CHECK_CALLBACK_ENV
+
+  data = sCallbackEnv->NewByteArray(len);
+  if (!data) {
+    ALOGE("%s: failed to allocate storage for report data", __FUNCTION__);
+    return;
+  }
+  sCallbackEnv->SetByteArrayRegion(data, 0, len, (jbyte*)p_data);
+
+  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onSetReport, (jbyte)type,
+                               (jbyte)id, data);
+
+  sCallbackEnv->DeleteLocalRef(data);
+}
+
+static void set_protocol_callback(uint8_t protocol) {
+  CHECK_CALLBACK_ENV
+
+  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onSetProtocol, protocol);
+}
+
+static void intr_data_callback(uint8_t report_id, uint16_t len,
+                               uint8_t* p_data) {
+  jbyteArray data;
+
+  CHECK_CALLBACK_ENV
+
+  data = sCallbackEnv->NewByteArray(len);
+  if (!data) {
+    ALOGE("%s: failed to allocate storage for report data", __FUNCTION__);
+    return;
+  }
+  sCallbackEnv->SetByteArrayRegion(data, 0, len, (jbyte*)p_data);
+
+  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onIntrData,
+                               (jbyte)report_id, data);
+
+  sCallbackEnv->DeleteLocalRef(data);
+}
+
+static void vc_unplug_callback(void) {
+  CHECK_CALLBACK_ENV
+
+  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onVirtualCableUnplug);
+}
+
+static bthd_callbacks_t sHiddCb = {
+    sizeof(sHiddCb),
+
+    application_state_callback,
+    connection_state_callback,
+    get_report_callback,
+    set_report_callback,
+    set_protocol_callback,
+    intr_data_callback,
+    vc_unplug_callback,
+};
+
+static void classInitNative(JNIEnv* env, jclass clazz) {
+  ALOGV("%s: done", __FUNCTION__);
+
+  method_onApplicationStateChanged =
+      env->GetMethodID(clazz, "onApplicationStateChanged", "([BZ)V");
+  method_onConnectStateChanged =
+      env->GetMethodID(clazz, "onConnectStateChanged", "([BI)V");
+  method_onGetReport = env->GetMethodID(clazz, "onGetReport", "(BBS)V");
+  method_onSetReport = env->GetMethodID(clazz, "onSetReport", "(BB[B)V");
+  method_onSetProtocol = env->GetMethodID(clazz, "onSetProtocol", "(B)V");
+  method_onIntrData = env->GetMethodID(clazz, "onIntrData", "(B[B)V");
+  method_onVirtualCableUnplug =
+      env->GetMethodID(clazz, "onVirtualCableUnplug", "()V");
+}
+
+static void initNative(JNIEnv* env, jobject object) {
+  const bt_interface_t* btif;
+  bt_status_t status;
+
+  ALOGV("%s enter", __FUNCTION__);
+
+  if ((btif = getBluetoothInterface()) == NULL) {
+    ALOGE("Cannot obtain BT interface");
+    return;
+  }
+
+  if (sHiddIf != NULL) {
+    ALOGW("Cleaning up interface");
+    sHiddIf->cleanup();
+    sHiddIf = NULL;
+  }
+
+  if (mCallbacksObj != NULL) {
+    ALOGW("Cleaning up callback object");
+    env->DeleteGlobalRef(mCallbacksObj);
+    mCallbacksObj = NULL;
+  }
+
+  if ((sHiddIf = (bthd_interface_t*)btif->get_profile_interface(
+           BT_PROFILE_HIDDEV_ID)) == NULL) {
+    ALOGE("Cannot obtain interface");
+    return;
+  }
+
+  if ((status = sHiddIf->init(&sHiddCb)) != BT_STATUS_SUCCESS) {
+    ALOGE("Failed to initialize interface (%d)", status);
+    sHiddIf = NULL;
+    return;
+  }
+
+  mCallbacksObj = env->NewGlobalRef(object);
+
+  ALOGV("%s done", __FUNCTION__);
+}
+
+static void cleanupNative(JNIEnv* env, jobject object) {
+  ALOGV("%s enter", __FUNCTION__);
+
+  if (sHiddIf != NULL) {
+    ALOGI("Cleaning up interface");
+    sHiddIf->cleanup();
+    sHiddIf = NULL;
+  }
+
+  if (mCallbacksObj != NULL) {
+    ALOGI("Cleaning up callback object");
+    env->DeleteGlobalRef(mCallbacksObj);
+    mCallbacksObj = NULL;
+  }
+
+  ALOGV("%s done", __FUNCTION__);
+}
+
+static void fill_qos(JNIEnv* env, jintArray in, bthd_qos_param_t* out) {
+  // set default values
+  out->service_type = 0x01;  // best effort
+  out->token_rate = out->token_bucket_size = out->peak_bandwidth =
+      0;                                                    // don't care
+  out->access_latency = out->delay_variation = 0xffffffff;  // don't care
+
+  if (in == NULL) return;
+
+  jsize len = env->GetArrayLength(in);
+
+  if (len != 6) return;
+
+  uint32_t* buf = (uint32_t*)calloc(len, sizeof(uint32_t));
+
+  if (buf == NULL) return;
+
+  env->GetIntArrayRegion(in, 0, len, (jint*)buf);
+
+  out->service_type = (uint8_t)buf[0];
+  out->token_rate = buf[1];
+  out->token_bucket_size = buf[2];
+  out->peak_bandwidth = buf[3];
+  out->access_latency = buf[4];
+  out->delay_variation = buf[5];
+
+  free(buf);
+}
+
+static jboolean registerAppNative(JNIEnv* env, jobject thiz, jstring name,
+                                  jstring description, jstring provider,
+                                  jbyte subclass, jbyteArray descriptors,
+                                  jintArray p_in_qos, jintArray p_out_qos) {
+  ALOGV("%s enter", __FUNCTION__);
+
+  jboolean result = JNI_FALSE;
+  bthd_app_param_t app_param;
+  bthd_qos_param_t in_qos;
+  bthd_qos_param_t out_qos;
+  jsize size;
+  uint8_t* data;
+
+  size = env->GetArrayLength(descriptors);
+  data = (uint8_t*)malloc(size);
+
+  if (data != NULL) {
+    env->GetByteArrayRegion(descriptors, 0, size, (jbyte*)data);
+
+    app_param.name = env->GetStringUTFChars(name, NULL);
+    app_param.description = env->GetStringUTFChars(description, NULL);
+    app_param.provider = env->GetStringUTFChars(provider, NULL);
+    app_param.subclass = subclass;
+    app_param.desc_list = data;
+    app_param.desc_list_len = size;
+
+    fill_qos(env, p_in_qos, &in_qos);
+    fill_qos(env, p_out_qos, &out_qos);
+
+    bt_status_t ret = sHiddIf->register_app(&app_param, &in_qos, &out_qos);
+
+    ALOGV("%s: register_app() returned %d", __FUNCTION__, ret);
+
+    if (ret == BT_STATUS_SUCCESS) {
+      result = JNI_TRUE;
+    }
+
+    env->ReleaseStringUTFChars(name, app_param.name);
+    env->ReleaseStringUTFChars(description, app_param.description);
+    env->ReleaseStringUTFChars(provider, app_param.provider);
+
+    free(data);
+  }
+
+  ALOGV("%s done (%d)", __FUNCTION__, result);
+
+  return result;
+}
+
+static jboolean unregisterAppNative(JNIEnv* env, jobject thiz) {
+  ALOGV("%s enter", __FUNCTION__);
+
+  jboolean result = JNI_FALSE;
+
+  bt_status_t ret = sHiddIf->unregister_app();
+
+  ALOGV("%s: unregister_app() returned %d", __FUNCTION__, ret);
+
+  if (ret == BT_STATUS_SUCCESS) {
+    result = JNI_TRUE;
+  }
+
+  ALOGV("%s done (%d)", __FUNCTION__, result);
+
+  return result;
+}
+
+static jboolean sendReportNative(JNIEnv* env, jobject thiz, jint id,
+                                 jbyteArray data) {
+  ALOGV("%s enter", __FUNCTION__);
+
+  jboolean result = JNI_FALSE;
+  jsize size;
+  uint8_t* buf;
+
+  size = env->GetArrayLength(data);
+  buf = (uint8_t*)malloc(size);
+
+  if (buf != NULL) {
+    env->GetByteArrayRegion(data, 0, size, (jbyte*)buf);
+
+    bt_status_t ret =
+        sHiddIf->send_report(BTHD_REPORT_TYPE_INTRDATA, id, size, buf);
+
+    ALOGV("%s: send_report() returned %d", __FUNCTION__, ret);
+
+    if (ret == BT_STATUS_SUCCESS) {
+      result = JNI_TRUE;
+    }
+
+    free(buf);
+  }
+
+  ALOGV("%s done (%d)", __FUNCTION__, result);
+
+  return result;
+}
+
+static jboolean replyReportNative(JNIEnv* env, jobject thiz, jbyte type,
+                                  jbyte id, jbyteArray data) {
+  ALOGV("%s enter", __FUNCTION__);
+
+  jboolean result = JNI_FALSE;
+  jsize size;
+  uint8_t* buf;
+
+  size = env->GetArrayLength(data);
+  buf = (uint8_t*)malloc(size);
+
+  if (buf != NULL) {
+    int report_type = (type & 0x03);
+    env->GetByteArrayRegion(data, 0, size, (jbyte*)buf);
+
+    bt_status_t ret =
+        sHiddIf->send_report((bthd_report_type_t)report_type, id, size, buf);
+
+    ALOGV("%s: send_report() returned %d", __FUNCTION__, ret);
+
+    if (ret == BT_STATUS_SUCCESS) {
+      result = JNI_TRUE;
+    }
+
+    free(buf);
+  }
+
+  ALOGV("%s done (%d)", __FUNCTION__, result);
+
+  return result;
+}
+
+static jboolean reportErrorNative(JNIEnv* env, jobject thiz, jbyte error) {
+  ALOGV("%s enter", __FUNCTION__);
+
+  jboolean result = JNI_FALSE;
+
+  bt_status_t ret = sHiddIf->report_error(error);
+
+  ALOGV("%s: report_error() returned %d", __FUNCTION__, ret);
+
+  if (ret == BT_STATUS_SUCCESS) {
+    result = JNI_TRUE;
+  }
+
+  ALOGV("%s done (%d)", __FUNCTION__, result);
+
+  return result;
+}
+
+static jboolean unplugNative(JNIEnv* env, jobject thiz) {
+  ALOGV("%s enter", __FUNCTION__);
+
+  jboolean result = JNI_FALSE;
+
+  bt_status_t ret = sHiddIf->virtual_cable_unplug();
+
+  ALOGV("%s: virtual_cable_unplug() returned %d", __FUNCTION__, ret);
+
+  if (ret == BT_STATUS_SUCCESS) {
+    result = JNI_TRUE;
+  }
+
+  ALOGV("%s done (%d)", __FUNCTION__, result);
+
+  return result;
+}
+
+static jboolean connectNative(JNIEnv* env, jobject thiz) {
+  ALOGV("%s enter", __FUNCTION__);
+
+  jboolean result = JNI_FALSE;
+
+  bt_status_t ret = sHiddIf->connect();
+
+  ALOGV("%s: connect() returned %d", __FUNCTION__, ret);
+
+  if (ret == BT_STATUS_SUCCESS) {
+    result = JNI_TRUE;
+  }
+
+  ALOGV("%s done (%d)", __FUNCTION__, result);
+
+  return result;
+}
+
+static jboolean disconnectNative(JNIEnv* env, jobject thiz) {
+  ALOGV("%s enter", __FUNCTION__);
+
+  jboolean result = JNI_FALSE;
+
+  bt_status_t ret = sHiddIf->disconnect();
+
+  ALOGV("%s: disconnect() returned %d", __FUNCTION__, ret);
+
+  if (ret == BT_STATUS_SUCCESS) {
+    result = JNI_TRUE;
+  }
+
+  ALOGV("%s done (%d)", __FUNCTION__, result);
+
+  return result;
+}
+
+static JNINativeMethod sMethods[] = {
+    {"classInitNative", "()V", (void*)classInitNative},
+    {"initNative", "()V", (void*)initNative},
+    {"cleanupNative", "()V", (void*)cleanupNative},
+    {"registerAppNative",
+     "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;B[B[I[I)Z",
+     (void*)registerAppNative},
+    {"unregisterAppNative", "()Z", (void*)unregisterAppNative},
+    {"sendReportNative", "(I[B)Z", (void*)sendReportNative},
+    {"replyReportNative", "(BB[B)Z", (void*)replyReportNative},
+    {"reportErrorNative", "(B)Z", (void*)reportErrorNative},
+    {"unplugNative", "()Z", (void*)unplugNative},
+    {"connectNative", "()Z", (void*)connectNative},
+    {"disconnectNative", "()Z", (void*)disconnectNative},
+};
+
+int register_com_android_bluetooth_hidd(JNIEnv* env) {
+  return jniRegisterNativeMethods(env,
+                                  "com/android/bluetooth/hid/HidDevService",
+                                  sMethods, NELEM(sMethods));
+}
+}
diff --git a/res/values/config.xml b/res/values/config.xml
index 3a5f95e..4282d29 100644
--- a/res/values/config.xml
+++ b/res/values/config.xml
@@ -30,6 +30,7 @@
     <bool name="profile_supported_sap">false</bool>
     <bool name="profile_supported_pbapclient">false</bool>
     <bool name="profile_supported_mapmce">false</bool>
+    <bool name="profile_supported_hidd">false</bool>
 
     <!-- If true, we will require location to be enabled on the device to
          fire Bluetooth LE scan result callbacks in addition to having one
diff --git a/src/com/android/bluetooth/btservice/Config.java b/src/com/android/bluetooth/btservice/Config.java
index 57ab1d7..7cba064 100644
--- a/src/com/android/bluetooth/btservice/Config.java
+++ b/src/com/android/bluetooth/btservice/Config.java
@@ -39,6 +39,7 @@
 import com.android.bluetooth.mapclient.MapClientService;
 import com.android.bluetooth.sap.SapService;
 import com.android.bluetooth.pbapclient.PbapClientService;
+import com.android.bluetooth.hid.HidDevService;
 
 public class Config {
     private static final String TAG = "AdapterServiceConfig";
@@ -46,27 +47,20 @@
      * List of profile services.
      */
     @SuppressWarnings("rawtypes")
-    //Do not inclue OPP and PBAP, because their services
-    //are not managed by AdapterService
+    // Do not inclue OPP and PBAP, because their services
+    // are not managed by AdapterService
     private static final Class[] PROFILE_SERVICES = {
-        HeadsetService.class,
-        A2dpService.class,
-        A2dpSinkService.class,
-        HidService.class,
-        HealthService.class,
-        PanService.class,
-        GattService.class,
-        BluetoothMapService.class,
-        HeadsetClientService.class,
-        AvrcpControllerService.class,
-        SapService.class,
-        PbapClientService.class,
-        MapClientService.class
-    };
+        HeadsetService.class,       A2dpService.class,
+        A2dpSinkService.class,      HidService.class,
+        HealthService.class,        PanService.class,
+        GattService.class,          BluetoothMapService.class,
+        HeadsetClientService.class, AvrcpControllerService.class,
+        SapService.class,           PbapClientService.class,
+        MapClientService.class,     HidDevService.class};
     /**
      * Resource flag to indicate whether profile is supported or not.
      */
-    private static final int[]  PROFILE_SERVICES_FLAG = {
+    private static final int[] PROFILE_SERVICES_FLAG = {
         R.bool.profile_supported_hs_hfp,
         R.bool.profile_supported_a2dp,
         R.bool.profile_supported_a2dp_sink,
@@ -79,8 +73,8 @@
         R.bool.profile_supported_avrcp_controller,
         R.bool.profile_supported_sap,
         R.bool.profile_supported_pbapclient,
-        R.bool.profile_supported_mapmce
-    };
+        R.bool.profile_supported_mapmce,
+        R.bool.profile_supported_hidd};
 
     private static Class[] SUPPORTED_PROFILES = new Class[0];
 
@@ -166,6 +160,8 @@
             profileIndex = BluetoothProfile.PBAP_CLIENT;
         } else if (profile == MapClientService.class) {
             profileIndex = BluetoothProfile.MAP_CLIENT;
+        } else if (profile == HidDevService.class) {
+          profileIndex = BluetoothProfile.HID_DEVICE;
         }
 
         return profileIndex;
diff --git a/src/com/android/bluetooth/hid/HidDevService.java b/src/com/android/bluetooth/hid/HidDevService.java
new file mode 100644
index 0000000..a4662c9
--- /dev/null
+++ b/src/com/android/bluetooth/hid/HidDevService.java
@@ -0,0 +1,624 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.bluetooth.hid;
+
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothHidDevice;
+import android.bluetooth.BluetoothHidDeviceAppConfiguration;
+import android.bluetooth.BluetoothHidDeviceAppQosSettings;
+import android.bluetooth.BluetoothHidDeviceAppSdpSettings;
+import android.bluetooth.BluetoothProfile;
+import android.bluetooth.IBluetoothHidDevice;
+import android.bluetooth.IBluetoothHidDeviceCallback;
+import android.content.Intent;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.Message;
+import android.os.RemoteException;
+import android.util.Log;
+
+import com.android.bluetooth.Utils;
+import com.android.bluetooth.btservice.ProfileService;
+
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.NoSuchElementException;
+
+/** @hide */
+public class HidDevService extends ProfileService {
+
+  private static final boolean DBG = true;
+
+  private static final String TAG = HidDevService.class.getSimpleName();
+
+  private static final int MESSAGE_APPLICATION_STATE_CHANGED = 1;
+  private static final int MESSAGE_CONNECT_STATE_CHANGED = 2;
+  private static final int MESSAGE_GET_REPORT = 3;
+  private static final int MESSAGE_SET_REPORT = 4;
+  private static final int MESSAGE_SET_PROTOCOL = 5;
+  private static final int MESSAGE_INTR_DATA = 6;
+  private static final int MESSAGE_VC_UNPLUG = 7;
+
+  private boolean mNativeAvailable = false;
+
+  private BluetoothDevice mHidDevice = null;
+
+  private int mHidDeviceState = BluetoothHidDevice.STATE_DISCONNECTED;
+
+  private BluetoothHidDeviceAppConfiguration mAppConfig = null;
+
+  private IBluetoothHidDeviceCallback mCallback = null;
+
+  private BluetoothHidDeviceDeathRecipient mDeathRcpt;
+
+  static { classInitNative(); }
+
+  private final Handler mHandler = new Handler() {
+
+    @Override
+    public void handleMessage(Message msg) {
+      if (DBG)
+        Log.v(TAG, "handleMessage(): msg.what=" + msg.what);
+
+      switch (msg.what) {
+      case MESSAGE_APPLICATION_STATE_CHANGED: {
+        BluetoothDevice device =
+            msg.obj != null ? getDevice((byte[])msg.obj) : null;
+        boolean success = (msg.arg1 != 0);
+
+        try {
+          if (mCallback != null)
+            mCallback.onAppStatusChanged(device, mAppConfig, success);
+          else
+            break;
+        } catch (RemoteException e) {
+          Log.e(TAG, "e=" + e.toString());
+          e.printStackTrace();
+        }
+
+        if (success) {
+          mDeathRcpt = new BluetoothHidDeviceDeathRecipient(HidDevService.this,
+                                                            mAppConfig);
+          if (mCallback != null) {
+            IBinder binder = mCallback.asBinder();
+            try {
+              binder.linkToDeath(mDeathRcpt, 0);
+              Log.i(TAG, "IBinder.linkToDeath() ok");
+            } catch (RemoteException e) {
+              e.printStackTrace();
+            }
+          }
+        } else if (mDeathRcpt != null) {
+          if (mCallback != null) {
+            IBinder binder = mCallback.asBinder();
+            try {
+              binder.unlinkToDeath(mDeathRcpt, 0);
+              Log.i(TAG, "IBinder.unlinkToDeath() ok");
+            } catch (NoSuchElementException e) {
+              e.printStackTrace();
+            }
+            mDeathRcpt.cleanup();
+            mDeathRcpt = null;
+          }
+        }
+
+        if (!success) {
+          mAppConfig = null;
+          mCallback = null;
+        }
+
+        break;
+      }
+
+      case MESSAGE_CONNECT_STATE_CHANGED: {
+        BluetoothDevice device = getDevice((byte[])msg.obj);
+        int halState = msg.arg1;
+        int state = convertHalState(halState);
+
+        try {
+          if (mCallback != null)
+            mCallback.onConnectionStateChanged(device, state);
+        } catch (RemoteException e) {
+          e.printStackTrace();
+        }
+
+        broadcastConnectionState(device, state);
+        break;
+      }
+
+      case MESSAGE_GET_REPORT:
+        byte type = (byte)msg.arg1;
+        byte id = (byte)msg.arg2;
+        int bufferSize = msg.obj == null ? 0 : ((Integer)msg.obj).intValue();
+
+        try {
+          if (mCallback != null)
+            mCallback.onGetReport(type, id, bufferSize);
+        } catch (RemoteException e) {
+          e.printStackTrace();
+        }
+        break;
+
+      case MESSAGE_SET_REPORT: {
+        byte reportType = (byte)msg.arg1;
+        byte reportId = (byte)msg.arg2;
+        byte[] data = ((ByteBuffer)msg.obj).array();
+
+        try {
+          if (mCallback != null)
+            mCallback.onSetReport(reportType, reportId, data);
+        } catch (RemoteException e) {
+          e.printStackTrace();
+        }
+        break;
+      }
+
+      case MESSAGE_SET_PROTOCOL:
+        byte protocol = (byte)msg.arg1;
+
+        try {
+          if (mCallback != null)
+            mCallback.onSetProtocol(protocol);
+        } catch (RemoteException e) {
+          e.printStackTrace();
+        }
+        break;
+
+      case MESSAGE_INTR_DATA:
+        byte reportId = (byte)msg.arg1;
+        byte[] data = ((ByteBuffer)msg.obj).array();
+
+        try {
+          if (mCallback != null)
+            mCallback.onIntrData(reportId, data);
+        } catch (RemoteException e) {
+          e.printStackTrace();
+        }
+        break;
+
+      case MESSAGE_VC_UNPLUG:
+        try {
+          if (mCallback != null)
+            mCallback.onVirtualCableUnplug();
+        } catch (RemoteException e) {
+          e.printStackTrace();
+        }
+        break;
+      }
+    }
+  };
+
+  private static class BluetoothHidDeviceDeathRecipient
+      implements IBinder.DeathRecipient {
+    private HidDevService mService;
+    private BluetoothHidDeviceAppConfiguration mAppConfig;
+
+    public BluetoothHidDeviceDeathRecipient(
+        HidDevService service, BluetoothHidDeviceAppConfiguration config) {
+      mService = service;
+      mAppConfig = config;
+    }
+
+    @Override
+    public void binderDied() {
+      Log.w(TAG, "Binder died, need to unregister app :(");
+      mService.unregisterApp(mAppConfig);
+    }
+
+    public void cleanup() {
+      mService = null;
+      mAppConfig = null;
+    }
+  }
+
+  private static class BluetoothHidDeviceBinder
+      extends IBluetoothHidDevice.Stub implements IProfileServiceBinder {
+
+    private static final String TAG =
+        BluetoothHidDeviceBinder.class.getSimpleName();
+
+    private HidDevService mService;
+
+    public BluetoothHidDeviceBinder(HidDevService service) {
+      mService = service;
+    }
+
+    @Override
+    public boolean cleanup() {
+      mService = null;
+      return true;
+    }
+
+    private HidDevService getService() {
+      if (!Utils.checkCaller()) {
+        Log.w(TAG, "HidDevice call not allowed for non-active user");
+        return null;
+      }
+
+      if (mService != null && mService.isAvailable()) {
+        return mService;
+      }
+
+      return null;
+    }
+
+    @Override
+    public boolean registerApp(BluetoothHidDeviceAppConfiguration config,
+                               BluetoothHidDeviceAppSdpSettings sdp,
+                               BluetoothHidDeviceAppQosSettings inQos,
+                               BluetoothHidDeviceAppQosSettings outQos,
+                               IBluetoothHidDeviceCallback callback) {
+      if (DBG)
+        Log.v(TAG, "registerApp()");
+
+      HidDevService service = getService();
+      if (service == null) {
+        return false;
+      }
+
+      return service.registerApp(config, sdp, inQos, outQos, callback);
+    }
+
+    @Override
+    public boolean unregisterApp(BluetoothHidDeviceAppConfiguration config) {
+      if (DBG)
+        Log.v(TAG, "unregisterApp()");
+
+      HidDevService service = getService();
+      if (service == null) {
+        return false;
+      }
+
+      return service.unregisterApp(config);
+    }
+
+    @Override
+    public boolean sendReport(int id, byte[] data) {
+      if (DBG)
+        Log.v(TAG, "sendReport(): id=" + id);
+
+      HidDevService service = getService();
+      if (service == null) {
+        return false;
+      }
+
+      return service.sendReport(id, data);
+    }
+
+    @Override
+    public boolean replyReport(byte type, byte id, byte[] data) {
+      if (DBG)
+        Log.v(TAG, "replyReport(): type=" + type + " id=" + id);
+
+      HidDevService service = getService();
+      if (service == null) {
+        return false;
+      }
+
+      return service.replyReport(type, id, data);
+    }
+
+    @Override
+    public boolean unplug() {
+      if (DBG)
+        Log.v(TAG, "unplug()");
+
+      HidDevService service = getService();
+      if (service == null) {
+        return false;
+      }
+
+      return service.unplug();
+    }
+
+    @Override
+    public boolean connect() {
+      if (DBG)
+        Log.v(TAG, "connect()");
+
+      HidDevService service = getService();
+      if (service == null) {
+        return false;
+      }
+
+      return service.connect();
+    }
+
+    @Override
+    public boolean disconnect() {
+      if (DBG)
+        Log.v(TAG, "disconnect()");
+
+      HidDevService service = getService();
+      if (service == null) {
+        return false;
+      }
+
+      return service.disconnect();
+    }
+
+    @Override
+    public boolean reportError(byte error) {
+      if (DBG)
+        Log.v(TAG, "reportError(), error = " + error);
+
+      HidDevService service = getService();
+      if (service == null) {
+        return false;
+      }
+
+      return service.reportError(error);
+    }
+  }
+
+  @Override
+  protected IProfileServiceBinder initBinder() {
+    return new BluetoothHidDeviceBinder(this);
+  }
+
+  synchronized boolean registerApp(BluetoothHidDeviceAppConfiguration config,
+                                   BluetoothHidDeviceAppSdpSettings sdp,
+                                   BluetoothHidDeviceAppQosSettings inQos,
+                                   BluetoothHidDeviceAppQosSettings outQos,
+                                   IBluetoothHidDeviceCallback callback) {
+    if (DBG)
+      Log.v(TAG, "registerApp()");
+
+    if (mAppConfig != null) {
+      return false;
+    }
+
+    mAppConfig = config;
+    mCallback = callback;
+
+    return registerAppNative(sdp.name, sdp.description, sdp.provider,
+                             sdp.subclass, sdp.descriptors,
+                             inQos == null ? null : inQos.toArray(),
+                             outQos == null ? null : outQos.toArray());
+  }
+
+  synchronized boolean
+  unregisterApp(BluetoothHidDeviceAppConfiguration config) {
+    if (DBG)
+      Log.v(TAG, "unregisterApp()");
+
+    if (mAppConfig == null || config == null || !config.equals(mAppConfig)) {
+      return false;
+    }
+
+    return unregisterAppNative();
+  }
+
+  synchronized boolean sendReport(int id, byte[] data) {
+    if (DBG)
+      Log.v(TAG, "sendReport(): id=" + id);
+
+    return sendReportNative(id, data);
+  }
+
+  synchronized boolean replyReport(byte type, byte id, byte[] data) {
+    if (DBG)
+      Log.v(TAG, "replyReport(): type=" + type + " id=" + id);
+
+    return replyReportNative(type, id, data);
+  }
+
+  synchronized boolean unplug() {
+    if (DBG)
+      Log.v(TAG, "unplug()");
+
+    return unplugNative();
+  }
+
+  synchronized boolean connect() {
+    if (DBG)
+      Log.v(TAG, "connect()");
+
+    return connectNative();
+  }
+
+  synchronized boolean disconnect() {
+    if (DBG)
+      Log.v(TAG, "disconnect()");
+
+    return disconnectNative();
+  }
+
+  synchronized boolean reportError(byte error) {
+    if (DBG)
+      Log.v(TAG, "reportError(): error = " + error);
+
+    return reportErrorNative(error);
+  }
+
+  @Override
+  protected boolean start() {
+    if (DBG)
+      Log.d(TAG, "start()");
+
+    initNative();
+    mNativeAvailable = true;
+
+    return true;
+  }
+
+  @Override
+  protected boolean stop() {
+    if (DBG)
+      Log.d(TAG, "stop()");
+
+    return true;
+  }
+
+  @Override
+  protected boolean cleanup() {
+    if (DBG)
+      Log.d(TAG, "cleanup()");
+
+    if (mNativeAvailable) {
+      cleanupNative();
+      mNativeAvailable = false;
+    }
+
+    return true;
+  }
+
+  private synchronized void onApplicationStateChanged(byte[] address,
+                                                      boolean registered) {
+    if (DBG)
+      Log.v(TAG, "onApplicationStateChanged(): registered=" + registered);
+
+    Message msg = mHandler.obtainMessage(MESSAGE_APPLICATION_STATE_CHANGED);
+    msg.obj = address;
+    msg.arg1 = registered ? 1 : 0;
+    mHandler.sendMessage(msg);
+  }
+
+  private synchronized void onConnectStateChanged(byte[] address, int state) {
+    if (DBG)
+      Log.v(TAG, "onConnectStateChanged(): address=" +
+                     Arrays.toString(address) + " state=" + state);
+
+    Message msg = mHandler.obtainMessage(MESSAGE_CONNECT_STATE_CHANGED);
+    msg.obj = address;
+    msg.arg1 = state;
+    mHandler.sendMessage(msg);
+  }
+
+  private synchronized void onGetReport(byte type, byte id, short bufferSize) {
+    if (DBG)
+      Log.v(TAG, "onGetReport(): type=" + type + " id=" + id + " bufferSize=" +
+                     bufferSize);
+
+    Message msg = mHandler.obtainMessage(MESSAGE_GET_REPORT);
+    msg.obj = bufferSize > 0 ? new Integer(bufferSize) : null;
+    msg.arg1 = type;
+    msg.arg2 = id;
+    mHandler.sendMessage(msg);
+  }
+
+  private synchronized void onSetReport(byte reportType, byte reportId,
+                                        byte[] data) {
+    if (DBG)
+      Log.v(TAG, "onSetReport(): reportType=" + reportType + " reportId=" +
+                     reportId);
+
+    ByteBuffer bb = ByteBuffer.wrap(data);
+
+    Message msg = mHandler.obtainMessage(MESSAGE_SET_REPORT);
+    msg.arg1 = reportType;
+    msg.arg2 = reportId;
+    msg.obj = bb;
+    mHandler.sendMessage(msg);
+  }
+
+  private synchronized void onSetProtocol(byte protocol) {
+    if (DBG)
+      Log.v(TAG, "onSetProtocol(): protocol=" + protocol);
+
+    Message msg = mHandler.obtainMessage(MESSAGE_SET_PROTOCOL);
+    msg.arg1 = protocol;
+    mHandler.sendMessage(msg);
+  }
+
+  private synchronized void onIntrData(byte reportId, byte[] data) {
+    if (DBG)
+      Log.v(TAG, "onIntrData(): reportId=" + reportId);
+
+    ByteBuffer bb = ByteBuffer.wrap(data);
+
+    Message msg = mHandler.obtainMessage(MESSAGE_INTR_DATA);
+    msg.arg1 = reportId;
+    msg.obj = bb;
+    mHandler.sendMessage(msg);
+  }
+
+  private synchronized void onVirtualCableUnplug() {
+    if (DBG)
+      Log.v(TAG, "onVirtualCableUnplug()");
+
+    Message msg = mHandler.obtainMessage(MESSAGE_VC_UNPLUG);
+    mHandler.sendMessage(msg);
+  }
+
+  private void broadcastConnectionState(BluetoothDevice device, int newState) {
+    if (DBG)
+      Log.v(TAG, "broadcastConnectionState(): device=" + device.getAddress() +
+                     " newState=" + newState);
+
+    if (mHidDevice != null && mHidDevice != device) {
+      Log.w(TAG, "Connection state changed for unknown device, ignoring");
+      return;
+    }
+
+    int prevState = mHidDeviceState;
+    mHidDeviceState = newState;
+
+    Log.i(TAG, "connection state for " + device.getAddress() + ": " +
+                   prevState + " -> " + newState);
+
+    if (prevState == newState) {
+      return;
+    }
+
+    notifyProfileConnectionStateChanged(device, BluetoothProfile.HID_DEVICE,
+                                        newState, prevState);
+
+    Intent intent =
+        new Intent(BluetoothHidDevice.ACTION_CONNECTION_STATE_CHANGED);
+    intent.putExtra(BluetoothProfile.EXTRA_PREVIOUS_STATE, prevState);
+    intent.putExtra(BluetoothProfile.EXTRA_STATE, newState);
+    intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device);
+    intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
+    sendBroadcast(intent, BLUETOOTH_PERM);
+  }
+
+  private static int convertHalState(int halState) {
+    switch (halState) {
+    case CONN_STATE_CONNECTED:
+      return BluetoothProfile.STATE_CONNECTED;
+    case CONN_STATE_CONNECTING:
+      return BluetoothProfile.STATE_CONNECTING;
+    case CONN_STATE_DISCONNECTED:
+      return BluetoothProfile.STATE_DISCONNECTED;
+    case CONN_STATE_DISCONNECTING:
+      return BluetoothProfile.STATE_DISCONNECTING;
+    default:
+      return BluetoothProfile.STATE_DISCONNECTED;
+    }
+  }
+
+  private final static int CONN_STATE_CONNECTED = 0;
+  private final static int CONN_STATE_CONNECTING = 1;
+  private final static int CONN_STATE_DISCONNECTED = 2;
+  private final static int CONN_STATE_DISCONNECTING = 3;
+
+  private native static void classInitNative();
+  private native void initNative();
+  private native void cleanupNative();
+  private native boolean registerAppNative(String name, String description,
+                                           String provider, byte subclass,
+                                           byte[] descriptors, int[] inQos,
+                                           int[] outQos);
+  private native boolean unregisterAppNative();
+  private native boolean sendReportNative(int id, byte[] data);
+  private native boolean replyReportNative(byte type, byte id, byte[] data);
+  private native boolean unplugNative();
+  private native boolean connectNative();
+  private native boolean disconnectNative();
+  private native boolean reportErrorNative(byte error);
+}