1 /* 2 * Copyright (C) 2022 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #define LOG_TAG "BTAudioProviderFactoryAIDL" 18 19 #include "BluetoothAudioProviderFactory.h" 20 21 #include <BluetoothAudioCodecs.h> 22 #include <android-base/logging.h> 23 24 #include "A2dpOffloadAudioProvider.h" 25 #include "A2dpSoftwareAudioProvider.h" 26 #include "BluetoothAudioProvider.h" 27 #include "HearingAidAudioProvider.h" 28 #include "LeAudioOffloadAudioProvider.h" 29 #include "LeAudioSoftwareAudioProvider.h" 30 31 namespace aidl { 32 namespace android { 33 namespace hardware { 34 namespace bluetooth { 35 namespace audio { 36 BluetoothAudioProviderFactory()37BluetoothAudioProviderFactory::BluetoothAudioProviderFactory() {} 38 openProvider(const SessionType session_type,std::shared_ptr<IBluetoothAudioProvider> * _aidl_return)39ndk::ScopedAStatus BluetoothAudioProviderFactory::openProvider( 40 const SessionType session_type, 41 std::shared_ptr<IBluetoothAudioProvider>* _aidl_return) { 42 LOG(INFO) << __func__ << " - SessionType=" << toString(session_type); 43 std::shared_ptr<BluetoothAudioProvider> provider = nullptr; 44 45 switch (session_type) { 46 case SessionType::A2DP_SOFTWARE_ENCODING_DATAPATH: 47 provider = ndk::SharedRefBase::make<A2dpSoftwareEncodingAudioProvider>(); 48 break; 49 case SessionType::A2DP_HARDWARE_OFFLOAD_ENCODING_DATAPATH: 50 provider = ndk::SharedRefBase::make<A2dpOffloadEncodingAudioProvider>(); 51 break; 52 case SessionType::HEARING_AID_SOFTWARE_ENCODING_DATAPATH: 53 provider = ndk::SharedRefBase::make<HearingAidAudioProvider>(); 54 break; 55 case SessionType::LE_AUDIO_SOFTWARE_ENCODING_DATAPATH: 56 provider = ndk::SharedRefBase::make<LeAudioSoftwareOutputAudioProvider>(); 57 break; 58 case SessionType::LE_AUDIO_HARDWARE_OFFLOAD_ENCODING_DATAPATH: 59 provider = ndk::SharedRefBase::make<LeAudioOffloadOutputAudioProvider>(); 60 break; 61 case SessionType::LE_AUDIO_SOFTWARE_DECODING_DATAPATH: 62 provider = ndk::SharedRefBase::make<LeAudioSoftwareInputAudioProvider>(); 63 break; 64 case SessionType::LE_AUDIO_HARDWARE_OFFLOAD_DECODING_DATAPATH: 65 provider = ndk::SharedRefBase::make<LeAudioOffloadInputAudioProvider>(); 66 break; 67 case SessionType::LE_AUDIO_BROADCAST_SOFTWARE_ENCODING_DATAPATH: 68 provider = 69 ndk::SharedRefBase::make<LeAudioSoftwareBroadcastAudioProvider>(); 70 break; 71 case SessionType::LE_AUDIO_BROADCAST_HARDWARE_OFFLOAD_ENCODING_DATAPATH: 72 provider = 73 ndk::SharedRefBase::make<LeAudioOffloadBroadcastAudioProvider>(); 74 break; 75 case SessionType::A2DP_SOFTWARE_DECODING_DATAPATH: 76 provider = ndk::SharedRefBase::make<A2dpSoftwareDecodingAudioProvider>(); 77 break; 78 case SessionType::A2DP_HARDWARE_OFFLOAD_DECODING_DATAPATH: 79 provider = ndk::SharedRefBase::make<A2dpOffloadDecodingAudioProvider>(); 80 break; 81 default: 82 provider = nullptr; 83 break; 84 } 85 86 if (provider == nullptr || !provider->isValid(session_type)) { 87 provider = nullptr; 88 LOG(ERROR) << __func__ << " - SessionType=" << toString(session_type); 89 return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); 90 } 91 *_aidl_return = provider; 92 93 return ndk::ScopedAStatus::ok(); 94 } 95 getProviderCapabilities(const SessionType session_type,std::vector<AudioCapabilities> * _aidl_return)96ndk::ScopedAStatus BluetoothAudioProviderFactory::getProviderCapabilities( 97 const SessionType session_type, 98 std::vector<AudioCapabilities>* _aidl_return) { 99 if (session_type == SessionType::A2DP_HARDWARE_OFFLOAD_ENCODING_DATAPATH || 100 session_type == SessionType::A2DP_HARDWARE_OFFLOAD_DECODING_DATAPATH) { 101 auto codec_capabilities = 102 BluetoothAudioCodecs::GetA2dpOffloadCodecCapabilities(session_type); 103 _aidl_return->resize(codec_capabilities.size()); 104 for (int i = 0; i < codec_capabilities.size(); i++) { 105 _aidl_return->at(i).set<AudioCapabilities::a2dpCapabilities>( 106 codec_capabilities[i]); 107 } 108 } else if (session_type == 109 SessionType::LE_AUDIO_HARDWARE_OFFLOAD_ENCODING_DATAPATH || 110 session_type == 111 SessionType::LE_AUDIO_HARDWARE_OFFLOAD_DECODING_DATAPATH || 112 session_type == 113 SessionType:: 114 LE_AUDIO_BROADCAST_HARDWARE_OFFLOAD_ENCODING_DATAPATH) { 115 std::vector<LeAudioCodecCapabilitiesSetting> db_codec_capabilities = 116 BluetoothAudioCodecs::GetLeAudioOffloadCodecCapabilities(session_type); 117 if (db_codec_capabilities.size()) { 118 _aidl_return->resize(db_codec_capabilities.size()); 119 for (int i = 0; i < db_codec_capabilities.size(); ++i) { 120 _aidl_return->at(i).set<AudioCapabilities::leAudioCapabilities>( 121 db_codec_capabilities[i]); 122 } 123 } 124 } else if (session_type != SessionType::UNKNOWN) { 125 auto pcm_capabilities = BluetoothAudioCodecs::GetSoftwarePcmCapabilities(); 126 _aidl_return->resize(pcm_capabilities.size()); 127 for (int i = 0; i < pcm_capabilities.size(); i++) { 128 _aidl_return->at(i).set<AudioCapabilities::pcmCapabilities>( 129 pcm_capabilities[i]); 130 } 131 } 132 133 LOG(INFO) << __func__ << " - SessionType=" << toString(session_type) 134 << " supports " << _aidl_return->size() << " codecs"; 135 return ndk::ScopedAStatus::ok(); 136 } 137 138 } // namespace audio 139 } // namespace bluetooth 140 } // namespace hardware 141 } // namespace android 142 } // namespace aidl