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

Commit 8cf1ba11 authored by Łukasz Rymanowski's avatar Łukasz Rymanowski Committed by Automerger Merge Worker
Browse files

leaudio: Minor refactor around connection state in native am: 5ca86ecf 

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



Change-Id: Ib8426910310356c9416bfb15293064886382a5e4
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 9f4a99f6 5ca86ecf

system/bta/le_audio/client.cc

+59 −20
Original line number Diff line number Diff line
@@ -66,6 +66,7 @@ using bluetooth::le_audio::GroupStatus; 
using bluetooth::le_audio::GroupStreamStatus;

using le_audio::CodecManager;

using le_audio::ContentControlIdKeeper;

using le_audio::DeviceConnectState;

using le_audio::LeAudioDevice;

using le_audio::LeAudioDeviceGroup;

using le_audio::LeAudioDeviceGroups;
@@ -471,7 +472,7 @@ class LeAudioClientImpl : public LeAudioClient { 
      if (group_id == bluetooth::groups::kGroupUnknown) return;



      LOG(INFO) << __func__ << "Set member adding ...";

      leAudioDevices_.Add(address, true);

      leAudioDevices_.Add(address, DeviceConnectState::CONNECTING_BY_USER);

      leAudioDevice = leAudioDevices_.FindByAddress(address);

    } else {

      if (leAudioDevice->group_id_ != bluetooth::groups::kGroupUnknown) {
@@ -988,7 +989,7 @@ class LeAudioClientImpl : public LeAudioClient { 


    if (leAudioDevice->conn_id_ != GATT_INVALID_CONN_ID) {

      Disconnect(address);

      leAudioDevice->removing_device_ = true;

      leAudioDevice->SetConnectionState(DeviceConnectState::REMOVING);

      return;

    }
@@ -1007,9 +1008,10 @@ class LeAudioClientImpl : public LeAudioClient { 
  void Connect(const RawAddress& address) override {

    LeAudioDevice* leAudioDevice = leAudioDevices_.FindByAddress(address);

    if (!leAudioDevice) {

      leAudioDevices_.Add(address, true);

      leAudioDevices_.Add(address, DeviceConnectState::CONNECTING_BY_USER);



    } else {

      leAudioDevice->connecting_actively_ = true;

      leAudioDevice->SetConnectionState(DeviceConnectState::CONNECTING_BY_USER);



      le_audio::MetricsCollector::Get()->OnConnectionStateChanged(

          leAudioDevice->group_id_, address, ConnectionState::CONNECTING,
@@ -1058,7 +1060,7 @@ class LeAudioClientImpl : public LeAudioClient { 
        source_audio_location, sink_supported_context_types,

        source_supported_context_types);



    leAudioDevices_.Add(address, false);

    leAudioDevices_.Add(address, DeviceConnectState::DISCONNECTED);

    leAudioDevice = leAudioDevices_.FindByAddress(address);



    int group_id = DeviceGroups::Get()->GetGroupId(
@@ -1105,6 +1107,9 @@ class LeAudioClientImpl : public LeAudioClient { 
    }



    if (autoconnect) {

      leAudioDevice->SetConnectionState(

          DeviceConnectState::CONNECTING_AUTOCONNECT);

      leAudioDevice->autoconnect_flag_ = true;

      BTA_GATTC_Open(gatt_if_, address, false, false);

    }

  }
@@ -1150,6 +1155,8 @@ class LeAudioClientImpl : public LeAudioClient { 
               << " to background connect to connected group: "

               << leAudioDevice->group_id_;



    leAudioDevice->SetConnectionState(

        DeviceConnectState::CONNECTING_AUTOCONNECT);

    BTA_GATTC_Open(gatt_if_, leAudioDevice->address_, false, false);

  }
@@ -1163,9 +1170,9 @@ class LeAudioClientImpl : public LeAudioClient { 
    }



    /* cancel pending direct connect */

    if (leAudioDevice->connecting_actively_) {

    if (leAudioDevice->GetConnectionState() ==

        DeviceConnectState::CONNECTING_BY_USER) {

      BTA_GATTC_CancelOpen(gatt_if_, address, true);

      leAudioDevice->connecting_actively_ = false;

    }



    /* Removes all registrations for connection */
@@ -1175,6 +1182,7 @@ class LeAudioClientImpl : public LeAudioClient { 
      /* User is disconnecting the device, we shall remove the autoconnect flag

       */

      btif_storage_set_leaudio_autoconnect(address, false);

      leAudioDevice->autoconnect_flag_ = false;



      auto group = aseGroups_.FindById(leAudioDevice->group_id_);

      if (group &&
@@ -1200,6 +1208,8 @@ class LeAudioClientImpl : public LeAudioClient { 
      return;

    }



    leAudioDevice->SetConnectionState(DeviceConnectState::DISCONNECTING);



    if (acl_force_disconnect) {

     leAudioDevice->DisconnectAcl();

     return;
@@ -1509,7 +1519,13 @@ class LeAudioClientImpl : public LeAudioClient { 


    if (status != GATT_SUCCESS) {

      /* autoconnect connection failed, that's ok */

      if (!leAudioDevice->connecting_actively_) return;

      if (leAudioDevice->GetConnectionState() ==

          DeviceConnectState::CONNECTING_AUTOCONNECT) {

        leAudioDevice->SetConnectionState(DeviceConnectState::DISCONNECTED);

        return;

      }



      leAudioDevice->SetConnectionState(DeviceConnectState::DISCONNECTED);



      LOG(ERROR) << "Failed to connect to LeAudio leAudioDevice, status: "

                 << +status;
@@ -1527,7 +1543,15 @@ class LeAudioClientImpl : public LeAudioClient { 


    BTM_RequestPeerSCA(leAudioDevice->address_, transport);



    leAudioDevice->connecting_actively_ = false;

    if (leAudioDevice->GetConnectionState() ==

        DeviceConnectState::CONNECTING_AUTOCONNECT) {

      leAudioDevice->SetConnectionState(

          DeviceConnectState::CONNECTED_AUTOCONNECT_GETTING_READY);

    } else {

      leAudioDevice->SetConnectionState(

          DeviceConnectState::CONNECTED_BY_USER_GETTING_READY);

    }



    leAudioDevice->conn_id_ = conn_id;

    leAudioDevice->mtu_ = mtu;
@@ -1633,13 +1657,17 @@ class LeAudioClientImpl : public LeAudioClient { 
    if (status != BTM_SUCCESS) {

      LOG(ERROR) << "Encryption failed"

                 << " status: " << int{status};

      BTA_GATTC_Close(leAudioDevice->conn_id_);

      if (leAudioDevice->connecting_actively_) {

      if (leAudioDevice->GetConnectionState() ==

          DeviceConnectState::CONNECTED_BY_USER_GETTING_READY) {

        callbacks_->OnConnectionState(ConnectionState::DISCONNECTED, address);

        le_audio::MetricsCollector::Get()->OnConnectionStateChanged(

            leAudioDevice->group_id_, address, ConnectionState::CONNECTED,

            le_audio::ConnectionStatus::FAILED);

      }



      leAudioDevice->SetConnectionState(DeviceConnectState::DISCONNECTING);



      BTA_GATTC_Close(leAudioDevice->conn_id_);

      return;

    }
@@ -1694,7 +1722,7 @@ class LeAudioClientImpl : public LeAudioClient { 
        leAudioDevice->group_id_, address, ConnectionState::DISCONNECTED,

        le_audio::ConnectionStatus::SUCCESS);



    if (leAudioDevice->removing_device_) {

    if (leAudioDevice->GetConnectionState() == DeviceConnectState::REMOVING) {

      if (leAudioDevice->group_id_ != bluetooth::groups::kGroupUnknown) {

        auto group = aseGroups_.FindById(leAudioDevice->group_id_);

        group_remove_node(group, address, true);
@@ -1704,7 +1732,11 @@ class LeAudioClientImpl : public LeAudioClient { 
    }

    /* Attempt background re-connect if disconnect was not intended locally */

    if (reason != GATT_CONN_TERMINATE_LOCAL_HOST) {

      leAudioDevice->SetConnectionState(

          DeviceConnectState::CONNECTING_AUTOCONNECT);

      BTA_GATTC_Open(gatt_if_, address, false, false);

    } else {

      leAudioDevice->SetConnectionState(DeviceConnectState::DISCONNECTED);

    }

  }
@@ -2258,22 +2290,29 @@ class LeAudioClientImpl : public LeAudioClient { 
  }



  void connectionReady(LeAudioDevice* leAudioDevice) {

    LOG_DEBUG("%s,  %s", leAudioDevice->address_.ToString().c_str(),

              bluetooth::common::ToString(leAudioDevice->GetConnectionState())

                  .c_str());

    callbacks_->OnConnectionState(ConnectionState::CONNECTED,

                                  leAudioDevice->address_);



    if (leAudioDevice->group_id_ != bluetooth::groups::kGroupUnknown) {

      LeAudioDeviceGroup* group = aseGroups_.FindById(leAudioDevice->group_id_);

      UpdateContextAndLocations(group, leAudioDevice);

      AttachToStreamingGroupIfNeeded(leAudioDevice);

    }



    if (leAudioDevice->first_connection_) {

    if (leAudioDevice->GetConnectionState() ==

            DeviceConnectState::CONNECTED_BY_USER_GETTING_READY &&

        (leAudioDevice->autoconnect_flag_ == false)) {

      btif_storage_set_leaudio_autoconnect(leAudioDevice->address_, true);

      leAudioDevice->first_connection_ = false;

      leAudioDevice->autoconnect_flag_ = true;

    }



    leAudioDevice->SetConnectionState(DeviceConnectState::CONNECTED);

    le_audio::MetricsCollector::Get()->OnConnectionStateChanged(

        leAudioDevice->group_id_, leAudioDevice->address_,

        ConnectionState::CONNECTED, le_audio::ConnectionStatus::SUCCESS);



    if (leAudioDevice->group_id_ != bluetooth::groups::kGroupUnknown) {

      LeAudioDeviceGroup* group = aseGroups_.FindById(leAudioDevice->group_id_);

      UpdateContextAndLocations(group, leAudioDevice);

      AttachToStreamingGroupIfNeeded(leAudioDevice);

    }

  }



  bool IsAseAcceptingAudioData(struct ase* ase) {

system/bta/le_audio/devices.cc

+56 −11
Original line number Diff line number Diff line
@@ -54,6 +54,42 @@ using le_audio::types::LeAudioContextType; 
using le_audio::types::LeAudioLc3Config;



namespace le_audio {

std::ostream& operator<<(std::ostream& os, const DeviceConnectState& state) {

  const char* char_value_ = "UNKNOWN";



  switch (state) {

    case DeviceConnectState::CONNECTED:

      char_value_ = "CONNECTED";

      break;

    case DeviceConnectState::DISCONNECTED:

      char_value_ = "DISCONNECTED";

      break;

    case DeviceConnectState::REMOVING:

      char_value_ = "REMOVING";

      break;

    case DeviceConnectState::DISCONNECTING:

      char_value_ = "DISCONNECTING";

      break;

    case DeviceConnectState::CONNECTING_BY_USER:

      char_value_ = "CONNECTING_BY_USER";

      break;

    case DeviceConnectState::CONNECTED_BY_USER_GETTING_READY:

      char_value_ = "CONNECTED_BY_USER_GETTING_READY";

      break;

    case DeviceConnectState::CONNECTING_AUTOCONNECT:

      char_value_ = "CONNECTING_AUTOCONNECT";

      break;

    case DeviceConnectState::CONNECTED_AUTOCONNECT_GETTING_READY:

      char_value_ = "CONNECTED_AUTOCONNECT_GETTING_READY";

      break;

  }



  os << char_value_ << " ("

     << "0x" << std::setfill('0') << std::setw(2) << static_cast<int>(state)

     << ")";

  return os;

}



/* LeAudioDeviceGroup Class methods implementation */

void LeAudioDeviceGroup::AddNode(

    const std::shared_ptr<LeAudioDevice>& leAudioDevice) {
@@ -973,7 +1009,11 @@ bool LeAudioDeviceGroup::CigAssignCisIds(LeAudioDevice* leAudioDevice) { 
  LOG_INFO("device: %s", leAudioDevice->address_.ToString().c_str());



  struct ase* ase = leAudioDevice->GetFirstActiveAse();

  ASSERT_LOG(ase, " Shouldn't be called without an active ASE");

  if (!ase) {

    LOG_ERROR(" Device %s shouldn't be called without an active ASE",

              leAudioDevice->address_.ToString().c_str());

    return false;

  }



  for (; ase != nullptr; ase = leAudioDevice->GetNextActiveAse(ase)) {

    uint8_t cis_id = kInvalidCisId;
@@ -1929,6 +1969,17 @@ void LeAudioDeviceGroup::Dump(int fd) { 
}



/* LeAudioDevice Class methods implementation */

void LeAudioDevice::SetConnectionState(DeviceConnectState state) {

  LOG_DEBUG(" %s --> %s",

            bluetooth::common::ToString(connection_state_).c_str(),

            bluetooth::common::ToString(state).c_str());

  connection_state_ = state;

}



DeviceConnectState LeAudioDevice::GetConnectionState(void) {

  return connection_state_;

}



void LeAudioDevice::ClearPACs(void) {

  snk_pacs_.clear();

  src_pacs_.clear();
@@ -2343,18 +2394,12 @@ void LeAudioDevice::SetSupportedContexts(AudioContexts snk_contexts, 
void LeAudioDevice::Dump(int fd) {

  std::stringstream stream;

  stream << std::boolalpha;

  stream << "\n\taddress: " << address_

         << (conn_id_ == GATT_INVALID_CONN_ID ? "\n\t  Not connected "

                                              : "\n\t  Connected conn_id =")

  stream << "\n\taddress: " << address_ << ": " << connection_state_ << ": "

         << (conn_id_ == GATT_INVALID_CONN_ID ? "" : std::to_string(conn_id_))

         << "\n\t  set member: " << csis_member_

         << "\n\t  known_service_handles_: " << known_service_handles_

         << "\n\t  notify_connected_after_read_: "

         << notify_connected_after_read_

         << "\n\t  removing_device_: " << removing_device_

         << "\n\t  first_connection_: " << first_connection_

         << "\n\t  encrypted_: " << encrypted_

         << "\n\t  connecting_actively_: " << connecting_actively_

         << notify_connected_after_read_ << "\n\t  encrypted_: " << encrypted_

         << "\n\t  number of ases_: " << static_cast<int>(ases_.size());



  if (ases_.size() > 0) {
@@ -2534,7 +2579,7 @@ std::vector<int> LeAudioDeviceGroups::GetGroupsIds(void) { 
}



/* LeAudioDevices Class methods implementation */

void LeAudioDevices::Add(const RawAddress& address, bool first_connection,

void LeAudioDevices::Add(const RawAddress& address, DeviceConnectState state,

                         int group_id) {

  auto device = FindByAddress(address);

  if (device != nullptr) {
@@ -2544,7 +2589,7 @@ void LeAudioDevices::Add(const RawAddress& address, bool first_connection, 
  }



  leAudioDevices_.emplace_back(

      std::make_shared<LeAudioDevice>(address, first_connection, group_id));

      std::make_shared<LeAudioDevice>(address, state, group_id));

}



void LeAudioDevices::Remove(const RawAddress& address) {

system/bta/le_audio/devices.h

+33 −11
Original line number Diff line number Diff line
@@ -34,6 +34,31 @@ 
#include "raw_address.h"



namespace le_audio {



/* Enums */

enum class DeviceConnectState : uint8_t {

  /* Initial state */

  DISCONNECTED,

  /* When ACL connected, encrypted, CCC registered and initial characteristics

     read is completed */

  CONNECTED,

  /* Used when device is unbonding (RemoveDevice() API is called) */

  REMOVING,

  /* Disconnecting */

  DISCONNECTING,

  /* 2 states below are used when user creates connection. Connect API is

     called. */

  CONNECTING_BY_USER,

  /* Always used after CONNECTING_BY_USER */

  CONNECTED_BY_USER_GETTING_READY,

  /* 2 states are used when autoconnect was used for the connection.*/

  CONNECTING_AUTOCONNECT,

  /* Always used after CONNECTING_AUTOCONNECT */

  CONNECTED_AUTOCONNECT_GETTING_READY,

};



std::ostream& operator<<(std::ostream& os, const DeviceConnectState& state);



/* Class definitions */



/* LeAudioDevice class represents GATT server device with ASCS, PAC services as
@@ -50,15 +75,11 @@ class LeAudioDevice { 
 public:

  RawAddress address_;



  DeviceConnectState connection_state_;

  bool known_service_handles_;

  bool notify_connected_after_read_;

  bool removing_device_;



  /* we are making active attempt to connect to this device, 'direct connect'.

   * This is true only during initial phase of first connection. */

  bool first_connection_;

  bool connecting_actively_;

  bool closing_stream_for_disconnection_;

  bool autoconnect_flag_;

  uint16_t conn_id_;

  uint16_t mtu_;

  bool encrypted_;
@@ -84,15 +105,14 @@ class LeAudioDevice { 
  alarm_t* link_quality_timer;

  uint16_t link_quality_timer_data;



  LeAudioDevice(const RawAddress& address_, bool first_connection,

  LeAudioDevice(const RawAddress& address_, DeviceConnectState state,

                int group_id = bluetooth::groups::kGroupUnknown)

      : address_(address_),

        connection_state_(state),

        known_service_handles_(false),

        notify_connected_after_read_(false),

        removing_device_(false),

        first_connection_(first_connection),

        connecting_actively_(first_connection),

        closing_stream_for_disconnection_(false),

        autoconnect_flag_(false),

        conn_id_(GATT_INVALID_CONN_ID),

        mtu_(0),

        encrypted_(false),
@@ -102,6 +122,8 @@ class LeAudioDevice { 
        link_quality_timer(nullptr) {}

  ~LeAudioDevice(void);



  void SetConnectionState(DeviceConnectState state);

  DeviceConnectState GetConnectionState(void);

  void ClearPACs(void);

  void RegisterPACs(std::vector<struct types::acs_ac_record>* apr_db,

                    std::vector<struct types::acs_ac_record>* apr);
@@ -171,7 +193,7 @@ class LeAudioDevice { 
 */

class LeAudioDevices {

 public:

  void Add(const RawAddress& address, bool first_connection,

  void Add(const RawAddress& address, le_audio::DeviceConnectState state,

           int group_id = bluetooth::groups::kGroupUnknown);

  void Remove(const RawAddress& address);

  LeAudioDevice* FindByAddress(const RawAddress& address);

system/bta/le_audio/devices_test.cc

+27 −25
Original line number Diff line number Diff line
@@ -35,6 +35,7 @@ namespace le_audio { 
namespace internal {

namespace {



using ::le_audio::DeviceConnectState;

using ::le_audio::LeAudioDevice;

using ::le_audio::LeAudioDeviceGroup;

using ::le_audio::LeAudioDevices;
@@ -72,23 +73,23 @@ class LeAudioDevicesTest : public Test { 
TEST_F(LeAudioDevicesTest, test_add) {

  RawAddress test_address_0 = GetTestAddress(0);

  ASSERT_EQ((size_t)0, devices_->Size());

  devices_->Add(test_address_0, true);

  devices_->Add(test_address_0, DeviceConnectState::CONNECTING_BY_USER);

  ASSERT_EQ((size_t)1, devices_->Size());

  devices_->Add(GetTestAddress(1), true, 1);

  devices_->Add(GetTestAddress(1), DeviceConnectState::CONNECTING_BY_USER, 1);

  ASSERT_EQ((size_t)2, devices_->Size());

  devices_->Add(test_address_0, true);

  devices_->Add(test_address_0, DeviceConnectState::CONNECTING_BY_USER);

  ASSERT_EQ((size_t)2, devices_->Size());

  devices_->Add(GetTestAddress(1), true, 2);

  devices_->Add(GetTestAddress(1), DeviceConnectState::CONNECTING_BY_USER, 2);

  ASSERT_EQ((size_t)2, devices_->Size());

}



TEST_F(LeAudioDevicesTest, test_remove) {

  RawAddress test_address_0 = GetTestAddress(0);

  devices_->Add(test_address_0, true);

  devices_->Add(test_address_0, DeviceConnectState::CONNECTING_BY_USER);

  RawAddress test_address_1 = GetTestAddress(1);

  devices_->Add(test_address_1, true);

  devices_->Add(test_address_1, DeviceConnectState::CONNECTING_BY_USER);

  RawAddress test_address_2 = GetTestAddress(2);

  devices_->Add(test_address_2, true);

  devices_->Add(test_address_2, DeviceConnectState::CONNECTING_BY_USER);

  ASSERT_EQ((size_t)3, devices_->Size());

  devices_->Remove(test_address_0);

  ASSERT_EQ((size_t)2, devices_->Size());
@@ -100,11 +101,11 @@ TEST_F(LeAudioDevicesTest, test_remove) { 


TEST_F(LeAudioDevicesTest, test_find_by_address_success) {

  RawAddress test_address_0 = GetTestAddress(0);

  devices_->Add(test_address_0, true);

  devices_->Add(test_address_0, DeviceConnectState::CONNECTING_BY_USER);

  RawAddress test_address_1 = GetTestAddress(1);

  devices_->Add(test_address_1, false);

  devices_->Add(test_address_1, DeviceConnectState::DISCONNECTED);

  RawAddress test_address_2 = GetTestAddress(2);

  devices_->Add(test_address_2, true);

  devices_->Add(test_address_2, DeviceConnectState::CONNECTING_BY_USER);

  LeAudioDevice* device = devices_->FindByAddress(test_address_1);

  ASSERT_NE(nullptr, device);

  ASSERT_EQ(test_address_1, device->address_);
@@ -112,20 +113,20 @@ TEST_F(LeAudioDevicesTest, test_find_by_address_success) { 


TEST_F(LeAudioDevicesTest, test_find_by_address_failed) {

  RawAddress test_address_0 = GetTestAddress(0);

  devices_->Add(test_address_0, true);

  devices_->Add(test_address_0, DeviceConnectState::CONNECTING_BY_USER);

  RawAddress test_address_2 = GetTestAddress(2);

  devices_->Add(test_address_2, true);

  devices_->Add(test_address_2, DeviceConnectState::CONNECTING_BY_USER);

  LeAudioDevice* device = devices_->FindByAddress(GetTestAddress(1));

  ASSERT_EQ(nullptr, device);

}



TEST_F(LeAudioDevicesTest, test_get_by_address_success) {

  RawAddress test_address_0 = GetTestAddress(0);

  devices_->Add(test_address_0, true);

  devices_->Add(test_address_0, DeviceConnectState::CONNECTING_BY_USER);

  RawAddress test_address_1 = GetTestAddress(1);

  devices_->Add(test_address_1, false);

  devices_->Add(test_address_1, DeviceConnectState::DISCONNECTED);

  RawAddress test_address_2 = GetTestAddress(2);

  devices_->Add(test_address_2, true);

  devices_->Add(test_address_2, DeviceConnectState::CONNECTING_BY_USER);

  std::shared_ptr<LeAudioDevice> device =

      devices_->GetByAddress(test_address_1);

  ASSERT_NE(nullptr, device);
@@ -134,28 +135,28 @@ TEST_F(LeAudioDevicesTest, test_get_by_address_success) { 


TEST_F(LeAudioDevicesTest, test_get_by_address_failed) {

  RawAddress test_address_0 = GetTestAddress(0);

  devices_->Add(test_address_0, true);

  devices_->Add(test_address_0, DeviceConnectState::CONNECTING_BY_USER);

  RawAddress test_address_2 = GetTestAddress(2);

  devices_->Add(test_address_2, true);

  devices_->Add(test_address_2, DeviceConnectState::CONNECTING_BY_USER);

  std::shared_ptr<LeAudioDevice> device =

      devices_->GetByAddress(GetTestAddress(1));

  ASSERT_EQ(nullptr, device);

}



TEST_F(LeAudioDevicesTest, test_find_by_conn_id_success) {

  devices_->Add(GetTestAddress(1), true);

  devices_->Add(GetTestAddress(1), DeviceConnectState::CONNECTING_BY_USER);

  RawAddress test_address_0 = GetTestAddress(0);

  devices_->Add(test_address_0, true);

  devices_->Add(GetTestAddress(4), true);

  devices_->Add(test_address_0, DeviceConnectState::CONNECTING_BY_USER);

  devices_->Add(GetTestAddress(4), DeviceConnectState::CONNECTING_BY_USER);

  LeAudioDevice* device = devices_->FindByAddress(test_address_0);

  device->conn_id_ = 0x0005;

  ASSERT_EQ(device, devices_->FindByConnId(0x0005));

}



TEST_F(LeAudioDevicesTest, test_find_by_conn_id_failed) {

  devices_->Add(GetTestAddress(1), true);

  devices_->Add(GetTestAddress(0), true);

  devices_->Add(GetTestAddress(4), true);

  devices_->Add(GetTestAddress(1), DeviceConnectState::CONNECTING_BY_USER);

  devices_->Add(GetTestAddress(0), DeviceConnectState::CONNECTING_BY_USER);

  devices_->Add(GetTestAddress(4), DeviceConnectState::CONNECTING_BY_USER);

  ASSERT_EQ(nullptr, devices_->FindByConnId(0x0006));

}
@@ -412,8 +413,8 @@ class LeAudioAseConfigurationTest : public Test { 
                               int snk_ase_num_cached = 0,

                               int src_ase_num_cached = 0) {

    int index = group_->Size() + 1;

    auto device =

        (std::make_shared<LeAudioDevice>(GetTestAddress(index), false));

    auto device = (std::make_shared<LeAudioDevice>(

        GetTestAddress(index), DeviceConnectState::DISCONNECTED));

    devices_.push_back(device);

    group_->AddNode(device);
@@ -449,6 +450,7 @@ class LeAudioAseConfigurationTest : public Test { 
        ::le_audio::codec_spec_conf::kLeAudioLocationFrontRight;



    device->conn_id_ = index;

    device->SetConnectionState(DeviceConnectState::CONNECTED);

    return device.get();

  }

system/bta/le_audio/le_audio_types.h

+2 −1
Original line number Diff line number Diff line
@@ -310,7 +310,6 @@ constexpr uint32_t kPresDelayNoPreference = 0x00000000; 
constexpr uint16_t kMaxTransportLatencyMin = 0x0005;

constexpr uint16_t kMaxTransportLatencyMax = 0x0FA0;



/* Enums */

enum class CigState : uint8_t { NONE, CREATING, CREATED, REMOVING, RECOVERING };



/* ASE states according to BAP defined state machine states */
@@ -600,6 +599,8 @@ std::ostream& operator<<(std::ostream& os, const AseState& state); 
std::ostream& operator<<(std::ostream& os, const CigState& state);

std::ostream& operator<<(std::ostream& os, const LeAudioLc3Config& config);

std::ostream& operator<<(std::ostream& os, const LeAudioContextType& context);

std::ostream& operator<<(std::ostream& os,

                         const AudioStreamDataPathState& state);

}  // namespace types



namespace set_configurations {