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

Commit 96277694 authored by Łukasz Rymanowski's avatar Łukasz Rymanowski Committed by Android (Google) Code Review
Browse files

Merge "leaudio: Fix improper cis calculations for TWS style earbuds" into tm-qpr-dev

parents 8b736c0e 5b75bc8e

system/bta/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -606,6 +606,7 @@ cc_test { 
        "le_audio/metrics_collector_linux.cc",

        "le_audio/mock_iso_manager.cc",

        "test/common/mock_controller.cc",

        "test/common/mock_csis_client.cc",

        "le_audio/state_machine.cc",

        "le_audio/state_machine_test.cc",

        "le_audio/storage_helper.cc",

system/bta/csis/csis_client.cc

+10 −0
Original line number Diff line number Diff line
@@ -525,6 +525,16 @@ class CsisClientImpl : public CsisClient { 
    }

  }



  int GetDesiredSize(int group_id) override {

    auto csis_group = FindCsisGroup(group_id);

    if (!csis_group) {

      LOG_INFO("Unknown group %d", group_id);

      return -1;

    }



    return csis_group->GetDesiredSize();

  }



  bool SerializeSets(const RawAddress& addr, std::vector<uint8_t>& out) const {

    auto device = FindDeviceByAddress(addr);

    if (device == nullptr) {

system/bta/csis/csis_types.h

+1 −1
Original line number Diff line number Diff line
@@ -64,7 +64,7 @@ struct hdl_pair { 


/* CSIS Types */

static constexpr uint8_t kDefaultScanDurationS = 5;

static constexpr uint8_t kDefaultCsisSetSize = 2;

static constexpr uint8_t kDefaultCsisSetSize = 1;

static constexpr uint8_t kUnknownRank = 0xff;



/* Enums */

system/bta/include/bta_csis_api.h

+1 −0
Original line number Diff line number Diff line
@@ -47,6 +47,7 @@ class CsisClient { 
      bluetooth::Uuid uuid = bluetooth::groups::kGenericContextUuid) = 0;

  virtual void LockGroup(int group_id, bool lock, CsisLockCb cb) = 0;

  virtual std::vector<RawAddress> GetDeviceList(int group_id) = 0;

  virtual int GetDesiredSize(int group_id) = 0;

};

}  // namespace csis

}  // namespace bluetooth

system/bta/le_audio/devices.cc

+51 −40
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ 
#include <map>



#include "audio_hal_client/audio_hal_client.h"

#include "bta_csis_api.h"

#include "bta_gatt_queue.h"

#include "bta_groups.h"

