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

Commit 50a02fae authored by Łukasz Rymanowski's avatar Łukasz Rymanowski
Browse files

leaudio: Minor refactor around connection state in native 

This is preparation for the fix in the following patch, where we will
need to have better connection state information on the device

Bug: 251097804
Test: atest BluetoothInstrumentationTests
Tag: #feature
Change-Id: Ie83da88010ac03458d298a015bc857fecc945f96
parent 4043764e

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 {