audio: import aidl hal
* hardware/interfaces/audio/aidl/default/ at android-16.0.0_r1.
This commit is contained in:
Konsta
342
audio/bluetooth/ModuleBluetooth.cpp
Normal file
342
audio/bluetooth/ModuleBluetooth.cpp
Normal file
@@ -0,0 +1,342 @@
|
||||
/*
|
||||
* 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
|
||||
Reference in New Issue
Block a user