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

Commit 8142ca03 authored by Łukasz Rymanowski's avatar Łukasz Rymanowski Committed by Gerrit Code Review
Browse files

Merge "leaudio: Fix bonding during phone call for SwB support" into main

parents 561c612d 0877721c

system/bta/csis/csis_client.cc

+1 −1
Original line number Diff line number Diff line
@@ -557,7 +557,7 @@ class CsisClientImpl : public CsisClient { 
    }

  }



  int GetDesiredSize(int group_id) override {

  int GetDesiredSize(int group_id) const override {

    auto csis_group = FindCsisGroup(group_id);

    if (!csis_group) {

      log::info("Unknown group {}", group_id);

system/bta/include/bta_csis_api.h

+1 −1
Original line number Diff line number Diff line
@@ -49,7 +49,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;

  virtual int GetDesiredSize(int group_id) const = 0;

};

}  // namespace csis

}  // namespace bluetooth

system/bta/le_audio/device_groups.cc

+14 −15
Original line number Diff line number Diff line
@@ -84,6 +84,15 @@ bool LeAudioDeviceGroup::IsAnyDeviceConnected(void) const { 


int LeAudioDeviceGroup::Size(void) const { return leAudioDevices_.size(); }



int LeAudioDeviceGroup::DesiredSize(void) const {

  int group_size = 0;

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

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

  }



  return group_size > 0 ? group_size : leAudioDevices_.size();

}



