A2DP Sink: Add support for BluetoothA2dpSink profile (9bf639a8) · Commits · e / os / android_packages_modules_Bluetooth

android/app/AndroidManifest.xml

+8 −0

Original line number	Original line	Diff line number	Diff line
	@@ -262,6 +262,14 @@
	<action android:name="android.bluetooth.IBluetoothA2dp" />		<action android:name="android.bluetooth.IBluetoothA2dp" />
	</intent-filter>		</intent-filter>
	</service>		</service>
			<service
			android:process="@string/process"
			android:name = ".a2dp.A2dpSinkService"
			android:enabled="@bool/profile_supported_a2dp_sink">
			<intent-filter>
			<action android:name="android.bluetooth.IBluetoothA2dpSink" />
			</intent-filter>
			</service>
	<service		<service
	android:process="@string/process"		android:process="@string/process"
	android:name = ".hid.HidService"		android:name = ".hid.HidService"

android/app/jni/Android.mk

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -7,6 +7,7 @@ LOCAL_SRC_FILES:= \
	com_android_bluetooth_hfp.cpp \		com_android_bluetooth_hfp.cpp \
	com_android_bluetooth_hfpclient.cpp \		com_android_bluetooth_hfpclient.cpp \
	com_android_bluetooth_a2dp.cpp \		com_android_bluetooth_a2dp.cpp \
			com_android_bluetooth_a2dp_sink.cpp \
	com_android_bluetooth_avrcp.cpp \		com_android_bluetooth_avrcp.cpp \
	com_android_bluetooth_hid.cpp \		com_android_bluetooth_hid.cpp \
	com_android_bluetooth_hdp.cpp \		com_android_bluetooth_hdp.cpp \

android/app/jni/com_android_bluetooth.h

+2 −0

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

	int register_com_android_bluetooth_a2dp(JNIEnv* env);		int register_com_android_bluetooth_a2dp(JNIEnv* env);

			int register_com_android_bluetooth_a2dp_sink(JNIEnv* env);

	int register_com_android_bluetooth_avrcp(JNIEnv* env);		int register_com_android_bluetooth_avrcp(JNIEnv* env);

	int register_com_android_bluetooth_hid(JNIEnv* env);		int register_com_android_bluetooth_hid(JNIEnv* env);

android/app/jni/com_android_bluetooth_a2dp_sink.cpp

0 → 100644

