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

Commit 3d7137cc authored by Jakub Tyszkowski's avatar Jakub Tyszkowski
Browse files

LeAudio: Encapsulate CIG logic in LeAudioDeviceGroup 

A collection of helper functions for managing CISes were put
into a CIG related subclass to improve encapsulation and readability.
Unused code was removed.

Bug: 295972694
Test: atest --host bluetooth_le_audio_test bluetooth_le_audio_client_test bluetooth_test_broadcaster bluetooth_test_broadcaster_state_machine bluetooth_le_audio_codec_manager_test
Change-Id: I5855e96c862b3513720d0594d957997cafd34565
parent 94882978

system/bta/le_audio/client.cc

+4 −6
Original line number Diff line number Diff line
@@ -480,7 +480,7 @@ class LeAudioClientImpl : public LeAudioClient { 
        group_id, ToString(group->GetState()).c_str(),

        ToString(group->GetTargetState()).c_str(), check_if_recovery_needed);

    group->SetTargetState(AseState::BTA_LE_AUDIO_ASE_STATE_IDLE);

    group->CigClearCis();

    group->ClearAllCises();

    group->PrintDebugState();



    /* There is an issue with a setting up stream or any other operation which
@@ -712,9 +712,9 @@ class LeAudioClientImpl : public LeAudioClient { 
    }

    LOG_DEBUG("Group %p, id: %d, size: %d, is cig_state %s", group,

              group->group_id_, group->Size(),

              ToString(group->cig_state_).c_str());

              ToString(group->cig.GetState()).c_str());

    if (group->IsEmpty() &&

        (group->cig_state_ == le_audio::types::CigState::NONE)) {

        (group->cig.GetState() == le_audio::types::CigState::NONE)) {

      aseGroups_.Remove(group->group_id_);

    }

  }
@@ -5279,9 +5279,7 @@ class LeAudioClientImpl : public LeAudioClient { 
      LOG_ERROR("Invalid group_id: %d", group_id);

      return;

    }

    CodecManager::GetInstance()->UpdateCisConfiguration(

        group->cises_, group->stream_conf.stream_params.get(direction),

        direction);

    group->UpdateCisConfiguration(direction);

  }



 private:

system/bta/le_audio/device_groups.cc

+64 −97
Original line number Diff line number Diff line
@@ -98,45 +98,32 @@ int LeAudioDeviceGroup::NumOfConnected(LeAudioContextType context_type) const { 


void LeAudioDeviceGroup::ClearSinksFromConfiguration(void) {

  LOG_INFO("Group %p, group_id %d", this, group_id_);

  auto direction = types::kLeAudioDirectionSink;



  auto& stream_params = stream_conf.stream_params.get(direction);

  stream_params.stream_locations.clear();

  stream_params.audio_channel_allocation = 0;

  stream_params.num_of_channels = 0;

  stream_params.num_of_devices = 0;

  stream_params.sample_frequency_hz = 0;

  stream_params.codec_frames_blocks_per_sdu = 0;

  stream_params.octets_per_codec_frame = 0;

  stream_params.frame_duration_us = 0;



  auto direction = types::kLeAudioDirectionSink;

  stream_conf.stream_params.get(direction).clear();

  CodecManager::GetInstance()->ClearCisConfiguration(direction);

}



void LeAudioDeviceGroup::ClearSourcesFromConfiguration(void) {

  LOG_INFO("Group %p, group_id %d", this, group_id_);

  auto direction = types::kLeAudioDirectionSource;



  auto& stream_params = stream_conf.stream_params.get(direction);

  stream_params.stream_locations.clear();

  stream_params.audio_channel_allocation = 0;

  stream_params.num_of_channels = 0;

  stream_params.num_of_devices = 0;

  stream_params.sample_frequency_hz = 0;

  stream_params.codec_frames_blocks_per_sdu = 0;

  stream_params.octets_per_codec_frame = 0;

  stream_params.frame_duration_us = 0;



  auto direction = types::kLeAudioDirectionSource;

  stream_conf.stream_params.get(direction).clear();

  CodecManager::GetInstance()->ClearCisConfiguration(direction);

}



void LeAudioDeviceGroup::CigClearCis(void) {

void LeAudioDeviceGroup::ClearAllCises(void) {

  LOG_INFO("group_id: %d", group_id_);

  cises_.clear();

  cig.cises.clear();

  ClearSinksFromConfiguration();

  ClearSourcesFromConfiguration();

}



void LeAudioDeviceGroup::UpdateCisConfiguration(uint8_t direction) {

  CodecManager::GetInstance()->UpdateCisConfiguration(

      cig.cises, stream_conf.stream_params.get(direction), direction);

}



void LeAudioDeviceGroup::Cleanup(void) {

  /* Bluetooth is off while streaming - disconnect CISes and remove CIG */

  if (GetState() == AseState::BTA_LE_AUDIO_ASE_STATE_STREAMING) {
@@ -178,7 +165,7 @@ void LeAudioDeviceGroup::Cleanup(void) { 
   */



  leAudioDevices_.clear();

  this->CigClearCis();

  ClearAllCises();

}



void LeAudioDeviceGroup::Deactivate(void) {
@@ -191,16 +178,6 @@ void LeAudioDeviceGroup::Deactivate(void) { 
  }

}



le_audio::types::CigState LeAudioDeviceGroup::GetCigState(void) const {

  return cig_state_;

}



void LeAudioDeviceGroup::SetCigState(le_audio::types::CigState state) {

  LOG_VERBOSE("%s -> %s", bluetooth::common::ToString(cig_state_).c_str(),

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

  cig_state_ = state;

}



bool LeAudioDeviceGroup::Activate(

  LeAudioContextType context_type,

  const BidirectionalPair<AudioContexts>& metadata_context_types,
@@ -215,7 +192,7 @@ bool LeAudioDeviceGroup::Activate( 
             ADDRESS_TO_LOGGABLE_CSTR(leAudioDevice.lock().get()->address_),

             activated ? "activated" : " not activated");

    if (activated) {

      if (!CigAssignCisIds(leAudioDevice.lock().get())) {

      if (!cig.AssignCisIds(leAudioDevice.lock().get())) {

        return false;

      }

      is_activate = true;
@@ -882,27 +859,12 @@ bool LeAudioDeviceGroup::HaveAllCisesDisconnected(void) const { 
  return true;

}



uint8_t LeAudioDeviceGroup::GetFirstFreeCisId(void) const {

  for (uint8_t id = 0; id < UINT8_MAX; id++) {

    auto iter = std::find_if(leAudioDevices_.begin(), leAudioDevices_.end(),

                             [id](auto& d) {

                               if (d.expired())

                                 return false;

                               else

                                 return ((d.lock()).get())->HasCisId(id);

                             });



    if (iter == leAudioDevices_.end()) return id;

  }



  return kInvalidCisId;

}



uint8_t LeAudioDeviceGroup::GetFirstFreeCisId(CisType cis_type) const {

  LOG_INFO("Group: %p, group_id: %d cis_type: %d", this, group_id_,

uint8_t LeAudioDeviceGroup::CigConfiguration::GetFirstFreeCisId(

    CisType cis_type) const {

  LOG_INFO("Group: %p, group_id: %d cis_type: %d", group_, group_->group_id_,

           static_cast<int>(cis_type));

  for (size_t id = 0; id < cises_.size(); id++) {

    if (cises_[id].addr.IsEmpty() && cises_[id].type == cis_type) {

  for (size_t id = 0; id < cises.size(); id++) {

    if (cises[id].addr.IsEmpty() && cises[id].type == cis_type) {

      return id;

    }

  }
@@ -946,11 +908,13 @@ int LeAudioDeviceGroup::GetAseCount(uint8_t direction) const { 
  return result;

}



void LeAudioDeviceGroup::CigGenerateCisIds(LeAudioContextType context_type) {

  LOG_INFO("Group %p, group_id: %d, context_type: %s", this, group_id_,

void LeAudioDeviceGroup::CigConfiguration::GenerateCisIds(

    LeAudioContextType context_type) {

  LOG_INFO("Group %p, group_id: %d, context_type: %s", group_,

           group_->group_id_,

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



  if (cises_.size() > 0) {

  if (cises.size() > 0) {

    LOG_INFO("CIS IDs already generated");

    return;

  }
@@ -965,16 +929,17 @@ void LeAudioDeviceGroup::CigGenerateCisIds(LeAudioContextType context_type) { 


  if (bluetooth::csis::CsisClient::IsCsisClientRunning()) {

    csis_group_size =

        bluetooth::csis::CsisClient::Get()->GetDesiredSize(group_id_);

        bluetooth::csis::CsisClient::Get()->GetDesiredSize(group_->group_id_);

  }

  /* If this is CSIS group, the csis_group_size will be > 0, otherwise -1.

   * If the last happen it means, group size is 1 */

  int group_size = csis_group_size > 0 ? csis_group_size : 1;



  get_cis_count(*confs, group_size, GetGroupStrategy(group_size),

                GetAseCount(types::kLeAudioDirectionSink),

                GetAseCount(types::kLeAudioDirectionSource), cis_count_bidir,

                cis_count_unidir_sink, cis_count_unidir_source);

  get_cis_count(*confs, group_size, group_->GetGroupStrategy(group_size),

                group_->GetAseCount(types::kLeAudioDirectionSink),

                group_->GetAseCount(types::kLeAudioDirectionSource),

                cis_count_bidir, cis_count_unidir_sink,

                cis_count_unidir_source);



  uint8_t idx = 0;

  while (cis_count_bidir > 0) {
@@ -984,7 +949,7 @@ void LeAudioDeviceGroup::CigGenerateCisIds(LeAudioContextType context_type) { 
        .conn_handle = 0,

        .addr = RawAddress::kEmpty,

    };

    cises_.push_back(cis_entry);

    cises.push_back(cis_entry);

    cis_count_bidir--;

    idx++;

  }
@@ -996,7 +961,7 @@ void LeAudioDeviceGroup::CigGenerateCisIds(LeAudioContextType context_type) { 
        .conn_handle = 0,

        .addr = RawAddress::kEmpty,

    };

    cises_.push_back(cis_entry);

    cises.push_back(cis_entry);

    cis_count_unidir_sink--;

    idx++;

  }
@@ -1008,13 +973,14 @@ void LeAudioDeviceGroup::CigGenerateCisIds(LeAudioContextType context_type) { 
        .conn_handle = 0,

        .addr = RawAddress::kEmpty,

    };

    cises_.push_back(cis_entry);

    cises.push_back(cis_entry);

    cis_count_unidir_source--;

    idx++;

  }

}



bool LeAudioDeviceGroup::CigAssignCisIds(LeAudioDevice* leAudioDevice) {

bool LeAudioDeviceGroup::CigConfiguration::AssignCisIds(

    LeAudioDevice* leAudioDevice) {

  ASSERT_LOG(leAudioDevice, "invalid device");

  LOG_INFO("device: %s", ADDRESS_TO_LOGGABLE_CSTR(leAudioDevice->address_));
@@ -1030,8 +996,8 @@ bool LeAudioDeviceGroup::CigAssignCisIds(LeAudioDevice* leAudioDevice) { 
    /* CIS ID already set */

    if (ase->cis_id != kInvalidCisId) {

      LOG_INFO("ASE ID: %d, is already assigned CIS ID: %d, type %d", ase->id,

               ase->cis_id, cises_[ase->cis_id].type);

      if (!cises_[ase->cis_id].addr.IsEmpty()) {

               ase->cis_id, cises[ase->cis_id].type);

      if (!cises[ase->cis_id].addr.IsEmpty()) {

        LOG_INFO("Bi-Directional CIS already assigned");

        continue;

      }
@@ -1063,7 +1029,7 @@ bool LeAudioDeviceGroup::CigAssignCisIds(LeAudioDevice* leAudioDevice) { 
      if (cis_id != kInvalidCisId) {

        ase->cis_id = cis_id;

        matching_bidir_ase->cis_id = cis_id;

        cises_[cis_id].addr = leAudioDevice->address_;

        cises[cis_id].addr = leAudioDevice->address_;



        LOG_INFO(

            " ASE ID: %d and ASE ID: %d, assigned Bi-Directional CIS ID: %d",
@@ -1097,7 +1063,7 @@ bool LeAudioDeviceGroup::CigAssignCisIds(LeAudioDevice* leAudioDevice) { 
      }



      ase->cis_id = cis_id;

      cises_[cis_id].addr = leAudioDevice->address_;

      cises[cis_id].addr = leAudioDevice->address_;

      LOG_INFO("ASE ID: %d, assigned Uni-Directional Sink CIS ID: %d", ase->id,

               ase->cis_id);

      continue;
@@ -1126,7 +1092,7 @@ bool LeAudioDeviceGroup::CigAssignCisIds(LeAudioDevice* leAudioDevice) { 
    }



    ase->cis_id = cis_id;

    cises_[cis_id].addr = leAudioDevice->address_;

    cises[cis_id].addr = leAudioDevice->address_;

    LOG_INFO("ASE ID: %d, assigned Uni-Directional Source CIS ID: %d", ase->id,

             ase->cis_id);

  }
@@ -1134,17 +1100,17 @@ bool LeAudioDeviceGroup::CigAssignCisIds(LeAudioDevice* leAudioDevice) { 
  return true;

}



void LeAudioDeviceGroup::CigAssignCisConnHandles(

void LeAudioDeviceGroup::CigConfiguration::AssignCisConnHandles(

    const std::vector<uint16_t>& conn_handles) {

  LOG_INFO("num of cis handles %d", static_cast<int>(conn_handles.size()));

  for (size_t i = 0; i < cises_.size(); i++) {

    cises_[i].conn_handle = conn_handles[i];

    LOG_INFO("assigning cis[%d] conn_handle: %d", cises_[i].id,

             cises_[i].conn_handle);

  for (size_t i = 0; i < cises.size(); i++) {

    cises[i].conn_handle = conn_handles[i];

    LOG_INFO("assigning cis[%d] conn_handle: %d", cises[i].id,

             cises[i].conn_handle);

  }

}



void LeAudioDeviceGroup::CigAssignCisConnHandlesToAses(

void LeAudioDeviceGroup::AssignCisConnHandlesToAses(

    LeAudioDevice* leAudioDevice) {

  ASSERT_LOG(leAudioDevice, "Invalid device");

  LOG_INFO("group: %p, group_id: %d, device: %s", this, group_id_,
@@ -1165,17 +1131,17 @@ void LeAudioDeviceGroup::CigAssignCisConnHandlesToAses( 
    auto ases_pair = leAudioDevice->GetAsesByCisId(ase->cis_id);



    if (ases_pair.sink && ases_pair.sink->active) {

      ases_pair.sink->cis_conn_hdl = cises_[ase->cis_id].conn_handle;

      ases_pair.sink->cis_conn_hdl = cig.cises[ase->cis_id].conn_handle;

      ases_pair.sink->cis_state = CisState::ASSIGNED;

    }

    if (ases_pair.source && ases_pair.source->active) {

      ases_pair.source->cis_conn_hdl = cises_[ase->cis_id].conn_handle;

      ases_pair.source->cis_conn_hdl = cig.cises[ase->cis_id].conn_handle;

      ases_pair.source->cis_state = CisState::ASSIGNED;

    }

  }

}



void LeAudioDeviceGroup::CigAssignCisConnHandlesToAses(void) {

void LeAudioDeviceGroup::AssignCisConnHandlesToAses(void) {

  LeAudioDevice* leAudioDevice = GetFirstActiveDevice();

  ASSERT_LOG(leAudioDevice, "Shouldn't be called without an active device.");
@@ -1184,17 +1150,18 @@ void LeAudioDeviceGroup::CigAssignCisConnHandlesToAses(void) { 
  /* Assign all CIS connection handles to ases */

  for (; leAudioDevice != nullptr;

       leAudioDevice = GetNextActiveDevice(leAudioDevice)) {

    CigAssignCisConnHandlesToAses(leAudioDevice);

    AssignCisConnHandlesToAses(leAudioDevice);

  }

}



void LeAudioDeviceGroup::CigUnassignCis(LeAudioDevice* leAudioDevice) {

void LeAudioDeviceGroup::CigConfiguration::UnassignCis(

    LeAudioDevice* leAudioDevice) {

  ASSERT_LOG(leAudioDevice, "Invalid device");



  LOG_INFO("Group %p, group_id %d, device: %s", this, group_id_,

  LOG_INFO("Group %p, group_id %d, device: %s", group_, group_->group_id_,

           ADDRESS_TO_LOGGABLE_CSTR(leAudioDevice->address_));



  for (struct le_audio::types::cis& cis_entry : cises_) {

  for (struct le_audio::types::cis& cis_entry : cises) {

    if (cis_entry.addr == leAudioDevice->address_) {

      cis_entry.addr = RawAddress::kEmpty;

    }
@@ -1684,18 +1651,18 @@ void LeAudioDeviceGroup::RemoveCisFromStreamIfNeeded( 
  /* Update CodecManager CIS configuration */

  if (old_sink_channels > stream_conf.stream_params.sink.num_of_channels) {

    CodecManager::GetInstance()->UpdateCisConfiguration(

        cises_,

        cig.cises,

        stream_conf.stream_params.get(le_audio::types::kLeAudioDirectionSink),

        le_audio::types::kLeAudioDirectionSink);

  }

  if (old_source_channels > stream_conf.stream_params.source.num_of_channels) {

    CodecManager::GetInstance()->UpdateCisConfiguration(

        cises_,

        cig.cises,

        stream_conf.stream_params.get(le_audio::types::kLeAudioDirectionSource),

        le_audio::types::kLeAudioDirectionSource);

  }



  CigUnassignCis(leAudioDevice);

  cig.UnassignCis(leAudioDevice);

}



bool LeAudioDeviceGroup::IsPendingConfiguration(void) const {
@@ -1913,7 +1880,7 @@ void LeAudioDeviceGroup::PrintDebugState(void) const { 
            << ", state: " << bluetooth::common::ToString(GetState())

            << ", target state: "

            << bluetooth::common::ToString(GetTargetState())

            << ", cig state: " << bluetooth::common::ToString(cig_state_)

            << ", cig state: " << bluetooth::common::ToString(cig.GetState())

            << ", \n group supported contexts: "

            << bluetooth::common::ToString(GetSupportedContexts())

            << ", \n group available contexts: "
@@ -1923,9 +1890,9 @@ void LeAudioDeviceGroup::PrintDebugState(void) const { 
            << ", \n active configuration name: "

            << (active_conf ? active_conf->name : " not set");



  if (cises_.size() > 0) {

    LOG_INFO("\n Allocated CISes: %d", static_cast<int>(cises_.size()));

    for (auto cis : cises_) {

  if (cig.cises.size() > 0) {

    LOG_INFO("\n Allocated CISes: %d", static_cast<int>(cig.cises.size()));

    for (auto cis : cig.cises) {

      LOG_INFO("\n cis id: %d, type: %d, conn_handle %d, addr: %s", cis.id,

               cis.type, cis.conn_handle, cis.addr.ToString().c_str());

    }
@@ -1971,7 +1938,7 @@ void LeAudioDeviceGroup::Dump(int fd, int active_group_id) const { 
         << " == " << (is_active ? ",\tActive\n" : ",\tInactive\n")

         << "      state: " << GetState()

         << ",\ttarget state: " << GetTargetState()

         << ",\tcig state: " << cig_state_ << "\n"

         << ",\tcig state: " << cig.GetState() << "\n"

         << "      group supported contexts: " << GetSupportedContexts() << "\n"

         << "      group available contexts: " << GetAvailableContexts() << "\n"

         << "      configuration context type: "
@@ -1993,11 +1960,11 @@ void LeAudioDeviceGroup::Dump(int fd, int active_group_id) const { 
         << "      num of sources(connected): "

         << stream_conf.stream_params.source.num_of_devices << "("

         << stream_conf.stream_params.source.stream_locations.size() << ")\n"

         << "      allocated CISes: " << static_cast<int>(cises_.size());

         << "      allocated CISes: " << static_cast<int>(cig.cises.size());



  if (cises_.size() > 0) {

  if (cig.cises.size() > 0) {

    stream << "\n\t == CISes == ";

    for (auto cis : cises_) {

    for (auto cis : cig.cises) {

      stream << "\n\t cis id: " << static_cast<int>(cis.id)

             << ",\ttype: " << static_cast<int>(cis.type)

             << ",\tconn_handle: " << static_cast<int>(cis.conn_handle)

system/bta/le_audio/device_groups.h

+31 −14
Original line number Diff line number Diff line
@@ -44,7 +44,32 @@ class LeAudioDeviceGroup { 
 public:

  const int group_id_;



  types::CigState cig_state_;

  class CigConfiguration {

   public:

    CigConfiguration() = delete;

    CigConfiguration(LeAudioDeviceGroup* group)

        : group_(group), state_(types::CigState::NONE) {}



    types::CigState GetState(void) const { return state_; }

    void SetState(le_audio::types::CigState state) {

      LOG_VERBOSE("%s -> %s", bluetooth::common::ToString(state_).c_str(),

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

      state_ = state;

    }



    void GenerateCisIds(types::LeAudioContextType context_type);

    bool AssignCisIds(LeAudioDevice* leAudioDevice);

    void AssignCisConnHandles(const std::vector<uint16_t>& conn_handles);

    void UnassignCis(LeAudioDevice* leAudioDevice);



    std::vector<struct types::cis> cises;



   private:

    uint8_t GetFirstFreeCisId(types::CisType cis_type) const;



    LeAudioDeviceGroup* group_;

    types::CigState state_;

  } cig;



  struct stream_configuration stream_conf;
@@ -56,10 +81,9 @@ class LeAudioDeviceGroup { 
  bool is_output_preference_le_audio;

  bool is_duplex_preference_le_audio;



  std::vector<struct types::cis> cises_;

  explicit LeAudioDeviceGroup(const int group_id)

      : group_id_(group_id),

        cig_state_(types::CigState::NONE),

        cig(this),

        stream_conf({}),

        audio_directions_(0),

        is_enabled_(true),
@@ -106,9 +130,6 @@ class LeAudioDeviceGroup { 
                    metadata_context_types,

                types::BidirectionalPair<std::vector<uint8_t>> ccid_lists);

  void Deactivate(void);

  types::CigState GetCigState(void) const;

  void SetCigState(le_audio::types::CigState state);

  void CigClearCis(void);

  void ClearSinksFromConfiguration(void);

  void ClearSourcesFromConfiguration(void);

  void Cleanup(void);
@@ -136,14 +157,10 @@ class LeAudioDeviceGroup { 
  bool IsGroupReadyToCreateStream(void) const;

  bool IsGroupReadyToSuspendStream(void) const;

  bool HaveAllCisesDisconnected(void) const;

  uint8_t GetFirstFreeCisId(void) const;

  uint8_t GetFirstFreeCisId(types::CisType cis_type) const;

  void CigGenerateCisIds(types::LeAudioContextType context_type);

  bool CigAssignCisIds(LeAudioDevice* leAudioDevice);

  void CigAssignCisConnHandles(const std::vector<uint16_t>& conn_handles);

  void CigAssignCisConnHandlesToAses(LeAudioDevice* leAudioDevice);

  void CigAssignCisConnHandlesToAses(void);

  void CigUnassignCis(LeAudioDevice* leAudioDevice);

  void ClearAllCises(void);

  void UpdateCisConfiguration(uint8_t direction);

  void AssignCisConnHandlesToAses(LeAudioDevice* leAudioDevice);

  void AssignCisConnHandlesToAses(void);

  bool Configure(types::LeAudioContextType context_type,

                 const types::BidirectionalPair<types::AudioContexts>&

                     metadata_context_types,

system/bta/le_audio/devices.cc

+0 −37
Original line number Diff line number Diff line
@@ -639,43 +639,6 @@ bool LeAudioDevice::HaveAnyCisConnected(void) { 
  return false;

}



bool LeAudioDevice::HasCisId(uint8_t id) {

  struct ase* ase = GetFirstActiveAse();



  while (ase) {

    if (ase->cis_id == id) return true;

    ase = GetNextActiveAse(ase);

  }



  return false;

}



uint8_t LeAudioDevice::GetMatchingBidirectionCisId(const struct ase* base_ase) {

  for (auto& ase : ases_) {

    auto& cis = ase.cis_id;

    if (!ase.active) continue;



    int num_cises =

        std::count_if(ases_.begin(), ases_.end(), [&cis](const auto& iter_ase) {

          return iter_ase.active && iter_ase.cis_id == cis;

        });



    /*

     * If there is only one ASE for device with unique CIS ID and opposite to

     * direction - it may be bi-directional/completive.

     */

    if (num_cises == 1 &&

        ((base_ase->direction == types::kLeAudioDirectionSink &&

          ase.direction == types::kLeAudioDirectionSource) ||

         (base_ase->direction == types::kLeAudioDirectionSource &&

          ase.direction == types::kLeAudioDirectionSink))) {

      return ase.cis_id;

    }

  }



  return kInvalidCisId;

}



uint8_t LeAudioDevice::GetLc3SupportedChannelCount(uint8_t direction) {

  auto& pacs =

      direction == types::kLeAudioDirectionSink ? snk_pacs_ : src_pacs_;

system/bta/le_audio/devices.h

+0 −2
Original line number Diff line number Diff line
@@ -169,8 +169,6 @@ class LeAudioDevice { 
  bool IsReadyToSuspendStream(void);

  bool HaveAllActiveAsesCisEst(void);

  bool HaveAnyCisConnected(void);

  bool HasCisId(uint8_t id);

  uint8_t GetMatchingBidirectionCisId(const struct types::ase* base_ase);

  const struct types::acs_ac_record* GetCodecConfigurationSupportedPac(

      uint8_t direction, const set_configurations::CodecCapabilitySetting&

                             codec_capability_setting);