| /* |
| * Copyright (C) 2023 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #define LOG_TAG "AHAL_ModuleBluetooth" |
| |
| #include <android-base/logging.h> |
| |
| #include "BluetoothAudioSession.h" |
| #include "core-impl/ModuleBluetooth.h" |
| #include "core-impl/StreamBluetooth.h" |
| |
| using aidl::android::hardware::audio::common::SinkMetadata; |
| using aidl::android::hardware::audio::common::SourceMetadata; |
| using aidl::android::hardware::bluetooth::audio::ChannelMode; |
| using aidl::android::hardware::bluetooth::audio::PcmConfiguration; |
| using aidl::android::media::audio::common::AudioChannelLayout; |
| using aidl::android::media::audio::common::AudioConfigBase; |
| using aidl::android::media::audio::common::AudioDeviceDescription; |
| using aidl::android::media::audio::common::AudioDeviceType; |
| using aidl::android::media::audio::common::AudioFormatDescription; |
| using aidl::android::media::audio::common::AudioFormatType; |
| using aidl::android::media::audio::common::AudioIoFlags; |
| using aidl::android::media::audio::common::AudioOffloadInfo; |
| using aidl::android::media::audio::common::AudioPort; |
| using aidl::android::media::audio::common::AudioPortConfig; |
| using aidl::android::media::audio::common::AudioPortExt; |
| using aidl::android::media::audio::common::AudioProfile; |
| using aidl::android::media::audio::common::Int; |
| using aidl::android::media::audio::common::MicrophoneInfo; |
| using aidl::android::media::audio::common::PcmType; |
| using android::bluetooth::audio::aidl::BluetoothAudioPortAidl; |
| using android::bluetooth::audio::aidl::BluetoothAudioPortAidlIn; |
| using android::bluetooth::audio::aidl::BluetoothAudioPortAidlOut; |
| |
| // TODO(b/312265159) bluetooth audio should be in its own process |
| // Remove this and the shared_libs when that happens |
| extern "C" binder_status_t createIBluetoothAudioProviderFactory(); |
| |
| namespace aidl::android::hardware::audio::core { |
| |
| namespace { |
| |
| PcmType pcmTypeFromBitsPerSample(int8_t bitsPerSample) { |
| if (bitsPerSample == 8) |
| return PcmType::UINT_8_BIT; |
| else if (bitsPerSample == 16) |
| return PcmType::INT_16_BIT; |
| else if (bitsPerSample == 24) |
| return PcmType::INT_24_BIT; |
| else if (bitsPerSample == 32) |
| return PcmType::INT_32_BIT; |
| ALOGE("Unsupported bitsPerSample: %d", bitsPerSample); |
| return PcmType::DEFAULT; |
| } |
| |
| AudioChannelLayout channelLayoutFromChannelMode(ChannelMode mode) { |
| if (mode == ChannelMode::MONO) { |
| return AudioChannelLayout::make<AudioChannelLayout::layoutMask>( |
| AudioChannelLayout::LAYOUT_MONO); |
| } else if (mode == ChannelMode::STEREO || mode == ChannelMode::DUALMONO) { |
| return AudioChannelLayout::make<AudioChannelLayout::layoutMask>( |
| AudioChannelLayout::LAYOUT_STEREO); |
| } |
| ALOGE("Unsupported channel mode: %s", toString(mode).c_str()); |
| return AudioChannelLayout{}; |
| } |
| |
| } // namespace |
| |
| ModuleBluetooth::ModuleBluetooth(std::unique_ptr<Module::Configuration>&& config) |
| : Module(Type::BLUETOOTH, std::move(config)) { |
| // TODO(b/312265159) bluetooth audio should be in its own process |
| // Remove this and the shared_libs when that happens |
| binder_status_t status = createIBluetoothAudioProviderFactory(); |
| if (status != STATUS_OK) { |
| LOG(ERROR) << "Failed to create bluetooth audio provider factory. Status: " |
| << ::android::statusToString(status); |
| } |
| } |
| |
| ndk::ScopedAStatus ModuleBluetooth::getBluetoothA2dp( |
| std::shared_ptr<IBluetoothA2dp>* _aidl_return) { |
| *_aidl_return = getBtA2dp().getInstance(); |
| LOG(DEBUG) << __func__ << ": returning instance of IBluetoothA2dp: " << _aidl_return->get(); |
| return ndk::ScopedAStatus::ok(); |
| } |
| |
| ndk::ScopedAStatus ModuleBluetooth::getBluetoothLe(std::shared_ptr<IBluetoothLe>* _aidl_return) { |
| *_aidl_return = getBtLe().getInstance(); |
| LOG(DEBUG) << __func__ << ": returning instance of IBluetoothLe: " << _aidl_return->get(); |
| return ndk::ScopedAStatus::ok(); |
| } |
| |
| ChildInterface<BluetoothA2dp>& ModuleBluetooth::getBtA2dp() { |
| if (!mBluetoothA2dp) { |
| auto handle = ndk::SharedRefBase::make<BluetoothA2dp>(); |
| handle->registerHandler(std::bind(&ModuleBluetooth::bluetoothParametersUpdated, this)); |
| mBluetoothA2dp = handle; |
| } |
| return mBluetoothA2dp; |
| } |
| |
| ChildInterface<BluetoothLe>& ModuleBluetooth::getBtLe() { |
| if (!mBluetoothLe) { |
| auto handle = ndk::SharedRefBase::make<BluetoothLe>(); |
| handle->registerHandler(std::bind(&ModuleBluetooth::bluetoothParametersUpdated, this)); |
| mBluetoothLe = handle; |
| } |
| return mBluetoothLe; |
| } |
| |
| ModuleBluetooth::BtProfileHandles ModuleBluetooth::getBtProfileManagerHandles() { |
| return std::make_tuple(std::weak_ptr<IBluetooth>(), getBtA2dp().getPtr(), getBtLe().getPtr()); |
| } |
| |
| ndk::ScopedAStatus ModuleBluetooth::getMicMute(bool* _aidl_return __unused) { |
| LOG(DEBUG) << __func__ << ": is not supported"; |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| ndk::ScopedAStatus ModuleBluetooth::setMicMute(bool in_mute __unused) { |
| LOG(DEBUG) << __func__ << ": is not supported"; |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| ndk::ScopedAStatus ModuleBluetooth::setAudioPortConfig(const AudioPortConfig& in_requested, |
| AudioPortConfig* out_suggested, |
| bool* _aidl_return) { |
| auto fillConfig = [this](const AudioPort& port, AudioPortConfig* config) { |
| if (port.ext.getTag() == AudioPortExt::device) { |
| CachedProxy proxy; |
| auto status = findOrCreateProxy(port, proxy); |
| if (status.isOk()) { |
| const auto& pcmConfig = proxy.pcmConfig; |
| LOG(DEBUG) << "setAudioPortConfig: suggesting port config from " |
| << pcmConfig.toString(); |
| const auto pcmType = pcmTypeFromBitsPerSample(pcmConfig.bitsPerSample); |
| const auto channelMask = channelLayoutFromChannelMode(pcmConfig.channelMode); |
| if (pcmType != PcmType::DEFAULT && channelMask != AudioChannelLayout{}) { |
| config->format = |
| AudioFormatDescription{.type = AudioFormatType::PCM, .pcm = pcmType}; |
| config->channelMask = channelMask; |
| config->sampleRate = Int{.value = pcmConfig.sampleRateHz}; |
| config->flags = port.flags; |
| config->ext = port.ext; |
| return true; |
| } |
| } |
| } |
| return generateDefaultPortConfig(port, config); |
| }; |
| return Module::setAudioPortConfigImpl(in_requested, fillConfig, out_suggested, _aidl_return); |
| } |
| |
| ndk::ScopedAStatus ModuleBluetooth::checkAudioPatchEndpointsMatch( |
| const std::vector<AudioPortConfig*>& sources, const std::vector<AudioPortConfig*>& sinks) { |
| // Both sources and sinks must be non-empty, this is guaranteed by 'setAudioPatch'. |
| const bool isInput = sources[0]->ext.getTag() == AudioPortExt::device; |
| const int32_t devicePortId = isInput ? sources[0]->portId : sinks[0]->portId; |
| const auto proxyIt = mProxies.find(devicePortId); |
| if (proxyIt == mProxies.end()) return ndk::ScopedAStatus::ok(); |
| const auto& pcmConfig = proxyIt->second.pcmConfig; |
| const AudioPortConfig* mixPortConfig = isInput ? sinks[0] : sources[0]; |
| if (!StreamBluetooth::checkConfigParams( |
| pcmConfig, AudioConfigBase{.sampleRate = mixPortConfig->sampleRate->value, |
| .channelMask = *(mixPortConfig->channelMask), |
| .format = *(mixPortConfig->format)})) { |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| if (int32_t handle = mixPortConfig->ext.get<AudioPortExt::mix>().handle; handle > 0) { |
| mConnections.insert(std::pair(handle, devicePortId)); |
| } |
| return ndk::ScopedAStatus::ok(); |
| } |
| |
| void ModuleBluetooth::onExternalDeviceConnectionChanged(const AudioPort& audioPort, |
| bool connected) { |
| if (!connected) mProxies.erase(audioPort.id); |
| } |
| |
| ndk::ScopedAStatus ModuleBluetooth::createInputStream( |
| StreamContext&& context, const SinkMetadata& sinkMetadata, |
| const std::vector<MicrophoneInfo>& microphones, std::shared_ptr<StreamIn>* result) { |
| CachedProxy proxy; |
| RETURN_STATUS_IF_ERROR(fetchAndCheckProxy(context, proxy)); |
| return createStreamInstance<StreamInBluetooth>(result, std::move(context), sinkMetadata, |
| microphones, getBtProfileManagerHandles(), |
| proxy.ptr, proxy.pcmConfig); |
| } |
| |
| ndk::ScopedAStatus ModuleBluetooth::createOutputStream( |
| StreamContext&& context, const SourceMetadata& sourceMetadata, |
| const std::optional<AudioOffloadInfo>& offloadInfo, std::shared_ptr<StreamOut>* result) { |
| CachedProxy proxy; |
| RETURN_STATUS_IF_ERROR(fetchAndCheckProxy(context, proxy)); |
| return createStreamInstance<StreamOutBluetooth>(result, std::move(context), sourceMetadata, |
| offloadInfo, getBtProfileManagerHandles(), |
| proxy.ptr, proxy.pcmConfig); |
| } |
| |
| ndk::ScopedAStatus ModuleBluetooth::populateConnectedDevicePort(AudioPort* audioPort, |
| int32_t nextPortId) { |
| if (audioPort->ext.getTag() != AudioPortExt::device) { |
| LOG(ERROR) << __func__ << ": not a device port: " << audioPort->toString(); |
| return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); |
| } |
| if (!::aidl::android::hardware::bluetooth::audio::BluetoothAudioSession::IsAidlAvailable()) { |
| LOG(ERROR) << __func__ << ": IBluetoothAudioProviderFactory AIDL service not available"; |
| return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); |
| } |
| const auto& devicePort = audioPort->ext.get<AudioPortExt::device>(); |
| const auto& description = devicePort.device.type; |
| // This method must return an error when the device can not be connected. |
| // Since A2DP/LE status events are sent asynchronously, it is more reliable |
| // to attempt connecting to the BT stack rather than judge by the A2DP/LE status. |
| if (description.connection != AudioDeviceDescription::CONNECTION_BT_A2DP && |
| description.connection != AudioDeviceDescription::CONNECTION_BT_LE && |
| !(description.connection == AudioDeviceDescription::CONNECTION_WIRELESS && |
| description.type == AudioDeviceType::OUT_HEARING_AID)) { |
| LOG(ERROR) << __func__ << ": unsupported device type: " << audioPort->toString(); |
| return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); |
| } |
| CachedProxy proxy; |
| RETURN_STATUS_IF_ERROR(createProxy(*audioPort, nextPortId, proxy)); |
| // If the device is actually connected, it is configured by the BT stack. |
| // Provide the current configuration instead of all possible profiles. |
| const auto& pcmConfig = proxy.pcmConfig; |
| audioPort->profiles.clear(); |
| audioPort->profiles.push_back( |
| AudioProfile{.format = AudioFormatDescription{.type = AudioFormatType::PCM, |
| .pcm = pcmTypeFromBitsPerSample( |
| pcmConfig.bitsPerSample)}, |
| .channelMasks = std::vector<AudioChannelLayout>( |
| {channelLayoutFromChannelMode(pcmConfig.channelMode)}), |
| .sampleRates = std::vector<int>({pcmConfig.sampleRateHz})}); |
| LOG(DEBUG) << __func__ << ": " << audioPort->toString(); |
| return ndk::ScopedAStatus::ok(); |
| } |
| |
| ndk::ScopedAStatus ModuleBluetooth::onMasterMuteChanged(bool) { |
| LOG(DEBUG) << __func__ << ": is not supported"; |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| ndk::ScopedAStatus ModuleBluetooth::onMasterVolumeChanged(float) { |
| LOG(DEBUG) << __func__ << ": is not supported"; |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| int32_t ModuleBluetooth::getNominalLatencyMs(const AudioPortConfig& portConfig) { |
| const auto connectionsIt = mConnections.find(portConfig.ext.get<AudioPortExt::mix>().handle); |
| if (connectionsIt != mConnections.end()) { |
| const auto proxyIt = mProxies.find(connectionsIt->second); |
| if (proxyIt != mProxies.end()) { |
| auto proxy = proxyIt->second.ptr; |
| size_t dataIntervalUs = 0; |
| if (!proxy->getPreferredDataIntervalUs(dataIntervalUs)) { |
| LOG(WARNING) << __func__ << ": could not fetch preferred data interval"; |
| } |
| const bool isInput = portConfig.flags->getTag() == AudioIoFlags::input; |
| return isInput ? StreamInBluetooth::getNominalLatencyMs(dataIntervalUs) |
| : StreamOutBluetooth::getNominalLatencyMs(dataIntervalUs); |
| } |
| } |
| LOG(ERROR) << __func__ << ": no connection or proxy found for " << portConfig.toString(); |
| return Module::getNominalLatencyMs(portConfig); |
| } |
| |
| ndk::ScopedAStatus ModuleBluetooth::createProxy(const AudioPort& audioPort, int32_t instancePortId, |
| CachedProxy& proxy) { |
| const bool isInput = audioPort.flags.getTag() == AudioIoFlags::input; |
| proxy.ptr = isInput ? std::shared_ptr<BluetoothAudioPortAidl>( |
| std::make_shared<BluetoothAudioPortAidlIn>()) |
| : std::shared_ptr<BluetoothAudioPortAidl>( |
| std::make_shared<BluetoothAudioPortAidlOut>()); |
| const auto& devicePort = audioPort.ext.get<AudioPortExt::device>(); |
| const auto device = devicePort.device.type; |
| bool registrationSuccess = false; |
| for (int i = 0; i < kCreateProxyRetries && !registrationSuccess; ++i) { |
| registrationSuccess = proxy.ptr->registerPort(device); |
| usleep(kCreateProxyRetrySleepMs * 1000); |
| } |
| if (!registrationSuccess) { |
| LOG(ERROR) << __func__ << ": failed to register BT port for " << device.toString(); |
| return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); |
| } |
| if (!proxy.ptr->loadAudioConfig(proxy.pcmConfig)) { |
| LOG(ERROR) << __func__ << ": state=" << proxy.ptr->getState() |
| << ", failed to load audio config"; |
| return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); |
| } |
| mProxies.insert(std::pair(instancePortId, proxy)); |
| return ndk::ScopedAStatus::ok(); |
| } |
| |
| ndk::ScopedAStatus ModuleBluetooth::fetchAndCheckProxy(const StreamContext& context, |
| CachedProxy& proxy) { |
| const auto connectionsIt = mConnections.find(context.getMixPortHandle()); |
| if (connectionsIt != mConnections.end()) { |
| const auto proxyIt = mProxies.find(connectionsIt->second); |
| if (proxyIt != mProxies.end()) { |
| proxy = proxyIt->second; |
| mProxies.erase(proxyIt); |
| } |
| mConnections.erase(connectionsIt); |
| } |
| if (proxy.ptr != nullptr) { |
| if (!StreamBluetooth::checkConfigParams( |
| proxy.pcmConfig, AudioConfigBase{.sampleRate = context.getSampleRate(), |
| .channelMask = context.getChannelLayout(), |
| .format = context.getFormat()})) { |
| return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); |
| } |
| } |
| // Not having a proxy is OK, it may happen in VTS tests when streams are opened on unconnected |
| // mix ports. |
| return ndk::ScopedAStatus::ok(); |
| } |
| |
| ndk::ScopedAStatus ModuleBluetooth::findOrCreateProxy(const AudioPort& audioPort, |
| CachedProxy& proxy) { |
| if (auto proxyIt = mProxies.find(audioPort.id); proxyIt != mProxies.end()) { |
| proxy = proxyIt->second; |
| return ndk::ScopedAStatus::ok(); |
| } |
| return createProxy(audioPort, audioPort.id, proxy); |
| } |
| |
| } // namespace aidl::android::hardware::audio::core |