+254 −0

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 "BluetoothA2dpSinkServiceJni"

			#define LOG_NDEBUG 0

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

			#include <string.h>

			namespace android {
			static jmethodID method_onConnectionStateChanged;
			static jmethodID method_onAudioStateChanged;
			static jmethodID method_onAudioConfigChanged;

			static const btav_interface_t *sBluetoothA2dpInterface = NULL;
			static jobject mCallbacksObj = NULL;
			static JNIEnv *sCallbackEnv = NULL;

			static bool checkCallbackThread() {
			// Always fetch the latest callbackEnv from AdapterService.
			// Caching this could cause this sCallbackEnv to go out-of-sync
			// with the AdapterService's ENV if an ASSOCIATE/DISASSOCIATE event
			// is received
			//if (sCallbackEnv == NULL) {
			sCallbackEnv = getCallbackEnv();
			//}

			JNIEnv* env = AndroidRuntime::getJNIEnv();
			if (sCallbackEnv != env \|\| sCallbackEnv == NULL) return false;
			return true;
			}

			static void bta2dp_connection_state_callback(btav_connection_state_t state, bt_bdaddr_t* bd_addr) {
			jbyteArray addr;

			ALOGI("%s", __FUNCTION__);

			if (!checkCallbackThread()) { \
			ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); \
			return; \
			}
			addr = sCallbackEnv->NewByteArray(sizeof(bt_bdaddr_t));
			if (!addr) {
			ALOGE("Fail to new jbyteArray bd addr for connection state");
			checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);
			return;
			}

			sCallbackEnv->SetByteArrayRegion(addr, 0, sizeof(bt_bdaddr_t), (jbyte*) bd_addr);
			sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onConnectionStateChanged, (jint) state,
			addr);
			checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);
			sCallbackEnv->DeleteLocalRef(addr);
			}

			static void bta2dp_audio_state_callback(btav_audio_state_t state, bt_bdaddr_t* bd_addr) {
			jbyteArray addr;

			ALOGI("%s", __FUNCTION__);

			if (!checkCallbackThread()) { \
			ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); \
			return; \
			}
			addr = sCallbackEnv->NewByteArray(sizeof(bt_bdaddr_t));
			if (!addr) {
			ALOGE("Fail to new jbyteArray bd addr for connection state");
			checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);
			return;
			}

			sCallbackEnv->SetByteArrayRegion(addr, 0, sizeof(bt_bdaddr_t), (jbyte*) bd_addr);
			sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAudioStateChanged, (jint) state,
			addr);
			checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);
			sCallbackEnv->DeleteLocalRef(addr);
			}

			static void bta2dp_audio_config_callback(bt_bdaddr_t *bd_addr, uint32_t sample_rate, uint8_t channel_count) {
			jbyteArray addr;

			ALOGI("%s", __FUNCTION__);

			if (!checkCallbackThread()) { \
			ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__); \
			return; \
			}
			addr = sCallbackEnv->NewByteArray(sizeof(bt_bdaddr_t));
			if (!addr) {
			ALOGE("Fail to new jbyteArray bd addr for connection state");
			checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);
			return;
			}

			sCallbackEnv->SetByteArrayRegion(addr, 0, sizeof(bt_bdaddr_t), (jbyte*) bd_addr);
			sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAudioConfigChanged, addr, (jint)sample_rate, (jint)channel_count);
			checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);
			sCallbackEnv->DeleteLocalRef(addr);
			}

			static btav_callbacks_t sBluetoothA2dpCallbacks = {
			sizeof(sBluetoothA2dpCallbacks),
			bta2dp_connection_state_callback,
			bta2dp_audio_state_callback,
			bta2dp_audio_config_callback
			};

			static void classInitNative(JNIEnv* env, jclass clazz) {
			int err;
			const bt_interface_t* btInf;
			bt_status_t status;

			method_onConnectionStateChanged =
			env->GetMethodID(clazz, "onConnectionStateChanged", "(I[B)V");

			method_onAudioStateChanged =
			env->GetMethodID(clazz, "onAudioStateChanged", "(I[B)V");

			method_onAudioConfigChanged =
			env->GetMethodID(clazz, "onAudioConfigChanged", "([BII)V");

			ALOGI("%s: succeeds", __FUNCTION__);
			}

			static void initNative(JNIEnv *env, jobject object) {
			const bt_interface_t* btInf;
			bt_status_t status;

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

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

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

			if ( (sBluetoothA2dpInterface = (btav_interface_t *)
			btInf->get_profile_interface(BT_PROFILE_ADVANCED_AUDIO_SINK_ID)) == NULL) {
			ALOGE("Failed to get Bluetooth A2DP Sink Interface");
			return;
			}

			if ( (status = sBluetoothA2dpInterface->init(&sBluetoothA2dpCallbacks)) != BT_STATUS_SUCCESS) {
			ALOGE("Failed to initialize Bluetooth A2DP Sink, status: %d", status);
			sBluetoothA2dpInterface = NULL;
			return;
			}

			mCallbacksObj = env->NewGlobalRef(object);
			}

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

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

			if (sBluetoothA2dpInterface !=NULL) {
			sBluetoothA2dpInterface->cleanup();
			sBluetoothA2dpInterface = NULL;
			}

			if (mCallbacksObj != NULL) {
			env->DeleteGlobalRef(mCallbacksObj);
			mCallbacksObj = NULL;
			}
			}

			static jboolean connectA2dpNative(JNIEnv *env, jobject object, jbyteArray address) {
			jbyte *addr;
			bt_bdaddr_t * btAddr;
			bt_status_t status;

			ALOGI("%s: sBluetoothA2dpInterface: %p", __FUNCTION__, sBluetoothA2dpInterface);
			if (!sBluetoothA2dpInterface) return JNI_FALSE;

			addr = env->GetByteArrayElements(address, NULL);
			btAddr = (bt_bdaddr_t *) addr;
			if (!addr) {
			jniThrowIOException(env, EINVAL);
			return JNI_FALSE;
			}

			if ((status = sBluetoothA2dpInterface->connect((bt_bdaddr_t *)addr)) != BT_STATUS_SUCCESS) {
			ALOGE("Failed HF connection, status: %d", status);
			}
			env->ReleaseByteArrayElements(address, addr, 0);
			return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
			}

			static jboolean disconnectA2dpNative(JNIEnv *env, jobject object, jbyteArray address) {
			jbyte *addr;
			bt_status_t status;

			if (!sBluetoothA2dpInterface) return JNI_FALSE;

			addr = env->GetByteArrayElements(address, NULL);
			if (!addr) {
			jniThrowIOException(env, EINVAL);
			return JNI_FALSE;
			}

			if ( (status = sBluetoothA2dpInterface->disconnect((bt_bdaddr_t *)addr)) != BT_STATUS_SUCCESS) {
			ALOGE("Failed HF disconnection, status: %d", status);
			}
			env->ReleaseByteArrayElements(address, addr, 0);
			return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
			}

			static JNINativeMethod sMethods[] = {
			{"classInitNative", "()V", (void *) classInitNative},
			{"initNative", "()V", (void *) initNative},
			{"cleanupNative", "()V", (void *) cleanupNative},
			{"connectA2dpNative", "([B)Z", (void *) connectA2dpNative},
			{"disconnectA2dpNative", "([B)Z", (void *) disconnectA2dpNative},
			};

			int register_com_android_bluetooth_a2dp_sink(JNIEnv* env)
			{
			return jniRegisterNativeMethods(env, "com/android/bluetooth/a2dp/A2dpSinkStateMachine",
			sMethods, NELEM(sMethods));
			}

			}

android/app/jni/com_android_bluetooth_btservice_AdapterService.cpp

+6 −1

Original line number	Original line	Diff line number	Diff line
	@@ -1116,7 +1116,12 @@ jint JNI_OnLoad(JavaVM jvm, void reserved)
	}		}

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

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