Merge "Remove code related to Health Device Profile" (6f0f00f9) · Commits · e / os / android_packages_modules_Bluetooth

android/app/AndroidManifest.xml

+0 −8

Original line number	Original line	Diff line number	Diff line
	@@ -351,14 +351,6 @@
	<action android:name="android.bluetooth.IBluetoothHidDevice" />		<action android:name="android.bluetooth.IBluetoothHidDevice" />
	</intent-filter>		</intent-filter>
	</service>		</service>
	<service
	android:process="@string/process"
	android:name = ".hdp.HealthService"
	android:enabled="@bool/profile_supported_hdp">
	<intent-filter>
	<action android:name="android.bluetooth.IBluetoothHealth" />
	</intent-filter>
	</service>
	<service		<service
	android:process="@string/process"		android:process="@string/process"
	android:name = ".pan.PanService"		android:name = ".pan.PanService"

android/app/jni/Android.bp

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -13,7 +13,6 @@ cc_library_shared {
	"com_android_bluetooth_hid_host.cpp",		"com_android_bluetooth_hid_host.cpp",
	"com_android_bluetooth_hid_device.cpp",		"com_android_bluetooth_hid_device.cpp",
	"com_android_bluetooth_hearing_aid.cpp",		"com_android_bluetooth_hearing_aid.cpp",
	"com_android_bluetooth_hdp.cpp",
	"com_android_bluetooth_pan.cpp",		"com_android_bluetooth_pan.cpp",
	"com_android_bluetooth_gatt.cpp",		"com_android_bluetooth_gatt.cpp",
	"com_android_bluetooth_sdp.cpp",		"com_android_bluetooth_sdp.cpp",

android/app/jni/com_android_bluetooth.h

+0 −2

Original line number	Original line	Diff line number	Diff line
	@@ -89,8 +89,6 @@ int register_com_android_bluetooth_hid_host(JNIEnv* env);

	int register_com_android_bluetooth_hid_device(JNIEnv* env);		int register_com_android_bluetooth_hid_device(JNIEnv* env);

	int register_com_android_bluetooth_hdp(JNIEnv* env);

	int register_com_android_bluetooth_pan(JNIEnv* env);		int register_com_android_bluetooth_pan(JNIEnv* env);

	int register_com_android_bluetooth_gatt (JNIEnv* env);		int register_com_android_bluetooth_gatt (JNIEnv* env);

android/app/jni/com_android_bluetooth_btservice_AdapterService.cpp

+0 −6

Original line number	Original line	Diff line number	Diff line
	@@ -1347,12 +1347,6 @@ jint JNI_OnLoad(JavaVM* jvm, void* reserved) {
	return JNI_ERR;		return JNI_ERR;
	}		}

	status = android::register_com_android_bluetooth_hdp(e);
	if (status < 0) {
	ALOGE("jni hdp registration failure: %d", status);
	return JNI_ERR;
	}

	status = android::register_com_android_bluetooth_pan(e);		status = android::register_com_android_bluetooth_pan(e);
	if (status < 0) {		if (status < 0) {
	ALOGE("jni pan registration failure: %d", status);		ALOGE("jni pan registration failure: %d", status);

android/app/jni/com_android_bluetooth_hdp.cpp

deleted100644 → 0

+0 −244

Original line number	Original line	Diff line number	Diff line
	/*
	* Copyright (C) 2012 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 "BluetoothHealthServiceJni"

	#define LOG_NDEBUG 0

	#include "android_runtime/AndroidRuntime.h"
	#include "com_android_bluetooth.h"
	#include "hardware/bt_hl.h"
	#include "utils/Log.h"

	#include <string.h>

	namespace android {

	static jmethodID method_onAppRegistrationState;
	static jmethodID method_onChannelStateChanged;

	static const bthl_interface_t* sBluetoothHdpInterface = NULL;
	static jobject mCallbacksObj = NULL;

	// Define callback functions
	static void app_registration_state_callback(int app_id,
	bthl_app_reg_state_t state) {
	CallbackEnv sCallbackEnv(__func__);
	if (!sCallbackEnv.valid()) return;
	sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAppRegistrationState,
	app_id, (jint)state);
	}

	static void channel_state_callback(int app_id, RawAddress* bd_addr,
	int mdep_cfg_index, int channel_id,
	bthl_channel_state_t state, int fd) {
	CallbackEnv sCallbackEnv(__func__);
	if (!sCallbackEnv.valid()) return;
	ScopedLocalRef<jbyteArray> addr(
	sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
	if (!addr.get()) {
	ALOGE("Fail to new jbyteArray bd addr for channel state");
	return;
	}

	// TODO(BT) check if fd is only valid for BTHH_CONN_STATE_CONNECTED state
	jobject fileDescriptor = NULL;
	if (state == BTHL_CONN_STATE_CONNECTED) {
	fileDescriptor = jniCreateFileDescriptor(sCallbackEnv.get(), fd);
	if (!fileDescriptor) {
	ALOGE("Failed to convert file descriptor, fd: %d", fd);
	return;
	}
	}

	sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
	(jbyte*)bd_addr);
	sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onChannelStateChanged,
	app_id, addr.get(), mdep_cfg_index, channel_id,
	(jint)state, fileDescriptor);
	}

	static bthl_callbacks_t sBluetoothHdpCallbacks = {
	sizeof(sBluetoothHdpCallbacks), app_registration_state_callback,
	channel_state_callback};

	// Define native functions

	static void classInitNative(JNIEnv* env, jclass clazz) {
	method_onAppRegistrationState =
	env->GetMethodID(clazz, "onAppRegistrationState", "(II)V");
	method_onChannelStateChanged = env->GetMethodID(
	clazz, "onChannelStateChanged", "(I[BIIILjava/io/FileDescriptor;)V");
	ALOGI("%s: succeeds", __func__);
	}

	static void initializeNative(JNIEnv* env, jobject object) {
	const bt_interface_t* btInf = getBluetoothInterface();
	if (btInf == NULL) {
	ALOGE("Bluetooth module is not loaded");
	return;
	}

	if (sBluetoothHdpInterface != NULL) {
	ALOGW("Cleaning up Bluetooth Health Interface before initializing...");
	sBluetoothHdpInterface->cleanup();
	sBluetoothHdpInterface = NULL;
	}

	if (mCallbacksObj != NULL) {
	ALOGW("Cleaning up Bluetooth Health callback object");
	env->DeleteGlobalRef(mCallbacksObj);
	mCallbacksObj = NULL;
	}

	sBluetoothHdpInterface =
	(bthl_interface_t*)btInf->get_profile_interface(BT_PROFILE_HEALTH_ID);
	if (sBluetoothHdpInterface == NULL) {
	ALOGE("Failed to get Bluetooth Health Interface");
	return;
	}

	bt_status_t status = sBluetoothHdpInterface->init(&sBluetoothHdpCallbacks);
	if (status != BT_STATUS_SUCCESS) {
	ALOGE("Failed to initialize Bluetooth HDP, status: %d", status);
	sBluetoothHdpInterface = NULL;
	return;
	}

	mCallbacksObj = env->NewGlobalRef(object);
	}

	static void cleanupNative(JNIEnv* env, jobject object) {
	const bt_interface_t* btInf = getBluetoothInterface();

	if (btInf == NULL) {
	ALOGE("Bluetooth module is not loaded");
	return;
	}

	if (sBluetoothHdpInterface != NULL) {
	ALOGW("Cleaning up Bluetooth Health Interface...");
	sBluetoothHdpInterface->cleanup();
	sBluetoothHdpInterface = NULL;
	}

	if (mCallbacksObj != NULL) {
	ALOGW("Cleaning up Bluetooth Health object");
	env->DeleteGlobalRef(mCallbacksObj);
	mCallbacksObj = NULL;
	}
	}

	static jint registerHealthAppNative(JNIEnv* env, jobject object, jint data_type,
	jint role, jstring name,
	jint channel_type) {
	if (!sBluetoothHdpInterface) {
	ALOGE(
	"Failed to register health app. No Bluetooth Health Interface "
	"available");
	return -1;
	}

	bthl_mdep_cfg_t mdep_cfg;
	mdep_cfg.mdep_role = (bthl_mdep_role_t)role;
	mdep_cfg.data_type = data_type;
	mdep_cfg.channel_type = (bthl_channel_type_t)channel_type;
	// TODO(BT) pass all the followings in from java instead of reuse name
	mdep_cfg.mdep_description = env->GetStringUTFChars(name, NULL);

	bthl_reg_param_t reg_param;
	reg_param.application_name = env->GetStringUTFChars(name, NULL);
	reg_param.provider_name = NULL;
	reg_param.srv_name = NULL;
	reg_param.srv_desp = NULL;
	reg_param.number_of_mdeps = 1;
	reg_param.mdep_cfg = &mdep_cfg;

	int app_id;
	bt_status_t status =
	sBluetoothHdpInterface->register_application(&reg_param, &app_id);
	if (status != BT_STATUS_SUCCESS) {
	ALOGE("Failed register health app, status: %d", status);
	return -1;
	}

	env->ReleaseStringUTFChars(name, mdep_cfg.mdep_description);
	env->ReleaseStringUTFChars(name, reg_param.application_name);
	return app_id;
	}

	static jboolean unregisterHealthAppNative(JNIEnv* env, jobject object,
	int app_id) {
	if (!sBluetoothHdpInterface) return JNI_FALSE;

	bt_status_t status = sBluetoothHdpInterface->unregister_application(app_id);
	if (status != BT_STATUS_SUCCESS) {
	ALOGE("Failed to unregister app %d, status: %d", app_id, status);
	}
	return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
	}

	static jint connectChannelNative(JNIEnv* env, jobject object,
	jbyteArray address, jint app_id) {
	if (!sBluetoothHdpInterface) return -1;

	jbyte* addr = env->GetByteArrayElements(address, NULL);
	if (!addr) {
	ALOGE("Bluetooth device address null");
	return -1;
	}

	jint chan_id;
	bt_status_t status = sBluetoothHdpInterface->connect_channel(
	app_id, (RawAddress*)addr, 0, &chan_id);
	if (status != BT_STATUS_SUCCESS) {
	ALOGE("Failed HDP channel connection, status: %d", status);
	chan_id = -1;
	}
	env->ReleaseByteArrayElements(address, addr, 0);

	return chan_id;
	}

	static jboolean disconnectChannelNative(JNIEnv* env, jobject object,
	jint channel_id) {
	if (!sBluetoothHdpInterface) return JNI_FALSE;

	bt_status_t status = sBluetoothHdpInterface->destroy_channel(channel_id);
	if (status != BT_STATUS_SUCCESS) {
	ALOGE("Failed disconnect health channel, status: %d", status);
	return JNI_FALSE;
	}
	return JNI_TRUE;
	}

	static JNINativeMethod sMethods[] = {
	{"classInitNative", "()V", (void*)classInitNative},
	{"initializeNative", "()V", (void*)initializeNative},
	{"cleanupNative", "()V", (void*)cleanupNative},
	{"registerHealthAppNative", "(IILjava/lang/String;I)I",
	(void*)registerHealthAppNative},
	{"unregisterHealthAppNative", "(I)Z", (void*)unregisterHealthAppNative},
	{"connectChannelNative", "([BI)I", (void*)connectChannelNative},
	{"disconnectChannelNative", "(I)Z", (void*)disconnectChannelNative},
	};

	int register_com_android_bluetooth_hdp(JNIEnv* env) {
	return jniRegisterNativeMethods(env,
	"com/android/bluetooth/hdp/HealthService",
	sMethods, NELEM(sMethods));
	}
	}