Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 8cad540b authored by Henri Chataing's avatar Henri Chataing Committed by Automerger Merge Worker
Browse files

Merge "btif_av: Make public the methods from btav_source_interface_t" into main am: 7b034a62 

Original change: https://android-review.googlesource.com/c/platform/packages/modules/Bluetooth/+/3134194



Change-Id: Iddd6458d8557a9920a4b72bd2fa304d3de77d716
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 52a2eed3 7b034a62

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;