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

Commit 55718123 authored by Bao Do's avatar Bao Do Committed by Automerger Merge Worker
Browse files

Add template functions and implement setCodecPriority am: 6112bda4 am: 49017418 am: ab870cc6 

Original change: https://android-review.googlesource.com/c/platform/hardware/interfaces/+/2836200



Change-Id: I54223bc23dab8a02b52afd6f18702a25eaaf9141
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 1dcad791 ab870cc6

bluetooth/audio/aidl/default/LeAudioOffloadAudioProvider.cpp

+68 −2
Original line number Diff line number Diff line
@@ -70,8 +70,8 @@ ndk::ScopedAStatus LeAudioOffloadAudioProvider::startSession( 
    return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);

  }



  return BluetoothAudioProvider::startSession(

      host_if, audio_config, latency_modes, _aidl_return);

  return BluetoothAudioProvider::startSession(host_if, audio_config,

                                              latency_modes, _aidl_return);

}



ndk::ScopedAStatus LeAudioOffloadAudioProvider::onSessionReady(
@@ -81,6 +81,72 @@ ndk::ScopedAStatus LeAudioOffloadAudioProvider::onSessionReady( 
  *_aidl_return = DataMQDesc();

  return ndk::ScopedAStatus::ok();

}

ndk::ScopedAStatus LeAudioOffloadAudioProvider::setCodecPriority(

    const CodecId& in_codecId, int32_t in_priority) {

  codec_priority_map_[in_codecId] = in_priority;

  return ndk::ScopedAStatus::ok();

};



ndk::ScopedAStatus LeAudioOffloadAudioProvider::getLeAudioAseConfiguration(

    const std::optional<std::vector<

        std::optional<IBluetoothAudioProvider::LeAudioDeviceCapabilities>>>&

        in_remoteSinkAudioCapabilities,

    const std::optional<std::vector<

        std::optional<IBluetoothAudioProvider::LeAudioDeviceCapabilities>>>&

        in_remoteSourceAudioCapabilities,

    const std::vector<IBluetoothAudioProvider::LeAudioConfigurationRequirement>&

        in_requirements,

    std::vector<IBluetoothAudioProvider::LeAudioAseConfigurationSetting>*

        _aidl_return) {

  /* TODO: Implement */

  (void)in_remoteSinkAudioCapabilities;

  (void)in_remoteSourceAudioCapabilities;

  (void)in_requirements;

  (void)_aidl_return;

  return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);

};



ndk::ScopedAStatus LeAudioOffloadAudioProvider::getLeAudioAseQosConfiguration(

    const IBluetoothAudioProvider::LeAudioAseQosConfigurationRequirement&

        in_qosRequirement,

    IBluetoothAudioProvider::LeAudioAseQosConfigurationPair* _aidl_return) {

  /* TODO: Implement */

  (void)in_qosRequirement;

  (void)_aidl_return;

  return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);

};



ndk::ScopedAStatus LeAudioOffloadAudioProvider::onSinkAseMetadataChanged(

    IBluetoothAudioProvider::AseState in_state,

    const std::optional<std::vector<std::optional<MetadataLtv>>>& in_metadata) {

  (void)in_state;

  (void)in_metadata;

  return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);

};



ndk::ScopedAStatus LeAudioOffloadAudioProvider::onSourceAseMetadataChanged(

    IBluetoothAudioProvider::AseState in_state,

    const std::optional<std::vector<std::optional<MetadataLtv>>>& in_metadata) {

  (void)in_state;

  (void)in_metadata;

  return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);

};



ndk::ScopedAStatus

LeAudioOffloadAudioProvider::getLeAudioBroadcastConfiguration(

    const std::optional<std::vector<

        std::optional<IBluetoothAudioProvider::LeAudioDeviceCapabilities>>>&

        in_remoteSinkAudioCapabilities,

    const IBluetoothAudioProvider::LeAudioBroadcastConfigurationRequirement&

        in_requirement,

    IBluetoothAudioProvider::LeAudioBroadcastConfigurationSetting*

        _aidl_return) {

  /* TODO: Implement */

  (void)in_remoteSinkAudioCapabilities;

  (void)in_requirement;

  (void)_aidl_return;

  return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);

};



}  // namespace audio

}  // namespace bluetooth

bluetooth/audio/aidl/default/LeAudioOffloadAudioProvider.h

+103 −2
Original line number Diff line number Diff line
@@ -16,7 +16,11 @@ 


#pragma once



#include <map>



#include "BluetoothAudioProvider.h"

#include "aidl/android/hardware/bluetooth/audio/LeAudioAseConfiguration.h"

#include "aidl/android/hardware/bluetooth/audio/MetadataLtv.h"



