1 /*
2 * Copyright (c) 2022 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 "session_stack.h"
17 #include "avsession_errors.h"
18 #include "avsession_sysevent.h"
19 #include "avsession_utils.h"
20
21 namespace OHOS::AVSession {
AddSession(pid_t pid,const std::string & abilityName,sptr<AVSessionItem> & item)22 int32_t SessionStack::AddSession(pid_t pid, const std::string& abilityName, sptr<AVSessionItem>& item)
23 {
24 std::lock_guard sessionStackLockGuard(sessionStackLock_);
25 if (sessions_.size() >= SessionContainer::SESSION_NUM_MAX) {
26 return ERR_SESSION_EXCEED_MAX;
27 }
28 sessions_.insert(std::make_pair(std::make_pair(pid, abilityName), item));
29 stack_.push_front(item);
30 HISYSEVENT_ADD_OPERATION_COUNT(Operation::OPT_CREATE_SESSION);
31 return AVSESSION_SUCCESS;
32 }
33
UpdateSessionSort(sptr<AVSessionItem> & item)34 void SessionStack::UpdateSessionSort(sptr<AVSessionItem>& item)
35 {
36 std::lock_guard sessionStackLockGuard(sessionStackLock_);
37 auto it = sessions_.find(std::make_pair(item->GetPid(), item->GetAbilityName()));
38 if (it == sessions_.end()) {
39 return;
40 }
41 stack_.remove(it->second);
42 sessions_.erase(it);
43 // change order by reinsert
44 sessions_.insert(std::make_pair(std::make_pair(item->GetPid(), item->GetAbilityName()), item));
45 stack_.push_front(item);
46 }
47
RemoveSession(pid_t pid)48 std::vector<sptr<AVSessionItem>> SessionStack::RemoveSession(pid_t pid)
49 {
50 std::vector<sptr<AVSessionItem>> result;
51 std::lock_guard sessionStackLockGuard(sessionStackLock_);
52 for (auto it = sessions_.begin(); it != sessions_.end();) {
53 if (it->first.first == pid) {
54 std::string sessionId = it->second->GetSessionId();
55 std::string fileName = AVSessionUtils::GetCachePathName() + sessionId + AVSessionUtils::GetFileSuffix();
56 AVSessionUtils::DeleteFile(fileName);
57 result.push_back(it->second);
58 stack_.remove(it->second);
59 it = sessions_.erase(it);
60 HISYSEVENT_ADD_OPERATION_COUNT(Operation::OPT_DELETE_SESSION);
61 } else {
62 it++;
63 }
64 }
65 return result;
66 }
67
RemoveSession(const std::string & sessionId)68 sptr<AVSessionItem> SessionStack::RemoveSession(const std::string& sessionId)
69 {
70 sptr<AVSessionItem> result;
71 std::lock_guard sessionStackLockGuard(sessionStackLock_);
72 for (auto it = sessions_.begin(); it != sessions_.end();) {
73 if (it->second->GetSessionId() == sessionId) {
74 std::string fileName = AVSessionUtils::GetCachePathName() + sessionId + AVSessionUtils::GetFileSuffix();
75 AVSessionUtils::DeleteFile(fileName);
76 result = it->second;
77 stack_.remove(it->second);
78 it = sessions_.erase(it);
79 HISYSEVENT_ADD_OPERATION_COUNT(Operation::OPT_DELETE_SESSION);
80 } else {
81 it++;
82 }
83 }
84 return result;
85 }
86
RemoveSession(pid_t pid,const std::string & abilityName)87 sptr<AVSessionItem> SessionStack::RemoveSession(pid_t pid, const std::string& abilityName)
88 {
89 std::lock_guard sessionStackLockGuard(sessionStackLock_);
90 auto it = sessions_.find(std::make_pair(pid, abilityName));
91 if (it == sessions_.end()) {
92 return nullptr;
93 }
94 HISYSEVENT_ADD_OPERATION_COUNT(Operation::OPT_DELETE_SESSION);
95 auto result = it->second;
96 std::string sessionId = result->GetSessionId();
97 std::string fileName = AVSessionUtils::GetCachePathName() + sessionId + AVSessionUtils::GetFileSuffix();
98 AVSessionUtils::DeleteFile(fileName);
99 sessions_.erase(it);
100 stack_.remove(result);
101 return result;
102 }
103
GetSession(pid_t pid,const std::string & abilityName)104 sptr<AVSessionItem> SessionStack::GetSession(pid_t pid, const std::string& abilityName)
105 {
106 std::lock_guard sessionStackLockGuard(sessionStackLock_);
107 auto it = sessions_.find(std::make_pair(pid, abilityName));
108 if (it == sessions_.end()) {
109 return nullptr;
110 }
111 return it->second;
112 }
113
PidHasSession(pid_t pid)114 bool SessionStack::PidHasSession(pid_t pid)
115 {
116 std::lock_guard sessionStackLockGuard(sessionStackLock_);
117 std::map<std::pair<pid_t, std::string>, sptr<AVSessionItem>>::iterator iter = sessions_.begin();
118 while (iter != sessions_.end()) {
119 if (iter->first.first == pid) {
120 return true;
121 }
122 ++iter;
123 }
124 return false;
125 }
126
GetSessionById(const std::string & sessionId)127 sptr<AVSessionItem> SessionStack::GetSessionById(const std::string& sessionId)
128 {
129 std::lock_guard sessionStackLockGuard(sessionStackLock_);
130 for (const auto& session : stack_) {
131 if (session->GetSessionId() == sessionId) {
132 return session;
133 }
134 }
135 return nullptr;
136 }
137
GetAllSessions()138 std::vector<sptr<AVSessionItem>> SessionStack::GetAllSessions()
139 {
140 std::vector<sptr<AVSessionItem>> result;
141 std::lock_guard sessionStackLockGuard(sessionStackLock_);
142 for (const auto& session : stack_) {
143 result.push_back(session);
144 }
145 return result;
146 }
147 } // namespace OHOS::AVSession
148