LE Audio State Machine and Native Interface boilerplate (7c95cce0) · Commits · e / os / android_packages_apps_Bluetooth

jni/com_android_bluetooth.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -157,6 +157,8 @@ int register_com_android_bluetooth_hearing_aid(JNIEnv* env);
		int register_com_android_bluetooth_btservice_BluetoothKeystore(JNIEnv* env);

		int register_com_android_bluetooth_btservice_activity_attribution(JNIEnv* env);

		int register_com_android_bluetooth_le_audio(JNIEnv* env);
		} // namespace android

		#endif /* COM_ANDROID_BLUETOOTH_H */

jni/com_android_bluetooth_btservice_AdapterService.cpp

+6 −0

Original line number	Diff line number	Diff line
		@@ -1486,5 +1486,11 @@ jint JNI_OnLoad(JavaVM* jvm, void* reserved) {
		return JNI_ERR;
		}

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

		return JNI_VERSION_1_6;
		}

jni/com_android_bluetooth_le_audio.cpp

0 → 100644

+280 −0

Original line number	Diff line number	Diff line
		/* Copyright 2019 HIMSA II K/S - www.himsa.com
		* Represented by EHIMA - www.ehima.com
		*
		* 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 "BluetoothLeAudioServiceJni"

		#define LOG_NDEBUG 0

		#include <hardware/bluetooth.h>

		#include <array>
		#include <optional>
		#include <shared_mutex>

		#include "com_android_bluetooth.h"
		#include "hardware/bt_le_audio.h"

		using bluetooth::le_audio::ConnectionState;
		using bluetooth::le_audio::GroupStatus;
		using bluetooth::le_audio::LeAudioClientCallbacks;
		using bluetooth::le_audio::LeAudioClientInterface;

		namespace android {
		static jmethodID method_onConnectionStateChanged;
		static jmethodID method_onGroupStatus;
		static jmethodID method_onAudioConf;
		static jmethodID method_onSetMemberAvailable;

		static LeAudioClientInterface* sLeAudioClientInterface = nullptr;
		static std::shared_timed_mutex interface_mutex;

		static jobject mCallbacksObj = nullptr;
		static std::shared_timed_mutex callbacks_mutex;

		class LeAudioClientCallbacksImpl : public LeAudioClientCallbacks {
		public:
		~LeAudioClientCallbacksImpl() = default;

		void OnConnectionState(ConnectionState state,
		const RawAddress& bd_addr) override {
		LOG(INFO) << __func__ << ", state:" << int(state);

		std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid() \|\| mCallbacksObj == nullptr) return;

		ScopedLocalRef<jbyteArray> addr(
		sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
		if (!addr.get()) {
		LOG(ERROR) << "Failed to new jbyteArray bd addr for connection state";
		return;
		}

		sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
		(jbyte*)&bd_addr);
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onConnectionStateChanged,
		(jint)state, addr.get());
		}

		void OnGroupStatus(uint8_t group_id, GroupStatus group_status,
		uint8_t group_flags) override {
		LOG(INFO) << __func__;

		std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid() \|\| mCallbacksObj == nullptr) return;

		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onGroupStatus,
		(jint)group_id, (jint)group_status,
		(jint)group_flags);
		}

		void OnAudioConf(const RawAddress& bd_addr, uint8_t direction,
		uint8_t group_id, uint32_t sink_audio_location,
		uint32_t source_audio_location) override {
		LOG(INFO) << __func__;

		std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid() \|\| mCallbacksObj == nullptr) return;

		ScopedLocalRef<jbyteArray> addr(
		sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
		if (!addr.get()) {
		LOG(ERROR) << "Failed to new jbyteArray bd addr for group status";
		return;
		}

		sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
		(jbyte*)&bd_addr);
		sCallbackEnv->CallVoidMethod(
		mCallbacksObj, method_onAudioConf, (jint)direction, (jint)group_id,
		(jint)sink_audio_location, (jint)source_audio_location, addr.get());
		}

		void OnSetMemberAvailable(const RawAddress& bd_addr,
		uint8_t group_id) override {
		LOG(INFO) << __func__ << ", group id:" << int(group_id);

		std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid() \|\| mCallbacksObj == nullptr) return;

		ScopedLocalRef<jbyteArray> addr(
		sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
		if (!addr.get()) {
		LOG(ERROR) << "Failed to new jbyteArray bd addr for connection state";
		return;
		}

		sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
		(jbyte*)&bd_addr);
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onSetMemberAvailable,
		addr.get(), (jint)group_id);
		}
		};

		static LeAudioClientCallbacksImpl sLeAudioClientCallbacks;

		static void classInitNative(JNIEnv* env, jclass clazz) {
		method_onGroupStatus = env->GetMethodID(clazz, "onGroupStatus", "(III)V");
		method_onAudioConf = env->GetMethodID(clazz, "onAudioConf", "(IIII[B)V");
		method_onConnectionStateChanged =
		env->GetMethodID(clazz, "onConnectionStateChanged", "(I[B)V");
		method_onSetMemberAvailable =
		env->GetMethodID(clazz, "onSetMemberAvailable", "([BI)V");
		}

		static void initNative(JNIEnv* env, jobject object) {
		std::unique_lock<std::shared_timed_mutex> interface_lock(interface_mutex);
		std::unique_lock<std::shared_timed_mutex> callbacks_lock(callbacks_mutex);

		const bt_interface_t* btInf = getBluetoothInterface();
		if (btInf == nullptr) {
		LOG(ERROR) << "Bluetooth module is not loaded";
		return;
		}

		if (mCallbacksObj != nullptr) {
		LOG(INFO) << "Cleaning up LeAudio callback object";
		env->DeleteGlobalRef(mCallbacksObj);
		mCallbacksObj = nullptr;
		}

		if ((mCallbacksObj = env->NewGlobalRef(object)) == nullptr) {
		LOG(ERROR) << "Failed to allocate Global Ref for LeAudio Callbacks";
		return;
		}

		sLeAudioClientInterface =
		(LeAudioClientInterface*)btInf->get_profile_interface(
		BT_PROFILE_LE_AUDIO_ID);
		if (sLeAudioClientInterface == nullptr) {
		LOG(ERROR) << "Failed to get Bluetooth LeAudio Interface";
		return;
		}

		sLeAudioClientInterface->Initialize(&sLeAudioClientCallbacks);
		}

		static void cleanupNative(JNIEnv* env, jobject object) {
		std::unique_lock<std::shared_timed_mutex> interface_lock(interface_mutex);
		std::unique_lock<std::shared_timed_mutex> callbacks_lock(callbacks_mutex);

		const bt_interface_t* btInf = getBluetoothInterface();
		if (btInf == nullptr) {
		LOG(ERROR) << "Bluetooth module is not loaded";
		return;
		}

		if (sLeAudioClientInterface != nullptr) {
		sLeAudioClientInterface->Cleanup();
		sLeAudioClientInterface = nullptr;
		}

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

		static jboolean connectLeAudioNative(JNIEnv* env, jobject object,
		jbyteArray address) {
		LOG(INFO) << __func__;
		std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
		if (!sLeAudioClientInterface) return JNI_FALSE;

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

		RawAddress* tmpraw = (RawAddress*)addr;
		sLeAudioClientInterface->Connect(*tmpraw);
		env->ReleaseByteArrayElements(address, addr, 0);
		return JNI_TRUE;
		}

		static jboolean disconnectLeAudioNative(JNIEnv* env, jobject object,
		jbyteArray address) {
		LOG(INFO) << __func__;
		std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
		if (!sLeAudioClientInterface) return JNI_FALSE;

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

		RawAddress* tmpraw = (RawAddress*)addr;
		sLeAudioClientInterface->Disconnect(*tmpraw);
		env->ReleaseByteArrayElements(address, addr, 0);
		return JNI_TRUE;
		}

		static void groupStreamNative(JNIEnv* env, jobject object, jint group_id,
		jint content_type) {
		LOG(INFO) << __func__;

		if (!sLeAudioClientInterface) {
		LOG(ERROR) << __func__ << ": Failed to get the Bluetooth LeAudio Interface";
		return;
		}

		sLeAudioClientInterface->GroupStream(group_id, content_type);
		}

		static void groupSuspendNative(JNIEnv* env, jobject object, jint group_id) {
		LOG(INFO) << __func__;

		if (!sLeAudioClientInterface) {
		LOG(ERROR) << __func__ << ": Failed to get the Bluetooth LeAudio Interface";
		return;
		}

		sLeAudioClientInterface->GroupSuspend(group_id);
		}

		static void groupStopNative(JNIEnv* env, jobject object, jint group_id) {
		LOG(INFO) << __func__;

		if (!sLeAudioClientInterface) {
		LOG(ERROR) << __func__ << ": Failed to get the Bluetooth LeAudio Interface";
		return;
		}

		sLeAudioClientInterface->GroupStop(group_id);
		}

		static JNINativeMethod sMethods[] = {
		{"classInitNative", "()V", (void*)classInitNative},
		{"initNative", "()V", (void*)initNative},
		{"cleanupNative", "()V", (void*)cleanupNative},
		{"connectLeAudioNative", "([B)Z", (void*)connectLeAudioNative},
		{"disconnectLeAudioNative", "([B)Z", (void*)disconnectLeAudioNative},
		{"groupStreamNative", "(II)V", (void*)groupStreamNative},
		{"groupSuspendNative", "(I)V", (void*)groupSuspendNative},
		{"groupStopNative", "(I)V", (void*)groupStopNative},
		};

		int register_com_android_bluetooth_le_audio(JNIEnv* env) {
		return jniRegisterNativeMethods(
		env, "com/android/bluetooth/le_audio/LeAudioNativeInterface", sMethods,
		NELEM(sMethods));
		}
		} // namespace android

src/com/android/bluetooth/le_audio/LeAudioNativeInterface.java

0 → 100644

+217 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2020 HIMSA II K/S - www.himsa.com.
		* Represented by EHIMA - www.ehima.com
		*
		* 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.
		*/

		/*
		* Defines the native interface that is used by state machine/service to
		* send or receive messages from the native stack. This file is registered
		* for the native methods in the corresponding JNI C++ file.
		*/
		package com.android.bluetooth.le_audio;

		import android.bluetooth.BluetoothAdapter;
		import android.bluetooth.BluetoothDevice;
		import android.util.Log;

		import com.android.bluetooth.Utils;
		import com.android.internal.annotations.GuardedBy;

		/**
		* LeAudio Native Interface to/from JNI.
		*/
		public class LeAudioNativeInterface {
		private static final String TAG = "LeAudioNativeInterface";
		private static final boolean DBG = true;
		private BluetoothAdapter mAdapter;

		@GuardedBy("INSTANCE_LOCK")
		private static LeAudioNativeInterface sInstance;
		private static final Object INSTANCE_LOCK = new Object();

		static {
		classInitNative();
		}

		private LeAudioNativeInterface() {
		mAdapter = BluetoothAdapter.getDefaultAdapter();
		if (mAdapter == null) {
		Log.wtfStack(TAG, "No Bluetooth Adapter Available");
		}
		}

		/**
		* Get singleton instance.
		*/
		public static LeAudioNativeInterface getInstance() {
		synchronized (INSTANCE_LOCK) {
		if (sInstance == null) {
		sInstance = new LeAudioNativeInterface();
		}
		return sInstance;
		}
		}

		private byte[] getByteAddress(BluetoothDevice device) {
		if (device == null) {
		return Utils.getBytesFromAddress("00:00:00:00:00:00");
		}
		return Utils.getBytesFromAddress(device.getAddress());
		}

		private void sendMessageToService(LeAudioStackEvent event) {
		LeAudioService service = LeAudioService.getLeAudioService();
		if (service != null) {
		service.messageFromNative(event);
		} else {
		Log.e(TAG, "Event ignored, service not available: " + event);
		}
		}

		private BluetoothDevice getDevice(byte[] address) {
		return mAdapter.getRemoteDevice(address);
		}

		// Callbacks from the native stack back into the Java framework.
		// All callbacks are routed via the Service which will disambiguate which
		// state machine the message should be routed to.
		private void onConnectionStateChanged(int state, byte[] address) {
		LeAudioStackEvent event =
		new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_CONNECTION_STATE_CHANGED);
		event.device = getDevice(address);
		event.valueInt1 = state;

		if (DBG) {
		Log.d(TAG, "onConnectionStateChanged: " + event);
		}
		sendMessageToService(event);
		}

		// Callbacks from the native stack back into the Java framework.
		// All callbacks are routed via the Service which will disambiguate which
		// state machine the message should be routed to.
		private void onSetMemberAvailable(byte[] address, int groupId) {
		LeAudioStackEvent event =
		new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_SET_MEMBER_AVAILABLE);
		event.device = getDevice(address);
		event.valueInt1 = groupId;
		if (DBG) {
		Log.d(TAG, "onSetMemberAvailable: " + event);
		}
		sendMessageToService(event);
		}

		private void onGroupStatus(int groupId, int groupStatus, int groupFlags) {
		LeAudioStackEvent event =
		new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_GROUP_STATUS_CHANGED);
		event.valueInt1 = groupId;
		event.valueInt2 = groupStatus;
		event.valueInt3 = groupFlags;
		event.device = null;

		if (DBG) {
		Log.d(TAG, "onGroupStatus: " + event);
		}
		sendMessageToService(event);
		}

		private void onAudioConf(int direction, int groupId, int sinkAudioLocation,
		int sourceAudioLocation, byte[] address) {
		LeAudioStackEvent event =
		new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_AUDIO_CONF_CHANGED);
		event.valueInt1 = direction;
		event.valueInt2 = groupId;
		event.valueInt3 = sinkAudioLocation;
		event.valueInt4 = sourceAudioLocation;
		event.device = getDevice(address);

		if (DBG) {
		Log.d(TAG, "onAudioConf: " + event);
		}
		sendMessageToService(event);
		}

		/**
		* Initializes the native interface.
		*
		* priorities to configure.
		*/
		public void init() {
		initNative();
		}

		/**
		* Cleanup the native interface.
		*/
		public void cleanup() {
		cleanupNative();
		}

		/**
		* Initiates LeAudio connection to a remote device.
		*
		* @param device the remote device
		* @return true on success, otherwise false.
		*/
		public boolean connectLeAudio(BluetoothDevice device) {
		return connectLeAudioNative(getByteAddress(device));
		}

		/**
		* Disconnects LeAudio from a remote device.
		*
		* @param device the remote device
		* @return true on success, otherwise false.
		*/
		public boolean disconnectLeAudio(BluetoothDevice device) {
		return disconnectLeAudioNative(getByteAddress(device));
		}

		/**
		* Enable content streaming.
		* @param groupId group identifier
		* @param contentType type of content to stream
		*/
		public void groupStream(int groupId, int contentType) {
		groupStreamNative(groupId, contentType);
		}

		/**
		* Suspend content streaming.
		* @param groupId group identifier
		*/
		public void groupSuspend(int groupId) {
		groupSuspendNative(groupId);
		}

		/**
		* Stop all content streaming.
		* @param groupId group identifier
		* TODO: Maybe we should use also pass the content type argument
		*/
		public void groupStop(int groupId) {
		groupStopNative(groupId);
		}

		// Native methods that call into the JNI interface
		private static native void classInitNative();
		private native void initNative();
		private native void cleanupNative();
		private native boolean connectLeAudioNative(byte[] address);
		private native boolean disconnectLeAudioNative(byte[] address);
		private native void groupStreamNative(int groupId, int contentType);
		private native void groupSuspendNative(int groupId);
		private native void groupStopNative(int groupId);
		}