int LeAudioDeviceGroup::NumOfConnected() const {

  /* return number of connected devices from the set*/

  return std::count_if(
@@ -1000,15 +1009,7 @@ void LeAudioDeviceGroup::CigConfiguration::GenerateCisIds( 
  uint8_t cis_count_bidir = 0;

  uint8_t cis_count_unidir_sink = 0;

  uint8_t cis_count_unidir_source = 0;

  int csis_group_size = 0;



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

    csis_group_size =

        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;

  int group_size = group_->DesiredSize();



  set_configurations::get_cis_count(

      context_type, group_size, group_->GetGroupSinkStrategy(),
@@ -1326,10 +1327,7 @@ bool LeAudioDeviceGroup::IsAudioSetConfigurationSupported( 
    // but use UNSPECIFIED which is always supported (but can be unavailable)

    auto device_cnt = NumOfAvailableForDirection(direction);

    if (device_cnt == 0) {

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

        device_cnt =

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

      }

      device_cnt = DesiredSize();

      if (device_cnt == 0) {

        log::error("Device count is 0");

        continue;
@@ -1428,7 +1426,8 @@ bool LeAudioDeviceGroup::IsAudioSetConfigurationSupported( 
   */

  bool dual_bidirection_swb_supported_ =

      CodecManager::GetInstance()->IsDualBiDirSwbSupported();

  if (Size() > 1 && CodecManager::GetInstance()->CheckCodecConfigIsBiDirSwb(

  if (DesiredSize() > 1 &&

      CodecManager::GetInstance()->CheckCodecConfigIsBiDirSwb(

          *audio_set_conf)) {

    if (!dual_bidirection_swb_supported_) {

      return false;

system/bta/le_audio/device_groups.h

+1 −0
Original line number Diff line number Diff line
@@ -151,6 +151,7 @@ class LeAudioDeviceGroup { 
  bool IsEmpty(void) const;

  bool IsAnyDeviceConnected(void) const;

  int Size(void) const;

  int DesiredSize(void) const;

  int NumOfConnected() const;

  int NumOfAvailableForDirection(int direction) const;

  bool Activate(types::LeAudioContextType context_type,

system/bta/le_audio/devices_test.cc

+68 −17
Original line number Diff line number Diff line
@@ -474,6 +474,8 @@ class LeAudioAseConfigurationTest : public Test { 
 protected:

  void SetUp() override {

    group_ = new LeAudioDeviceGroup(group_id_);

    desired_group_size_ = -1;



    bluetooth::manager::SetMockBtmInterface(&btm_interface_);

    bluetooth::hci::testing::mock_controller_ = &controller_interface_;
@@ -488,8 +490,10 @@ class LeAudioAseConfigurationTest : public Test { 
    ON_CALL(mock_csis_client_module_, GetDeviceList(_))

        .WillByDefault(Invoke([this](int group_id) { return addresses_; }));

    ON_CALL(mock_csis_client_module_, GetDesiredSize(_))

        .WillByDefault(

            Invoke([this](int group_id) { return (int)(addresses_.size()); }));

        .WillByDefault(Invoke([this](int group_id) {

          return desired_group_size_ > 0 ? desired_group_size_

                                         : (int)(addresses_.size());

        }));

    SetUpMockCodecManager(codec_location);

  }
@@ -565,18 +569,18 @@ class LeAudioAseConfigurationTest : public Test { 
    }

  }



  LeAudioDevice* AddTestDevice(int snk_ase_num, int src_ase_num,

                               int snk_ase_num_cached = 0,

                               int src_ase_num_cached = 0,

                               bool invert_ases_emplacement = false,

                               bool out_of_range_device = false) {

  LeAudioDevice* AddTestDevice(

      int snk_ase_num, int src_ase_num, int snk_ase_num_cached = 0,

      int src_ase_num_cached = 0, bool invert_ases_emplacement = false,

      bool out_of_range_device = false,

      uint8_t allocation = codec_spec_conf::kLeAudioLocationFrontLeft |

                           codec_spec_conf::kLeAudioLocationFrontRight) {

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

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

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

    devices_.push_back(device);

    log::info("addresses {}", (int)(addresses_.size()));

    addresses_.push_back(device->address_);

    log::info("Addresses {}", (int)(addresses_.size()));

    log::info("Number of devices {}", (int)(addresses_.size()));



    if (out_of_range_device == false) {

      group_->AddNode(device);
@@ -629,12 +633,8 @@ class LeAudioAseConfigurationTest : public Test { 
    device->SetAvailableContexts(

        {.sink = AudioContexts(kLeAudioContextAllTypes),

         .source = AudioContexts(kLeAudioContextAllTypes)});

    device->snk_audio_locations_ =

        ::bluetooth::le_audio::codec_spec_conf::kLeAudioLocationFrontLeft |

        ::bluetooth::le_audio::codec_spec_conf::kLeAudioLocationFrontRight;

    device->src_audio_locations_ =

        ::bluetooth::le_audio::codec_spec_conf::kLeAudioLocationFrontLeft |

        ::bluetooth::le_audio::codec_spec_conf::kLeAudioLocationFrontRight;

    device->snk_audio_locations_ = allocation;

    device->src_audio_locations_ = allocation;



    device->conn_id_ = index;

    device->SetConnectionState(out_of_range_device
@@ -987,12 +987,25 @@ class LeAudioAseConfigurationTest : public Test { 
             UINT8_TO_VEC_UINT8(supported_codec_frames_per_sdu)},

        }),

        .channel_count_per_iso_stream = 1};



    auto swb_config = AudioSetConfiguration({

        .name = "Two-OneChan-SnkAse-Lc3_32_2-Two-OneChan-SrcAse-Lc3_32_2_SWB",

        .confs = {.sink = {AseConfiguration(swb), AseConfiguration(swb)},

                  .source = {AseConfiguration(swb), AseConfiguration(swb)}},

    });



    auto swb_config_single = AudioSetConfiguration({

        .name = "One-OneChan-SnkAse-Lc3_32_2-One-OneChan-SrcAse-Lc3_32_2_SWB",

        .confs = {.sink =

                      {

                          AseConfiguration(swb),

                      },

                  .source =

                      {

                          AseConfiguration(swb),

                      }},

    });



    ASSERT_FALSE(swb.params.IsEmpty());

    ASSERT_TRUE(swb.params.Find(codec_spec_conf::kLeAudioLtvTypeSamplingFreq)

                    .has_value());
@@ -1018,7 +1031,15 @@ class LeAudioAseConfigurationTest : public Test { 
                  .source = {AseConfiguration(non_swb),

                             AseConfiguration(non_swb)}},

    });

    AudioSetConfigurations configs = {{&swb_config, &non_swb_config}};

    auto non_swb_config_single = AudioSetConfiguration({

        .name =

            "One-OneChan-SnkAse-Lc3_16_2-One-OneChan-SrcAse-Lc3_16_2_NON_SWB",

        .confs = {.sink = {AseConfiguration(non_swb)},

                  .source = {AseConfiguration(non_swb)}},

    });

    AudioSetConfigurations configs = {{&swb_config, &swb_config_single,

                                       &non_swb_config,

                                       &non_swb_config_single}};



    // Support single channel per ASE to activate two ASES on both direction

    for (auto config : configs) {
@@ -1169,6 +1190,8 @@ class LeAudioAseConfigurationTest : public Test { 
  }



  const int group_id_ = 6;

  int desired_group_size_ = -1;



  std::vector<std::shared_ptr<LeAudioDevice>> devices_;

  std::vector<RawAddress> addresses_;

  LeAudioDeviceGroup* group_ = nullptr;
@@ -1493,6 +1516,31 @@ TEST_F(LeAudioAseConfigurationTest, 
      CodecManager::GetInstance()->CheckCodecConfigIsDualBiDirSwb(*config));

}



TEST_F(LeAudioAseConfigurationTest,

       test_earbuds_conversational_stereo_microphone_no_swb_one_bonded) {

  /* There will be 2 eabuds eventually but for the moment only 1 is bonded

   * Turn off the dual bidir SWB support

   */

  desired_group_size_ = 2;

  ON_CALL(*mock_codec_manager_, IsDualBiDirSwbSupported)

      .WillByDefault(Return(false));

  ASSERT_FALSE(CodecManager::GetInstance()->IsDualBiDirSwbSupported());



  const auto context_type = LeAudioContextType::CONVERSATIONAL;

  TestSingleDevDualBidir(

      AddTestDevice(1, 1, 0, 0, false, false,

                    codec_spec_conf::kLeAudioLocationFrontLeft),

      context_type);



  // Verify non-SWB config was selected

  auto config = group_->GetCachedConfiguration(context_type).get();

  ASSERT_NE(nullptr, config);

  ASSERT_FALSE(

      CodecManager::GetInstance()->CheckCodecConfigIsDualBiDirSwb(*config));

  ASSERT_FALSE(

      CodecManager::GetInstance()->CheckCodecConfigIsBiDirSwb(*config));

}



TEST_F(LeAudioAseConfigurationTest,

       test_earbuds_conversational_stereo_microphone_swb) {

  // Turn on the dual bidir SWB support
@@ -1971,7 +2019,7 @@ TEST_F(LeAudioAseConfigurationTest, test_reactivation_conversational) { 


  /* Verify ASEs assigned CISes by counting assigned to bi-directional CISes */

  int bi_dir_ases_count = std::count_if(

      tws_headset->ases_.begin(), tws_headset->ases_.end(), [=](auto& ase) {

      tws_headset->ases_.begin(), tws_headset->ases_.end(), [this](auto& ase) {

        return this->group_->cig.cises[ase.cis_id].type ==

               CisType::CIS_TYPE_BIDIRECTIONAL;

      });
@@ -2006,6 +2054,9 @@ TEST_F(LeAudioAseConfigurationTest, test_num_of_connected) { 
 * 4. There is no dual device scenario with strategy stereo channels per device

 */

TEST_F(LeAudioAseConfigurationTest, test_getting_cis_count) {

  /* Set desired size to 2 */

  desired_group_size_ = 2;



  LeAudioDevice* left = AddTestDevice(2, 1);

  LeAudioDevice* right = AddTestDevice(0, 0, 0, 0, false, true);