Merge "Added transport in HID host JNI" into main am: ea6ebccd27 am: e920882bee (6465bcf2) · Commits · e / os / android_packages_modules_Bluetooth

android/app/jni/com_android_bluetooth_hid_host.cpp

+88 −47

Original line number	Diff line number	Diff line
		@@ -50,6 +50,8 @@ static jbyteArray marshall_bda(RawAddress* bd_addr) {
		}

		static void connection_state_callback(RawAddress* bd_addr,
		tBLE_ADDR_TYPE addr_type,
		tBT_TRANSPORT transport,
		bthh_connection_state_t state) {
		std::shared_lock<std::shared_timed_mutex> lock(mCallbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		@@ -65,10 +67,13 @@ static void connection_state_callback(RawAddress* bd_addr,
		}

		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onConnectStateChanged,
		addr.get(), (jint)state);
		addr.get(), (jint)addr_type, (jint)transport,
		(jint)state);
		}

		static void get_protocol_mode_callback(RawAddress* bd_addr,
		tBLE_ADDR_TYPE addr_type,
		tBT_TRANSPORT transport,
		bthh_status_t hh_status,
		bthh_protocol_mode_t mode) {
		std::shared_lock<std::shared_timed_mutex> lock(mCallbacks_mutex);
		@@ -90,11 +95,14 @@ static void get_protocol_mode_callback(RawAddress* bd_addr,
		}

		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onGetProtocolMode,
		addr.get(), (jint)mode);
		addr.get(), (jint)addr_type, (jint)transport,
		(jint)mode);
		}

		static void get_report_callback(RawAddress* bd_addr, bthh_status_t hh_status,
		uint8_t* rpt_data, int rpt_size) {
		static void get_report_callback(RawAddress* bd_addr, tBLE_ADDR_TYPE addr_type,
		tBT_TRANSPORT transport,
		bthh_status_t hh_status, uint8_t* rpt_data,
		int rpt_size) {
		std::shared_lock<std::shared_timed_mutex> lock(mCallbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		@@ -121,10 +129,13 @@ static void get_report_callback(RawAddress* bd_addr, bthh_status_t hh_status,

		sCallbackEnv->SetByteArrayRegion(data.get(), 0, rpt_size, (jbyte*)rpt_data);
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onGetReport, addr.get(),
		data.get(), (jint)rpt_size);
		(jint)addr_type, (jint)transport, data.get(),
		(jint)rpt_size);
		}

		static void virtual_unplug_callback(RawAddress* bd_addr,
		tBLE_ADDR_TYPE addr_type,
		tBT_TRANSPORT transport,
		bthh_status_t hh_status) {
		log::verbose("call to virtual_unplug_callback");
		std::shared_lock<std::shared_timed_mutex> lock(mCallbacks_mutex);
		@@ -140,10 +151,13 @@ static void virtual_unplug_callback(RawAddress* bd_addr,
		return;
		}
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onVirtualUnplug,
		addr.get(), (jint)hh_status);
		addr.get(), (jint)addr_type, (jint)transport,
		(jint)hh_status);
		}

		static void handshake_callback(RawAddress* bd_addr, bthh_status_t hh_status) {
		static void handshake_callback(RawAddress* bd_addr, tBLE_ADDR_TYPE addr_type,
		tBT_TRANSPORT transport,
		bthh_status_t hh_status) {
		std::shared_lock<std::shared_timed_mutex> lock(mCallbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		@@ -158,10 +172,13 @@ static void handshake_callback(RawAddress* bd_addr, bthh_status_t hh_status) {
		return;
		}
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onHandshake, addr.get(),
		(jint)addr_type, (jint)transport,
		(jint)hh_status);
		}

		static void get_idle_time_callback(RawAddress* bd_addr,
		tBLE_ADDR_TYPE addr_type,
		tBT_TRANSPORT transport,
		bthh_status_t /* hh_status */,
		int idle_time) {
		std::shared_lock<std::shared_timed_mutex> lock(mCallbacks_mutex);
		@@ -174,6 +191,7 @@ static void get_idle_time_callback(RawAddress* bd_addr,
		return;
		}
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onGetIdleTime, addr.get(),
		(jint)addr_type, (jint)transport,
		(jint)idle_time);
		}

		@@ -249,7 +267,8 @@ static void cleanupNative(JNIEnv* env, jobject /* object */) {
		}

		static jboolean connectHidNative(JNIEnv* env, jobject /* object */,
		jbyteArray address) {
		jbyteArray address, jint address_type,
		jint transport) {
		if (!sBluetoothHidInterface) return JNI_FALSE;

		jbyte* addr = env->GetByteArrayElements(address, NULL);
		@@ -259,7 +278,9 @@ static jboolean connectHidNative(JNIEnv* env, jobject /* object */,
		}

		jboolean ret = JNI_TRUE;
		bt_status_t status = sBluetoothHidInterface->connect((RawAddress*)addr);
		bt_status_t status = sBluetoothHidInterface->connect(
		(RawAddress*)addr, (tBLE_ADDR_TYPE)address_type,
		(tBT_TRANSPORT)transport);
		if (status != BT_STATUS_SUCCESS && status != BT_STATUS_BUSY) {
		log::error("Failed HID channel connection, status: {}",
		bt_status_text(status));
		@@ -271,7 +292,8 @@ static jboolean connectHidNative(JNIEnv* env, jobject /* object */,
		}

		static jboolean disconnectHidNative(JNIEnv* env, jobject /* object */,
		jbyteArray address) {
		jbyteArray address, jint address_type,
		jint transport) {
		jbyte* addr;
		jboolean ret = JNI_TRUE;
		if (!sBluetoothHidInterface) return JNI_FALSE;
		@@ -282,7 +304,9 @@ static jboolean disconnectHidNative(JNIEnv* env, jobject /* object */,
		return JNI_FALSE;
		}

		bt_status_t status = sBluetoothHidInterface->disconnect((RawAddress*)addr);
		bt_status_t status = sBluetoothHidInterface->disconnect(
		(RawAddress*)addr, (tBLE_ADDR_TYPE)address_type,
		(tBT_TRANSPORT)transport);
		if (status != BT_STATUS_SUCCESS) {
		log::error("Failed disconnect hid channel, status: {}",
		bt_status_text(status));
		@@ -294,7 +318,8 @@ static jboolean disconnectHidNative(JNIEnv* env, jobject /* object */,
		}

		static jboolean getProtocolModeNative(JNIEnv* env, jobject /* object */,
		jbyteArray address) {
		jbyteArray address, jint address_type,
		jint transport) {
		if (!sBluetoothHidInterface) return JNI_FALSE;

		jbyte* addr = env->GetByteArrayElements(address, NULL);
		@@ -307,7 +332,8 @@ static jboolean getProtocolModeNative(JNIEnv* env, jobject /* object */,
		// TODO: protocolMode is unused by the backend: see b/28908173
		bthh_protocol_mode_t protocolMode = BTHH_UNSUPPORTED_MODE;
		bt_status_t status = sBluetoothHidInterface->get_protocol(
		(RawAddress*)addr, (bthh_protocol_mode_t)protocolMode);
		(RawAddress*)addr, (tBLE_ADDR_TYPE)address_type, (tBT_TRANSPORT)transport,
		(bthh_protocol_mode_t)protocolMode);
		if (status != BT_STATUS_SUCCESS) {
		log::error("Failed get protocol mode, status: {}", bt_status_text(status));
		ret = JNI_FALSE;
		@@ -318,7 +344,8 @@ static jboolean getProtocolModeNative(JNIEnv* env, jobject /* object */,
		}

		static jboolean virtualUnPlugNative(JNIEnv* env, jobject /* object */,
		jbyteArray address) {
		jbyteArray address, jint address_type,
		jint transport) {
		if (!sBluetoothHidInterface) return JNI_FALSE;

		jbyte* addr = env->GetByteArrayElements(address, NULL);
		@@ -328,8 +355,9 @@ static jboolean virtualUnPlugNative(JNIEnv* env, jobject /* object */,
		}

		jboolean ret = JNI_TRUE;
		bt_status_t status =
		sBluetoothHidInterface->virtual_unplug((RawAddress*)addr);
		bt_status_t status = sBluetoothHidInterface->virtual_unplug(
		(RawAddress*)addr, (tBLE_ADDR_TYPE)address_type,
		(tBT_TRANSPORT)transport);
		if (status != BT_STATUS_SUCCESS) {
		log::error("Failed virual unplug, status: {}", bt_status_text(status));
		ret = JNI_FALSE;
		@@ -339,7 +367,8 @@ static jboolean virtualUnPlugNative(JNIEnv* env, jobject /* object */,
		}

		static jboolean setProtocolModeNative(JNIEnv* env, jobject /* object */,
		jbyteArray address, jint protocolMode) {
		jbyteArray address, jint address_type,
		jint transport, jint protocolMode) {
		if (!sBluetoothHidInterface) return JNI_FALSE;

		log::debug("protocolMode = {}", protocolMode);
		@@ -364,8 +393,9 @@ static jboolean setProtocolModeNative(JNIEnv* env, jobject /* object */,
		}

		jboolean ret = JNI_TRUE;
		bt_status_t status =
		sBluetoothHidInterface->set_protocol((RawAddress*)addr, mode);
		bt_status_t status = sBluetoothHidInterface->set_protocol(
		(RawAddress*)addr, (tBLE_ADDR_TYPE)address_type, (tBT_TRANSPORT)transport,
		mode);
		if (status != BT_STATUS_SUCCESS) {
		log::error("Failed set protocol mode, status: {}", bt_status_text(status));
		ret = JNI_FALSE;
		@@ -376,7 +406,8 @@ static jboolean setProtocolModeNative(JNIEnv* env, jobject /* object */,
		}

		static jboolean getReportNative(JNIEnv* env, jobject /* object */,
		jbyteArray address, jbyte reportType,
		jbyteArray address, jint address_type,
		jint transport, jbyte reportType,
		jbyte reportId, jint bufferSize) {
		log::verbose("reportType = {}, reportId = {}, bufferSize = {}", reportType,
		reportId, bufferSize);
		@@ -392,7 +423,8 @@ static jboolean getReportNative(JNIEnv* env, jobject /* object */,
		jint rId = reportId;

		bt_status_t status = sBluetoothHidInterface->get_report(
		(RawAddress*)addr, (bthh_report_type_t)rType, (uint8_t)rId, bufferSize);
		(RawAddress*)addr, (tBLE_ADDR_TYPE)address_type, (tBT_TRANSPORT)transport,
		(bthh_report_type_t)rType, (uint8_t)rId, bufferSize);
		jboolean ret = JNI_TRUE;
		if (status != BT_STATUS_SUCCESS) {
		log::error("Failed get report, status: {}", bt_status_text(status));
		@@ -404,7 +436,8 @@ static jboolean getReportNative(JNIEnv* env, jobject /* object */,
		}

		static jboolean setReportNative(JNIEnv* env, jobject /* object */,
		jbyteArray address, jbyte reportType,
		jbyteArray address, jint address_type,
		jint transport, jbyte reportType,
		jstring report) {
		log::verbose("reportType = {}", reportType);
		if (!sBluetoothHidInterface) return JNI_FALSE;
		@@ -419,7 +452,8 @@ static jboolean setReportNative(JNIEnv* env, jobject /* object */,

		jboolean ret = JNI_TRUE;
		bt_status_t status = sBluetoothHidInterface->set_report(
		(RawAddress)addr, (bthh_report_type_t)rType, (char)c_report);
		(RawAddress*)addr, (tBLE_ADDR_TYPE)address_type, (tBT_TRANSPORT)transport,
		(bthh_report_type_t)rType, (char*)c_report);
		if (status != BT_STATUS_SUCCESS) {
		log::error("Failed set report, status: {}", bt_status_text(status));
		ret = JNI_FALSE;
		@@ -431,7 +465,8 @@ static jboolean setReportNative(JNIEnv* env, jobject /* object */,
		}

		static jboolean sendDataNative(JNIEnv* env, jobject /* object */,
		jbyteArray address, jstring report) {
		jbyteArray address, jint address_type,
		jint transport, jstring report) {
		log::verbose("");
		jboolean ret = JNI_TRUE;
		if (!sBluetoothHidInterface) return JNI_FALSE;
		@@ -444,8 +479,9 @@ static jboolean sendDataNative(JNIEnv* env, jobject /* object */,

		const char* c_report = env->GetStringUTFChars(report, NULL);

		bt_status_t status =
		sBluetoothHidInterface->send_data((RawAddress)addr, (char)c_report);
		bt_status_t status = sBluetoothHidInterface->send_data(
		(RawAddress*)addr, (tBLE_ADDR_TYPE)address_type, (tBT_TRANSPORT)transport,
		(char*)c_report);
		if (status != BT_STATUS_SUCCESS) {
		log::error("Failed set data, status: {}", bt_status_text(status));
		ret = JNI_FALSE;
		@@ -457,7 +493,8 @@ static jboolean sendDataNative(JNIEnv* env, jobject /* object */,
		}

		static jboolean getIdleTimeNative(JNIEnv* env, jobject /* object */,
		jbyteArray address) {
		jbyteArray address, jint address_type,
		jint transport) {
		if (!sBluetoothHidInterface) return JNI_FALSE;

		jbyte* addr = env->GetByteArrayElements(address, NULL);
		@@ -466,7 +503,9 @@ static jboolean getIdleTimeNative(JNIEnv* env, jobject /* object */,
		return JNI_FALSE;
		}

		bt_status_t status = sBluetoothHidInterface->get_idle_time((RawAddress*)addr);
		bt_status_t status = sBluetoothHidInterface->get_idle_time(
		(RawAddress*)addr, (tBLE_ADDR_TYPE)address_type,
		(tBT_TRANSPORT)transport);
		if (status != BT_STATUS_SUCCESS) {
		log::error("Failed get idle time, status: {}", bt_status_text(status));
		}
		@@ -476,7 +515,8 @@ static jboolean getIdleTimeNative(JNIEnv* env, jobject /* object */,
		}

		static jboolean setIdleTimeNative(JNIEnv* env, jobject /* object */,
		jbyteArray address, jbyte idle_time) {
		jbyteArray address, jint address_type,
		jint transport, jbyte idle_time) {
		if (!sBluetoothHidInterface) return JNI_FALSE;

		jbyte* addr = env->GetByteArrayElements(address, NULL);
		@@ -485,8 +525,9 @@ static jboolean setIdleTimeNative(JNIEnv* env, jobject /* object */,
		return JNI_FALSE;
		}

		bt_status_t status =
		sBluetoothHidInterface->set_idle_time((RawAddress*)addr, idle_time);
		bt_status_t status = sBluetoothHidInterface->set_idle_time(
		(RawAddress*)addr, (tBLE_ADDR_TYPE)address_type, (tBT_TRANSPORT)transport,
		idle_time);
		if (status != BT_STATUS_SUCCESS) {
		log::error("Failed set idle time, status: {}", bt_status_text(status));
		}
		@@ -499,16 +540,16 @@ int register_com_android_bluetooth_hid_host(JNIEnv* env) {
		const JNINativeMethod methods[] = {
		{"initializeNative", "()V", (void*)initializeNative},
		{"cleanupNative", "()V", (void*)cleanupNative},
		{"connectHidNative", "([B)Z", (void*)connectHidNative},
		{"disconnectHidNative", "([B)Z", (void*)disconnectHidNative},
		{"getProtocolModeNative", "([B)Z", (void*)getProtocolModeNative},
		{"virtualUnPlugNative", "([B)Z", (void*)virtualUnPlugNative},
		{"setProtocolModeNative", "([BB)Z", (void*)setProtocolModeNative},
		{"getReportNative", "([BBBI)Z", (void*)getReportNative},
		{"setReportNative", "([BBLjava/lang/String;)Z", (void*)setReportNative},
		{"sendDataNative", "([BLjava/lang/String;)Z", (void*)sendDataNative},
		{"getIdleTimeNative", "([B)Z", (void*)getIdleTimeNative},
		{"setIdleTimeNative", "([BB)Z", (void*)setIdleTimeNative},
		{"connectHidNative", "([BII)Z", (void*)connectHidNative},
		{"disconnectHidNative", "([BII)Z", (void*)disconnectHidNative},
		{"getProtocolModeNative", "([BII)Z", (void*)getProtocolModeNative},
		{"virtualUnPlugNative", "([BII)Z", (void*)virtualUnPlugNative},
		{"setProtocolModeNative", "([BIIB)Z", (void*)setProtocolModeNative},
		{"getReportNative", "([BIIBBI)Z", (void*)getReportNative},
		{"setReportNative", "([BIIBLjava/lang/String;)Z", (void*)setReportNative},
		{"sendDataNative", "([BIILjava/lang/String;)Z", (void*)sendDataNative},
		{"getIdleTimeNative", "([BII)Z", (void*)getIdleTimeNative},
		{"setIdleTimeNative", "([BIIB)Z", (void*)setIdleTimeNative},
		};
		const int result = REGISTER_NATIVE_METHODS(
		env, "com/android/bluetooth/hid/HidHostNativeInterface", methods);
		@@ -517,12 +558,12 @@ int register_com_android_bluetooth_hid_host(JNIEnv* env) {
		}

		const JNIJavaMethod javaMethods[] = {
		{"onConnectStateChanged", "([BI)V", &method_onConnectStateChanged},
		{"onGetProtocolMode", "([BI)V", &method_onGetProtocolMode},
		{"onGetReport", "([B[BI)V", &method_onGetReport},
		{"onHandshake", "([BI)V", &method_onHandshake},
		{"onVirtualUnplug", "([BI)V", &method_onVirtualUnplug},
		{"onGetIdleTime", "([BI)V", &method_onGetIdleTime},
		{"onConnectStateChanged", "([BIII)V", &method_onConnectStateChanged},
		{"onGetProtocolMode", "([BIII)V", &method_onGetProtocolMode},
		{"onGetReport", "([BII[BI)V", &method_onGetReport},
		{"onHandshake", "([BIII)V", &method_onHandshake},
		{"onVirtualUnplug", "([BIII)V", &method_onVirtualUnplug},
		{"onGetIdleTime", "([BIII)V", &method_onGetIdleTime},
		};
		GET_JAVA_METHODS(env, "com/android/bluetooth/hid/HidHostNativeInterface",
		javaMethods);

android/app/src/com/android/bluetooth/hid/HidHostNativeInterface.java

+60 −42

Original line number	Diff line number	Diff line
		@@ -60,44 +60,51 @@ public class HidHostNativeInterface {
		cleanupNative();
		}

		boolean connectHid(byte[] address) {
		return connectHidNative(address);
		boolean connectHid(byte[] address, int addressType, int transport) {
		return connectHidNative(address, addressType, transport);
		}

		boolean disconnectHid(byte[] address) {
		return disconnectHidNative(address);
		boolean disconnectHid(byte[] address, int addressType, int transport) {
		return disconnectHidNative(address, addressType, transport);
		}

		boolean getProtocolMode(byte[] address) {
		return getProtocolModeNative(address);
		boolean getProtocolMode(byte[] address, int addressType, int transport) {
		return getProtocolModeNative(address, addressType, transport);
		}

		boolean virtualUnPlug(byte[] address) {
		return virtualUnPlugNative(address);
		boolean virtualUnPlug(byte[] address, int addressType, int transport) {
		return virtualUnPlugNative(address, addressType, transport);
		}

		boolean setProtocolMode(byte[] address, byte protocolMode) {
		return setProtocolModeNative(address, protocolMode);
		boolean setProtocolMode(byte[] address, int addressType, int transport, byte protocolMode) {
		return setProtocolModeNative(address, addressType, transport, protocolMode);
		}

		boolean getReport(byte[] address, byte reportType, byte reportId, int bufferSize) {
		return getReportNative(address, reportType, reportId, bufferSize);
		boolean getReport(
		byte[] address,
		int addressType,
		int transport,
		byte reportType,
		byte reportId,
		int bufferSize) {
		return getReportNative(address, addressType, transport, reportType, reportId, bufferSize);
		}

		boolean setReport(byte[] address, byte reportType, String report) {
		return setReportNative(address, reportType, report);
		boolean setReport(
		byte[] address, int addressType, int transport, byte reportType, String report) {
		return setReportNative(address, addressType, transport, reportType, report);
		}

		boolean sendData(byte[] address, String report) {
		return sendDataNative(address, report);
		boolean sendData(byte[] address, int addressType, int transport, String report) {
		return sendDataNative(address, addressType, transport, report);
		}

		boolean setIdleTime(byte[] address, byte idleTime) {
		return setIdleTimeNative(address, idleTime);
		boolean setIdleTime(byte[] address, int addressType, int transport, byte idleTime) {
		return setIdleTimeNative(address, addressType, transport, idleTime);
		}

		boolean getIdleTime(byte[] address) {
		return getIdleTimeNative(address);
		boolean getIdleTime(byte[] address, int addressType, int transport) {
		return getIdleTimeNative(address, addressType, transport);
		}

		private static int convertHalState(int halState) {
		@@ -120,34 +127,36 @@ public class HidHostNativeInterface {
		/********************************* callbacks from native **********************************/
		/**********************************************************************************************/

		private void onConnectStateChanged(byte[] address, int state) {
		private void onConnectStateChanged(byte[] address, int addressType, int transport, int state) {
		if (DBG) Log.d(TAG, "onConnectStateChanged: state=" + state);
		mHidHostService.onConnectStateChanged(address, convertHalState(state));
		mHidHostService.onConnectStateChanged(
		address, addressType, transport, convertHalState(state));
		}

		private void onGetProtocolMode(byte[] address, int mode) {
		private void onGetProtocolMode(byte[] address, int addressType, int transport, int mode) {
		if (DBG) Log.d(TAG, "onGetProtocolMode()");
		mHidHostService.onGetProtocolMode(address, mode);
		mHidHostService.onGetProtocolMode(address, addressType, transport, mode);
		}

		private void onGetReport(byte[] address, byte[] report, int rptSize) {
		private void onGetReport(
		byte[] address, int addressType, int transport, byte[] report, int rptSize) {
		if (DBG) Log.d(TAG, "onGetReport()");
		mHidHostService.onGetReport(address, report, rptSize);
		mHidHostService.onGetReport(address, addressType, transport, report, rptSize);
		}

		private void onHandshake(byte[] address, int status) {
		private void onHandshake(byte[] address, int addressType, int transport, int status) {
		if (DBG) Log.d(TAG, "onHandshake: status=" + status);
		mHidHostService.onHandshake(address, status);
		mHidHostService.onHandshake(address, addressType, transport, status);
		}

		private void onVirtualUnplug(byte[] address, int status) {
		private void onVirtualUnplug(byte[] address, int addressType, int transport, int status) {
		if (DBG) Log.d(TAG, "onVirtualUnplug: status=" + status);
		mHidHostService.onVirtualUnplug(address, status);
		mHidHostService.onVirtualUnplug(address, addressType, transport, status);
		}

		private void onGetIdleTime(byte[] address, int idleTime) {
		private void onGetIdleTime(byte[] address, int addressType, int transport, int idleTime) {
		if (DBG) Log.d(TAG, "onGetIdleTime()");
		mHidHostService.onGetIdleTime(address, idleTime);
		mHidHostService.onGetIdleTime(address, addressType, transport, idleTime);
		}

		/**********************************************************************************************/
		@@ -166,24 +175,33 @@ public class HidHostNativeInterface {

		private native void cleanupNative();

		private native boolean connectHidNative(byte[] btAddress);
		private native boolean connectHidNative(byte[] btAddress, int addressType, int transport);

		private native boolean disconnectHidNative(byte[] btAddress);
		private native boolean disconnectHidNative(byte[] btAddress, int addressType, int transport);

		private native boolean getProtocolModeNative(byte[] btAddress);
		private native boolean getProtocolModeNative(byte[] btAddress, int addressType, int transport);

		private native boolean virtualUnPlugNative(byte[] btAddress);
		private native boolean virtualUnPlugNative(byte[] btAddress, int addressType, int transport);

		private native boolean setProtocolModeNative(byte[] btAddress, byte protocolMode);
		private native boolean setProtocolModeNative(
		byte[] btAddress, int addressType, int transport, byte protocolMode);

		private native boolean getReportNative(
		byte[] btAddress, byte reportType, byte reportId, int bufferSize);
		byte[] btAddress,
		int addressType,
		int transport,
		byte reportType,
		byte reportId,
		int bufferSize);

		private native boolean setReportNative(byte[] btAddress, byte reportType, String report);
		private native boolean setReportNative(
		byte[] btAddress, int addressType, int transport, byte reportType, String report);

		private native boolean sendDataNative(byte[] btAddress, String report);
		private native boolean sendDataNative(
		byte[] btAddress, int addressType, int transport, String report);

		private native boolean setIdleTimeNative(byte[] btAddress, byte idleTime);
		private native boolean setIdleTimeNative(
		byte[] btAddress, int addressType, int transport, byte idleTime);

		private native boolean getIdleTimeNative(byte[] btAddress);
		private native boolean getIdleTimeNative(byte[] btAddress, int addressType, int transport);
		}

android/app/src/com/android/bluetooth/hid/HidHostService.java

+197 −139

File changed.

Preview size limit exceeded, changes collapsed.

system/bta/hh/bta_hh_act.cc

+10 −6

Original line number	Diff line number	Diff line
		@@ -502,7 +502,7 @@ void bta_hh_connect(tBTA_HH_DEV_CB* p_cb, const tBTA_HH_DATA* p_data) {
		bt_property_t remote_properties = {BT_PROPERTY_UUIDS, sizeof(remote_uuids),
		&remote_uuids};
		const RawAddress& bd_addr = p_data->api_conn.link_spec.addrt.bda;

		p_cb->link_spec = p_data->api_conn.link_spec;
		// Find the device type
		tBT_DEVICE_TYPE dev_type;
		tBLE_ADDR_TYPE addr_type;
		@@ -554,6 +554,11 @@ void bta_hh_connect(tBTA_HH_DEV_CB* p_cb, const tBTA_HH_DATA* p_data) {
		ADDRESS_TO_LOGGABLE_CSTR(bd_addr), bredr, hid_available, le_acl,
		hogp_available, dev_type, p_cb->is_le_device);

		// TODO: Use requested address type and transport
		p_cb->link_spec.addrt.type = addr_type;
		p_cb->link_spec.transport =
		p_cb->is_le_device ? BT_TRANSPORT_LE : BT_TRANSPORT_BR_EDR;

		p_cb->mode = p_data->api_conn.mode;
		bta_hh_cb.p_cur = p_cb;

		@@ -641,8 +646,7 @@ void bta_hh_open_cmpl_act(tBTA_HH_DEV_CB* p_cb, const tBTA_HH_DATA* p_data) {
		"%s initiator:%s", (p_cb->is_le_device) ? "le" : "classic",
		(p_cb->incoming_conn) ? "remote" : "local"));

		if (!p_cb->is_le_device)
		{
		if (!p_cb->is_le_device) {
		/* inform role manager */
		bta_sys_conn_open(BTA_ID_HH, p_cb->app_id, p_cb->link_spec.addrt.bda);

		@@ -1005,7 +1009,8 @@ void bta_hh_maint_dev_act(tBTA_HH_DEV_CB* p_cb, const tBTA_HH_DATA* p_data) {
		dev_info.link_spec = p_dev_info->link_spec;
		/* initialize callback data */
		if (p_cb->hid_handle == BTA_HH_INVALID_HANDLE) {
		if (BTM_UseLeLink(p_data->api_conn.link_spec.addrt.bda)) {
		if (BTM_UseLeLink(p_data->api_maintdev.link_spec.addrt.bda)) {
		p_cb->link_spec.transport = BT_TRANSPORT_LE;
		p_cb->is_le_device = true;
		dev_info.handle = bta_hh_le_add_device(p_cb, p_dev_info);
		if (dev_info.handle != BTA_HH_INVALID_HANDLE)
		@@ -1049,8 +1054,7 @@ void bta_hh_maint_dev_act(tBTA_HH_DEV_CB* p_cb, const tBTA_HH_DATA* p_data) {
		bta_hh_le_remove_dev_bg_conn(p_cb);
		bta_hh_sm_execute(p_cb, BTA_HH_API_CLOSE_EVT, NULL);
		bta_hh_clean_up_kdev(p_cb);
		} else
		{
		} else {
		if (HID_HostRemoveDev(dev_info.handle) == HID_SUCCESS) {
		dev_info.status = BTA_HH_OK;

system/bta/hh/bta_hh_le.cc

+4 −3

Original line number	Diff line number	Diff line
		@@ -290,9 +290,10 @@ static tBTA_HH_DEV_CB* bta_hh_le_find_dev_cb_by_conn_id(uint16_t conn_id) {

		/*******************************************************************************
		*
		* Function bta_hh_le_find_dev_cb_by_bda
		* Function bta_hh_le_find_dev_cb_by_addr_transport
		*
		* Description Utility function find a device control block by BD address.
		* Description Utility function find a device control block by ACL link
		* specification.
		*
		******************************************************************************/
		static tBTA_HH_DEV_CB* bta_hh_le_find_dev_cb_by_bda(
		@@ -962,7 +963,7 @@ static void bta_hh_le_pri_service_discovery(tBTA_HH_DEV_CB* p_cb) {
		*
		******************************************************************************/
		static void bta_hh_le_encrypt_cback(const RawAddress* bd_addr,
		UNUSED_ATTR tBT_TRANSPORT transport,
		tBT_TRANSPORT transport,
		UNUSED_ATTR void* p_ref_data,
		tBTM_STATUS result) {
		tAclLinkSpec link_spec;