#include "bta_le_audio_api.h"
@@ -967,10 +968,16 @@ void LeAudioDeviceGroup::CigGenerateCisIds( 
  uint8_t cis_count_bidir = 0;

  uint8_t cis_count_unidir_sink = 0;

  uint8_t cis_count_unidir_source = 0;

  get_cis_count(confs, GetGroupStrategy(),

  int csis_group_size =

      bluetooth::csis::CsisClient::Get()->GetDesiredSize(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(),

                GetAseCount(types::kLeAudioDirectionSink),

                GetAseCount(types::kLeAudioDirectionSource), &cis_count_bidir,

                &cis_count_unidir_sink, &cis_count_unidir_source);

                GetAseCount(types::kLeAudioDirectionSource), cis_count_bidir,

                cis_count_unidir_sink, cis_count_unidir_source);



  uint8_t idx = 0;

  while (cis_count_bidir > 0) {
@@ -980,7 +987,6 @@ void LeAudioDeviceGroup::CigGenerateCisIds( 
        .type = CisType::CIS_TYPE_BIDIRECTIONAL,

        .conn_handle = 0,

    };



    cises_.push_back(cis_entry);

    cis_count_bidir--;

    idx++;
@@ -1045,20 +1051,23 @@ bool LeAudioDeviceGroup::CigAssignCisIds(LeAudioDevice* leAudioDevice) { 
        cis_id = GetFirstFreeCisId(CisType::CIS_TYPE_BIDIRECTIONAL);

      }



      if (cis_id == kInvalidCisId) {

        LOG_ERROR(" Unable to get free Bi-Directional CIS ID");

        return false;

      }



      if (cis_id != kInvalidCisId) {

        ase->cis_id = cis_id;

        matching_bidir_ase->cis_id = cis_id;

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



      LOG_INFO(" ASE ID: %d and ASE ID: %d, assigned Bi-Directional CIS ID: %d",

        LOG_INFO(

            " ASE ID: %d and ASE ID: %d, assigned Bi-Directional CIS ID: %d",

            +ase->id, +matching_bidir_ase->id, +ase->cis_id);

        continue;

      }



      LOG_WARN(

          " ASE ID: %d, unable to get free Bi-Directional CIS ID but maybe "

          "thats fine. Try using unidirectional.",

          ase->id);

    }



    if (ase->direction == types::kLeAudioDirectionSink) {

      if (cis_id == kInvalidCisId) {

        cis_id = GetFirstFreeCisId(CisType::CIS_TYPE_UNIDIRECTIONAL_SINK);
@@ -1267,7 +1276,7 @@ bool LeAudioDeviceGroup::IsConfigurationSupported( 


    if (ent.direction == types::kLeAudioDirectionSink &&

        strategy != required_snk_strategy) {

      LOG_INFO(" Sink strategy mismatch (%d!=%d)",

      LOG_INFO(" Sink strategy mismatch group!=cfg.entry (%d!=%d)",

               static_cast<int>(required_snk_strategy),

               static_cast<int>(strategy));

      return false;
@@ -1535,12 +1544,12 @@ bool LeAudioDevice::ConfigureAses( 
                      std::vector<uint8_t>());

    }



    DLOG(INFO) << __func__ << " device=" << address_

               << ", activated ASE id=" << +ase->id

               << ", direction=" << +ase->direction

               << ", max_sdu_size=" << +ase->max_sdu_size

               << ", cis_id=" << +ase->cis_id

               << ", target_latency=" << +ent.target_latency;

    LOG_DEBUG(

        "device=%s, activated ASE id=%d, direction=%s, max_sdu_size=%d, "

        "cis_id=%d, target_latency=%d",

        address_.ToString().c_str(), ase->id,

        (ent.direction == 1 ? "snk" : "src"), ase->max_sdu_size, ase->cis_id,

        ent.target_latency);



    ase = GetFirstInactiveAse(ent.direction, reuse_cis_id);

  }
@@ -1575,9 +1584,9 @@ bool LeAudioDeviceGroup::ConfigureAses( 
  types::AudioLocations group_src_audio_locations = 0;



  for (const auto& ent : (*audio_set_conf).confs) {

    DLOG(INFO) << __func__

               << " Looking for requirements: " << audio_set_conf->name << " - "

               << (ent.direction == 1 ? "snk" : "src");

    LOG_DEBUG(" Looking for requirements: %s,  - %s",

              audio_set_conf->name.c_str(),

              (ent.direction == 1 ? "snk" : "src"));



    uint8_t required_device_cnt = ent.device_cnt;

    uint8_t max_required_ase_per_dev =
@@ -1585,10 +1594,11 @@ bool LeAudioDeviceGroup::ConfigureAses( 
    uint8_t active_ase_num = 0;

    le_audio::types::LeAudioConfigurationStrategy strategy = ent.strategy;



    DLOG(INFO) << __func__ << " Number of devices: " << +required_device_cnt

               << " number of ASEs: " << +ent.ase_cnt

               << " Max ASE per device: " << +max_required_ase_per_dev

               << " strategy: " << (int)strategy;

    LOG_DEBUG(

        "Number of devices: %d number of ASEs: %d, Max ASE per device: %d "

        "strategy: %d",

        required_device_cnt, ent.ase_cnt, max_required_ase_per_dev,

        (int)strategy);



    for (auto* device = GetFirstDeviceWithActiveContext(context_type);

         device != nullptr && required_device_cnt > 0;
@@ -1621,14 +1631,14 @@ bool LeAudioDeviceGroup::ConfigureAses( 


    if (required_device_cnt > 0) {

      /* Don't left any active devices if requirements are not met */

      LOG(ERROR) << __func__ << " could not configure all the devices";

      LOG_ERROR(" could not configure all the devices");

      Deactivate();

      return false;

    }

  }



  LOG(INFO) << "Choosed ASE Configuration for group: " << this->group_id_

            << " configuration: " << audio_set_conf->name;

  LOG_INFO("Choosed ASE Configuration for group: %d, configuration: %s",

           group_id_, audio_set_conf->name.c_str());



  configuration_context_type_ = context_type;

  metadata_context_type_ = metadata_context_type;
@@ -1904,21 +1914,22 @@ bool LeAudioDeviceGroup::Configure(LeAudioContextType context_type, 
  const set_configurations::AudioSetConfiguration* conf =

      available_context_to_configuration_map[context_type];



  DLOG(INFO) << __func__;



  if (!conf) {

    LOG(ERROR) << __func__ << ", requested context type: "

               << loghex(static_cast<uint16_t>(context_type))

               << ", is in mismatch with cached available contexts";

    LOG_ERROR(

        ", requested context type: %s , is in mismatch with cached available "

        "contexts ",

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

    return false;

  }



  DLOG(INFO) << __func__ << " setting context type: " << int(context_type);

  LOG_DEBUG(" setting context type: %s",

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



  if (!ConfigureAses(conf, context_type, metadata_context_type, ccid_list)) {

    LOG(ERROR) << __func__ << ", requested pick ASE config context type: "

               << loghex(static_cast<uint16_t>(context_type))

               << ", is in mismatch with cached available contexts";

    LOG_ERROR(

        ", requested context type: %s , is in mismatch with cached available "

        "contexts",

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

    return false;

  }