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
GetSessionById(const std::string & sessionId)131 sptr<AVSessionItem> SessionStack::GetSessionById(const std::string& sessionId)
132 {
133 std::lock_guard sessionStackLockGuard(sessionStackLock_);
134 for (const auto& session : stack_) {
135 if (session->GetSessionId() == sessionId) {
136 return session;
137 }
138 }
139 return nullptr;
140 }
141
GetAllSessions()142 std::vector<sptr<AVSessionItem>> SessionStack::GetAllSessions()
143 {
144 std::vector<sptr<AVSessionItem>> result;
145 std::lock_guard sessionStackLockGuard(sessionStackLock_);
146 for (const auto& session : stack_) {
147 result.push_back(session);
148 }
149 return result;
150 }
151
IsEmpty()152 bool SessionStack::IsEmpty()
153 {
154 return stack_.empty();
155 }
156
getAllSessionNum()157 int32_t SessionStack::getAllSessionNum()
158 {
159 return static_cast<int32_t>(stack_.size());
160 }
161 } // namespace OHOS::AVSession
162