1 /*
2 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <sstream>
17 #include <iomanip>
18 #include <iostream>
19 #include <regex>
20
21 #include "accesstoken_kit.h"
22 #include "app_manager_adapter.h"
23 #include "audio_adapter.h"
24 #include "avsession_errors.h"
25 #include "avsession_log.h"
26 #include "avsession_info.h"
27 #include "device_manager.h"
28 #include "remote_session_capability_set.h"
29 #include "remote_session_source_proxy.h"
30 #include "remote_session_sink_proxy.h"
31 #include "file_ex.h"
32 #include "iservice_registry.h"
33 #include "key_event_adapter.h"
34 #include "nlohmann/json.hpp"
35 #include "permission_checker.h"
36 #include "system_ability_definition.h"
37 #include "session_stack.h"
38 #include "avsession_trace.h"
39 #include "hash_calculator.h"
40 #include "avsession_dumper.h"
41 #include "command_send_limit.h"
42 #include "avsession_sysevent.h"
43 #include "json_utils.h"
44 #include "avsession_utils.h"
45 #include "avcontrol_command.h"
46 #include "avsession_event_handler.h"
47 #include "bundle_status_adapter.h"
48 #include "params_config_operator.h"
49 #include "avsession_service.h"
50
51 #ifdef EFFICIENCY_MANAGER_ENABLE
52 #include "continuous_task_app_info.h"
53 #include "suspend_manager_client.h"
54 #endif
55
56 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
57 #include "av_router.h"
58 #endif
59
60 #if !defined(WINDOWS_PLATFORM) and !defined(MAC_PLATFORM) and !defined(IOS_PLATFORM)
61 #include <malloc.h>
62 #endif
63
64 using namespace std;
65 using namespace nlohmann;
66 using namespace OHOS::AudioStandard;
67
68 namespace OHOS::AVSession {
69 REGISTER_SYSTEM_ABILITY_BY_ID(AVSessionService, AVSESSION_SERVICE_ID, true);
70
AVSessionService(int32_t systemAbilityId,bool runOnCreate)71 AVSessionService::AVSessionService(int32_t systemAbilityId, bool runOnCreate)
72 : SystemAbility(systemAbilityId, runOnCreate)
73 {
74 SLOGD("construct");
75 }
76
~AVSessionService()77 AVSessionService::~AVSessionService()
78 {
79 std::string cachePath(AVSessionUtils::GetCachePathName());
80 AVSessionUtils::DeleteCacheFiles(cachePath);
81 SLOGD("destroy");
82 }
83
OnStart()84 void AVSessionService::OnStart()
85 {
86 std::string cachePath(AVSessionUtils::GetCachePathName());
87 AVSessionUtils::DeleteCacheFiles(cachePath);
88 CHECK_AND_RETURN_LOG(Publish(this), "publish avsession service failed");
89 dumpHelper_ = std::make_unique<AVSessionDumper>();
90 CHECK_AND_RETURN_LOG(dumpHelper_ != nullptr, "no memory");
91 CommandSendLimit::GetInstance().StartTimer();
92
93 ParamsConfigOperator::GetInstance().InitConfig();
94 auto ret = ParamsConfigOperator::GetInstance().GetValueIntByKey("historicalRecordMaxNum", &maxHistoryNums);
95 if (ret == AVSESSION_ERROR) {
96 maxHistoryNums = defMaxHistoryNum;
97 }
98
99 #ifdef ENABLE_BACKGROUND_AUDIO_CONTROL
100 backgroundAudioController_.Init(this);
101 AddInnerSessionListener(&backgroundAudioController_);
102 #endif
103
104 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
105 AVRouter::GetInstance().Init(this);
106 #endif
107
108 AddSystemAbilityListener(MULTIMODAL_INPUT_SERVICE_ID);
109 AddSystemAbilityListener(AUDIO_POLICY_SERVICE_ID);
110 AddSystemAbilityListener(APP_MGR_SERVICE_ID);
111 AddSystemAbilityListener(DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID);
112 AddSystemAbilityListener(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
113 HISYSEVENT_REGITER;
114 HISYSEVENT_BEHAVIOR("SESSION_SERVICE_START", "SERVICE_NAME", "AVSessionService",
115 "SERVICE_ID", AVSESSION_SERVICE_ID, "DETAILED_MSG", "avsession service start success");
116 }
117
OnDump()118 void AVSessionService::OnDump()
119 {
120 }
121
OnStop()122 void AVSessionService::OnStop()
123 {
124 CommandSendLimit::GetInstance().StopTimer();
125 }
126
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)127 void AVSessionService::OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId)
128 {
129 switch (systemAbilityId) {
130 case MULTIMODAL_INPUT_SERVICE_ID:
131 InitKeyEvent();
132 break;
133 case AUDIO_POLICY_SERVICE_ID:
134 InitAudio();
135 break;
136 case APP_MGR_SERVICE_ID:
137 InitAMS();
138 break;
139 case DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID:
140 InitDM();
141 break;
142 case BUNDLE_MGR_SERVICE_SYS_ABILITY_ID:
143 InitBMS();
144 break;
145 default:
146 SLOGE("undefined system ability %{public}d", systemAbilityId);
147 }
148 }
149
InitKeyEvent()150 void AVSessionService::InitKeyEvent()
151 {
152 SLOGI("enter");
153 std::vector<int32_t> keyCodes = {
154 MMI::KeyEvent::KEYCODE_MEDIA_PLAY_PAUSE,
155 MMI::KeyEvent::KEYCODE_MEDIA_STOP,
156 MMI::KeyEvent::KEYCODE_MEDIA_NEXT,
157 MMI::KeyEvent::KEYCODE_MEDIA_PREVIOUS,
158 MMI::KeyEvent::KEYCODE_MEDIA_REWIND,
159 MMI::KeyEvent::KEYCODE_MEDIA_FAST_FORWARD,
160 MMI::KeyEvent::KEYCODE_HEADSETHOOK,
161 };
162
163 KeyEventAdapter::GetInstance().SubscribeKeyEvent(
164 keyCodes, [this](const auto& keyEvent) { SendSystemAVKeyEvent(*keyEvent); });
165 }
166
UpdateTopSession(const sptr<AVSessionItem> & newTopSession)167 void AVSessionService::UpdateTopSession(const sptr<AVSessionItem>& newTopSession)
168 {
169 if (newTopSession == nullptr) {
170 std::lock_guard lockGuard(sessionAndControllerLock_);
171 if (topSession_ != nullptr) {
172 topSession_->SetTop(false);
173 }
174 topSession_ = nullptr;
175 SLOGI("set topSession to nullptr");
176 HISYSEVENT_BEHAVIOR("FOCUS_CHANGE", "DETAILED_MSG", "avsessionservice set topsession to nullptr");
177 return;
178 }
179
180 SLOGI("uid=%{public}d sessionId=%{public}s", newTopSession->GetUid(), newTopSession->GetSessionId().c_str());
181 AVSessionDescriptor descriptor;
182 {
183 std::lock_guard lockGuard(sessionAndControllerLock_);
184 if (topSession_ != nullptr) {
185 topSession_->SetTop(false);
186 HISYSEVENT_BEHAVIOR("FOCUS_CHANGE",
187 "OLD_BUNDLE_NAME", topSession_->GetDescriptor().elementName_.GetBundleName(),
188 "OLD_MODULE_NAME", topSession_->GetDescriptor().elementName_.GetModuleName(),
189 "OLD_ABILITY_NAME", topSession_->GetAbilityName(), "OLD_SESSION_PID", topSession_->GetPid(),
190 "OLD_SESSION_UID", topSession_->GetUid(), "OLD_SESSION_ID", topSession_->GetSessionId(),
191 "OLD_SESSION_TAG", topSession_->GetDescriptor().sessionTag_,
192 "OLD_SESSION_TYPE", topSession_->GetDescriptor().sessionType_,
193 "BUNDLE_NAME", newTopSession->GetDescriptor().elementName_.GetBundleName(),
194 "MODULE_NAME", newTopSession->GetDescriptor().elementName_.GetModuleName(),
195 "ABILITY_NAME", newTopSession->GetAbilityName(), "SESSION_PID", newTopSession->GetPid(),
196 "SESSION_UID", newTopSession->GetUid(), "SESSION_ID", newTopSession->GetSessionId(),
197 "SESSION_TAG", newTopSession->GetDescriptor().sessionTag_,
198 "SESSION_TYPE", newTopSession->GetDescriptor().sessionType_,
199 "DETAILED_MSG", "avsessionservice handlefocussession, updatetopsession");
200 }
201 topSession_ = newTopSession;
202 topSession_->SetTop(true);
203 descriptor = topSession_->GetDescriptor();
204 }
205 NotifyTopSessionChanged(descriptor);
206 }
207
HandleFocusSession(const FocusSessionStrategy::FocusSessionChangeInfo & info)208 void AVSessionService::HandleFocusSession(const FocusSessionStrategy::FocusSessionChangeInfo& info)
209 {
210 std::lock_guard lockGuard(sessionAndControllerLock_);
211 if (topSession_ && topSession_->GetUid() == info.uid) {
212 SLOGI("same session");
213 return;
214 }
215 for (const auto& session : GetContainer().GetAllSessions()) {
216 if (session->GetUid() == info.uid) {
217 UpdateTopSession(session);
218 return;
219 }
220 }
221 }
222
SelectFocusSession(const FocusSessionStrategy::FocusSessionChangeInfo & info)223 bool AVSessionService::SelectFocusSession(const FocusSessionStrategy::FocusSessionChangeInfo& info)
224 {
225 for (const auto& session : GetContainer().GetAllSessions()) {
226 if (session->GetDescriptor().sessionTag_ == "RemoteCast") {
227 SLOGI("Remote sessions do not need to be saved to history");
228 continue;
229 }
230 if (session->GetUid() != info.uid) {
231 continue;
232 }
233 std::lock_guard sortFileLockGuard(sortFileReadWriteLock_);
234 SLOGI("true");
235 std::string oldSortContent;
236 if (!LoadStringFromFileEx(AVSESSION_FILE_DIR + SORT_FILE_NAME, oldSortContent)) {
237 SLOGE("SelectFocusSession read sort fail !");
238 return true;
239 }
240 nlohmann::json values = json::parse(oldSortContent, nullptr, false);
241 CHECK_AND_RETURN_RET_LOG(!values.is_discarded(), true, "json object is null");
242 const std::string bundleNameTop = session->GetBundleName();
243 const std::string abilityNameTop = session->GetAbilityName();
244 for (auto value : values) {
245 if (bundleNameTop == value["bundleName"] &&
246 abilityNameTop == value["abilityName"]) {
247 values.erase(std::remove(values.begin(), values.end(), value));
248 break;
249 }
250 }
251 if (values.size() >= (size_t)maxHistoryNums) {
252 values.erase(values.end() - 1);
253 }
254 nlohmann::json value;
255 value["sessionId"] = session->GetSessionId();
256 value["bundleName"] = session->GetBundleName();
257 value["abilityName"] = session->GetAbilityName();
258 if (values.size() <= 0) {
259 values.push_back(value);
260 } else {
261 values.insert(values.begin(), value);
262 }
263 std::string newSortContent = values.dump();
264 SLOGD("SelectFocusSession::Dump json object finished");
265 if (!SaveStringToFileEx(AVSESSION_FILE_DIR + SORT_FILE_NAME, newSortContent)) {
266 SLOGE("SelectFocusSession save sort fail !");
267 }
268 return true;
269 }
270 SLOGI("false");
271 return false;
272 }
273
InitAudio()274 void AVSessionService::InitAudio()
275 {
276 SLOGI("enter");
277 AudioAdapter::GetInstance().Init();
278 focusSessionStrategy_.Init();
279 focusSessionStrategy_.RegisterFocusSessionChangeCallback([this] (const auto& info) {
280 HandleFocusSession(info);
281 });
282 focusSessionStrategy_.RegisterFocusSessionSelector([this] (const auto& info) {
283 return SelectFocusSession(info);
284 });
285 AudioAdapter::GetInstance().AddStreamRendererStateListener([this] (const AudioRendererChangeInfos& infos) {
286 OutputDeviceChangeListener(infos);
287 });
288 }
289
SelectSessionByUid(const AudioRendererChangeInfo & info)290 sptr <AVSessionItem> AVSessionService::SelectSessionByUid(const AudioRendererChangeInfo& info)
291 {
292 for (const auto& session : GetContainer().GetAllSessions()) {
293 if (session->GetUid() == info.clientUID) {
294 return session;
295 }
296 }
297 SLOGI("has no session");
298 return nullptr;
299 }
300
OutputDeviceChangeListener(const AudioRendererChangeInfos & infos)301 void AVSessionService::OutputDeviceChangeListener(const AudioRendererChangeInfos& infos)
302 {
303 for (const auto& info : infos) {
304 SLOGI("clientUID is %{public}d, rendererState is %{public}d, deviceId is %{public}d", info->clientUID,
305 static_cast<int32_t>(info->rendererState), info->outputDeviceInfo.deviceId);
306 }
307 }
308
InitAMS()309 void AVSessionService::InitAMS()
310 {
311 SLOGI("enter");
312 AppManagerAdapter::GetInstance().Init();
313 }
314
InitDM()315 void AVSessionService::InitDM()
316 {
317 SLOGI("enter");
318 auto callback = std::make_shared<AVSessionInitDMCallback>();
319 CHECK_AND_RETURN_LOG(callback != nullptr, "no memory");
320 int32_t ret = OHOS::DistributedHardware::DeviceManager::GetInstance().InitDeviceManager("av_session", callback);
321 CHECK_AND_RETURN_LOG(ret == 0, "InitDeviceManager error ret is %{public}d", ret);
322 }
323
InitBMS()324 void AVSessionService::InitBMS()
325 {
326 std::lock_guard sortFileLockGuard(sortFileReadWriteLock_);
327 SLOGI("enter");
328 BundleStatusAdapter::GetInstance().Init();
329 std::string oldSortContent;
330 if (LoadStringFromFileEx(AVSESSION_FILE_DIR + SORT_FILE_NAME, oldSortContent)) {
331 nlohmann::json values = json::parse(oldSortContent, nullptr, false);
332 CHECK_AND_RETURN_LOG(!values.is_discarded(), "json object is null");
333 auto callback = [this](std::string bundleName) {
334 DeleteHistoricalRecord(bundleName);
335 };
336 for (auto value : values) {
337 if (!BundleStatusAdapter::GetInstance().SubscribeBundleStatusEvent(value["bundleName"], callback)) {
338 std::string bundleName = value["bundleName"];
339 SLOGE("SubscribeBundleStatusEvent failed for bundle:%{public}s", bundleName.c_str());
340 }
341 }
342 }
343 }
344
GetContainer()345 SessionContainer& AVSessionService::GetContainer()
346 {
347 static SessionStack sessionStack;
348 return sessionStack;
349 }
350
AllocSessionId()351 std::string AVSessionService::AllocSessionId()
352 {
353 auto curNum = sessionSeqNum_++;
354 std::string id = std::to_string(GetCallingPid()) + "-" + std::to_string(GetCallingUid()) + "-" +
355 std::to_string(curNum);
356 SLOGI("%{public}s", id.c_str());
357
358 HashCalculator hashCalculator;
359 CHECK_AND_RETURN_RET_LOG(hashCalculator.Init() == AVSESSION_SUCCESS, "", "hash init failed");
360 CHECK_AND_RETURN_RET_LOG(hashCalculator.Update(std::vector<uint8_t>(id.begin(), id.end())) == AVSESSION_SUCCESS,
361 "", "hash update failed");
362 std::vector<uint8_t> hash;
363 CHECK_AND_RETURN_RET_LOG(hashCalculator.GetResult(hash) == AVSESSION_SUCCESS, "", "hash get result failed");
364
365 std::stringstream stream;
366 for (const auto byte : hash) {
367 stream << std::uppercase << std::hex << std::setfill('0') << std::setw(allocSpace) << static_cast<int>(byte);
368 }
369 return stream.str();
370 }
371
AbilityHasSession(pid_t pid)372 bool AVSessionService::AbilityHasSession(pid_t pid)
373 {
374 std::lock_guard lockGuard(sessionAndControllerLock_);
375 return GetContainer().PidHasSession(pid);
376 }
377
GetPresentController(pid_t pid,const std::string & sessionId)378 sptr<AVControllerItem> AVSessionService::GetPresentController(pid_t pid, const std::string& sessionId)
379 {
380 std::lock_guard lockGuard(sessionAndControllerLock_);
381 auto it = controllers_.find(pid);
382 if (it != controllers_.end()) {
383 for (const auto& controller: it->second) {
384 if (controller->HasSession(sessionId)) {
385 return controller;
386 }
387 }
388 }
389 SLOGI("not found");
390 return nullptr;
391 }
392
NotifySessionCreate(const AVSessionDescriptor & descriptor)393 void AVSessionService::NotifySessionCreate(const AVSessionDescriptor& descriptor)
394 {
395 std::lock_guard lockGuard(sessionListenersLock_);
396 for (const auto& listener : innerSessionListeners_) {
397 listener->OnSessionCreate(descriptor);
398 }
399 for (const auto& [pid, listener] : sessionListeners_) {
400 AVSESSION_TRACE_SYNC_START("AVSessionService::OnSessionCreate");
401 listener->OnSessionCreate(descriptor);
402 }
403 }
404
NotifySessionRelease(const AVSessionDescriptor & descriptor)405 void AVSessionService::NotifySessionRelease(const AVSessionDescriptor& descriptor)
406 {
407 std::lock_guard lockGuard(sessionListenersLock_);
408 for (const auto& listener : innerSessionListeners_) {
409 listener->OnSessionRelease(descriptor);
410 }
411 for (const auto& [pid, listener] : sessionListeners_) {
412 listener->OnSessionRelease(descriptor);
413 }
414 }
415
NotifyTopSessionChanged(const AVSessionDescriptor & descriptor)416 void AVSessionService::NotifyTopSessionChanged(const AVSessionDescriptor& descriptor)
417 {
418 std::lock_guard lockGuard(sessionListenersLock_);
419 for (const auto& listener : innerSessionListeners_) {
420 listener->OnTopSessionChange(descriptor);
421 }
422 for (const auto& [pid, listener] : sessionListeners_) {
423 AVSESSION_TRACE_SYNC_START("AVSessionService::OnTopSessionChange");
424 listener->OnTopSessionChange(descriptor);
425 }
426 }
427
NotifyAudioSessionCheck(const int32_t uid)428 void AVSessionService::NotifyAudioSessionCheck(const int32_t uid)
429 {
430 SLOGI("Start searching for the corresponding callback");
431 std::lock_guard lockGuard(sessionListenersLock_);
432 for (const auto& listener : innerSessionListeners_) {
433 SLOGI("Found inner session listener");
434 listener->OnAudioSessionChecked(uid);
435 }
436 for (const auto& [pid, listener] : sessionListeners_) {
437 SLOGI("Found session listener with pid");
438 AVSESSION_TRACE_SYNC_START("AVSessionService::OnAudioSessionCheck");
439 listener->OnAudioSessionChecked(uid);
440 }
441 }
442
443 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
444
ReleaseCastSession()445 void AVSessionService::ReleaseCastSession()
446 {
447 for (const auto& session : GetContainer().GetAllSessions()) {
448 if (session->GetDescriptor().sessionTag_ == "RemoteCast") {
449 std::string sessionId = session->GetDescriptor().sessionId_;
450 SLOGI("Already has a cast session %{public}s", sessionId.c_str());
451 UpdateTopSession(nullptr);
452 auto session = GetContainer().RemoveSession(sessionId);
453 session->UnRegisterDeviceStateCallback();
454 session->StopCastSession();
455 session->ReleaseAVCastControllerInner();
456 session->Destroy();
457 }
458 }
459 }
460
CreateSessionByCast(const int64_t castHandle)461 void AVSessionService::CreateSessionByCast(const int64_t castHandle)
462 {
463 AppExecFwk::ElementName elementName;
464 elementName.SetBundleName("castBundleName");
465 elementName.SetAbilityName("castAbilityName");
466 sptr<AVSessionItem> sinkSession = CreateSessionInner("RemoteCast",
467 AVSession::SESSION_TYPE_AUDIO, false, elementName);
468 CHECK_AND_RETURN_LOG(sinkSession != nullptr, "CreateSession at sink failed");
469 SLOGI("Create Cast sink sessionId %{public}s", sinkSession->GetSessionId().c_str());
470 sinkSession->SetCastHandle(castHandle);
471 sinkSession->RegisterDeviceStateCallback();
472 }
473
NotifyDeviceAvailable(const OutputDeviceInfo & castOutputDeviceInfo)474 void AVSessionService::NotifyDeviceAvailable(const OutputDeviceInfo& castOutputDeviceInfo)
475 {
476 for (DeviceInfo deviceInfo : castOutputDeviceInfo.deviceInfos_) {
477 std::lock_guard lockGuard(castDeviceInfoMapLock_);
478 castDeviceInfoMap_[deviceInfo.deviceId_] = deviceInfo;
479 for (const auto& session : GetContainer().GetAllSessions()) {
480 session->UpdateCastDeviceMap(deviceInfo);
481 }
482 }
483 std::lock_guard lockGuard(sessionListenersLock_);
484 for (const auto& listener : innerSessionListeners_) {
485 listener->OnDeviceAvailable(castOutputDeviceInfo);
486 }
487 for (const auto& [pid, listener] : sessionListeners_) {
488 AVSESSION_TRACE_SYNC_START("AVSessionService::OnDeviceAvailable");
489 listener->OnDeviceAvailable(castOutputDeviceInfo);
490 }
491 }
492
NotifyDeviceOffline(const std::string & deviceId)493 void AVSessionService::NotifyDeviceOffline(const std::string& deviceId)
494 {
495 std::lock_guard lockGuard(sessionListenersLock_);
496 for (const auto& listener : innerSessionListeners_) {
497 listener->OnDeviceOffline(deviceId);
498 }
499 for (const auto& [pid, listener] : sessionListeners_) {
500 AVSESSION_TRACE_SYNC_START("AVSessionService::OnDeviceOffline");
501 listener->OnDeviceOffline(deviceId);
502 }
503 }
504
StartCast(const SessionToken & sessionToken,const OutputDeviceInfo & outputDeviceInfo)505 int32_t AVSessionService::StartCast(const SessionToken& sessionToken, const OutputDeviceInfo& outputDeviceInfo)
506 {
507 SLOGI("SessionId is %{public}s", sessionToken.sessionId.c_str());
508 if (!PermissionChecker::GetInstance().CheckSystemPermission()) {
509 SLOGE("StartCast: CheckSystemPermission failed");
510 HISYSEVENT_SECURITY("CONTROL_PERMISSION_DENIED", "CALLER_UID", GetCallingUid(), "CALLER_PID", GetCallingPid(),
511 "ERROR_MSG", "avsessionservice StartCast checksystempermission failed");
512 return ERR_NO_PERMISSION;
513 }
514
515 sptr<AVSessionItem> session = GetContainer().GetSessionById(sessionToken.sessionId);
516 CHECK_AND_RETURN_RET_LOG(session != nullptr, ERR_SESSION_NOT_EXIST, "session %{public}s not exist",
517 sessionToken.sessionId.c_str());
518
519 int32_t ret = session->StartCast(outputDeviceInfo);
520 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "StartCast failed");
521
522 #ifdef EFFICIENCY_MANAGER_ENABLE
523 int32_t uid = session->GetDescriptor().uid_;
524 int32_t pid = session->GetDescriptor().pid_;
525 std::string bundleName = BundleStatusAdapter::GetInstance().GetBundleNameFromUid(uid);
526 CHECK_AND_RETURN_RET_LOG(bundleName != "", AVSESSION_ERROR, "GetBundleNameFromUid failed");
527 SuspendManager::ContinuousTaskAppInfo appInfo(uid, pid, bundleName,
528 SuspendManager::ContinuousTaskState::TASK_START);
529 ErrCode suspendManagerErr = SuspendManager::SuspendManagerClient::GetInstance().ReportContinuousTaskEvent(
530 SuspendManager::ReportEventType::DIS_COMP_CHANGE, appInfo, AVSESSION_SERVICE_ID);
531 CHECK_AND_RETURN_RET_LOG(suspendManagerErr == ERR_OK, AVSESSION_ERROR, "Report continuous task event failed");
532 #endif
533 return AVSESSION_SUCCESS;
534 }
535
StopCast(const SessionToken & sessionToken)536 int32_t AVSessionService::StopCast(const SessionToken& sessionToken)
537 {
538 if (!PermissionChecker::GetInstance().CheckSystemPermission()) {
539 SLOGE("StopCast: CheckSystemPermission failed");
540 HISYSEVENT_SECURITY("CONTROL_PERMISSION_DENIED", "CALLER_UID", GetCallingUid(), "CALLER_PID", GetCallingPid(),
541 "ERROR_MSG", "avsessionservice StopCast checksystempermission failed");
542 return ERR_NO_PERMISSION;
543 }
544
545 sptr<AVSessionItem> session = GetContainer().GetSessionById(sessionToken.sessionId);
546 CHECK_AND_RETURN_RET_LOG(session != nullptr, AVSESSION_SUCCESS, "StopCast: session is not exist");
547 CHECK_AND_RETURN_RET_LOG(session->StopCast() == AVSESSION_SUCCESS, AVSESSION_ERROR, "StopCast failed");
548 if (session->GetDescriptor().sessionTag_ == "RemoteCast") {
549 SLOGI("Stop cast at sink, start destroy sink avsession");
550 session->Destroy();
551 return AVSESSION_SUCCESS;
552 }
553
554 #ifdef EFFICIENCY_MANAGER_ENABLE
555 SLOGI("Stop register continuous task");
556 int32_t uid = session->GetDescriptor().uid_;
557 int32_t pid = session->GetDescriptor().pid_;
558 std::string bundleName = BundleStatusAdapter::GetInstance().GetBundleNameFromUid(uid);
559 CHECK_AND_RETURN_RET_LOG(bundleName != "", AVSESSION_ERROR, "GetBundleNameFromUid failed");
560 SuspendManager::ContinuousTaskAppInfo appInfo(uid, pid, bundleName,
561 SuspendManager::ContinuousTaskState::TASK_END);
562 ErrCode suspendManagerErr = SuspendManager::SuspendManagerClient::GetInstance().ReportContinuousTaskEvent(
563 SuspendManager::ReportEventType::DIS_COMP_CHANGE, appInfo, AVSESSION_SERVICE_ID);
564 CHECK_AND_RETURN_RET_LOG(suspendManagerErr == ERR_OK, AVSESSION_ERROR, "Report continuous task event failed");
565 SLOGI("Report continuous task event for pid: %{public}d finished", pid);
566 #endif
567 return AVSESSION_SUCCESS;
568 }
569 #endif
570
CreateNewSession(const std::string & tag,int32_t type,bool thirdPartyApp,const AppExecFwk::ElementName & elementName)571 sptr<AVSessionItem> AVSessionService::CreateNewSession(const std::string& tag, int32_t type, bool thirdPartyApp,
572 const AppExecFwk::ElementName& elementName)
573 {
574 SLOGI("%{public}s %{public}d %{public}s %{public}s", tag.c_str(), type,
575 elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
576 AVSessionDescriptor descriptor;
577 descriptor.sessionId_ = AllocSessionId();
578 if (descriptor.sessionId_.empty()) {
579 SLOGE("alloc session id failed");
580 return nullptr;
581 }
582 descriptor.sessionTag_ = tag;
583 descriptor.sessionType_ = type;
584 descriptor.elementName_ = elementName;
585 descriptor.isThirdPartyApp_ = thirdPartyApp;
586
587 sptr<AVSessionItem> result = new(std::nothrow) AVSessionItem(descriptor);
588 if (result == nullptr) {
589 return nullptr;
590 }
591 result->SetPid(GetCallingPid());
592 result->SetUid(GetCallingUid());
593 result->SetServiceCallbackForRelease([this](AVSessionItem& session) {
594 SLOGI("Start handle session release event");
595 HandleSessionRelease(session);
596 });
597 SLOGI("success sessionId=%{public}s", result->GetSessionId().c_str());
598 {
599 std::lock_guard lockGuard(sessionAndControllerLock_);
600 if (topSession_ == nullptr) {
601 UpdateTopSession(result);
602 }
603 }
604
605 OutputDeviceInfo outputDeviceInfo;
606 DeviceInfo deviceInfo;
607 deviceInfo.castCategory_ = AVCastCategory::CATEGORY_LOCAL;
608 deviceInfo.deviceId_ = "0";
609 deviceInfo.deviceName_ = "LocalDevice";
610 outputDeviceInfo.deviceInfos_.emplace_back(deviceInfo);
611 result->SetOutputDevice(outputDeviceInfo);
612
613 return result;
614 }
615
CreateSessionInner(const std::string & tag,int32_t type,bool thirdPartyApp,const AppExecFwk::ElementName & elementName)616 sptr <AVSessionItem> AVSessionService::CreateSessionInner(const std::string& tag, int32_t type, bool thirdPartyApp,
617 const AppExecFwk::ElementName& elementName)
618 {
619 SLOGI("CreateSessionInner enter");
620 CHECK_AND_RETURN_RET_LOG(!tag.empty(), nullptr, "tag is empty");
621 CHECK_AND_RETURN_RET_LOG(type == AVSession::SESSION_TYPE_AUDIO || type == AVSession::SESSION_TYPE_VIDEO,
622 nullptr, "type is invalid");
623 CHECK_AND_RETURN_RET_LOG(!elementName.GetBundleName().empty() && !elementName.GetAbilityName().empty(),
624 nullptr, "element is invalid");
625 std::regex nameRegex("[A-Za-z\\w\\.]*");
626 if (!std::regex_match(elementName.GetBundleName(), nameRegex)) {
627 SLOGE("CreateSessionInner err regex, bundleName=%{public}s", (elementName.GetBundleName()).c_str());
628 return nullptr;
629 }
630 if (!std::regex_match(elementName.GetAbilityName(), nameRegex)) {
631 SLOGE("CreateSessionInner err regex, abilityName=%{public}s", (elementName.GetAbilityName()).c_str());
632 return nullptr;
633 }
634 auto pid = GetCallingPid();
635 std::lock_guard lockGuard(sessionAndControllerLock_);
636 if (AbilityHasSession(pid)) {
637 SLOGI("process %{public}d %{public}s already has one session", pid, elementName.GetAbilityName().c_str());
638 return nullptr;
639 }
640
641 auto result = CreateNewSession(tag, type, thirdPartyApp, elementName);
642 if (result == nullptr) {
643 SLOGE("create new session failed");
644 dumpHelper_->SetErrorInfo(" AVSessionService::CreateSessionInner create new session failed");
645 HISYSEVENT_FAULT("CONTROL_COMMAND_FAILED", "CALLER_PID", pid, "TAG", tag, "TYPE", type, "BUNDLE_NAME",
646 elementName.GetBundleName(), "ERROR_MSG", "avsessionservice createsessioninner create new session failed");
647 return nullptr;
648 }
649 if (GetContainer().AddSession(pid, elementName.GetAbilityName(), result) != AVSESSION_SUCCESS) {
650 SLOGI("session num exceed max");
651 return nullptr;
652 }
653 HISYSEVENT_ADD_LIFE_CYCLE_INFO(elementName.GetBundleName(),
654 AppManagerAdapter::GetInstance().IsAppBackground(GetCallingUid()), type, true);
655
656 NotifySessionCreate(result->GetDescriptor());
657 SLOGI("success");
658 return result;
659 }
660
CreateSessionInner(const std::string & tag,int32_t type,const AppExecFwk::ElementName & elementName)661 sptr <IRemoteObject> AVSessionService::CreateSessionInner(const std::string& tag, int32_t type,
662 const AppExecFwk::ElementName& elementName)
663 {
664 auto session = CreateSessionInner(tag, type, !PermissionChecker::GetInstance().CheckSystemPermission(),
665 elementName);
666 CHECK_AND_RETURN_RET_LOG(session != nullptr, session, "session is nullptr");
667
668 refreshSortFileOnCreateSession(session->GetSessionId(), elementName);
669
670 {
671 std::lock_guard lockGuard1(abilityManagerLock_);
672 std::string bundleName = session->GetDescriptor().elementName_.GetBundleName();
673 std::string abilityName = session->GetDescriptor().elementName_.GetAbilityName();
674 auto it = abilityManager_.find(bundleName + abilityName);
675 if (it != abilityManager_.end()) {
676 it->second->StartAbilityByCallDone(session->GetDescriptor().sessionId_);
677 }
678 }
679
680 {
681 std::lock_guard lockGuard(isAllSessionCastLock_);
682 SLOGI("isAllSessionCast_ is %{public}d", isAllSessionCast_);
683 CHECK_AND_RETURN_RET_LOG(isAllSessionCast_, session, "no need to cast");
684 }
685 CHECK_AND_RETURN_RET_LOG(CastAudioForNewSession(session) == AVSESSION_SUCCESS, session, "cast new session error");
686 return session;
687 }
688
refreshSortFileOnCreateSession(const std::string & sessionId,const AppExecFwk::ElementName & elementName)689 void AVSessionService::refreshSortFileOnCreateSession(const std::string& sessionId,
690 const AppExecFwk::ElementName& elementName)
691 {
692 std::lock_guard sortFileLockGuard(sortFileReadWriteLock_);
693 SLOGI("refresh sort when session created, bundleName=%{public}s", (elementName.GetBundleName()).c_str());
694 std::string oldSortContent;
695 if (LoadStringFromFileEx(AVSESSION_FILE_DIR + SORT_FILE_NAME, oldSortContent)) {
696 nlohmann::json values = json::parse(oldSortContent, nullptr, false);
697 CHECK_AND_RETURN_LOG(!values.is_discarded(), "sort json object is null");
698 if (oldSortContent.find(elementName.GetBundleName()) == string::npos) {
699 auto callback = [this](std::string bundleName) {
700 DeleteHistoricalRecord(bundleName);
701 };
702 if (!BundleStatusAdapter::GetInstance().SubscribeBundleStatusEvent(elementName.GetBundleName(), callback)) {
703 SLOGE("SubscribeBundleStatusEvent failed");
704 }
705 }
706 for (auto value : values) {
707 if (elementName.GetBundleName() == value["bundleName"] &&
708 elementName.GetAbilityName() == value["abilityName"]) {
709 values.erase(std::remove(values.begin(), values.end(), value));
710 }
711 }
712 if (values.size() >= (size_t)maxHistoryNums) {
713 values.erase(values.end() - 1);
714 }
715 nlohmann::json value;
716 value["sessionId"] = sessionId;
717 value["bundleName"] = elementName.GetBundleName();
718 value["abilityName"] = elementName.GetAbilityName();
719 if (values.size() <= 0) {
720 values.push_back(value);
721 } else {
722 values.insert(values.begin(), value);
723 }
724 std::string newSortContent = values.dump();
725 SLOGD("refreshSortFileOnCreateSession::Dump json object finished");
726 if (!SaveStringToFileEx(AVSESSION_FILE_DIR + SORT_FILE_NAME, newSortContent)) {
727 SLOGE("SaveStringToFile failed, filename=%{public}s", SORT_FILE_NAME);
728 }
729 } else {
730 SLOGE("LoadStringToFile failed, filename=%{public}s", SORT_FILE_NAME);
731 }
732 }
733
GetAllSessionDescriptors(std::vector<AVSessionDescriptor> & descriptors)734 int32_t AVSessionService::GetAllSessionDescriptors(std::vector<AVSessionDescriptor>& descriptors)
735 {
736 if (!PermissionChecker::GetInstance().CheckSystemPermission()) {
737 SLOGE("GetAllSessionDescriptors: CheckSystemPermission failed");
738 HISYSEVENT_SECURITY("CONTROL_PERMISSION_DENIED", "CALLER_UID", GetCallingUid(), "CALLER_PID", GetCallingPid(),
739 "ERROR_MSG", "avsessionservice getallsessiondescriptors checksystempermission failed");
740 return ERR_NO_PERMISSION;
741 }
742
743 std::lock_guard lockGuard(sessionAndControllerLock_);
744 std::lock_guard sortFileLockGuard(sortFileReadWriteLock_);
745
746 std::string oldSortContent;
747 if (!LoadStringFromFileEx(AVSESSION_FILE_DIR + SORT_FILE_NAME, oldSortContent)) {
748 SLOGE("GetAllSessionDescriptors read sort fail! ");
749 for (const auto& session: GetContainer().GetAllSessions()) {
750 descriptors.push_back(session->GetDescriptor());
751 }
752 SLOGI("size=%{public}d", static_cast<int32_t>(descriptors.size()));
753 return AVSESSION_SUCCESS;
754 }
755 nlohmann::json values = json::parse(oldSortContent, nullptr, false);
756 CHECK_AND_RETURN_RET_LOG(!values.is_discarded(), AVSESSION_SUCCESS, "json object is null");
757 for (auto& value : values) {
758 auto session = GetContainer().GetSessionById(value["sessionId"]);
759 if (session != nullptr) {
760 descriptors.push_back(session->GetDescriptor());
761 }
762 }
763
764 for (const auto& session: GetContainer().GetAllSessions()) {
765 bool duplicateSession = false;
766 for (const auto& desc: descriptors) {
767 if (desc.sessionId_ == session->GetSessionId()) {
768 duplicateSession = true;
769 break;
770 }
771 }
772 if (!duplicateSession) {
773 descriptors.push_back(session->GetDescriptor());
774 }
775 }
776 SLOGI("size=%{public}d", static_cast<int32_t>(descriptors.size()));
777 return AVSESSION_SUCCESS;
778 }
779
GetSessionDescriptorsBySessionId(const std::string & sessionId,AVSessionDescriptor & descriptor)780 int32_t AVSessionService::GetSessionDescriptorsBySessionId(const std::string& sessionId,
781 AVSessionDescriptor& descriptor)
782 {
783 std::lock_guard lockGuard(sessionAndControllerLock_);
784 sptr<AVSessionItem> session = GetContainer().GetSessionById(sessionId);
785 CHECK_AND_RETURN_RET_LOG(session != nullptr, AVSESSION_ERROR, "session not exist");
786
787 auto pid = GetCallingPid();
788 if (pid == session->GetPid()) {
789 descriptor = session->GetDescriptor();
790 return AVSESSION_SUCCESS;
791 }
792 if (!PermissionChecker::GetInstance().CheckSystemPermission()) {
793 SLOGE("GetSessionDescriptorsBySessionId: CheckSystemPermission failed");
794 HISYSEVENT_SECURITY("CONTROL_PERMISSION_DENIED", "CALLER_UID", GetCallingUid(),
795 "CALLER_PID", pid, "SESSION_ID", sessionId,
796 "ERROR_MSG", "avsessionservice getsessiondescriptors by sessionid checksystempermission failed");
797 return ERR_NO_PERMISSION;
798 }
799 descriptor = session->GetDescriptor();
800 return AVSESSION_SUCCESS;
801 }
802
GetHistoricalSessionDescriptors(int32_t maxSize,std::vector<AVSessionDescriptor> & descriptors)803 int32_t AVSessionService::GetHistoricalSessionDescriptors(int32_t maxSize,
804 std::vector<AVSessionDescriptor>& descriptors)
805 {
806 if (!PermissionChecker::GetInstance().CheckSystemPermission()) {
807 SLOGE("GetAllSessionDescriptors: CheckSystemPermission failed");
808 HISYSEVENT_SECURITY("CONTROL_PERMISSION_DENIED", "CALLER_UID", GetCallingUid(), "CALLER_PID", GetCallingPid(),
809 "ERROR_MSG", "avsessionservice GetHistoricalSessionDescriptors checksystempermission failed");
810 return ERR_NO_PERMISSION;
811 }
812 std::lock_guard lockGuard(sessionAndControllerLock_);
813 std::lock_guard sortFileLockGuard(sortFileReadWriteLock_);
814 std::string oldSortContent;
815 std::vector<AVSessionDescriptor> tempDescriptors;
816 if (!LoadStringFromFileEx(AVSESSION_FILE_DIR + SORT_FILE_NAME, oldSortContent)) {
817 SLOGE("GetHistoricalSessionDescriptors read sort fail, Return!");
818 return AVSESSION_ERROR;
819 }
820 nlohmann::json sortValues = json::parse(oldSortContent, nullptr, false);
821 CHECK_AND_RETURN_RET_LOG(!sortValues.is_discarded(), AVSESSION_ERROR, "json object is null");
822 for (const auto& value : sortValues) {
823 auto session = GetContainer().GetSessionById(value["sessionId"]);
824 if (session != nullptr) {
825 tempDescriptors.push_back(session->GetDescriptor());
826 } else {
827 AVSessionDescriptor descriptor;
828 descriptor.sessionId_ = value["sessionId"];
829 descriptor.elementName_.SetBundleName(value["bundleName"]);
830 descriptor.elementName_.SetAbilityName(value["abilityName"]);
831 tempDescriptors.push_back(descriptor);
832 }
833 }
834 if (tempDescriptors.size() == 0 && GetContainer().GetAllSessions().size() == 0) {
835 SLOGE("GetHistoricalSessionDescriptors read empty, return default!");
836 AVSessionDescriptor descriptor;
837 descriptor.sessionId_ = DEFAULT_SESSION_ID;
838 descriptor.elementName_.SetBundleName(DEFAULT_BUNDLE_NAME);
839 descriptor.elementName_.SetAbilityName(DEFAULT_ABILITY_NAME);
840 tempDescriptors.push_back(descriptor);
841 }
842 if (maxSize < 0 || maxSize > maxHistoryNums) {
843 maxSize = unSetHistoryNum;
844 }
845 for (auto iterator = tempDescriptors.begin(); iterator != tempDescriptors.end(); ++iterator) {
846 if (descriptors.size() >= (size_t)maxSize) {
847 break;
848 }
849 descriptors.push_back(*iterator);
850 }
851 SLOGI("get historical session size=%{public}d", static_cast<int>(descriptors.size()));
852 return AVSESSION_SUCCESS;
853 }
854
CreateNewControllerForSession(pid_t pid,sptr<AVSessionItem> & session)855 sptr<AVControllerItem> AVSessionService::CreateNewControllerForSession(pid_t pid, sptr<AVSessionItem>& session)
856 {
857 SLOGI("pid=%{public}d sessionId=%{public}s", pid, session->GetSessionId().c_str());
858 sptr<AVControllerItem> result = new(std::nothrow) AVControllerItem(pid, session);
859 if (result == nullptr) {
860 SLOGE("malloc controller failed");
861 return nullptr;
862 }
863 result->SetServiceCallbackForRelease([this](AVControllerItem& controller) { HandleControllerRelease(controller); });
864 session->AddController(pid, result);
865 return result;
866 }
867
GetSubNode(const nlohmann::json & node,const std::string & name)868 const nlohmann::json& AVSessionService::GetSubNode(const nlohmann::json& node, const std::string& name)
869 {
870 static const nlohmann::json jsonNull = nlohmann::json::value_t::null;
871 if (node.is_discarded() || node.is_null()) {
872 SLOGE("json node is invalid");
873 return jsonNull;
874 }
875
876 if (name.empty()) {
877 SLOGE("name is invalid");
878 return node;
879 }
880
881 auto it = node.find(name);
882 if (it == node.end()) {
883 SLOGE("%{public}s is not exist in json", name.c_str());
884 return jsonNull;
885 }
886 return *it;
887 }
888
IsHistoricalSession(const std::string & sessionId)889 bool AVSessionService::IsHistoricalSession(const std::string& sessionId)
890 {
891 {
892 std::string sortContent;
893 std::lock_guard sortFileLockGuard(sortFileReadWriteLock_);
894 if (!LoadStringFromFileEx(AVSESSION_FILE_DIR + SORT_FILE_NAME, sortContent)) {
895 SLOGE("IsHistoricalSession read sort failed, filename=%{public}s", SORT_FILE_NAME);
896 return false;
897 }
898 if (sortContent.find(sessionId) == string::npos) {
899 SLOGE("IsHistoricalSession find session no sort, sessionId=%{public}s", sessionId.c_str());
900 return false;
901 }
902 }
903
904 auto session = GetContainer().GetSessionById(sessionId);
905 if (session != nullptr) {
906 SLOGE("IsHistoricalSession find session alive, sessionId=%{public}s", sessionId.c_str());
907 return false;
908 }
909 SLOGE("IsHistoricalSession find session historical, sessionId=%{public}s", sessionId.c_str());
910 return true;
911 }
912
StartDefaultAbilityByCall(std::string & sessionId)913 int32_t AVSessionService::StartDefaultAbilityByCall(std::string& sessionId)
914 {
915 std::string bundleName = DEFAULT_BUNDLE_NAME;
916 std::string abilityName = DEFAULT_ABILITY_NAME;
917 std::string sortContent;
918
919 {
920 std::lock_guard sortFileLockGuard(sortFileReadWriteLock_);
921 if (!LoadStringFromFileEx(AVSESSION_FILE_DIR + SORT_FILE_NAME, sortContent)) {
922 SLOGE("GetAllSessionDescriptors read sort fail! ");
923 return AVSESSION_ERROR;
924 }
925 }
926
927 if (!sortContent.empty()) {
928 nlohmann::json sortValues = json::parse(sortContent, nullptr, false);
929 CHECK_AND_RETURN_RET_LOG(!sortValues.is_discarded(), AVSESSION_ERROR, "json object is null");
930 for (auto& value : sortValues) {
931 auto session = GetContainer().GetSessionById(value["sessionId"]);
932 if (session == nullptr) {
933 bundleName = value["bundleName"];
934 abilityName = value["abilityName"];
935 break;
936 }
937 }
938 }
939 std::shared_ptr<AbilityManagerAdapter> ability = nullptr;
940 {
941 std::lock_guard lockGuard(abilityManagerLock_);
942 auto it = abilityManager_.find(bundleName + abilityName);
943 if (it != abilityManager_.end()) {
944 ability = it->second;
945 } else {
946 ability = std::make_shared<AbilityManagerAdapter>(bundleName, abilityName);
947 if (ability == nullptr) {
948 return ERR_NO_MEMORY;
949 }
950 abilityManager_[bundleName + abilityName] = ability;
951 }
952 }
953 int32_t ret = ability->StartAbilityByCall(sessionId);
954
955 std::lock_guard lockGuard(abilityManagerLock_);
956 if (ret != ERR_START_ABILITY_IS_RUNNING) {
957 abilityManager_.erase(bundleName + abilityName);
958 }
959 return ret;
960 }
961
StartAbilityByCall(const std::string & sessionIdNeeded,std::string & sessionId)962 int32_t AVSessionService::StartAbilityByCall(const std::string& sessionIdNeeded, std::string& sessionId)
963 {
964 std::string content;
965
966 {
967 std::lock_guard sortFileLockGuard(sortFileReadWriteLock_);
968 if (!LoadStringFromFileEx(AVSESSION_FILE_DIR + SORT_FILE_NAME, content)) {
969 SLOGE("LoadStringFromFile failed, filename=%{public}s", SORT_FILE_NAME);
970 return AVSESSION_ERROR;
971 }
972 }
973
974 nlohmann::json values = json::parse(content, nullptr, false);
975 CHECK_AND_RETURN_RET_LOG(!values.is_discarded(), AVSESSION_ERROR, "json object is null");
976 std::string bundleName;
977 std::string abilityName;
978 for (auto& value : values) {
979 if (sessionIdNeeded == value["sessionId"]) {
980 bundleName = value["bundleName"];
981 abilityName = value["abilityName"];
982 break;
983 }
984 }
985 if (bundleName.empty() || abilityName.empty()) {
986 SLOGE("Get bundle name & ability name failed, sessionId=%{public}s", sessionIdNeeded.c_str());
987 return AVSESSION_ERROR;
988 }
989 std::shared_ptr<AbilityManagerAdapter> ability = nullptr;
990 {
991 std::lock_guard lockGuard(abilityManagerLock_);
992 auto it = abilityManager_.find(bundleName + abilityName);
993 if (it != abilityManager_.end()) {
994 ability = it->second;
995 } else {
996 ability = std::make_shared<AbilityManagerAdapter>(bundleName, abilityName);
997 if (ability == nullptr) {
998 return ERR_NO_MEMORY;
999 }
1000 abilityManager_[bundleName + abilityName] = ability;
1001 }
1002 }
1003 int32_t ret = ability->StartAbilityByCall(sessionId);
1004
1005 std::lock_guard lockGuard(abilityManagerLock_);
1006 if (ret != ERR_START_ABILITY_IS_RUNNING) {
1007 abilityManager_.erase(bundleName + abilityName);
1008 }
1009 return ret;
1010 }
1011
CreateControllerInner(const std::string & sessionId,sptr<IRemoteObject> & object)1012 int32_t AVSessionService::CreateControllerInner(const std::string& sessionId, sptr<IRemoteObject>& object)
1013 {
1014 if (!PermissionChecker::GetInstance().CheckSystemPermission()) {
1015 SLOGE("CreateControllerInner: CheckSystemPermission failed");
1016 HISYSEVENT_SECURITY("CONTROL_PERMISSION_DENIED", "CALLER_UID", GetCallingUid(),
1017 "CALLER_PID", GetCallingPid(), "SESSION_ID", sessionId,
1018 "ERROR_MSG", "avsessionservice createcontrollerinner checksystempermission failed");
1019 return ERR_NO_PERMISSION;
1020 }
1021 std::string sessionIdInner;
1022 if (sessionId == "default") {
1023 auto ret = StartDefaultAbilityByCall(sessionIdInner);
1024 if (ret != AVSESSION_SUCCESS) {
1025 SLOGE("StartDefaultAbilityByCall failed: %{public}d", ret);
1026 return ret;
1027 }
1028 } else {
1029 if (IsHistoricalSession(sessionId)) {
1030 auto ret = StartAbilityByCall(sessionId, sessionIdInner);
1031 if (ret != AVSESSION_SUCCESS) {
1032 SLOGE("StartAbilityByCall failed: %{public}d", ret);
1033 return ret;
1034 }
1035 } else {
1036 sessionIdInner = sessionId;
1037 }
1038 }
1039 auto pid = GetCallingPid();
1040 std::lock_guard lockGuard(sessionAndControllerLock_);
1041 if (GetPresentController(pid, sessionIdInner) != nullptr) {
1042 SLOGI("controller already exist");
1043 return ERR_CONTROLLER_IS_EXIST;
1044 }
1045
1046 auto session = GetContainer().GetSessionById(sessionIdInner);
1047 if (session == nullptr) {
1048 SLOGE("no session id %{public}s", sessionIdInner.c_str());
1049 return ERR_SESSION_NOT_EXIST;
1050 }
1051
1052 auto result = CreateNewControllerForSession(pid, session);
1053 if (result == nullptr) {
1054 SLOGE("create new controller failed");
1055 return ERR_NO_MEMORY;
1056 }
1057
1058 controllers_[pid].push_back(result);
1059 object = result;
1060 SLOGI("success");
1061 return AVSESSION_SUCCESS;
1062 }
1063
1064 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
GetAVCastControllerInner(const std::string & sessionId,sptr<IRemoteObject> & object)1065 int32_t AVSessionService::GetAVCastControllerInner(const std::string& sessionId, sptr<IRemoteObject>& object)
1066 {
1067 SLOGI("Start get cast controller");
1068 auto session = GetContainer().GetSessionById(sessionId);
1069 CHECK_AND_RETURN_RET_LOG(session != nullptr, AVSESSION_ERROR, "StopCast: session is not exist");
1070 auto result = session->GetAVCastControllerInner();
1071 CHECK_AND_RETURN_RET_LOG(result != nullptr, AVSESSION_ERROR, "GetAVCastControllerInner failed");
1072 object = result;
1073 return AVSESSION_SUCCESS;
1074 }
1075 #endif
1076
AddSessionListener(pid_t pid,const sptr<ISessionListener> & listener)1077 void AVSessionService::AddSessionListener(pid_t pid, const sptr<ISessionListener>& listener)
1078 {
1079 std::lock_guard lockGuard(sessionListenersLock_);
1080 sessionListeners_[pid] = listener;
1081 }
1082
RemoveSessionListener(pid_t pid)1083 void AVSessionService::RemoveSessionListener(pid_t pid)
1084 {
1085 std::lock_guard lockGuard(sessionListenersLock_);
1086 sessionListeners_.erase(pid);
1087 }
1088
AddInnerSessionListener(SessionListener * listener)1089 void AVSessionService::AddInnerSessionListener(SessionListener* listener)
1090 {
1091 std::lock_guard lockGuard(sessionListenersLock_);
1092 innerSessionListeners_.push_back(listener);
1093 }
1094
RegisterSessionListener(const sptr<ISessionListener> & listener)1095 int32_t AVSessionService::RegisterSessionListener(const sptr<ISessionListener>& listener)
1096 {
1097 SLOGI("Enter RegisterSessionListener process");
1098 if (!PermissionChecker::GetInstance().CheckSystemPermission()) {
1099 SLOGE("RegisterSessionListener: CheckSystemPermission failed");
1100 HISYSEVENT_SECURITY("CONTROL_PERMISSION_DENIED", "CALLER_UID", GetCallingUid(), "CALLER_PID", GetCallingPid(),
1101 "ERROR_MSG", "avsessionservice registersessionlistener checksystempermission failed");
1102 return ERR_NO_PERMISSION;
1103 }
1104 AddSessionListener(GetCallingPid(), listener);
1105 return AVSESSION_SUCCESS;
1106 }
1107
HandleEventHandlerCallBack()1108 void AVSessionService::HandleEventHandlerCallBack()
1109 {
1110 SLOGI("handle eventHandler callback");
1111 AVControlCommand cmd;
1112 std::lock_guard lockGuard(sessionAndControllerLock_);
1113 if (pressCount_ >= THREE_CLICK && topSession_) {
1114 cmd.SetCommand(AVControlCommand::SESSION_CMD_PLAY_PREVIOUS);
1115 topSession_->ExecuteControllerCommand(cmd);
1116 } else if (pressCount_ == DOUBLE_CLICK && topSession_) {
1117 cmd.SetCommand(AVControlCommand::SESSION_CMD_PLAY_NEXT);
1118 topSession_->ExecuteControllerCommand(cmd);
1119 } else if (pressCount_ == ONE_CLICK) {
1120 SLOGI("HandleEventHandlerCallBack on ONE_CLICK ");
1121 if (!topSession_) {
1122 SLOGI("HandleEventHandlerCallBack ONE_CLICK without topSession_");
1123 sptr<IRemoteObject> object;
1124 int32_t ret = CreateControllerInner("default", object);
1125 SLOGI("HandleEventHandlerCallBack ONE_CLICK !topSession_ ret : %{public}d", static_cast<int32_t>(ret));
1126 }
1127 if (topSession_) {
1128 SLOGI("HandleEventHandlerCallBack ONE_CLICK with topSession_ ");
1129 auto playbackState = topSession_->GetPlaybackState();
1130 if (playbackState.GetState() == AVPlaybackState::PLAYBACK_STATE_PLAY) {
1131 cmd.SetCommand(AVControlCommand::SESSION_CMD_PAUSE);
1132 } else {
1133 cmd.SetCommand(AVControlCommand::SESSION_CMD_PLAY);
1134 }
1135 topSession_->ExecuteControllerCommand(cmd);
1136 }
1137 } else {
1138 SLOGI("press invalid");
1139 }
1140 pressCount_ = 0;
1141 isFirstPress_ = true;
1142 }
1143
SendSystemAVKeyEvent(const MMI::KeyEvent & keyEvent)1144 int32_t AVSessionService::SendSystemAVKeyEvent(const MMI::KeyEvent& keyEvent)
1145 {
1146 if (!PermissionChecker::GetInstance().CheckSystemPermission()) {
1147 SLOGE("SendSystemAVKeyEvent: CheckSystemPermission failed");
1148 HISYSEVENT_SECURITY("CONTROL_PERMISSION_DENIED", "CALLER_UID", GetCallingUid(), "CALLER_PID", GetCallingPid(),
1149 "KEY_CODE", keyEvent.GetKeyCode(), "KEY_ACTION", keyEvent.GetKeyAction(),
1150 "ERROR_MSG", "avsessionservice sendsystemavkeyevent checksystempermission failed");
1151 return ERR_NO_PERMISSION;
1152 }
1153 SLOGI("key=%{public}d", keyEvent.GetKeyCode());
1154 if (keyEvent.GetKeyCode() == MMI::KeyEvent::KEYCODE_HEADSETHOOK) {
1155 pressCount_++;
1156 if (isFirstPress_) {
1157 auto ret = AVSessionEventHandler::GetInstance().AVSessionPostTask([this]() {
1158 HandleEventHandlerCallBack();
1159 }, "SendSystemAVKeyEvent", CLICK_TIMEOUT);
1160 CHECK_AND_RETURN_RET_LOG(ret, AVSESSION_ERROR, "init eventHandler failed");
1161 isFirstPress_ = false;
1162 }
1163 return AVSESSION_SUCCESS;
1164 }
1165 std::lock_guard lockGuard(sessionAndControllerLock_);
1166 if (topSession_) {
1167 topSession_->HandleMediaKeyEvent(keyEvent);
1168 } else {
1169 SLOGI("topSession is nullptr");
1170 }
1171 return AVSESSION_SUCCESS;
1172 }
1173
SendSystemControlCommand(const AVControlCommand & command)1174 int32_t AVSessionService::SendSystemControlCommand(const AVControlCommand &command)
1175 {
1176 if (!PermissionChecker::GetInstance().CheckSystemPermission()) {
1177 SLOGE("SendSystemControlCommand: CheckSystemPermission failed");
1178 HISYSEVENT_SECURITY("CONTROL_PERMISSION_DENIED", "CALLER_UID", GetCallingUid(),
1179 "CALLER_PID", GetCallingPid(), "CMD", command.GetCommand(),
1180 "ERROR_MSG", "avsessionservice sendsystemcontrolcommand checksystempermission failed");
1181 return ERR_NO_PERMISSION;
1182 }
1183 SLOGI("cmd=%{public}d", command.GetCommand());
1184 std::lock_guard lockGuard(sessionAndControllerLock_);
1185 if (topSession_) {
1186 CHECK_AND_RETURN_RET_LOG(CommandSendLimit::GetInstance().IsCommandSendEnable(GetCallingPid()),
1187 ERR_COMMAND_SEND_EXCEED_MAX, "command excuted number exceed max");
1188 topSession_->ExecuteControllerCommand(command);
1189 }
1190 return AVSESSION_SUCCESS;
1191 }
1192
AddClientDeathObserver(pid_t pid,const sptr<IClientDeath> & observer)1193 void AVSessionService::AddClientDeathObserver(pid_t pid, const sptr<IClientDeath>& observer)
1194 {
1195 std::lock_guard lockGuard(clientDeathObserversLock_);
1196 clientDeathObservers_[pid] = observer;
1197 }
1198
RemoveClientDeathObserver(pid_t pid)1199 void AVSessionService::RemoveClientDeathObserver(pid_t pid)
1200 {
1201 std::lock_guard lockGuard(clientDeathObserversLock_);
1202 clientDeathObservers_.erase(pid);
1203 }
1204
RegisterClientDeathObserver(const sptr<IClientDeath> & observer)1205 int32_t AVSessionService::RegisterClientDeathObserver(const sptr<IClientDeath>& observer)
1206 {
1207 SLOGI("enter");
1208 auto pid = GetCallingPid();
1209 auto* recipient = new(std::nothrow) ClientDeathRecipient([this, pid]() { OnClientDied(pid); });
1210 if (recipient == nullptr) {
1211 SLOGE("malloc failed");
1212 HISYSEVENT_FAULT("CONTROL_COMMAND_FAILED", "ERROR_TYPE", "RGS_CLIENT_DEATH_OBSERVER_FAILED",
1213 "ERROR_INFO", "avsession service register client death observer malloc failed");
1214 return AVSESSION_ERROR;
1215 }
1216
1217 if (!observer->AsObject()->AddDeathRecipient(recipient)) {
1218 SLOGE("add death recipient for %{public}d failed", pid);
1219 HISYSEVENT_FAULT("CONTROL_COMMAND_FAILED", "ERROR_TYPE", "RGS_CLIENT_DEATH_FAILED", "CALLING_PID", pid,
1220 "ERROR_INFO", "avsession service register client death observer, add death recipient failed");
1221 return AVSESSION_ERROR;
1222 }
1223
1224 AddClientDeathObserver(pid, observer);
1225 return AVSESSION_SUCCESS;
1226 }
1227
OnClientDied(pid_t pid)1228 void AVSessionService::OnClientDied(pid_t pid)
1229 {
1230 SLOGI("pid=%{public}d", pid);
1231 RemoveSessionListener(pid);
1232 RemoveClientDeathObserver(pid);
1233
1234 std::lock_guard lockGuard(sessionAndControllerLock_);
1235 ClearSessionForClientDiedNoLock(pid);
1236 ClearControllerForClientDiedNoLock(pid);
1237 }
1238
DeleteHistoricalRecord(const std::string & bundleName)1239 void AVSessionService::DeleteHistoricalRecord(const std::string& bundleName)
1240 {
1241 std::lock_guard sortFileLockGuard(sortFileReadWriteLock_);
1242 SLOGI("delete historical record, bundleName=%{public}s", bundleName.c_str());
1243 std::string oldContent;
1244 std::string newContent;
1245 nlohmann::json values;
1246 if (!LoadStringFromFileEx(AVSESSION_FILE_DIR + SORT_FILE_NAME, oldContent)) {
1247 SLOGE("LoadStringFromFile failed, filename=%{public}s", SORT_FILE_NAME);
1248 return;
1249 }
1250 values = json::parse(oldContent, nullptr, false);
1251 CHECK_AND_RETURN_LOG(!values.is_discarded(), "json object is null");
1252 for (auto value : values) {
1253 if (bundleName == value["bundleName"]) {
1254 values.erase(std::remove(values.begin(), values.end(), value));
1255 break;
1256 }
1257 }
1258 newContent = values.dump();
1259 SLOGD("DeleteHistoricalRecord::Dump json object finished");
1260 if (!SaveStringToFileEx(AVSESSION_FILE_DIR + SORT_FILE_NAME, newContent)) {
1261 SLOGE("SaveStringToFile failed, filename=%{public}s", SORT_FILE_NAME);
1262 return;
1263 }
1264 }
1265
HandleSessionRelease(AVSessionItem & session)1266 void AVSessionService::HandleSessionRelease(AVSessionItem& session)
1267 {
1268 SLOGI("HandleSessionRelease, sessionId=%{public}s", session.GetSessionId().c_str());
1269 NotifySessionRelease(session.GetDescriptor());
1270 std::lock_guard lockGuard(sessionAndControllerLock_);
1271 GetContainer().RemoveSession(session.GetPid(), session.GetAbilityName());
1272 if (topSession_.GetRefPtr() == &session) {
1273 UpdateTopSession(nullptr);
1274 }
1275 if (session.GetRemoteSource() != nullptr) {
1276 auto sessionPtr = GetContainer().GetSessionById(session.GetSessionId());
1277 if (sessionPtr != nullptr) {
1278 int32_t ret = CancelCastAudioForClientExit(session.GetPid(), sessionPtr);
1279 SLOGI("CancelCastAudioForClientExit ret is %{public}d", ret);
1280 }
1281 } else {
1282 SLOGI("GetContainer has no this session");
1283 }
1284 HISYSEVENT_ADD_LIFE_CYCLE_INFO(session.GetDescriptor().elementName_.GetBundleName(),
1285 AppManagerAdapter::GetInstance().IsAppBackground(GetCallingUid()),
1286 session.GetDescriptor().sessionType_, false);
1287 }
1288
HandleControllerRelease(AVControllerItem & controller)1289 void AVSessionService::HandleControllerRelease(AVControllerItem& controller)
1290 {
1291 auto pid = controller.GetPid();
1292 std::lock_guard lockGuard(sessionAndControllerLock_);
1293 auto it = controllers_.find(pid);
1294 if (it == controllers_.end()) {
1295 return;
1296 }
1297 SLOGI("remove controller");
1298 it->second.remove(&controller);
1299 if (it->second.empty()) {
1300 controllers_.erase(pid);
1301 }
1302 }
1303
Dump(std::int32_t fd,const std::vector<std::u16string> & args)1304 std::int32_t AVSessionService::Dump(std::int32_t fd, const std::vector<std::u16string>& args)
1305 {
1306 if (fd < 0) {
1307 SLOGE("dump fd invalid");
1308 return ERR_INVALID_PARAM;
1309 }
1310
1311 if (dumpHelper_ == nullptr) {
1312 SLOGE("dumpHelper_ is nullptr!");
1313 return ERR_INVALID_PARAM;
1314 }
1315
1316 std::vector<std::string> argsInStr;
1317 for (const auto& arg : args) {
1318 SLOGI("Dump args: %s", Str16ToStr8(arg).c_str());
1319 argsInStr.emplace_back(Str16ToStr8(arg));
1320 }
1321
1322 std::string result;
1323 dumpHelper_->Dump(argsInStr, result, *this);
1324 std::int32_t ret = dprintf(fd, "%s", result.c_str());
1325 if (ret < 0) {
1326 SLOGI("dprintf to dump fd failed");
1327 return ERR_INVALID_PARAM;
1328 }
1329 return AVSESSION_SUCCESS;
1330 }
1331
GetService(const std::string & deviceId)1332 sptr <RemoteSessionCommandProcess> AVSessionService::GetService(const std::string& deviceId)
1333 {
1334 SLOGI("enter");
1335 auto mgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1336 if (mgr == nullptr) {
1337 SLOGE("failed to get sa mgr");
1338 return nullptr;
1339 }
1340 auto object = mgr->GetSystemAbility(AVSESSION_SERVICE_ID, deviceId);
1341 if (object == nullptr) {
1342 SLOGE("failed to get service");
1343 return nullptr;
1344 }
1345 auto remoteService = iface_cast<RemoteSessionCommandProcess>(object);
1346 return remoteService;
1347 }
1348
IsLocalDevice(const std::string & networkId)1349 bool AVSessionService::IsLocalDevice(const std::string& networkId)
1350 {
1351 std::string localNetworkId;
1352 CHECK_AND_RETURN_RET_LOG(GetLocalNetworkId(localNetworkId) == AVSESSION_SUCCESS, AVSESSION_ERROR,
1353 "GetLocalNetworkId error");
1354 if (networkId == localNetworkId || networkId == "LocalDevice") {
1355 SLOGI("local device");
1356 return true;
1357 }
1358 SLOGI("not local device");
1359 return false;
1360 }
1361
GetLocalNetworkId(std::string & networkId)1362 int32_t AVSessionService::GetLocalNetworkId(std::string& networkId)
1363 {
1364 SLOGI("GetLocalNetworkId");
1365 DistributedHardware::DmDeviceInfo deviceInfo;
1366 int32_t ret = DistributedHardware::DeviceManager::GetInstance().GetLocalDeviceInfo("av_session", deviceInfo);
1367 CHECK_AND_RETURN_RET_LOG(ret == 0, ret, "get local deviceInfo failed");
1368 networkId = deviceInfo.networkId;
1369 return AVSESSION_SUCCESS;
1370 }
1371
GetTrustedDeviceName(const std::string & networkId,std::string & deviceName)1372 int32_t AVSessionService::GetTrustedDeviceName(const std::string& networkId, std::string& deviceName)
1373 {
1374 SLOGI("GetTrustedDeviceName");
1375 std::vector<OHOS::DistributedHardware::DmDeviceInfo> deviceList {};
1376 if (IsLocalDevice(networkId)) {
1377 deviceName = "LocalDevice";
1378 return AVSESSION_SUCCESS;
1379 }
1380 int32_t ret = GetTrustedDevicesInfo(deviceList);
1381 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "get devicesInfo failed");
1382 SLOGI("deviceList size is %{public}d", static_cast<int32_t>(deviceList.size()));
1383 for (const auto& device : deviceList) {
1384 SLOGI("device networkId is %{public}.6s", device.networkId);
1385 ret = strcmp(device.networkId, networkId.c_str());
1386 if (ret == 0) {
1387 deviceName = device.deviceName;
1388 SLOGI("deviceName is %{public}s", deviceName.c_str());
1389 return AVSESSION_SUCCESS;
1390 }
1391 }
1392 SLOGI("can not find this device %{public}.6s", networkId.c_str());
1393 return AVSESSION_ERROR;
1394 }
1395
GetTrustedDevicesInfo(std::vector<OHOS::DistributedHardware::DmDeviceInfo> & deviceList)1396 int32_t AVSessionService::GetTrustedDevicesInfo(std::vector<OHOS::DistributedHardware::DmDeviceInfo>& deviceList)
1397 {
1398 SLOGI("GetTrustedDevicesInfo");
1399 int32_t ret = DistributedHardware::DeviceManager::GetInstance().GetTrustedDeviceList("av_session", "", deviceList);
1400 CHECK_AND_RETURN_RET_LOG(ret == 0, ret, "get trusted device list failed");
1401 return AVSESSION_SUCCESS;
1402 }
1403
SetBasicInfo(std::string & sessionInfo)1404 int32_t AVSessionService::SetBasicInfo(std::string& sessionInfo)
1405 {
1406 AVSessionBasicInfo basicInfo;
1407 basicInfo.metaDataCap_ = AVMetaData::localCapability;
1408 basicInfo.playBackStateCap_ = AVPlaybackState::localCapability;
1409 basicInfo.controlCommandCap_ = AVControlCommand::localCapability;
1410 int32_t ret = GetLocalNetworkId(basicInfo.networkId_);
1411 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, AVSESSION_ERROR, "GetLocalNetworkId failed");
1412
1413 ret = JsonUtils::SetSessionBasicInfo(sessionInfo, basicInfo);
1414 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, AVSESSION_ERROR, "SetDeviceId failed");
1415 return AVSESSION_SUCCESS;
1416 }
1417
SetDeviceInfo(const std::vector<AudioStandard::AudioDeviceDescriptor> & castAudioDescriptors,sptr<AVSessionItem> & session)1418 void AVSessionService::SetDeviceInfo(const std::vector<AudioStandard::AudioDeviceDescriptor>& castAudioDescriptors,
1419 sptr <AVSessionItem>& session)
1420 {
1421 CHECK_AND_RETURN_LOG(session != nullptr && castAudioDescriptors.size() > 0, "invalid argument");
1422 SLOGI("castAudioDescriptors size is %{public}d", static_cast<int32_t>(castAudioDescriptors.size()));
1423 SLOGI("session id is %{public}s", session->GetSessionId().c_str());
1424
1425 OutputDeviceInfo outputDeviceInfo;
1426 outputDeviceInfo.deviceInfos_.clear();
1427 int32_t castCategory = AVCastCategory::CATEGORY_LOCAL;
1428 if (!IsLocalDevice(castAudioDescriptors[0].networkId_)) {
1429 castCategory = AVCastCategory::CATEGORY_REMOTE;
1430 }
1431 for (const auto &audioDescriptor : castAudioDescriptors) {
1432 DeviceInfo deviceInfo;
1433 deviceInfo.castCategory_ = castCategory;
1434 deviceInfo.deviceId_ = std::to_string(audioDescriptor.deviceId_);
1435 deviceInfo.deviceName_ = audioDescriptor.deviceName_;
1436 SLOGI("deviceName is %{public}s", audioDescriptor.deviceName_.c_str());
1437 SLOGI("deviceId is %{public}d", audioDescriptor.deviceId_);
1438 outputDeviceInfo.deviceInfos_.emplace_back(deviceInfo);
1439 }
1440 session->SetOutputDevice(outputDeviceInfo);
1441 }
1442
GetAudioDescriptorByDeviceId(const std::vector<sptr<AudioStandard::AudioDeviceDescriptor>> & descriptors,const std::string & deviceId,AudioStandard::AudioDeviceDescriptor & audioDescriptor)1443 bool AVSessionService::GetAudioDescriptorByDeviceId(const std::vector<sptr<AudioStandard::AudioDeviceDescriptor>>&
1444 descriptors, const std::string& deviceId,
1445 AudioStandard::AudioDeviceDescriptor& audioDescriptor)
1446 {
1447 for (const auto& descriptor : descriptors) {
1448 if (std::to_string(descriptor->deviceId_) == deviceId) {
1449 audioDescriptor = *descriptor;
1450 SLOGI("deviceId is %{public}d, networkId is %{public}.6s", audioDescriptor.deviceId_,
1451 audioDescriptor.networkId_.c_str());
1452 return true;
1453 }
1454 }
1455 SLOGI("deviceId is %{public}s, not found in all audio descriptor", deviceId.c_str());
1456 return false;
1457 }
1458
GetDeviceInfo(const sptr<AVSessionItem> & session,const std::vector<AudioStandard::AudioDeviceDescriptor> & descriptors,std::vector<AudioStandard::AudioDeviceDescriptor> & castSinkDescriptors,std::vector<AudioStandard::AudioDeviceDescriptor> & cancelSinkDescriptors)1459 void AVSessionService::GetDeviceInfo(const sptr <AVSessionItem>& session,
1460 const std::vector<AudioStandard::AudioDeviceDescriptor>& descriptors,
1461 std::vector<AudioStandard::AudioDeviceDescriptor>& castSinkDescriptors,
1462 std::vector<AudioStandard::AudioDeviceDescriptor>& cancelSinkDescriptors)
1463 {
1464 if (descriptors.size() != 1) {
1465 SLOGI("descriptor size is %{public}d, not support", static_cast<int32_t>(descriptors.size()));
1466 return;
1467 }
1468 castSinkDescriptors.push_back(descriptors[0]);
1469 SLOGI("cast to deviceId %{public}d, networkId_ is %{public}.6s", descriptors[0].deviceId_,
1470 descriptors[0].networkId_.c_str());
1471
1472 OutputDeviceInfo tempOutputDeviceInfo;
1473 session->GetOutputDevice(tempOutputDeviceInfo);
1474 // If not in remote, return directly
1475 if (tempOutputDeviceInfo.deviceInfos_.size() == 0 || tempOutputDeviceInfo.deviceInfos_[0].castCategory_ == 1) {
1476 SLOGI("castCategory is %{public}d, no need to cancel", tempOutputDeviceInfo.deviceInfos_[0].castCategory_);
1477 return;
1478 }
1479 int32_t ret = GetAudioDescriptor(session->GetDescriptor().outputDeviceInfo_.deviceInfos_[0].deviceId_,
1480 cancelSinkDescriptors);
1481 CHECK_AND_RETURN_LOG(ret == AVSESSION_SUCCESS, "get cancelSinkDescriptors failed");
1482 }
1483
SelectOutputDevice(const int32_t uid,const AudioDeviceDescriptor & descriptor)1484 int32_t AVSessionService::SelectOutputDevice(const int32_t uid, const AudioDeviceDescriptor& descriptor)
1485 {
1486 SLOGI("uid is %{public}d", uid);
1487 sptr <AudioStandard::AudioRendererFilter> audioFilter = new(std::nothrow) AudioRendererFilter();
1488 CHECK_AND_RETURN_RET_LOG(audioFilter != nullptr, ERR_NO_MEMORY, "new AudioRendererFilter failed");
1489 audioFilter->uid = uid;
1490 audioFilter->rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
1491 audioFilter->rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
1492
1493 std::vector<sptr<AudioDeviceDescriptor>> audioDescriptor;
1494 auto audioDeviceDescriptor = new(std::nothrow) AudioDeviceDescriptor(descriptor);
1495 CHECK_AND_RETURN_RET_LOG(audioDeviceDescriptor != nullptr, ERR_NO_MEMORY, "audioDeviceDescriptor is nullptr");
1496 audioDescriptor.push_back(audioDeviceDescriptor);
1497 SLOGI("select the device %{public}s id %{public}d role is %{public}d, networkId is %{public}.6s",
1498 descriptor.deviceName_.c_str(), descriptor.deviceId_, static_cast<int32_t>(descriptor.deviceRole_),
1499 descriptor.networkId_.c_str());
1500
1501 AudioSystemManager *audioSystemMgr = AudioSystemManager::GetInstance();
1502 CHECK_AND_RETURN_RET_LOG(audioSystemMgr != nullptr, AVSESSION_ERROR, "get AudioSystemManager instance failed");
1503 int32_t ret = audioSystemMgr->SelectOutputDevice(audioFilter, audioDescriptor);
1504 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, AVSESSION_ERROR, "SelectOutputDevice failed");
1505
1506 return AVSESSION_SUCCESS;
1507 }
1508
CastAudio(const SessionToken & token,const std::vector<AudioStandard::AudioDeviceDescriptor> & sinkAudioDescriptors)1509 int32_t AVSessionService::CastAudio(const SessionToken& token,
1510 const std::vector<AudioStandard::AudioDeviceDescriptor>& sinkAudioDescriptors)
1511 {
1512 SLOGI("sessionId is %{public}s", token.sessionId.c_str());
1513 if (!PermissionChecker::GetInstance().CheckSystemPermission()) {
1514 SLOGE("CastAudio: CheckSystemPermission failed");
1515 HISYSEVENT_SECURITY("CONTROL_PERMISSION_DENIED", "CALLER_UID", GetCallingUid(), "CALLER_PID", GetCallingPid(),
1516 "ERROR_MSG", "avsessionservice CastAudio checksystempermission failed");
1517 return ERR_NO_PERMISSION;
1518 }
1519
1520 std::string sourceSessionInfo;
1521 int32_t ret = SetBasicInfo(sourceSessionInfo);
1522 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "SetBasicInfo failed");
1523 sptr<AVSessionItem> session = GetContainer().GetSessionById(token.sessionId);
1524 CHECK_AND_RETURN_RET_LOG(session != nullptr, ERR_SESSION_NOT_EXIST, "session %{public}s not exist",
1525 token.sessionId.c_str());
1526 ret = JsonUtils::SetSessionDescriptor(sourceSessionInfo, session->GetDescriptor());
1527 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "SetDescriptorInfo failed");
1528 ret = CastAudioProcess(sinkAudioDescriptors, sourceSessionInfo, session);
1529 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "CastAudioProcess failed");
1530 return AVSESSION_SUCCESS;
1531 }
1532
CastAudioProcess(const std::vector<AudioStandard::AudioDeviceDescriptor> & descriptors,const std::string & sourceSessionInfo,sptr<AVSessionItem> & session)1533 int32_t AVSessionService::CastAudioProcess(const std::vector<AudioStandard::AudioDeviceDescriptor>& descriptors,
1534 const std::string& sourceSessionInfo,
1535 sptr <AVSessionItem>& session)
1536 {
1537 SLOGI("start");
1538 std::vector<AudioDeviceDescriptor> castSinkDescriptors;
1539 std::vector<AudioDeviceDescriptor> cancelSinkDescriptors;
1540 GetDeviceInfo(session, descriptors, castSinkDescriptors, cancelSinkDescriptors);
1541
1542 if (cancelSinkDescriptors.size() > 0) {
1543 int32_t ret = CancelCastAudioInner(cancelSinkDescriptors, sourceSessionInfo, session);
1544 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "CancelCastAudioInner failed");
1545 }
1546
1547 if (castSinkDescriptors.size() > 0) {
1548 int32_t ret = CastAudioInner(castSinkDescriptors, sourceSessionInfo, session);
1549 if (ret != AVSESSION_SUCCESS) {
1550 SLOGE("CastAudioInner failed, try cancel it. ret is %{public}d",
1551 CancelCastAudioInner(castSinkDescriptors, sourceSessionInfo, session));
1552 return ret;
1553 }
1554 }
1555
1556 SetDeviceInfo(descriptors, session);
1557 return AVSESSION_SUCCESS;
1558 }
1559
CastAudioInner(const std::vector<AudioStandard::AudioDeviceDescriptor> & sinkAudioDescriptors,const std::string & sourceSessionInfo,const sptr<AVSessionItem> & session)1560 int32_t AVSessionService::CastAudioInner(const std::vector<AudioStandard::AudioDeviceDescriptor>& sinkAudioDescriptors,
1561 const std::string& sourceSessionInfo,
1562 const sptr <AVSessionItem>& session)
1563 {
1564 SLOGI("start");
1565 CHECK_AND_RETURN_RET_LOG(sinkAudioDescriptors.size() > 0, AVSESSION_ERROR, "sinkDescriptors is empty");
1566 std::string sourceDevice;
1567 CHECK_AND_RETURN_RET_LOG(GetLocalNetworkId(sourceDevice) == AVSESSION_SUCCESS, AVSESSION_ERROR,
1568 "GetLocalNetworkId failed");
1569 SLOGI("networkId_: %{public}.6s, role %{public}d", sinkAudioDescriptors[0].networkId_.c_str(),
1570 static_cast<int32_t>(sinkAudioDescriptors[0].deviceRole_));
1571 if (IsLocalDevice(sinkAudioDescriptors[0].networkId_)) {
1572 int32_t ret = SelectOutputDevice(session->GetUid(), sinkAudioDescriptors[0]);
1573 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "selectOutputDevice failed");
1574 return AVSESSION_SUCCESS;
1575 }
1576
1577 SLOGI("sinkAudioDescriptors size is %{public}d", static_cast<int32_t>(sinkAudioDescriptors.size()));
1578 for (const auto& sinkAudioDescriptor : sinkAudioDescriptors) {
1579 std::string sinkSessionInfo;
1580 auto service = GetService(sinkAudioDescriptor.networkId_);
1581 CHECK_AND_RETURN_RET_LOG(service != nullptr, AVSESSION_ERROR, "GetService %{public}s failed",
1582 sinkAudioDescriptor.networkId_.c_str());
1583 int32_t ret = service->ProcessCastAudioCommand(RemoteServiceCommand::COMMAND_CAST_AUDIO, sourceSessionInfo,
1584 sinkSessionInfo);
1585 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "ProcessCastAudioCommand failed");
1586 std::string sinkCapability;
1587 ret = JsonUtils::GetAllCapability(sinkSessionInfo, sinkCapability);
1588 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "GetAllCapability failed");
1589 ret = session->CastAudioToRemote(sourceDevice, sinkAudioDescriptor.networkId_, sinkCapability);
1590 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "CastAudioToRemote failed");
1591 HISYSEVENT_BEHAVIOR("SESSION_CAST",
1592 "BUNDLE_NAME", session->GetDescriptor().elementName_.GetBundleName(),
1593 "MODULE_NAME", session->GetDescriptor().elementName_.GetModuleName(),
1594 "ABILITY_NAME", session->GetDescriptor().elementName_.GetAbilityName(),
1595 "SESSION_PID", session->GetDescriptor().pid_,
1596 "SESSION_UID", session->GetDescriptor().uid_,
1597 "SESSION_ID", session->GetDescriptor().sessionId_,
1598 "SESSION_TAG", session->GetDescriptor().sessionTag_,
1599 "SESSION_TYPE", session->GetDescriptor().sessionType_,
1600 "CAST_TYPE", 0,
1601 "DEST_DEVICE_TYPE", sinkAudioDescriptor.deviceType_,
1602 "DEST_DEVICE_NAME", sinkAudioDescriptor.deviceName_.c_str(),
1603 "DEST_DEVICE_ID", sinkAudioDescriptor.deviceId_,
1604 "DETAILED_MSG", "avsession service cast audio");
1605 ret = SelectOutputDevice(session->GetUid(), sinkAudioDescriptor);
1606 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "selectOutputDevice failed");
1607 }
1608 SLOGI("success");
1609 return AVSESSION_SUCCESS;
1610 }
1611
CancelCastAudioInner(const std::vector<AudioStandard::AudioDeviceDescriptor> & sinkDevices,const std::string & sourceSessionInfo,const sptr<AVSessionItem> & session)1612 int32_t AVSessionService::CancelCastAudioInner(const std::vector<AudioStandard::AudioDeviceDescriptor>& sinkDevices,
1613 const std::string& sourceSessionInfo,
1614 const sptr <AVSessionItem>& session)
1615 {
1616 SLOGI("cancel sinkDevices size is %{public}d", static_cast<int32_t>(sinkDevices.size()));
1617 CHECK_AND_RETURN_RET_LOG(!sinkDevices.empty(), AVSESSION_ERROR, "sinkDevices is empty");
1618 for (const auto& sinkDevice : sinkDevices) {
1619 if (IsLocalDevice(sinkDevice.networkId_)) {
1620 SLOGI("cancel Local device %{public}.6s", sinkDevice.networkId_.c_str());
1621 continue;
1622 }
1623 std::string sinkSessionInfo;
1624 SLOGI("cancel sinkDevices sinkDevice.networkId_ is %{public}.6s", sinkDevice.networkId_.c_str());
1625 auto service = GetService(sinkDevice.networkId_);
1626 CHECK_AND_RETURN_RET_LOG(service != nullptr, AVSESSION_ERROR, "GetService %{public}s failed",
1627 sinkDevice.networkId_.c_str());
1628 int32_t ret = service->ProcessCastAudioCommand(RemoteServiceCommand::COMMAND_CANCEL_CAST_AUDIO,
1629 sourceSessionInfo, sinkSessionInfo);
1630 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "ProcessCastAudioCommand failed");
1631 ret = session->SourceCancelCastAudio(sinkDevice.networkId_);
1632 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "SourceCancelCastAudio failed");
1633 }
1634 return AVSESSION_SUCCESS;
1635 }
1636
CastAudioForNewSession(const sptr<AVSessionItem> & session)1637 int32_t AVSessionService::CastAudioForNewSession(const sptr<AVSessionItem>& session)
1638 {
1639 SLOGI("new sessionId is %{public}s", session->GetSessionId().c_str());
1640 SessionToken token;
1641 token.sessionId = session->GetSessionId();
1642 token.pid = session->GetPid();
1643 token.uid = session->GetUid();
1644
1645 int32_t ret = AVSESSION_SUCCESS;
1646 std::vector<AudioStandard::AudioDeviceDescriptor> castSinkDevices;
1647 {
1648 std::lock_guard lockGuard(outputDeviceIdLock_);
1649 ret = GetAudioDescriptor(outputDeviceId_, castSinkDevices);
1650 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "GetAudioDescriptor failed");
1651 }
1652
1653 ret = CastAudio(token, castSinkDevices);
1654 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "CastAudio error, session Id is %{public}s",
1655 token.sessionId.c_str());
1656
1657 SLOGI("success");
1658 return AVSESSION_SUCCESS;
1659 }
1660
CastAudioForAll(const std::vector<AudioStandard::AudioDeviceDescriptor> & sinkAudioDescriptors)1661 int32_t AVSessionService::CastAudioForAll(const std::vector<AudioStandard::AudioDeviceDescriptor>& sinkAudioDescriptors)
1662 {
1663 CHECK_AND_RETURN_RET_LOG(sinkAudioDescriptors.size() > 0, ERR_INVALID_PARAM, "sinkAudioDescriptors is empty");
1664 if (!PermissionChecker::GetInstance().CheckSystemPermission()) {
1665 SLOGE("CastAudioForAll: CheckSystemPermission failed");
1666 HISYSEVENT_SECURITY("CONTROL_PERMISSION_DENIED", "CALLER_UID", GetCallingUid(), "CALLER_PID", GetCallingPid(),
1667 "ERROR_MSG", "avsessionservice CastAudioForAll checksystempermission failed");
1668 return ERR_NO_PERMISSION;
1669 }
1670
1671 {
1672 std::lock_guard lockGuard(isAllSessionCastLock_);
1673 isAllSessionCast_ = false;
1674 if (!IsLocalDevice(sinkAudioDescriptors[0].networkId_)) {
1675 isAllSessionCast_ = true;
1676 }
1677 }
1678 for (const auto& session : GetContainer().GetAllSessions()) {
1679 SessionToken token;
1680 token.sessionId = session->GetSessionId();
1681 token.pid = session->GetPid();
1682 token.uid = session->GetUid();
1683 SLOGI("cast session %{public}s", token.sessionId.c_str());
1684 int32_t ret = CastAudio(token, sinkAudioDescriptors);
1685 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "CastAudio session %{public}s failed",
1686 token.sessionId.c_str());
1687 {
1688 std::lock_guard lockGuard(outputDeviceIdLock_);
1689 outputDeviceId_ = session->GetDescriptor().outputDeviceInfo_.deviceInfos_[0].deviceId_;
1690 }
1691 }
1692
1693 SLOGI("isAllSessionCast_ %{public}d, outputDeviceId_ is %{public}s", isAllSessionCast_, outputDeviceId_.c_str());
1694 return AVSESSION_SUCCESS;
1695 }
1696
ProcessCastAudioCommand(const RemoteServiceCommand command,const std::string & input,std::string & output)1697 int32_t AVSessionService::ProcessCastAudioCommand(const RemoteServiceCommand command, const std::string& input,
1698 std::string& output)
1699 {
1700 SLOGI("ProcessCastAudioCommand is %{public}d", static_cast<int32_t>(command));
1701 CHECK_AND_RETURN_RET_LOG(command > COMMAND_INVALID && command < COMMAND_MAX, AVSESSION_ERROR, "invalid command");
1702 if (command == COMMAND_CAST_AUDIO) {
1703 int ret = RemoteCastAudioInner(input, output);
1704 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "RemoteCastAudioInner error");
1705 return AVSESSION_SUCCESS;
1706 }
1707
1708 int ret = RemoteCancelCastAudioInner(input);
1709 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "RemoteCancelCastAudioInner error");
1710 SLOGI("success");
1711 return AVSESSION_SUCCESS;
1712 }
1713
RemoteCastAudioInner(const std::string & sourceSessionInfo,std::string & sinkSessionInfo)1714 int32_t AVSessionService::RemoteCastAudioInner(const std::string& sourceSessionInfo, std::string& sinkSessionInfo)
1715 {
1716 SLOGI("sourceInfo : %{public}s", sourceSessionInfo.c_str());
1717 AVSessionDescriptor sourceDescriptor;
1718 int32_t ret = JsonUtils::GetSessionDescriptor(sourceSessionInfo, sourceDescriptor);
1719 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "GetSessionDescriptor failed");
1720
1721 ret = SetBasicInfo(sinkSessionInfo);
1722 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, AVSESSION_ERROR, "SetBasicInfo failed");
1723 AVSessionBasicInfo sinkDeviceInfo;
1724 ret = JsonUtils::GetSessionBasicInfo(sinkSessionInfo, sinkDeviceInfo);
1725 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "GetBasicInfo failed");
1726
1727 sptr <AVSessionItem> session = CreateSessionInner(sourceDescriptor.sessionTag_, sourceDescriptor.sessionType_,
1728 sourceDescriptor.isThirdPartyApp_,
1729 sourceDescriptor.elementName_);
1730 SLOGI("source sessionId_ %{public}s", sourceDescriptor.sessionId_.c_str());
1731 CHECK_AND_RETURN_RET_LOG(session != nullptr, AVSESSION_ERROR, "CreateSession failed");
1732 SLOGI("sink deviceId %{public}s", session->GetSessionId().c_str());
1733
1734 {
1735 std::lock_guard lockGuard(castAudioSessionMapLock_);
1736 castAudioSessionMap_[sourceDescriptor.sessionId_] = session->GetSessionId();
1737 }
1738
1739 AVSessionBasicInfo sourceDeviceInfo;
1740 ret = JsonUtils::GetSessionBasicInfo(sourceSessionInfo, sourceDeviceInfo);
1741 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "GetBasicInfo failed");
1742 std::string sourceCapability;
1743 ret = JsonUtils::GetAllCapability(sourceSessionInfo, sourceCapability);
1744 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "GetAllCapability failed");
1745 ret = session->CastAudioFromRemote(sourceDescriptor.sessionId_, sourceDeviceInfo.networkId_,
1746 sinkDeviceInfo.networkId_, sourceCapability);
1747 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "CastAudioFromRemote failed");
1748 SLOGI("CastAudioFromRemote success");
1749 JsonUtils::SetSessionDescriptor(sinkSessionInfo, session->GetDescriptor());
1750 SLOGI("sinkSessionInfo : %{public}s", sinkSessionInfo.c_str());
1751 return AVSESSION_SUCCESS;
1752 }
1753
RemoteCancelCastAudioInner(const std::string & sessionInfo)1754 int32_t AVSessionService::RemoteCancelCastAudioInner(const std::string& sessionInfo)
1755 {
1756 SLOGI("sessionInfo is %{public}s", sessionInfo.c_str());
1757 AVSessionBasicInfo sourceDeviceInfo;
1758 int32_t ret = JsonUtils::GetSessionBasicInfo(sessionInfo, sourceDeviceInfo);
1759 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "GetBasicInfo failed");
1760 AVSessionDescriptor sourceDescriptor;
1761 ret = JsonUtils::GetSessionDescriptor(sessionInfo, sourceDescriptor);
1762 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "GetSessionDescriptor failed");
1763
1764 std::lock_guard lockGuard(castAudioSessionMapLock_);
1765 auto iter = castAudioSessionMap_.find(sourceDescriptor.sessionId_);
1766 CHECK_AND_RETURN_RET_LOG(iter != castAudioSessionMap_.end(), AVSESSION_ERROR, "no source session %{public}s",
1767 sourceDescriptor.sessionId_.c_str());
1768 auto session = GetContainer().GetSessionById(iter->second);
1769 CHECK_AND_RETURN_RET_LOG(session != nullptr, AVSESSION_ERROR, "no sink session %{public}s", iter->second.c_str());
1770
1771 ret = session->SinkCancelCastAudio();
1772 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "SinkCancelCastAudio failed");
1773 ClearSessionNoLock(session->GetSessionId());
1774 castAudioSessionMap_.erase(sourceDescriptor.sessionId_);
1775 SLOGI("cancel source session %{public}s success", sourceDescriptor.sessionId_.c_str());
1776 return AVSESSION_SUCCESS;
1777 }
1778
CancelCastAudioForClientExit(pid_t pid,const sptr<AVSessionItem> & session)1779 int32_t AVSessionService::CancelCastAudioForClientExit(pid_t pid, const sptr<AVSessionItem>& session)
1780 {
1781 CHECK_AND_RETURN_RET_LOG(session != nullptr, AVSESSION_ERROR, "session is nullptr");
1782 SLOGI("pid is %{public}d, sessionId is %{public}s", static_cast<int32_t>(pid), session->GetSessionId().c_str());
1783 std::string sourceSessionInfo;
1784 int32_t ret = SetBasicInfo(sourceSessionInfo);
1785 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "SetBasicInfo failed");
1786 ret = JsonUtils::SetSessionDescriptor(sourceSessionInfo, session->GetDescriptor());
1787 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "SetDescriptorInfo failed");
1788
1789 std::vector<AudioStandard::AudioDeviceDescriptor> cancelSinkDevices;
1790 ret = GetAudioDescriptor(session->GetDescriptor().outputDeviceInfo_.deviceInfos_[0].deviceId_, cancelSinkDevices);
1791 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "GetAudioDescriptor failed");
1792
1793 ret = CancelCastAudioInner(cancelSinkDevices, sourceSessionInfo, session);
1794 CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, ret, "CancelCastAudioInner failed");
1795 return AVSESSION_SUCCESS;
1796 }
1797
GetAudioDescriptor(const std::string deviceId,std::vector<AudioStandard::AudioDeviceDescriptor> & audioDeviceDescriptors)1798 int32_t AVSessionService::GetAudioDescriptor(const std::string deviceId,
1799 std::vector<AudioStandard::AudioDeviceDescriptor>& audioDeviceDescriptors)
1800 {
1801 auto audioDescriptors = AudioSystemManager::GetInstance()->GetDevices(ALL_L_D_DEVICES_FLAG);
1802 AudioDeviceDescriptor audioDescriptor;
1803 if (GetAudioDescriptorByDeviceId(audioDescriptors, deviceId, audioDescriptor)) {
1804 audioDeviceDescriptors.push_back(audioDescriptor);
1805 SLOGI("get audio deviceId %{public}d, networkId_ is %{public}.6s", audioDescriptor.deviceId_,
1806 audioDescriptor.networkId_.c_str());
1807 return AVSESSION_SUCCESS;
1808 }
1809 SLOGI("can not get deviceId %{public}s info", deviceId.c_str());
1810 return AVSESSION_ERROR;
1811 }
1812
ClearSessionForClientDiedNoLock(pid_t pid)1813 void AVSessionService::ClearSessionForClientDiedNoLock(pid_t pid)
1814 {
1815 auto sessions = GetContainer().RemoveSession(pid);
1816 for (const auto& session : sessions) {
1817 if (topSession_ == session) {
1818 UpdateTopSession(nullptr);
1819 }
1820 if (session->GetRemoteSource() != nullptr) {
1821 int32_t ret = CancelCastAudioForClientExit(pid, session);
1822 SLOGI("CancelCastAudioForClientExit ret is %{public}d", ret);
1823 }
1824 SLOGI("remove sessionId=%{public}s", session->GetSessionId().c_str());
1825 session->Destroy();
1826 }
1827 }
1828
ClearSessionNoLock(const std::string & sessionId)1829 void AVSessionService::ClearSessionNoLock(const std::string& sessionId)
1830 {
1831 auto session = GetContainer().RemoveSession(sessionId);
1832 if (topSession_ == session) {
1833 UpdateTopSession(nullptr);
1834 }
1835 SLOGI("remove sessionId=%{public}s", session->GetSessionId().c_str());
1836 session->Destroy();
1837 }
1838
ClearControllerForClientDiedNoLock(pid_t pid)1839 void AVSessionService::ClearControllerForClientDiedNoLock(pid_t pid)
1840 {
1841 auto it = controllers_.find(pid);
1842 CHECK_AND_RETURN_LOG(it != controllers_.end(), "no find controller");
1843 auto controllers = std::move(it->second);
1844 SLOGI("remove controllers size=%{public}d", static_cast<int>(controllers.size()));
1845 if (!controllers.empty()) {
1846 for (const auto& controller : controllers) {
1847 controller->Destroy();
1848 }
1849 }
1850 it = controllers_.find(pid);
1851 CHECK_AND_RETURN_LOG(it != controllers_.end(), "no find controller");
1852 controllers_.erase(pid);
1853 }
1854
ClientDeathRecipient(const std::function<void ()> & callback)1855 ClientDeathRecipient::ClientDeathRecipient(const std::function<void()>& callback)
1856 : callback_(callback)
1857 {
1858 SLOGD("construct");
1859 }
1860
OnRemoteDied(const wptr<IRemoteObject> & object)1861 void ClientDeathRecipient::OnRemoteDied(const wptr<IRemoteObject>& object)
1862 {
1863 if (callback_) {
1864 callback_();
1865 }
1866 }
1867
LoadStringFromFileEx(const string & filePath,string & content)1868 bool AVSessionService::LoadStringFromFileEx(const string& filePath, string& content)
1869 {
1870 ifstream file(filePath.c_str());
1871 if (!file.is_open()) {
1872 SLOGD("file not open! try open first ! ");
1873 file.open(filePath.c_str(), ios::app);
1874 if (!file.is_open()) {
1875 SLOGE("open file again fail !");
1876 return false;
1877 }
1878 }
1879 file.seekg(0, ios::end);
1880 const long fileLength = file.tellg();
1881 SLOGI("get file length(%{public}ld)!", fileLength);
1882 if (fileLength > maxFileLength) {
1883 SLOGE("invalid file length(%{public}ld)!", fileLength);
1884 return false;
1885 }
1886 if (fileLength <= 0) {
1887 SLOGD("file new create empty ! try set init json ");
1888 ofstream fileWrite;
1889 fileWrite.open(filePath.c_str(), ios::out | ios::trunc);
1890 nlohmann::json emptyValue;
1891 std::string emptyContent = emptyValue.dump();
1892 SLOGD("LoadStringFromFileEx::Dump json object finished");
1893 fileWrite.write(emptyContent.c_str(), emptyContent.length());
1894 if (fileWrite.fail()) {
1895 SLOGE("file empty init json fail ! ");
1896 return false;
1897 }
1898 }
1899 content.clear();
1900 file.seekg(0, ios::beg);
1901 copy(istreambuf_iterator<char>(file), istreambuf_iterator<char>(), back_inserter(content));
1902 return true;
1903 }
1904
SaveStringToFileEx(const std::string & filePath,const std::string & content)1905 bool AVSessionService::SaveStringToFileEx(const std::string& filePath, const std::string& content)
1906 {
1907 ofstream file;
1908 file.open(filePath.c_str(), ios::out | ios::trunc);
1909 if (!file.is_open()) {
1910 SLOGE("open file failed! ");
1911 return false;
1912 }
1913 if (content.empty()) {
1914 SLOGE("write content is empty, no need to do write! ");
1915 }
1916 file.write(content.c_str(), content.length());
1917 if (file.fail()) {
1918 SLOGE("write content to file failed! ");
1919 return false;
1920 }
1921 return true;
1922 }
1923 } // namespace OHOS::AVSession
1924