mirror of
https://github.com/openharmony/multimedia_av_session.git
synced 2026-08-25 06:18:12 -04:00
xuhy
920 lines
36 KiB
C++
920 lines
36 KiB
C++
/*
|
|
* Copyright (c) 2022-2025 Huawei Device Co., Ltd.
|
|
* 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.
|
|
*/
|
|
|
|
#include "avcontroller_item.h"
|
|
#include "ipc_skeleton.h"
|
|
#include "avsession_errors.h"
|
|
#include "avsession_log.h"
|
|
#include "avsession_utils.h"
|
|
#include "avsession_pixel_map_adapter.h"
|
|
#include "avsession_trace.h"
|
|
#include "command_send_limit.h"
|
|
#include "avsession_utils.h"
|
|
#include "permission_checker.h"
|
|
#include "avsession_sysevent.h"
|
|
#include "avmedia_center_control_type.h"
|
|
#include "want_params.h"
|
|
#include "string_wrapper.h"
|
|
#include "bundle_status_adapter.h"
|
|
#include "stream_dfx_manager.h"
|
|
#include "audio_errors.h"
|
|
|
|
#if !defined(WINDOWS_PLATFORM) and !defined(MAC_PLATFORM) and !defined(IOS_PLATFORM)
|
|
#include <malloc.h>
|
|
#endif
|
|
|
|
namespace OHOS::AVSession {
|
|
AVControllerItem::AVControllerItem(pid_t pid, const sptr<AVSessionItem>& session, int32_t userId)
|
|
: pid_(pid), session_(session), userId_(userId)
|
|
{
|
|
#ifdef CAR_FEATURE_ENABLE
|
|
createTime_ = std::chrono::duration_cast<std::chrono::milliseconds>(
|
|
std::chrono::system_clock::now().time_since_epoch()).count();
|
|
#endif
|
|
std::lock_guard sessionLockGuard(sessionMutex_);
|
|
if (session_ != nullptr) {
|
|
sessionId_ = session_->GetSessionId();
|
|
}
|
|
}
|
|
|
|
AVControllerItem::~AVControllerItem()
|
|
{
|
|
}
|
|
|
|
int32_t AVControllerItem::GetUserId()
|
|
{
|
|
return userId_;
|
|
}
|
|
|
|
int32_t AVControllerItem::RegisterCallbackInner(const sptr<IRemoteObject>& callback)
|
|
{
|
|
std::lock_guard lockGuard(callbackMutex_);
|
|
SLOGD("do register callback for controller %{public}d", static_cast<int>(pid_));
|
|
if (pid_ == 0 && migrateProxyCallback_ != nullptr && callback != nullptr) {
|
|
callbackListForMigrate_[OHOS::IPCSkeleton::GetCallingPid()] = iface_cast<IAVControllerCallback>(callback);
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
callback_ = iface_cast<IAVControllerCallback>(callback);
|
|
CHECK_AND_RETURN_RET_LOG(callback_ != nullptr, AVSESSION_ERROR, "RegisterCallbackInner callback_ is nullptr");
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
int32_t AVControllerItem::RemoveCallbackForMigrate(pid_t pid)
|
|
{
|
|
std::lock_guard lockGuard(callbackMutex_);
|
|
SLOGI("remove migrate callback for %{public}d", static_cast<int32_t>(pid));
|
|
callbackListForMigrate_.erase(pid);
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
int32_t AVControllerItem::RegisterAVControllerCallback(const std::shared_ptr<AVControllerCallback> &callback)
|
|
{
|
|
std::lock_guard lockGuard(callbackMutex_);
|
|
innerCallback_ = callback;
|
|
CHECK_AND_RETURN_RET_LOG(innerCallback_ != nullptr, AVSESSION_ERROR, "RegisterCallbackInner callback_ is nullptr");
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
int32_t AVControllerItem::UnregisterAVControllerCallback()
|
|
{
|
|
std::lock_guard lockGuard(callbackMutex_);
|
|
SLOGI("UnregisterAVControllerCallback pid %{public}d", static_cast<int>(pid_));
|
|
innerCallback_ = nullptr;
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
int32_t AVControllerItem::RegisterMigrateAVSessionProxyCallback(
|
|
const std::function<int32_t(const std::string&, AAFwk::WantParams&)>& callback)
|
|
{
|
|
migrateProxyCallback_ = callback;
|
|
CHECK_AND_RETURN_RET_LOG(migrateProxyCallback_ != nullptr, AVSESSION_ERROR,
|
|
"RegisterMigrateAVSessionProxyCallback migrateProxyCallback_ is nullptr");
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
int32_t AVControllerItem::GetAVCallMetaData(AVCallMetaData& avCallMetaData)
|
|
{
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST, "session not exist");
|
|
avCallMetaData = session_->GetAVCallMetaData();
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
int32_t AVControllerItem::GetAVCallState(AVCallState& avCallState)
|
|
{
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST, "session not exist");
|
|
avCallState = session_->GetAVCallState();
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
// LCOV_EXCL_START
|
|
int32_t AVControllerItem::GetAVPlaybackState(AVPlaybackState& state)
|
|
{
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_SESSION_NOT_EXIST_LOCAL_GET, "session not exist", false),
|
|
"session not exist");
|
|
state = session_->GetPlaybackState();
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
// LCOV_EXCL_STOP
|
|
|
|
int32_t AVControllerItem::ReadImgForMetaData(AVMetaData& data)
|
|
{
|
|
if (!data.GetMetaMask().test(AVMetaData::META_KEY_MEDIA_IMAGE)) {
|
|
SLOGI("curNoImgFor:%{public}s", AVSessionUtils::GetAnonyTitle(data.GetTitle()).c_str());
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_SESSION_NOT_EXIST_LOCAL_SET, "SetImgForMetaData session not exist", false),
|
|
"SetImgForMetaData session not exist");
|
|
std::shared_ptr<AVSessionPixelMap> innerPixelMap = std::make_shared<AVSessionPixelMap>();
|
|
session_->ReadMetaDataImg(innerPixelMap);
|
|
data.SetMediaImage(innerPixelMap);
|
|
|
|
std::shared_ptr<AVSessionPixelMap> avQueuePixelMap = data.GetAVQueueImage();
|
|
session_->ReadMetaDataAVQueueImg(avQueuePixelMap);
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
int32_t AVControllerItem::GetAVMetaData(AVMetaData& data)
|
|
{
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_SESSION_NOT_EXIST_LOCAL_GET, "session not exist", false),
|
|
"session not exist");
|
|
data = session_->GetMetaDataWithoutImg();
|
|
int32_t ret = ReadImgForMetaData(data);
|
|
CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "ReadImgForMetaData with ret:%{public}d", ret);
|
|
if (data.GetMediaImage() != nullptr && !data.GetMediaImageUri().empty()) {
|
|
SLOGD("isFromSession %{public}d|%{public}d|%{public}s", isFromSession_, data.GetMediaImageTopic(),
|
|
AVSessionUtils::GetAnonyTitle(data.GetTitle()).c_str());
|
|
if (isFromSession_) {
|
|
data.GetMediaImage()->Clear();
|
|
} else {
|
|
return ERR_INVALID_PARAM;
|
|
}
|
|
}
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
void AVControllerItem::DoMetadataImgClean(AVMetaData& data)
|
|
{
|
|
std::lock_guard metaMaskLockGuard(metaMaskMutex_);
|
|
SLOGD("still clear media img in DoMetadataImgClean");
|
|
std::shared_ptr<AVSessionPixelMap> innerQueuePixelMap = data.GetAVQueueImage();
|
|
AVSessionPixelMapAdapter::CleanAVSessionPixelMap(innerQueuePixelMap);
|
|
SLOGD("ImgClean:%{public}d", data.GetMediaImageTopic());
|
|
std::shared_ptr<AVSessionPixelMap> innerMediaPixelMap = data.GetMediaImage();
|
|
AVSessionPixelMapAdapter::CleanAVSessionPixelMap(innerMediaPixelMap);
|
|
}
|
|
|
|
// LCOV_EXCL_START
|
|
int32_t AVControllerItem::GetAVQueueItems(std::vector<AVQueueItem>& items)
|
|
{
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_SESSION_NOT_EXIST_LOCAL_GET, "session not exist", false),
|
|
"session not exist");
|
|
items = session_->GetQueueItems();
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
int32_t AVControllerItem::GetAVQueueTitle(std::string& title)
|
|
{
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_SESSION_NOT_EXIST_LOCAL_GET, "session not exist", false),
|
|
"session not exist");
|
|
title = session_->GetQueueTitle();
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
int32_t AVControllerItem::SkipToQueueItem(int32_t& itemId)
|
|
{
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_SESSION_NOT_EXIST_LOCAL_SET, "session not exist", false),
|
|
"session not exist");
|
|
session_->HandleSkipToQueueItem(itemId);
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
int32_t AVControllerItem::GetExtras(AAFwk::WantParams& extras)
|
|
{
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_SESSION_NOT_EXIST_LOCAL_GET, "session not exist", false),
|
|
"session not exist");
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(CommandSendLimit::GetInstance().IsCommandSendEnable(
|
|
OHOS::IPCSkeleton::GetCallingPid()), ERR_COMMAND_SEND_EXCEED_MAX,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_COMMAND_SEND_EXCEED_MAX_LOCAL_GET,
|
|
"command send number exceed max", false), "command send number exceed max");
|
|
extras = session_->GetExtras();
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
int32_t AVControllerItem::GetExtrasWithEvent(const std::string& extraEvent, AAFwk::WantParams& extras)
|
|
{
|
|
if (migrateProxyCallback_ != nullptr) {
|
|
int32_t ret = migrateProxyCallback_(extraEvent, extras);
|
|
CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "extraEvent not support");
|
|
} else {
|
|
SLOGI("migrateProxyCallback_ function is nullptr");
|
|
}
|
|
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_SESSION_NOT_EXIST_LOCAL_GET, "session not exist", false),
|
|
"session not exist");
|
|
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
int32_t AVControllerItem::SendAVKeyEvent(const MMI::KeyEvent& keyEvent)
|
|
{
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_SESSION_NOT_EXIST_LOCAL_SET, "session not exist", false),
|
|
"session not exist");
|
|
session_->HandleMediaKeyEvent(keyEvent);
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
int32_t AVControllerItem::GetLaunchAbility(AbilityRuntime::WantAgent::WantAgent& ability)
|
|
{
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_SESSION_NOT_EXIST_LOCAL_GET, "session not exist", false),
|
|
"session not exist");
|
|
ability = session_->GetLaunchAbility();
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
int32_t AVControllerItem::GetValidCommands(std::vector<int32_t>& cmds)
|
|
{
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_SESSION_NOT_EXIST_LOCAL_GET, "session not exist", false),
|
|
"session not exist");
|
|
cmds = session_->GetSupportCommand();
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
// LCOV_EXCL_STOP
|
|
|
|
int32_t AVControllerItem::IsSessionActive(bool& isActive)
|
|
{
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_SESSION_NOT_EXIST_LOCAL_GET, "session not exist", false),
|
|
"session not exist");
|
|
isActive = session_->IsActive();
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
// LCOV_EXCL_START
|
|
int32_t AVControllerItem::SendControlCommand(const AVControlCommand& cmd)
|
|
{
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_SESSION_NOT_EXIST_LOCAL_SET, "session not exist", false),
|
|
"session not exist");
|
|
std::vector<int32_t> cmds = session_->GetSupportCommand();
|
|
if (std::find(cmds.begin(), cmds.end(), cmd.GetCommand()) == cmds.end()) {
|
|
SLOGE("The command that needs to be sent is not supported.");
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_COMMAND_NOT_SUPPORT_LOCAL_SET, "The command is not supported", false);
|
|
return ERR_COMMAND_NOT_SUPPORT;
|
|
}
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(CommandSendLimit::GetInstance().IsCommandSendEnable(
|
|
OHOS::IPCSkeleton::GetCallingPid()), ERR_COMMAND_SEND_EXCEED_MAX,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_COMMAND_SEND_EXCEED_MAX_LOCAL_SET,
|
|
"command send number exceed max", false), "command send number exceed max");
|
|
session_->ExecuteControllerCommand(cmd);
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
// LCOV_EXCL_STOP
|
|
|
|
int32_t AVControllerItem::SendCommonCommand(const std::string& commonCommand, const AAFwk::WantParams& commandArgs)
|
|
{
|
|
if (migrateProxyCallback_ != nullptr) {
|
|
int32_t ret = migrateProxyCallback_(commonCommand, const_cast<AAFwk::WantParams&>(commandArgs));
|
|
CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "extraEvent not support");
|
|
} else {
|
|
SLOGI("migrateProxyCallback_ function is nullptr");
|
|
}
|
|
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_SESSION_NOT_EXIST_LOCAL_SET, "Session not exist", false),
|
|
"Session not exist");
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(CommandSendLimit::GetInstance().IsCommandSendEnable(
|
|
OHOS::IPCSkeleton::GetCallingPid()), ERR_COMMAND_SEND_EXCEED_MAX,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_COMMAND_SEND_EXCEED_MAX_LOCAL_SET,
|
|
"common command send number exceed max", false), "common command send number exceed max");
|
|
session_->ExecueCommonCommand(commonCommand, commandArgs);
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
int32_t AVControllerItem::SendCustomData(const AAFwk::WantParams& data)
|
|
{
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_RETURN_RET_LOG(data.HasParam("customData"), AVSESSION_ERROR, "Params don't have customData");
|
|
auto value = data.GetParam("customData");
|
|
AAFwk::IString* stringValue = AAFwk::IString::Query(value);
|
|
CHECK_AND_RETURN_RET_LOG(stringValue != nullptr, AVSESSION_ERROR, "customData is an invalid string");
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_SESSION_NOT_EXIST_LOCAL_SET, "Session not exist", false),
|
|
"Session not exist");
|
|
session_->ExecuteCustomData(data);
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
// LCOV_EXCL_START
|
|
int32_t AVControllerItem::SetAVCallMetaFilter(const AVCallMetaData::AVCallMetaMaskType& filter)
|
|
{
|
|
std::lock_guard lockGuard(avCallMetaMaskMutex_);
|
|
avCallMetaMask_ = filter;
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
int32_t AVControllerItem::SetAVCallStateFilter(const AVCallState::AVCallStateMaskType& filter)
|
|
{
|
|
std::lock_guard lockGuard(avCallStateMaskMutex_);
|
|
avCallStateMask_ = filter;
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
int32_t AVControllerItem::SetMetaFilter(const AVMetaData::MetaMaskType& filter)
|
|
{
|
|
std::lock_guard lockGuard(metaMaskMutex_);
|
|
metaMask_ = filter;
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
int32_t AVControllerItem::GetMetaFilter(AVMetaData::MetaMaskType& filter)
|
|
{
|
|
std::lock_guard lockGuard(metaMaskMutex_);
|
|
filter = metaMask_;
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
int32_t AVControllerItem::SetPlaybackFilter(const AVPlaybackState::PlaybackStateMaskType& filter)
|
|
{
|
|
std::lock_guard lockGuard(playbackMaskMutex_);
|
|
playbackMask_ = filter;
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
int32_t AVControllerItem::GetPlaybackFilter(AVPlaybackState::PlaybackStateMaskType& filter)
|
|
{
|
|
std::lock_guard lockGuard(playbackMaskMutex_);
|
|
filter = playbackMask_;
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
// LCOV_EXCL_STOP
|
|
|
|
int32_t AVControllerItem::Destroy()
|
|
{
|
|
if (sessionId_ == "DEFAULT") {
|
|
SLOGE("controller create inside can not be destroy from outside");
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
SLOGI("controller destroyed for pid %{public}d", static_cast<int>(pid_));
|
|
{
|
|
std::lock_guard callbackLockGuard(callbackMutex_);
|
|
callback_ = nullptr;
|
|
innerCallback_ = nullptr;
|
|
}
|
|
|
|
{
|
|
std::lock_guard serviceCallbacklockGuard(serviceCallbackMutex_);
|
|
if (serviceCallback_) {
|
|
serviceCallback_(*this);
|
|
}
|
|
}
|
|
|
|
sptr<AVSessionItem> session;
|
|
{
|
|
std::lock_guard sessionLockGuard(sessionMutex_);
|
|
session = session_;
|
|
if (session != nullptr) {
|
|
session_ = nullptr;
|
|
sessionId_.clear();
|
|
}
|
|
}
|
|
|
|
if (session != nullptr) {
|
|
session->HandleControllerRelease(pid_);
|
|
}
|
|
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
int32_t AVControllerItem::DestroyWithoutReply()
|
|
{
|
|
SLOGI("do controller DestroyWithoutReply for pid %{public}d", static_cast<int>(pid_));
|
|
{
|
|
std::lock_guard callbackLockGuard(callbackMutex_);
|
|
innerCallback_ = nullptr;
|
|
callback_ = nullptr;
|
|
}
|
|
|
|
sptr<AVSessionItem> session;
|
|
{
|
|
std::lock_guard sessionLockGuard(sessionMutex_);
|
|
session = session_;
|
|
if (session != nullptr) {
|
|
sessionId_.clear();
|
|
session_ = nullptr;
|
|
}
|
|
}
|
|
|
|
if (session != nullptr) {
|
|
session->HandleControllerRelease(pid_);
|
|
}
|
|
|
|
return AVSESSION_SUCCESS;
|
|
}
|
|
|
|
// LCOV_EXCL_START
|
|
std::string AVControllerItem::GetSessionId()
|
|
{
|
|
std::lock_guard sessionLockGuard(sessionMutex_);
|
|
return sessionId_;
|
|
}
|
|
// LCOV_EXCL_STOP
|
|
|
|
AppExecFwk::ElementName AVControllerItem::GetElementOfSession()
|
|
{
|
|
std::lock_guard sessionLockGuard(sessionMutex_);
|
|
AppExecFwk::ElementName elementOfSession;
|
|
CHECK_AND_RETURN_RET_LOG(session_ != nullptr, elementOfSession, "session not exist");
|
|
elementOfSession.SetBundleName(session_->GetBundleName());
|
|
elementOfSession.SetAbilityName(session_->GetAbilityName());
|
|
return elementOfSession;
|
|
}
|
|
|
|
void AVControllerItem::HandleSessionDestroy()
|
|
{
|
|
{
|
|
std::lock_guard callbackLockGuard(callbackMutex_);
|
|
if (callback_ != nullptr) {
|
|
callback_->OnSessionDestroy();
|
|
}
|
|
if (innerCallback_ != nullptr) {
|
|
innerCallback_->OnSessionDestroy();
|
|
}
|
|
}
|
|
std::lock_guard sessionLockGuard(sessionMutex_);
|
|
session_ = nullptr;
|
|
sessionId_.clear();
|
|
}
|
|
|
|
// LCOV_EXCL_START
|
|
void AVControllerItem::HandleAVCallStateChange(const AVCallState& avCallState)
|
|
{
|
|
std::lock_guard callbackLockGuard(callbackMutex_);
|
|
AVCallState stateOut;
|
|
std::lock_guard avCallStateLockGuard(avCallStateMaskMutex_);
|
|
if (avCallState.CopyToByMask(avCallStateMask_, stateOut)) {
|
|
SLOGI("update avcall state");
|
|
AVSESSION_TRACE_SYNC_START("AVControllerItem::OnAVCallStateChange");
|
|
if (callback_ != nullptr) {
|
|
callback_->OnAVCallStateChange(stateOut);
|
|
}
|
|
if (innerCallback_ != nullptr) {
|
|
innerCallback_->OnAVCallStateChange(stateOut);
|
|
}
|
|
}
|
|
}
|
|
|
|
void AVControllerItem::HandleAVCallMetaDataChange(const AVCallMetaData& avCallMetaData)
|
|
{
|
|
std::lock_guard callbackLockGuard(callbackMutex_);
|
|
AVCallMetaData metaOut;
|
|
std::lock_guard avCallMetaDataMaskLockGuard(avCallMetaMaskMutex_);
|
|
if (avCallMetaData.CopyToByMask(avCallMetaMask_, metaOut)) {
|
|
if (avCallMetaMask_.test(AVCallMetaData::AVCALL_META_KEY_MEDIA_IMAGE)) {
|
|
std::shared_ptr<AVSessionPixelMap> innerPixelMap = nullptr;
|
|
if (metaOut.GetMediaImage() != nullptr && session_ != nullptr) {
|
|
innerPixelMap = metaOut.GetMediaImage();
|
|
session_->ReadMetaDataImg(innerPixelMap);
|
|
}
|
|
metaOut.SetMediaImage(innerPixelMap);
|
|
}
|
|
|
|
if (avCallMetaMask_.test(AVCallMetaData::AVCALL_META_KEY_NAME)) {
|
|
metaOut.SetName(avCallMetaData.GetName());
|
|
}
|
|
|
|
if (avCallMetaMask_.test(AVCallMetaData::AVCALL_META_KEY_PHONE_NUMBER)) {
|
|
metaOut.SetPhoneNumber(avCallMetaData.GetPhoneNumber());
|
|
}
|
|
SLOGI("update avcall meta data");
|
|
}
|
|
|
|
if (callback_ != nullptr) {
|
|
callback_->OnAVCallMetaDataChange(metaOut);
|
|
}
|
|
if (innerCallback_ != nullptr) {
|
|
innerCallback_->OnAVCallMetaDataChange(metaOut);
|
|
}
|
|
AVSESSION_TRACE_SYNC_START("AVControllerItem::OnAVCallMetaDataChange");
|
|
}
|
|
|
|
void AVControllerItem::HandlePlaybackStateChange(const AVPlaybackState& state,
|
|
const AVPlaybackState::PlaybackStateMaskType& changedStateMask)
|
|
{
|
|
std::lock_guard callbackLockGuard(callbackMutex_);
|
|
AVPlaybackState stateOut;
|
|
std::lock_guard playbackLockGuard(playbackMaskMutex_);
|
|
AVPlaybackState::PlaybackStateMaskType validMask = playbackMask_.all() ? playbackMask_ :
|
|
changedStateMask & playbackMask_;
|
|
if (state.CopyToByMask(validMask, stateOut)) {
|
|
AVSESSION_TRACE_SYNC_START("AVControllerItem::OnPlaybackStateChange");
|
|
if (callback_ != nullptr) {
|
|
callback_->OnPlaybackStateChange(stateOut);
|
|
}
|
|
if (innerCallback_ != nullptr) {
|
|
innerCallback_->OnPlaybackStateChange(stateOut);
|
|
}
|
|
for (const auto& [pid, listener] : callbackListForMigrate_) {
|
|
CHECK_AND_CONTINUE(listener != nullptr);
|
|
listener->OnPlaybackStateChange(stateOut);
|
|
}
|
|
}
|
|
}
|
|
|
|
void AVControllerItem::HandleMetaDataChange(const AVMetaData& data, const AVMetaData::MetaMaskType& changedDataMask)
|
|
{
|
|
sptr<IAVControllerCallback> callback;
|
|
std::shared_ptr<AVControllerCallback> innerCallback;
|
|
{
|
|
std::lock_guard callbackLockGuard(callbackMutex_);
|
|
callback = callback_;
|
|
innerCallback = innerCallback_;
|
|
}
|
|
sptr<AVSessionItem> session;
|
|
{
|
|
std::lock_guard sessionLockGuard(sessionMutex_);
|
|
session = session_;
|
|
}
|
|
AVMetaData metaOut;
|
|
std::lock_guard metaMaskLockGuard(metaMaskMutex_);
|
|
AVMetaData::MetaMaskType validMask = metaMask_.all() ? metaMask_ : changedDataMask & metaMask_;
|
|
bool copyResult = data.CopyToByMask(validMask, metaOut);
|
|
CHECK_AND_PRINT_LOG(copyResult, "controller:%{public}d no mask", static_cast<int>(pid_));
|
|
if (copyResult) {
|
|
if ((metaMask_.test(AVMetaData::META_KEY_MEDIA_IMAGE)) && (metaOut.GetMediaImage() != nullptr)) {
|
|
CHECK_AND_RETURN_LOG(session != nullptr, "Session not exist");
|
|
std::shared_ptr<AVSessionPixelMap> innerPixelMap = metaOut.GetMediaImage();
|
|
session->ReadMetaDataImg(innerPixelMap);
|
|
metaOut.SetMediaImage(innerPixelMap);
|
|
}
|
|
if ((metaMask_.test(AVMetaData::META_KEY_AVQUEUE_IMAGE)) && (metaOut.GetAVQueueImage() != nullptr)) {
|
|
CHECK_AND_RETURN_LOG(session != nullptr, "Session not exist");
|
|
std::shared_ptr<AVSessionPixelMap> avQueuePixelMap = metaOut.GetAVQueueImage();
|
|
session->ReadMetaDataAVQueueImg(avQueuePixelMap);
|
|
metaOut.SetAVQueueImage(avQueuePixelMap);
|
|
}
|
|
metaOut.SetAssetId(data.GetAssetId());
|
|
SLOGI("update metaData pid %{public}d, title %{public}s", static_cast<int>(pid_),
|
|
AVSessionUtils::GetAnonyTitle(metaOut.GetTitle()).c_str());
|
|
AVSESSION_TRACE_SYNC_START("AVControllerItem::OnMetaDataChange");
|
|
if (metaOut.GetMediaImage() != nullptr && !metaOut.GetMediaImageUri().empty()) {
|
|
SLOGI("isFromSession %{public}d in metaChange", isFromSession_);
|
|
if (isFromSession_) {
|
|
metaOut.GetMediaImage()->Clear();
|
|
} else {
|
|
metaOut.SetMediaImageUri("");
|
|
}
|
|
}
|
|
if (callback != nullptr) {
|
|
callback->OnMetaDataChange(metaOut);
|
|
}
|
|
if (innerCallback != nullptr) {
|
|
innerCallback->OnMetaDataChange(metaOut);
|
|
}
|
|
DealMetaDataChangeForMigrate(metaOut);
|
|
}
|
|
std::shared_ptr<AVSessionPixelMap> innerQueuePixelMap = metaOut.GetAVQueueImage();
|
|
if (innerQueuePixelMap != nullptr) {
|
|
innerQueuePixelMap->Clear();
|
|
}
|
|
std::shared_ptr<AVSessionPixelMap> innerMediaPixelMap = metaOut.GetMediaImage();
|
|
if (innerMediaPixelMap != nullptr) {
|
|
innerMediaPixelMap->Clear();
|
|
}
|
|
}
|
|
|
|
void AVControllerItem::DealMetaDataChangeForMigrate(const AVMetaData& data)
|
|
{
|
|
std::lock_guard lockGuard(callbackMutex_);
|
|
for (const auto& [pid, listener] : callbackListForMigrate_) {
|
|
CHECK_AND_CONTINUE(listener != nullptr);
|
|
listener->OnMetaDataChange(data);
|
|
}
|
|
}
|
|
|
|
void AVControllerItem::HandleOutputDeviceChange(const int32_t connectionState, const OutputDeviceInfo& outputDeviceInfo)
|
|
{
|
|
std::lock_guard lockGuard(callbackMutex_);
|
|
if (callback_ != nullptr) {
|
|
callback_->OnOutputDeviceChange(connectionState, outputDeviceInfo);
|
|
}
|
|
}
|
|
// LCOV_EXCL_STOP
|
|
|
|
void AVControllerItem::HandleActiveStateChange(bool isActive)
|
|
{
|
|
std::lock_guard lockGuard(callbackMutex_);
|
|
if (callback_ != nullptr) {
|
|
callback_->OnActiveStateChange(isActive);
|
|
}
|
|
}
|
|
|
|
// LCOV_EXCL_START
|
|
void AVControllerItem::HandleValidCommandChange(const std::vector<int32_t>& cmds)
|
|
{
|
|
std::lock_guard lockGuard(callbackMutex_);
|
|
SLOGD("do OnValidCommandChange with pid %{public}d cmd list size %{public}d",
|
|
static_cast<int>(pid_), static_cast<int>(cmds.size()));
|
|
if (callback_ != nullptr) {
|
|
callback_->OnValidCommandChange(cmds);
|
|
}
|
|
if (innerCallback_ != nullptr) {
|
|
innerCallback_->OnValidCommandChange(cmds);
|
|
}
|
|
for (const auto& [pid, listener] : callbackListForMigrate_) {
|
|
CHECK_AND_CONTINUE(listener != nullptr);
|
|
listener->OnValidCommandChange(cmds);
|
|
}
|
|
}
|
|
// LCOV_EXCL_STOP
|
|
|
|
void AVControllerItem::HandleSetSessionEvent(const std::string& event, const AAFwk::WantParams& args)
|
|
{
|
|
std::lock_guard lockGuard(callbackMutex_);
|
|
if (callback_ != nullptr) {
|
|
callback_->OnSessionEventChange(event, args);
|
|
}
|
|
for (const auto& [pid, listener] : callbackListForMigrate_) {
|
|
CHECK_AND_CONTINUE(listener != nullptr);
|
|
listener->OnSessionEventChange(event, args);
|
|
}
|
|
}
|
|
|
|
// LCOV_EXCL_START
|
|
void AVControllerItem::HandleQueueItemsChange(const std::vector<AVQueueItem>& items)
|
|
{
|
|
std::lock_guard lockGuard(callbackMutex_);
|
|
AVSESSION_TRACE_SYNC_START("AVControllerItem::OnQueueItemsChange");
|
|
if (callback_ != nullptr) {
|
|
callback_->OnQueueItemsChange(items);
|
|
}
|
|
}
|
|
|
|
void AVControllerItem::HandleQueueTitleChange(const std::string& title)
|
|
{
|
|
std::lock_guard lockGuard(callbackMutex_);
|
|
AVSESSION_TRACE_SYNC_START("AVControllerItem::OnQueueTitleChange");
|
|
if (callback_ != nullptr) {
|
|
callback_->OnQueueTitleChange(title);
|
|
}
|
|
}
|
|
|
|
void AVControllerItem::HandleExtrasChange(const AAFwk::WantParams& extras)
|
|
{
|
|
std::lock_guard lockGuard(callbackMutex_);
|
|
AVSESSION_TRACE_SYNC_START("AVControllerItem::OnSetExtras");
|
|
if (callback_ != nullptr) {
|
|
callback_->OnExtrasChange(extras);
|
|
}
|
|
}
|
|
|
|
int32_t AVControllerItem::GetMediaCenterControlType(std::vector<int32_t>& controlTypes)
|
|
{
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_SESSION_NOT_EXIST_LOCAL_GET, "session not exist", false),
|
|
"session not exist");
|
|
return session_->GetMediaCenterControlType(controlTypes);
|
|
}
|
|
|
|
void AVControllerItem::HandleMediaCenterControlTypeChange(const std::vector<int32_t>& controlTypes)
|
|
{
|
|
std::lock_guard lockGuard(callbackMutex_);
|
|
SLOGI("HandleMediaCenterControlTypeChange size=%{public}zu", controlTypes.size());
|
|
if (callback_ != nullptr) {
|
|
callback_->OnMediaCenterControlTypeChanged(controlTypes);
|
|
}
|
|
if (innerCallback_ != nullptr) {
|
|
innerCallback_->OnMediaCenterControlTypeChanged(controlTypes);
|
|
}
|
|
}
|
|
|
|
int32_t AVControllerItem::GetSupportedPlaySpeeds(std::vector<double>& speeds)
|
|
{
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_SESSION_NOT_EXIST_LOCAL_GET, "session not exist", false),
|
|
"session not exist");
|
|
return session_->GetSupportedPlaySpeeds(speeds);
|
|
}
|
|
|
|
int32_t AVControllerItem::GetSupportedLoopModes(std::vector<int32_t>& loopModes)
|
|
{
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_SESSION_NOT_EXIST_LOCAL_GET, "session not exist", false),
|
|
"session not exist");
|
|
return session_->GetSupportedLoopModes(loopModes);
|
|
}
|
|
|
|
void AVControllerItem::HandleSupportedPlaySpeedsChange(const std::vector<double>& speeds)
|
|
{
|
|
std::lock_guard lockGuard(callbackMutex_);
|
|
SLOGI("HandleSupportedPlaySpeedsChange size=%{public}zu", speeds.size());
|
|
if (callback_ != nullptr) {
|
|
callback_->OnSupportedPlaySpeedsChanged(speeds);
|
|
}
|
|
if (innerCallback_ != nullptr) {
|
|
innerCallback_->OnSupportedPlaySpeedsChanged(speeds);
|
|
}
|
|
}
|
|
|
|
void AVControllerItem::HandleSupportedLoopModesChange(const std::vector<int32_t>& loopModes)
|
|
{
|
|
std::lock_guard lockGuard(callbackMutex_);
|
|
SLOGI("HandleSupportedLoopModesChange size=%{public}zu", loopModes.size());
|
|
if (callback_ != nullptr) {
|
|
callback_->OnSupportedLoopModesChanged(loopModes);
|
|
}
|
|
if (innerCallback_ != nullptr) {
|
|
innerCallback_->OnSupportedLoopModesChanged(loopModes);
|
|
}
|
|
}
|
|
// LCOV_EXCL_STOP
|
|
|
|
void AVControllerItem::HandleCustomData(const AAFwk::WantParams& data)
|
|
{
|
|
std::lock_guard lockGuard(callbackMutex_);
|
|
AVSESSION_TRACE_SYNC_START("AVControllerItem::OnCustomData");
|
|
if (callback_ != nullptr) {
|
|
callback_->OnCustomData(data);
|
|
}
|
|
}
|
|
|
|
void AVControllerItem::HandleDesktopLyricVisibilityChanged(bool isVisible)
|
|
{
|
|
std::lock_guard lockGuard(callbackMutex_);
|
|
AVSESSION_TRACE_SYNC_START("AVControllerItem::OnDesktopLyricVisibilityChanged");
|
|
if (callback_ != nullptr) {
|
|
callback_->OnDesktopLyricVisibilityChanged(isVisible);
|
|
}
|
|
}
|
|
|
|
void AVControllerItem::HandleDesktopLyricStateChanged(const DesktopLyricState &state)
|
|
{
|
|
std::lock_guard lockGuard(callbackMutex_);
|
|
AVSESSION_TRACE_SYNC_START("AVControllerItem::OnDesktopLyricStateChanged");
|
|
if (callback_ != nullptr) {
|
|
callback_->OnDesktopLyricStateChanged(state);
|
|
}
|
|
}
|
|
|
|
void AVControllerItem::HandleDesktopLyricEnabled(bool isEnabled)
|
|
{
|
|
std::lock_guard lockGuard(callbackMutex_);
|
|
AVSESSION_TRACE_SYNC_START("AVControllerItem::HandleDesktopLyricEnabled");
|
|
if (callback_ != nullptr) {
|
|
callback_->OnDesktopLyricEnabled(isEnabled);
|
|
}
|
|
}
|
|
|
|
pid_t AVControllerItem::GetPid() const
|
|
{
|
|
return pid_;
|
|
}
|
|
|
|
bool AVControllerItem::HasSession(const std::string& sessionId)
|
|
{
|
|
std::lock_guard sessionLockGuard(sessionMutex_);
|
|
return sessionId_ == sessionId;
|
|
}
|
|
|
|
void AVControllerItem::SetServiceCallbackForRelease(const std::function<void(AVControllerItem&)>& callback)
|
|
{
|
|
std::lock_guard lockGuard(serviceCallbackMutex_);
|
|
serviceCallback_ = callback;
|
|
}
|
|
|
|
std::string AVControllerItem::GetSessionType()
|
|
{
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_RETURN_RET_LOG(session_ != nullptr, "SESSION_NULL", "session not exist");
|
|
std::string sessionTypeStr = session_->GetSessionType();
|
|
return sessionTypeStr;
|
|
}
|
|
|
|
AVSessionDescriptor AVControllerItem::GetSessionDescriptor()
|
|
{
|
|
#ifdef CAR_FEATURE_ENABLE
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_RETURN_RET_LOG(session_ != nullptr, AVSessionDescriptor(), "session not exist");
|
|
return session_->GetDescriptor();
|
|
#else
|
|
return AVSessionDescriptor();
|
|
#endif
|
|
}
|
|
|
|
int32_t AVControllerItem::IsDesktopLyricEnabled(bool &isEnabled)
|
|
{
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_SESSION_NOT_EXIST_LOCAL_GET, "session not exist", false),
|
|
"session not exist");
|
|
return session_->IsDesktopLyricEnabled(isEnabled);
|
|
}
|
|
|
|
int32_t AVControllerItem::SetDesktopLyricVisible(bool isVisible)
|
|
{
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_SESSION_NOT_EXIST_LOCAL_SET, "session not exist", false),
|
|
"session not exist");
|
|
std::string callingBundleName = BundleStatusAdapter::GetInstance().GetBundleNameFromUid(GetCallingUid());
|
|
SLOGI("controller call");
|
|
return session_->SetDesktopLyricVisibleInner(isVisible, callingBundleName);
|
|
}
|
|
|
|
int32_t AVControllerItem::IsDesktopLyricVisible(bool &isVisible)
|
|
{
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_SESSION_NOT_EXIST_LOCAL_GET, "session not exist", false),
|
|
"session not exist");
|
|
return session_->IsDesktopLyricVisible(isVisible);
|
|
}
|
|
|
|
int32_t AVControllerItem::SetDesktopLyricState(DesktopLyricState state)
|
|
{
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_SESSION_NOT_EXIST_LOCAL_SET, "session not exist", false),
|
|
"session not exist");
|
|
std::string callingBundleName = BundleStatusAdapter::GetInstance().GetBundleNameFromUid(GetCallingUid());
|
|
SLOGI("controller call");
|
|
return session_->SetDesktopLyricStateInner(state, callingBundleName);
|
|
}
|
|
|
|
int32_t AVControllerItem::GetDesktopLyricState(DesktopLyricState &state)
|
|
{
|
|
std::lock_guard lockGuard(sessionMutex_);
|
|
CHECK_AND_CALL_FUNC_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST,
|
|
AudioStandard::StreamDfxManager::GetInstance().SendAudioErrorEvent(static_cast<int32_t>(getuid()),
|
|
AudioStandard::AVSESSION_CONTROL_SESSION_NOT_EXIST_LOCAL_GET, "session not exist", false),
|
|
"session not exist");
|
|
return session_->GetDesktopLyricState(state);
|
|
}
|
|
} // namespace OHOS::AVSession
|