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