Merge "btif_av: Make public the methods from btav_source_interface_t" into main (7b034a62) · Commits · e / os / android_packages_modules_Bluetooth

android/app/jni/com_android_bluetooth_a2dp.cpp

+21 −67

Original line number	Diff line number	Diff line
		@@ -14,12 +14,12 @@
		* limitations under the License.
		*/

		#define LOG_TAG "BluetoothA2dpServiceJni"

		#include <string.h>
		#define LOG_TAG "bluetooth-a2dp"

		#include <cstring>
		#include <shared_mutex>

		#include "btif/include/btif_av.h"
		#include "btif/include/btif_util.h"
		#include "com_android_bluetooth.h"
		#include "hardware/bt_av.h"
		@@ -44,7 +44,6 @@ static struct {
		jmethodID getCodecSpecific4;
		} android_bluetooth_BluetoothCodecConfig;

		static const btav_source_interface_t* sBluetoothA2dpInterface = nullptr;
		static std::vector<btav_a2dp_codec_info_t> supported_codecs;
		static std::shared_timed_mutex interface_mutex;

		@@ -261,11 +260,8 @@ static void initNative(JNIEnv* env, jobject object,
		return;
		}

		if (sBluetoothA2dpInterface != nullptr) {
		log::warn("Cleaning up A2DP Interface before initializing...");
		sBluetoothA2dpInterface->cleanup();
		sBluetoothA2dpInterface = nullptr;
		}
		btif_av_source_cleanup();

		if (mCallbacksObj != nullptr) {
		log::warn("Cleaning up A2DP callback object");
		@@ -285,27 +281,18 @@ static void initNative(JNIEnv* env, jobject object,
		return;
		}

		sBluetoothA2dpInterface =
		(btav_source_interface_t*)btInf->get_profile_interface(
		BT_PROFILE_ADVANCED_AUDIO_ID);
		if (sBluetoothA2dpInterface == nullptr) {
		log::error("Failed to get Bluetooth A2DP Interface");
		return;
		}

		std::vector<btav_a2dp_codec_config_t> codec_priorities =
		prepareCodecPreferences(env, object, codecConfigArray);

		std::vector<btav_a2dp_codec_config_t> codec_offloading =
		prepareCodecPreferences(env, object, codecOffloadingArray);

		bt_status_t status = sBluetoothA2dpInterface->init(
		bt_status_t status = btif_av_source_init(
		&sBluetoothA2dpCallbacks, maxConnectedAudioDevices, codec_priorities,
		codec_offloading, &supported_codecs);
		if (status != BT_STATUS_SUCCESS) {
		log::error("Failed to initialize Bluetooth A2DP, status: {}",
		bt_status_text(status));
		sBluetoothA2dpInterface = nullptr;
		return;
		}
		}
		@@ -320,10 +307,7 @@ static void cleanupNative(JNIEnv* env, jobject /* object */) {
		return;
		}

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

		env->DeleteGlobalRef(android_bluetooth_BluetoothCodecConfig.clazz);
		android_bluetooth_BluetoothCodecConfig.clazz = nullptr;
		@@ -335,8 +319,6 @@ static void cleanupNative(JNIEnv* env, jobject /* object */) {
		}

		static jobjectArray getSupportedCodecTypesNative(JNIEnv* env) {
		log::info("{}", fmt::ptr(sBluetoothA2dpInterface));

		jclass android_bluetooth_BluetoothCodecType_clazz = (jclass)env->NewGlobalRef(
		env->FindClass("android/bluetooth/BluetoothCodecType"));
		if (android_bluetooth_BluetoothCodecType_clazz == nullptr) {
		@@ -376,11 +358,6 @@ static jobjectArray getSupportedCodecTypesNative(JNIEnv* env) {
		static jboolean connectA2dpNative(JNIEnv* env, jobject /* object */,
		jbyteArray address) {
		std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
		if (!sBluetoothA2dpInterface) {
		log::error("Failed to get the Bluetooth A2DP Interface");
		return JNI_FALSE;
		}

		jbyte* addr = env->GetByteArrayElements(address, nullptr);
		if (!addr) {
		jniThrowIOException(env, EINVAL);
		@@ -389,9 +366,9 @@ static jboolean connectA2dpNative(JNIEnv* env, jobject /* object */,

		RawAddress bd_addr;
		bd_addr.FromOctets(reinterpret_cast<const uint8_t*>(addr));
		log::info("sBluetoothA2dpInterface: {}, {}",
		fmt::ptr(sBluetoothA2dpInterface), bd_addr);
		bt_status_t status = sBluetoothA2dpInterface->connect(bd_addr);

		log::info("{}", bd_addr);
		bt_status_t status = btif_av_source_connect(bd_addr);
		if (status != BT_STATUS_SUCCESS) {
		log::error("Failed A2DP connection, status: {}", bt_status_text(status));
		}
		@@ -402,11 +379,6 @@ static jboolean connectA2dpNative(JNIEnv* env, jobject /* object */,
		static jboolean disconnectA2dpNative(JNIEnv* env, jobject /* object */,
		jbyteArray address) {
		std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
		if (!sBluetoothA2dpInterface) {
		log::error("Failed to get the Bluetooth A2DP Interface");
		return JNI_FALSE;
		}

		jbyte* addr = env->GetByteArrayElements(address, nullptr);
		if (!addr) {
		jniThrowIOException(env, EINVAL);
		@@ -415,9 +387,9 @@ static jboolean disconnectA2dpNative(JNIEnv* env, jobject /* object */,

		RawAddress bd_addr;
		bd_addr.FromOctets(reinterpret_cast<const uint8_t*>(addr));
		log::info("sBluetoothA2dpInterface: {}, {}",
		fmt::ptr(sBluetoothA2dpInterface), bd_addr);
		bt_status_t status = sBluetoothA2dpInterface->disconnect(bd_addr);

		log::info("{}", bd_addr);
		bt_status_t status = btif_av_source_disconnect(bd_addr);
		if (status != BT_STATUS_SUCCESS) {
		log::error("Failed A2DP disconnection, status: {}", bt_status_text(status));
		}
		@@ -428,13 +400,8 @@ static jboolean disconnectA2dpNative(JNIEnv* env, jobject /* object */,
		static jboolean setSilenceDeviceNative(JNIEnv* env, jobject /* object */,
		jbyteArray address, jboolean silence) {
		std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
		if (!sBluetoothA2dpInterface) {
		log::error("Failed to get the Bluetooth A2DP Interface");
		return JNI_FALSE;
		}

		jbyte* addr = env->GetByteArrayElements(address, nullptr);

		RawAddress bd_addr = RawAddress::kEmpty;
		if (addr) {
		bd_addr.FromOctets(reinterpret_cast<const uint8_t*>(addr));
		@@ -442,11 +409,9 @@ static jboolean setSilenceDeviceNative(JNIEnv* env, jobject /* object */,
		if (bd_addr == RawAddress::kEmpty) {
		return JNI_FALSE;
		}
		log::info("sBluetoothA2dpInterface: {}, {}: silence: {}",
		fmt::ptr(sBluetoothA2dpInterface), bd_addr,
		static_cast<bool>(silence));
		bt_status_t status =
		sBluetoothA2dpInterface->set_silence_device(bd_addr, silence);

		log::info("{}: silence={}", bd_addr, silence);
		bt_status_t status = btif_av_source_set_silence_device(bd_addr, silence);
		if (status != BT_STATUS_SUCCESS) {
		log::error("Failed A2DP set_silence_device, status: {}",
		bt_status_text(status));
		@@ -458,20 +423,15 @@ static jboolean setSilenceDeviceNative(JNIEnv* env, jobject /* object */,
		static jboolean setActiveDeviceNative(JNIEnv* env, jobject /* object */,
		jbyteArray address) {
		std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
		if (!sBluetoothA2dpInterface) {
		log::error("Failed to get the Bluetooth A2DP Interface");
		return JNI_FALSE;
		}

		jbyte* addr = env->GetByteArrayElements(address, nullptr);

		RawAddress bd_addr = RawAddress::kEmpty;
		if (addr) {
		bd_addr.FromOctets(reinterpret_cast<const uint8_t*>(addr));
		}
		log::info("sBluetoothA2dpInterface: {}, {}",
		fmt::ptr(sBluetoothA2dpInterface), bd_addr);
		bt_status_t status = sBluetoothA2dpInterface->set_active_device(bd_addr);

		log::info("{}", bd_addr);
		bt_status_t status = btif_av_source_set_active_device(bd_addr);
		if (status != BT_STATUS_SUCCESS) {
		log::error("Failed A2DP set_active_device, status: {}",
		bt_status_text(status));
		@@ -484,11 +444,6 @@ static jboolean setCodecConfigPreferenceNative(JNIEnv* env, jobject object,
		jbyteArray address,
		jobjectArray codecConfigArray) {
		std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
		if (!sBluetoothA2dpInterface) {
		log::error("Failed to get the Bluetooth A2DP Interface");
		return JNI_FALSE;
		}

		jbyte* addr = env->GetByteArrayElements(address, nullptr);
		if (!addr) {
		jniThrowIOException(env, EINVAL);
		@@ -499,11 +454,10 @@ static jboolean setCodecConfigPreferenceNative(JNIEnv* env, jobject object,
		bd_addr.FromOctets(reinterpret_cast<const uint8_t*>(addr));
		std::vector<btav_a2dp_codec_config_t> codec_preferences =
		prepareCodecPreferences(env, object, codecConfigArray);
		log::info("sBluetoothA2dpInterface: {}, {}: {}",
		fmt::ptr(sBluetoothA2dpInterface), bd_addr,
		log::info("{}: {}", bd_addr,
		btav_a2dp_codec_config_t::PrintCodecs(codec_preferences));
		bt_status_t status =
		sBluetoothA2dpInterface->config_codec(bd_addr, codec_preferences);
		btif_av_source_set_codec_config_preference(bd_addr, codec_preferences);
		if (status != BT_STATUS_SUCCESS) {
		log::error("Failed codec configuration, status: {}",
		bt_status_text(status));

system/btif/include/btif_av.h

+28 −21

Original line number	Diff line number	Diff line
		@@ -29,13 +29,28 @@
		#include "include/hardware/bt_av.h"
		#include "types/raw_address.h"

		// #include "bta/include/bta_av_api.h"
		// #include "btif/include/btif_common.h"
		/* Interface methods for the A2DP source stack. */

		bt_status_t btif_av_source_init(
		btav_source_callbacks_t* callbacks, int max_connected_audio_devices,
		const std::vector<btav_a2dp_codec_config_t>& codec_priorities,
		const std::vector<btav_a2dp_codec_config_t>& offloading_preference,
		std::vector<btav_a2dp_codec_info_t>* supported_codecs);
		bt_status_t btif_av_source_connect(const RawAddress& peer_address);
		bt_status_t btif_av_source_disconnect(const RawAddress& peer_address);
		bt_status_t btif_av_source_set_silence_device(const RawAddress& peer_address,
		bool silence);
		bt_status_t btif_av_source_set_active_device(const RawAddress& peer_address);
		bt_status_t btif_av_source_set_codec_config_preference(
		const RawAddress& peer_address,
		std::vector<btav_a2dp_codec_config_t> codec_preferences);
		void btif_av_source_cleanup();

		/**
		* Enum to represent the type of local a2dp profile.
		*/
		enum class A2dpType { kSource, kSink, kUnknown };

		/**
		* When the local device is A2DP source, get the address of the active peer.
		*/
		@@ -223,15 +238,6 @@ uint16_t btif_av_get_audio_delay(const A2dpType local_a2dp_type);
		*/
		void btif_av_reset_audio_delay(void);

		/**
		* Called to disconnect peer device when
		* remote initiatied offload start failed
		*
		* @param peer_address to disconnect
		*
		*/
		void btif_av_src_disconnect_sink(const RawAddress& peer_address);

		/**
		* check A2DP offload support enabled
		* @param none
		@@ -287,14 +293,15 @@ void btif_av_connect_sink_delayed(uint8_t handle,
		/**
		* Check whether A2DP Source is enabled.
		*/
		extern bool btif_av_is_source_enabled(void);
		extern bool btif_av_both_enable(void);
		extern bool btif_av_src_sink_coexist_enabled(void);
		extern bool btif_av_is_sink_enabled(void);
		extern bool btif_av_is_connected_addr(const RawAddress& peer_address,
		bool btif_av_is_source_enabled(void);
		bool btif_av_both_enable(void);
		bool btif_av_src_sink_coexist_enabled(void);
		bool btif_av_is_sink_enabled(void);
		bool btif_av_is_connected_addr(const RawAddress& peer_address,
		const A2dpType local_a2dp_type);
		extern bool btif_av_peer_is_connected_sink(const RawAddress& peer_address);
		extern bool btif_av_peer_is_connected_source(const RawAddress& peer_address);
		extern bool btif_av_peer_is_sink(const RawAddress& peer_address);
		extern bool btif_av_peer_is_source(const RawAddress& peer_address);
		bool btif_av_peer_is_connected_sink(const RawAddress& peer_address);
		bool btif_av_peer_is_connected_source(const RawAddress& peer_address);
		bool btif_av_peer_is_sink(const RawAddress& peer_address);
		bool btif_av_peer_is_source(const RawAddress& peer_address);

		#endif /* BTIF_AV_H */

system/btif/src/bluetooth.cc

+0 −4

Original line number	Diff line number	Diff line
		@@ -142,7 +142,6 @@ bool is_local_device_atv = false;
		/* handsfree profile - client */
		extern const bthf_client_interface_t* btif_hf_client_get_interface();
		/* advanced audio profile */
		extern const btav_source_interface_t* btif_av_get_src_interface();
		extern const btav_sink_interface_t* btif_av_get_sink_interface();
		/rfc l2cap/
		extern const btsock_interface_t* btif_sock_get_interface();
		@@ -886,9 +885,6 @@ static const void* get_profile_interface(const char* profile_id) {
		if (is_profile(profile_id, BT_PROFILE_PAN_ID))
		return btif_pan_get_interface();

		if (is_profile(profile_id, BT_PROFILE_ADVANCED_AUDIO_ID))
		return btif_av_get_src_interface();

		if (is_profile(profile_id, BT_PROFILE_ADVANCED_AUDIO_SINK_ID))
		return btif_av_get_sink_interface();

system/btif/src/btif_a2dp.cc

+1 −1

Original line number	Diff line number	Diff line
		@@ -202,7 +202,7 @@ void btif_a2dp_on_offload_started(const RawAddress& peer_addr,
		// suspend is triggered for remote start. Disconnect only if SoC
		// returned failure for offload VSC
		log::error("peer {} offload start failed", peer_addr);
		btif_av_src_disconnect_sink(peer_addr);
		btif_av_source_disconnect(peer_addr);
		}
		}
		if (bluetooth::audio::a2dp::is_hal_enabled()) {

system/btif/src/btif_av.cc

+13 −36

Original line number	Diff line number	Diff line
		@@ -816,7 +816,6 @@ static BtifAvSink btif_av_sink;
		btif_rc_handler(e, d); \
		} break;

		static bt_status_t src_disconnect_sink(const RawAddress& peer_address);
		static bt_status_t sink_disconnect_src(const RawAddress& peer_address);
		static void btif_av_source_dispatch_sm_event(const RawAddress& peer_address,
		btif_av_sm_event_t event);
		@@ -1847,7 +1846,7 @@ bool BtifAvStateMachine::StateIdle::ProcessEvent(uint32_t event, void* p_data) {
		// Check whether connection is allowed
		if (peer_.IsSink()) {
		can_connect = btif_av_source.AllowedToConnect(peer_.PeerAddress());
		if (!can_connect) src_disconnect_sink(peer_.PeerAddress());
		if (!can_connect) btif_av_source_disconnect(peer_.PeerAddress());
		} else if (peer_.IsSource()) {
		can_connect = btif_av_sink.AllowedToConnect(peer_.PeerAddress());
		if (!can_connect) sink_disconnect_src(peer_.PeerAddress());
		@@ -1901,7 +1900,7 @@ bool BtifAvStateMachine::StateIdle::ProcessEvent(uint32_t event, void* p_data) {
		if (btif_av_src_sink_coexist_enabled())
		BTA_AvCloseRc(((tBTA_AV*)p_data)->rc_open.rc_handle);
		else
		src_disconnect_sink(peer_.PeerAddress());
		btif_av_source_disconnect(peer_.PeerAddress());
		}
		} else if (peer_.IsSource()) {
		can_connect = btif_av_sink.AllowedToConnect(peer_.PeerAddress());
		@@ -2030,7 +2029,7 @@ bool BtifAvStateMachine::StateIdle::ProcessEvent(uint32_t event, void* p_data) {
		peer_.PeerAddress());

		if (peer_.IsSink()) {
		src_disconnect_sink(peer_.PeerAddress());
		btif_av_source_disconnect(peer_.PeerAddress());
		} else if (peer_.IsSource()) {
		sink_disconnect_src(peer_.PeerAddress());
		}
		@@ -2233,7 +2232,7 @@ bool BtifAvStateMachine::StateOpening::ProcessEvent(uint32_t event,
		bool can_connect = true;
		if (peer_.IsSink()) {
		can_connect = btif_av_source.AllowedToConnect(peer_.PeerAddress());
		if (!can_connect) src_disconnect_sink(peer_.PeerAddress());
		if (!can_connect) btif_av_source_disconnect(peer_.PeerAddress());
		} else if (peer_.IsSource()) {
		can_connect = btif_av_sink.AllowedToConnect(peer_.PeerAddress());
		if (!can_connect) sink_disconnect_src(peer_.PeerAddress());
		@@ -2566,7 +2565,7 @@ bool BtifAvStateMachine::StateOpened::ProcessEvent(uint32_t event,
		btif_a2dp_command_ack(A2DP_CTRL_ACK_FAILURE);
		}
		if (peer_.IsSink()) {
		src_disconnect_sink(peer_.PeerAddress());
		btif_av_source_disconnect(peer_.PeerAddress());
		} else if (peer_.IsSource()) {
		sink_disconnect_src(peer_.PeerAddress());
		}
		@@ -3577,7 +3576,7 @@ static void bta_av_sink_media_callback(const RawAddress& peer_address,
		}

		// Initializes the AV interface for source mode
		static bt_status_t init_src(
		bt_status_t btif_av_source_init(
		btav_source_callbacks_t* callbacks, int max_connected_audio_devices,
		const std::vector<btav_a2dp_codec_config_t>& codec_priorities,
		const std::vector<btav_a2dp_codec_config_t>& offloading_preference,
		@@ -3686,7 +3685,7 @@ static void set_active_peer_int(uint8_t peer_sep,
		peer_ready_promise.set_value();
		}

		static bt_status_t src_connect_sink(const RawAddress& peer_address) {
		bt_status_t btif_av_source_connect(const RawAddress& peer_address) {
		log::info("peer={}", peer_address);

		if (!btif_av_source.Enabled()) {
		@@ -3712,7 +3711,7 @@ static bt_status_t sink_connect_src(const RawAddress& peer_address) {
		connect_int);
		}

		static bt_status_t src_disconnect_sink(const RawAddress& peer_address) {
		bt_status_t btif_av_source_disconnect(const RawAddress& peer_address) {
		log::info("peer={}", peer_address);

		if (!btif_av_source.Enabled()) {
		@@ -3768,7 +3767,7 @@ static bt_status_t sink_set_active_device(const RawAddress& peer_address) {
		return status;
		}

		static bt_status_t src_set_silence_sink(const RawAddress& peer_address,
		bt_status_t btif_av_source_set_silence_device(const RawAddress& peer_address,
		bool silence) {
		log::info("peer={} silence={}", peer_address, silence);

		@@ -3782,7 +3781,7 @@ static bt_status_t src_set_silence_sink(const RawAddress& peer_address,
		base::BindOnce(&set_source_silence_peer_int, peer_address, silence));
		}

		static bt_status_t src_set_active_sink(const RawAddress& peer_address) {
		bt_status_t btif_av_source_set_active_device(const RawAddress& peer_address) {
		log::info("peer={}", peer_address);

		if (!btif_av_source.Enabled()) {
		@@ -3804,7 +3803,7 @@ static bt_status_t src_set_active_sink(const RawAddress& peer_address) {
		return status;
		}

		static bt_status_t codec_config_src(
		bt_status_t btif_av_source_set_codec_config_preference(
		const RawAddress& peer_address,
		std::vector<btav_a2dp_codec_config_t> codec_preferences) {
		log::info("peer={} codec_preferences=[{}]", peer_address,
		@@ -3835,7 +3834,7 @@ static bt_status_t codec_config_src(
		return status;
		}

		static void cleanup_src(void) {
		void btif_av_source_cleanup(void) {
		log::info("");
		do_in_main_thread(FROM_HERE,
		base::BindOnce(&BtifAvSource::Cleanup,
		@@ -3848,17 +3847,6 @@ static void cleanup_sink(void) {
		base::Unretained(&btif_av_sink)));
		}

		static const btav_source_interface_t bt_av_src_interface = {
		sizeof(btav_source_interface_t),
		init_src,
		src_connect_sink,
		src_disconnect_sink,
		src_set_silence_sink,
		src_set_active_sink,
		codec_config_src,
		cleanup_src,
		};

		static const btav_sink_interface_t bt_av_sink_interface = {
		sizeof(btav_sink_interface_t),
		init_sink,
		@@ -3929,12 +3917,6 @@ void btif_av_stream_start_offload(void) {
		BTIF_AV_OFFLOAD_START_REQ_EVT);
		}

		void btif_av_src_disconnect_sink(const RawAddress& peer_address) {
		log::info("peer={}", peer_address);

		src_disconnect_sink(peer_address);
		}

		bool btif_av_stream_ready(const A2dpType local_a2dp_type) {
		// Make sure the main adapter is enabled
		if (btif_is_enabled() == 0) {
		@@ -4075,11 +4057,6 @@ bt_status_t btif_av_sink_execute_service(bool enable) {
		return BT_STATUS_SUCCESS;
		}

		// Get the AV callback interface for A2DP source profile
		const btav_source_interface_t* btif_av_get_src_interface(void) {
		return &bt_av_src_interface;
		}

		// Get the AV callback interface for A2DP sink profile
		const btav_sink_interface_t* btif_av_get_sink_interface(void) {
		return &bt_av_sink_interface;