namespace aidl {

namespace android {
@@ -24,6 +28,13 @@ namespace hardware { 
namespace bluetooth {

namespace audio {



using LeAudioAseConfigurationSetting =

    IBluetoothAudioProvider::LeAudioAseConfigurationSetting;

using AseDirectionRequirement = IBluetoothAudioProvider::

    LeAudioConfigurationRequirement::AseDirectionRequirement;

using AseDirectionConfiguration = IBluetoothAudioProvider::

    LeAudioAseConfigurationSetting::AseDirectionConfiguration;



class LeAudioOffloadAudioProvider : public BluetoothAudioProvider {

 public:

  LeAudioOffloadAudioProvider();
@@ -33,11 +44,101 @@ class LeAudioOffloadAudioProvider : public BluetoothAudioProvider { 
  ndk::ScopedAStatus startSession(

      const std::shared_ptr<IBluetoothAudioPort>& host_if,

      const AudioConfiguration& audio_config,

      const std::vector<LatencyMode>& latency_modes,

      DataMQDesc* _aidl_return);

      const std::vector<LatencyMode>& latency_modes, DataMQDesc* _aidl_return);

  ndk::ScopedAStatus setCodecPriority(const CodecId& in_codecId,

                                      int32_t in_priority) override;

  ndk::ScopedAStatus getLeAudioAseConfiguration(

      const std::optional<std::vector<

          std::optional<IBluetoothAudioProvider::LeAudioDeviceCapabilities>>>&

          in_remoteSinkAudioCapabilities,

      const std::optional<std::vector<

          std::optional<IBluetoothAudioProvider::LeAudioDeviceCapabilities>>>&

          in_remoteSourceAudioCapabilities,

      const std::vector<

          IBluetoothAudioProvider::LeAudioConfigurationRequirement>&

          in_requirements,

      std::vector<IBluetoothAudioProvider::LeAudioAseConfigurationSetting>*

          _aidl_return) override;

  ndk::ScopedAStatus getLeAudioAseQosConfiguration(

      const IBluetoothAudioProvider::LeAudioAseQosConfigurationRequirement&

          in_qosRequirement,

      IBluetoothAudioProvider::LeAudioAseQosConfigurationPair* _aidl_return)

      override;

  ndk::ScopedAStatus onSinkAseMetadataChanged(

      IBluetoothAudioProvider::AseState in_state,

      const std::optional<std::vector<std::optional<MetadataLtv>>>& in_metadata)

      override;

  ndk::ScopedAStatus onSourceAseMetadataChanged(

      IBluetoothAudioProvider::AseState in_state,

      const std::optional<std::vector<std::optional<MetadataLtv>>>& in_metadata)

      override;

  ndk::ScopedAStatus getLeAudioBroadcastConfiguration(

      const std::optional<std::vector<

          std::optional<IBluetoothAudioProvider::LeAudioDeviceCapabilities>>>&

          in_remoteSinkAudioCapabilities,

      const IBluetoothAudioProvider::LeAudioBroadcastConfigurationRequirement&

          in_requirement,

      IBluetoothAudioProvider::LeAudioBroadcastConfigurationSetting*

          _aidl_return) override;



 private:

  ndk::ScopedAStatus onSessionReady(DataMQDesc* _aidl_return) override;

  std::map<CodecId, uint32_t> codec_priority_map_;



  // Private matching function definitions

  bool isMatchedValidCodec(CodecId cfg_codec, CodecId req_codec);

  bool isMatchedContext(

      AudioContext setting_context,

      const IBluetoothAudioProvider::LeAudioDeviceCapabilities& capabilities);

  bool isMatchedSamplingFreq(

      CodecSpecificConfigurationLtv::SamplingFrequency& cfg_freq,

      CodecSpecificCapabilitiesLtv::SupportedSamplingFrequencies&

          capability_freq);

  bool isMatchedFrameDuration(

      CodecSpecificConfigurationLtv::FrameDuration& cfg_fduration,

      CodecSpecificCapabilitiesLtv::SupportedFrameDurations&

          capability_fduration);

  bool isMatchedAudioChannel(

      CodecSpecificConfigurationLtv::AudioChannelAllocation& cfg_channel,

      CodecSpecificCapabilitiesLtv::SupportedAudioChannelCounts&

          capability_channel);

  bool isMatchedCodecFramesPerSDU(

      CodecSpecificConfigurationLtv::CodecFrameBlocksPerSDU& cfg_frame_sdu,

      CodecSpecificCapabilitiesLtv::SupportedMaxCodecFramesPerSDU&

          capability_frame_sdu);

  bool isMatchedOctetsPerCodecFrame(

      CodecSpecificConfigurationLtv::OctetsPerCodecFrame& cfg_octets,

      CodecSpecificCapabilitiesLtv::SupportedOctetsPerCodecFrame&

          capability_octets);

  bool isCapabilitiesMatchedCodecConfiguration(

      std::vector<CodecSpecificConfigurationLtv>& codec_cfg,

      std::vector<CodecSpecificCapabilitiesLtv> codec_capabilities);

  bool isRequirementAseConfigurationMatched(

      LeAudioAseConfiguration setting_cfg,

      LeAudioAseConfiguration requirement_cfg);

  void filterCapabilitiesAseDirectionConfiguration(

      std::vector<std::optional<AseDirectionConfiguration>>&

          direction_configurations,

      const IBluetoothAudioProvider::LeAudioDeviceCapabilities& capabilities,

      std::vector<std::optional<AseDirectionConfiguration>>&

          valid_direction_configurations);

  void filterRequirementAseDirectionConfiguration(

      std::vector<std::optional<AseDirectionConfiguration>>&

          direction_configurations,

      const std::optional<std::vector<std::optional<AseDirectionRequirement>>>&

          requirements,

      std::vector<std::optional<AseDirectionConfiguration>>&

          valid_direction_configurations);

  std::optional<LeAudioAseConfigurationSetting>

  getCapabilitiesMatchedAseConfigurationSettings(

      IBluetoothAudioProvider::LeAudioAseConfigurationSetting& setting,

      const IBluetoothAudioProvider::LeAudioDeviceCapabilities& capabilities,

      uint8_t direction);

  std::optional<LeAudioAseConfigurationSetting>

  getRequirementMatchedAseConfigurationSettings(

      IBluetoothAudioProvider::LeAudioAseConfigurationSetting& setting,

      const IBluetoothAudioProvider::LeAudioConfigurationRequirement&

          requirement);

};



class LeAudioOffloadOutputAudioProvider : public LeAudioOffloadAudioProvider {