311 lines
12 KiB
C++
311 lines
12 KiB
C++
/*
|
|
* Copyright (C) 2022 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 "BTAudioProviderStub"
|
|
|
|
#include "BluetoothAudioProvider.h"
|
|
|
|
#include <BluetoothAudioSessionReport.h>
|
|
#include <android-base/logging.h>
|
|
|
|
#include "A2dpOffloadCodecFactory.h"
|
|
|
|
namespace aidl {
|
|
namespace android {
|
|
namespace hardware {
|
|
namespace bluetooth {
|
|
namespace audio {
|
|
|
|
struct BluetoothAudioProviderContext {
|
|
SessionType session_type;
|
|
};
|
|
|
|
static void binderUnlinkedCallbackAidl(void* cookie) {
|
|
LOG(INFO) << __func__;
|
|
BluetoothAudioProviderContext* ctx =
|
|
static_cast<BluetoothAudioProviderContext*>(cookie);
|
|
delete ctx;
|
|
}
|
|
|
|
static void binderDiedCallbackAidl(void* cookie) {
|
|
LOG(INFO) << __func__;
|
|
BluetoothAudioProviderContext* ctx =
|
|
static_cast<BluetoothAudioProviderContext*>(cookie);
|
|
CHECK_NE(ctx, nullptr);
|
|
|
|
BluetoothAudioSessionReport::OnSessionEnded(ctx->session_type);
|
|
}
|
|
|
|
BluetoothAudioProvider::BluetoothAudioProvider() {
|
|
death_recipient_ = ::ndk::ScopedAIBinder_DeathRecipient(
|
|
AIBinder_DeathRecipient_new(binderDiedCallbackAidl));
|
|
AIBinder_DeathRecipient_setOnUnlinked(death_recipient_.get(),
|
|
binderUnlinkedCallbackAidl);
|
|
}
|
|
|
|
ndk::ScopedAStatus BluetoothAudioProvider::startSession(
|
|
const std::shared_ptr<IBluetoothAudioPort>& host_if,
|
|
const AudioConfiguration& audio_config,
|
|
const std::vector<LatencyMode>& latencyModes,
|
|
DataMQDesc* _aidl_return) {
|
|
if (host_if == nullptr) {
|
|
*_aidl_return = DataMQDesc();
|
|
LOG(ERROR) << __func__ << " - SessionType=" << toString(session_type_)
|
|
<< " Illegal argument";
|
|
return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
|
|
}
|
|
|
|
latency_modes_ = latencyModes;
|
|
audio_config_ = std::make_unique<AudioConfiguration>(audio_config);
|
|
stack_iface_ = host_if;
|
|
BluetoothAudioProviderContext* cookie =
|
|
new BluetoothAudioProviderContext{session_type_};
|
|
|
|
AIBinder_linkToDeath(stack_iface_->asBinder().get(), death_recipient_.get(),
|
|
cookie);
|
|
|
|
LOG(INFO) << __func__ << " - SessionType=" << toString(session_type_);
|
|
onSessionReady(_aidl_return);
|
|
return ndk::ScopedAStatus::ok();
|
|
}
|
|
|
|
ndk::ScopedAStatus BluetoothAudioProvider::endSession() {
|
|
LOG(INFO) << __func__ << " - SessionType=" << toString(session_type_);
|
|
|
|
if (stack_iface_ != nullptr) {
|
|
BluetoothAudioSessionReport::OnSessionEnded(session_type_);
|
|
|
|
AIBinder_unlinkToDeath(stack_iface_->asBinder().get(),
|
|
death_recipient_.get(), this);
|
|
} else {
|
|
LOG(INFO) << __func__ << " - SessionType=" << toString(session_type_)
|
|
<< " has NO session";
|
|
}
|
|
|
|
stack_iface_ = nullptr;
|
|
audio_config_ = nullptr;
|
|
|
|
return ndk::ScopedAStatus::ok();
|
|
}
|
|
|
|
ndk::ScopedAStatus BluetoothAudioProvider::streamStarted(
|
|
BluetoothAudioStatus status) {
|
|
if (stack_iface_ != nullptr) {
|
|
LOG(INFO) << __func__ << " - SessionType=" << toString(session_type_)
|
|
<< ", status=" << toString(status);
|
|
BluetoothAudioSessionReport::ReportControlStatus(session_type_, true,
|
|
status);
|
|
} else {
|
|
LOG(WARNING) << __func__ << " - SessionType=" << toString(session_type_)
|
|
<< ", status=" << toString(status) << " has NO session";
|
|
}
|
|
|
|
return ndk::ScopedAStatus::ok();
|
|
}
|
|
|
|
ndk::ScopedAStatus BluetoothAudioProvider::streamSuspended(
|
|
BluetoothAudioStatus status) {
|
|
LOG(INFO) << __func__ << " - SessionType=" << toString(session_type_)
|
|
<< ", status=" << toString(status);
|
|
|
|
if (stack_iface_ != nullptr) {
|
|
BluetoothAudioSessionReport::ReportControlStatus(session_type_, false,
|
|
status);
|
|
} else {
|
|
LOG(WARNING) << __func__ << " - SessionType=" << toString(session_type_)
|
|
<< ", status=" << toString(status) << " has NO session";
|
|
}
|
|
return ndk::ScopedAStatus::ok();
|
|
}
|
|
|
|
ndk::ScopedAStatus BluetoothAudioProvider::updateAudioConfiguration(
|
|
const AudioConfiguration& audio_config) {
|
|
if (stack_iface_ == nullptr || audio_config_ == nullptr) {
|
|
LOG(INFO) << __func__ << " - SessionType=" << toString(session_type_)
|
|
<< " has NO session";
|
|
return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
|
|
}
|
|
|
|
if (audio_config.getTag() != audio_config_->getTag()) {
|
|
LOG(INFO) << __func__ << " - SessionType=" << toString(session_type_)
|
|
<< " audio config type is not match";
|
|
return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
|
|
}
|
|
|
|
audio_config_ = std::make_unique<AudioConfiguration>(audio_config);
|
|
BluetoothAudioSessionReport::ReportAudioConfigChanged(session_type_,
|
|
*audio_config_);
|
|
LOG(INFO) << __func__ << " - SessionType=" << toString(session_type_)
|
|
<< " | audio_config=" << audio_config.toString();
|
|
return ndk::ScopedAStatus::ok();
|
|
}
|
|
|
|
ndk::ScopedAStatus BluetoothAudioProvider::setLowLatencyModeAllowed(
|
|
bool allowed) {
|
|
if (stack_iface_ == nullptr) {
|
|
LOG(INFO) << __func__ << " - SessionType=" << toString(session_type_)
|
|
<< " has NO session";
|
|
return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
|
|
}
|
|
LOG(INFO) << __func__ << " - allowed " << allowed;
|
|
BluetoothAudioSessionReport::ReportLowLatencyModeAllowedChanged(
|
|
session_type_, allowed);
|
|
return ndk::ScopedAStatus::ok();
|
|
}
|
|
|
|
ndk::ScopedAStatus BluetoothAudioProvider::parseA2dpConfiguration(
|
|
[[maybe_unused]] const CodecId& codec_id,
|
|
[[maybe_unused]] const std::vector<uint8_t>& configuration,
|
|
[[maybe_unused]] CodecParameters* codec_parameters,
|
|
[[maybe_unused]] A2dpStatus* _aidl_return) {
|
|
LOG(INFO) << __func__ << " - SessionType=" << toString(session_type_)
|
|
<< " is illegal";
|
|
return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
|
|
}
|
|
|
|
ndk::ScopedAStatus BluetoothAudioProvider::getA2dpConfiguration(
|
|
[[maybe_unused]] const std::vector<A2dpRemoteCapabilities>&
|
|
remote_a2dp_capabilities,
|
|
[[maybe_unused]] const A2dpConfigurationHint& hint,
|
|
[[maybe_unused]] std::optional<audio::A2dpConfiguration>* _aidl_return) {
|
|
LOG(INFO) << __func__ << " - SessionType=" << toString(session_type_)
|
|
<< " is illegal";
|
|
|
|
return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
|
|
}
|
|
|
|
ndk::ScopedAStatus BluetoothAudioProvider::setCodecPriority(
|
|
const ::aidl::android::hardware::bluetooth::audio::CodecId& in_codecId,
|
|
int32_t in_priority) {
|
|
/* TODO: Implement */
|
|
(void)in_codecId;
|
|
(void)in_priority;
|
|
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
|
|
};
|
|
|
|
ndk::ScopedAStatus BluetoothAudioProvider::getLeAudioAseConfiguration(
|
|
const std::optional<std::vector<std::optional<
|
|
::aidl::android::hardware::bluetooth::audio::IBluetoothAudioProvider::
|
|
LeAudioDeviceCapabilities>>>& in_remoteSinkAudioCapabilities,
|
|
const std::optional<std::vector<std::optional<
|
|
::aidl::android::hardware::bluetooth::audio::IBluetoothAudioProvider::
|
|
LeAudioDeviceCapabilities>>>& in_remoteSourceAudioCapabilities,
|
|
const std::vector<
|
|
::aidl::android::hardware::bluetooth::audio::IBluetoothAudioProvider::
|
|
LeAudioConfigurationRequirement>& in_requirements,
|
|
std::vector<::aidl::android::hardware::bluetooth::audio::
|
|
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 BluetoothAudioProvider::getLeAudioAseQosConfiguration(
|
|
const ::aidl::android::hardware::bluetooth::audio::IBluetoothAudioProvider::
|
|
LeAudioAseQosConfigurationRequirement& in_qosRequirement,
|
|
::aidl::android::hardware::bluetooth::audio::IBluetoothAudioProvider::
|
|
LeAudioAseQosConfigurationPair* _aidl_return) {
|
|
/* TODO: Implement */
|
|
(void)in_qosRequirement;
|
|
(void)_aidl_return;
|
|
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
|
|
};
|
|
|
|
ndk::ScopedAStatus BluetoothAudioProvider::getLeAudioAseDatapathConfiguration(
|
|
const std::optional<::aidl::android::hardware::bluetooth::audio::
|
|
IBluetoothAudioProvider::StreamConfig>&
|
|
in_sinkConfig,
|
|
const std::optional<::aidl::android::hardware::bluetooth::audio::
|
|
IBluetoothAudioProvider::StreamConfig>&
|
|
in_sourceConfig,
|
|
::aidl::android::hardware::bluetooth::audio::IBluetoothAudioProvider::
|
|
LeAudioDataPathConfigurationPair* _aidl_return) {
|
|
/* TODO: Implement */
|
|
(void)in_sinkConfig;
|
|
(void)in_sourceConfig;
|
|
(void)_aidl_return;
|
|
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
|
|
}
|
|
|
|
ndk::ScopedAStatus BluetoothAudioProvider::onSinkAseMetadataChanged(
|
|
::aidl::android::hardware::bluetooth::audio::IBluetoothAudioProvider::
|
|
AseState in_state,
|
|
int32_t cigId, int32_t cisId,
|
|
const std::optional<std::vector<std::optional<
|
|
::aidl::android::hardware::bluetooth::audio::MetadataLtv>>>&
|
|
in_metadata) {
|
|
/* TODO: Implement */
|
|
(void)in_state;
|
|
(void)cigId;
|
|
(void)cisId;
|
|
(void)in_metadata;
|
|
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
|
|
};
|
|
|
|
ndk::ScopedAStatus BluetoothAudioProvider::onSourceAseMetadataChanged(
|
|
::aidl::android::hardware::bluetooth::audio::IBluetoothAudioProvider::
|
|
AseState in_state,
|
|
int32_t cigId, int32_t cisId,
|
|
const std::optional<std::vector<std::optional<
|
|
::aidl::android::hardware::bluetooth::audio::MetadataLtv>>>&
|
|
in_metadata) {
|
|
/* TODO: Implement */
|
|
(void)in_state;
|
|
(void)cigId;
|
|
(void)cisId;
|
|
(void)in_metadata;
|
|
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
|
|
};
|
|
|
|
ndk::ScopedAStatus BluetoothAudioProvider::getLeAudioBroadcastConfiguration(
|
|
const std::optional<std::vector<std::optional<
|
|
::aidl::android::hardware::bluetooth::audio::IBluetoothAudioProvider::
|
|
LeAudioDeviceCapabilities>>>& in_remoteSinkAudioCapabilities,
|
|
const ::aidl::android::hardware::bluetooth::audio::IBluetoothAudioProvider::
|
|
LeAudioBroadcastConfigurationRequirement& in_requirement,
|
|
::aidl::android::hardware::bluetooth::audio::IBluetoothAudioProvider::
|
|
LeAudioBroadcastConfigurationSetting* _aidl_return) {
|
|
/* TODO: Implement */
|
|
(void)in_remoteSinkAudioCapabilities;
|
|
(void)in_requirement;
|
|
(void)_aidl_return;
|
|
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
|
|
};
|
|
|
|
ndk::ScopedAStatus
|
|
BluetoothAudioProvider::getLeAudioBroadcastDatapathConfiguration(
|
|
const ::aidl::android::hardware::bluetooth::audio::AudioContext& in_context,
|
|
const std::vector<::aidl::android::hardware::bluetooth::audio::
|
|
LeAudioBroadcastConfiguration::BroadcastStreamMap>&
|
|
in_streamMap,
|
|
::aidl::android::hardware::bluetooth::audio::IBluetoothAudioProvider::
|
|
LeAudioDataPathConfiguration* _aidl_return) {
|
|
/* TODO: Implement */
|
|
(void)in_context;
|
|
(void)in_streamMap;
|
|
(void)_aidl_return;
|
|
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
|
|
}
|
|
|
|
} // namespace audio
|
|
} // namespace bluetooth
|
|
} // namespace hardware
|
|
} // namespace android
|
|
} // namespace aidl
|