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 "process_priority_info.h"
17 #include "memmgr_log.h"
18 #include "reclaim_priority_constants.h"
19
20 #include <sstream>
21
22 namespace OHOS {
23 namespace Memory {
24 namespace {
25 const std::string TAG = "ProcessPriorityInfo";
26 } // namespace
27
ProcessPriorityInfo(pid_t pid,int bundleUid,int priority,bool isImportant)28 ProcessPriorityInfo::ProcessPriorityInfo(pid_t pid, int bundleUid, int priority, bool isImportant)
29 {
30 this->uid_ = bundleUid;
31 this->pid_ = pid;
32 this->priority_ = priority;
33 this->priorityIfImportant_ = priority;
34 this->isImportant_ = isImportant;
35 this->isVisible_ = false;
36 this->isRender_ = false;
37 this->isFreground = (priority == RECLAIM_PRIORITY_FOREGROUND) ? true : false;
38 this->isBackgroundRunning = false;
39 this->isSuspendDelay = false;
40 this->isEventStart = false;
41 this->isDistDeviceConnected = false;
42 this->isExtension_ = false;
43 this->extensionBindStatus = EXTENSION_STATUS_BIND_UNKOWN;
44 this->isAbilityStarting_ = false;
45 this->startingAbilityTime_ = INVALID_TIME;
46 }
47
ProcessPriorityInfo(const ProcessPriorityInfo & copyProcess)48 ProcessPriorityInfo::ProcessPriorityInfo(const ProcessPriorityInfo ©Process)
49 {
50 this->uid_ = copyProcess.uid_;
51 this->pid_ = copyProcess.pid_;
52 this->priority_ = copyProcess.priority_;
53 this->priorityIfImportant_ = copyProcess.priorityIfImportant_;
54 this->isImportant_ = copyProcess.isImportant_;
55 this->isVisible_ = copyProcess.isVisible_;
56 this->isRender_ = copyProcess.isRender_;
57 this->isFreground = copyProcess.isFreground;
58 this->isExtension_ = copyProcess.isExtension_;
59 this->hasUI_ = copyProcess.hasUI_;
60 this->isBackgroundRunning = copyProcess.isBackgroundRunning;
61 this->isSuspendDelay = copyProcess.isSuspendDelay;
62 this->isEventStart = copyProcess.isEventStart;
63 this->isDistDeviceConnected = copyProcess.isDistDeviceConnected;
64 this->extensionBindStatus = copyProcess.extensionBindStatus;
65 for (auto &pair : copyProcess.procsBindToMe_) {
66 this->procsBindToMe_.insert(std::make_pair(pair.first, pair.second));
67 }
68 for (auto &pair : copyProcess.procsBindFromMe_) {
69 this->procsBindFromMe_.insert(std::make_pair(pair.first, pair.second));
70 }
71
72 this->isAbilityStarting_ = copyProcess.isAbilityStarting_;
73 this->startingAbilityTime_ = copyProcess.startingAbilityTime_;
74 }
75
~ProcessPriorityInfo()76 ProcessPriorityInfo::~ProcessPriorityInfo()
77 {
78 procsBindToMe_.clear();
79 procsBindFromMe_.clear();
80 }
81
SetPriority(int targetPriority)82 void ProcessPriorityInfo::SetPriority(int targetPriority)
83 {
84 priority_ = targetPriority;
85 HILOGD("set process[%{public}d] priority to %{public}d", pid_, priority_);
86 }
87
ExtensionConnectorsCount()88 int32_t ProcessPriorityInfo::ExtensionConnectorsCount()
89 {
90 return procsBindToMe_.size();
91 }
92
ProcBindToMe(int32_t pid,int32_t uid)93 void ProcessPriorityInfo::ProcBindToMe(int32_t pid, int32_t uid)
94 {
95 procsBindToMe_[pid] = uid;
96 HILOGE("insert process[pid=%{public}d, uid=%{public}d] to procsBindToMe_, map size = %{public}zu",
97 pid, uid, procsBindToMe_.size());
98 }
99
ProcUnBindToMe(int32_t pid)100 void ProcessPriorityInfo::ProcUnBindToMe(int32_t pid)
101 {
102 procsBindToMe_.erase(pid);
103 HILOGE("remove process[pid=%{public}d] to procsBindToMe_, map size = %{public}zu",
104 pid, procsBindToMe_.size());
105 }
106
ProcBindFromMe(int32_t pid,int32_t uid)107 void ProcessPriorityInfo::ProcBindFromMe(int32_t pid, int32_t uid)
108 {
109 procsBindFromMe_[pid] = uid;
110 HILOGE("insert process[pid=%{public}d, uid=%{public}d] to procsBindFromMe_, map size = %{public}zu",
111 pid, uid, procsBindFromMe_.size());
112 }
113
ProcUnBindFromMe(int32_t pid)114 void ProcessPriorityInfo::ProcUnBindFromMe(int32_t pid)
115 {
116 procsBindFromMe_.erase(pid);
117 HILOGE("remove process[pid=%{public}d] to procsBindFromMe_, map size = %{public}zu",
118 pid, procsBindFromMe_.size());
119 }
120
ProcsBindToMe()121 std::string ProcessPriorityInfo::ProcsBindToMe()
122 {
123 std::stringstream ss;
124 ss << "[";
125 for (auto &pair : procsBindToMe_) {
126 ss << "(pid=" << pair.first << ", uid=" << pair.second << ") ";
127 }
128 ss << "]";
129 return ss.str();
130 }
131
ProcsBindFromMe()132 std::string ProcessPriorityInfo::ProcsBindFromMe()
133 {
134 std::stringstream ss;
135 ss << "[";
136 for (auto &pair : procsBindFromMe_) {
137 ss << "(pid=" << pair.first << ", uid=" << pair.second << ") ";
138 }
139 ss << "]";
140 return ss.str();
141 }
142
IsAbilityStarting() const143 bool ProcessPriorityInfo::IsAbilityStarting() const
144 {
145 return isAbilityStarting_;
146 }
147
SetIsAbilityStarting(bool isAbilityStarting)148 void ProcessPriorityInfo::SetIsAbilityStarting(bool isAbilityStarting)
149 {
150 isAbilityStarting_ = isAbilityStarting;
151 }
152
SetStartingAbilityTime(int64_t time)153 void ProcessPriorityInfo::SetStartingAbilityTime(int64_t time)
154 {
155 startingAbilityTime_ = time;
156 }
157
GetStartingAbilityTime() const158 int64_t ProcessPriorityInfo::GetStartingAbilityTime() const
159 {
160 return startingAbilityTime_;
161 }
162
163 } // namespace Memory
164 } // namespace OHOS
165