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)28 ProcessPriorityInfo::ProcessPriorityInfo(pid_t pid, int bundleUid, int priority)
29 {
30 this->uid_ = bundleUid;
31 this->pid_ = pid;
32 this->priority_ = priority;
33 this->isVisible_ = false;
34 this->isRender_ = false;
35 this->isFreground = (priority == RECLAIM_PRIORITY_FOREGROUND) ? true : false;
36 this->isBackgroundRunning = false;
37 this->isSuspendDelay = false;
38 this->isEventStart = false;
39 this->isDistDeviceConnected = false;
40 this->isExtension = false;
41 this->extensionBindStatus = EXTENSION_STATUS_BIND_UNKOWN;
42 }
43
ProcessPriorityInfo(const ProcessPriorityInfo & copyProcess)44 ProcessPriorityInfo::ProcessPriorityInfo(const ProcessPriorityInfo ©Process)
45 {
46 this->uid_ = copyProcess.uid_;
47 this->pid_ = copyProcess.pid_;
48 this->priority_ = copyProcess.priority_;
49 this->isVisible_ = copyProcess.isVisible_;
50 this->isRender_ = copyProcess.isRender_;
51 this->isFreground = copyProcess.isFreground;
52 this->isExtension = copyProcess.isExtension;
53 this->isBackgroundRunning = copyProcess.isBackgroundRunning;
54 this->isSuspendDelay = copyProcess.isSuspendDelay;
55 this->isEventStart = copyProcess.isEventStart;
56 this->isDistDeviceConnected = copyProcess.isDistDeviceConnected;
57 this->extensionBindStatus = copyProcess.extensionBindStatus;
58 for (auto connectors : copyProcess.extensionConnectors_) {
59 this->AddExtensionConnector(connectors);
60 }
61 for (auto callerUid : copyProcess.extensionProcessUids_) {
62 this->AddExtensionProcessUid(callerUid);
63 }
64 for (auto connectorUid : copyProcess.extensionConnectorUids_) {
65 this->AddExtensionConnectorUid(connectorUid);
66 }
67 }
68
~ProcessPriorityInfo()69 ProcessPriorityInfo::~ProcessPriorityInfo()
70 {
71 extensionConnectors_.clear();
72 extensionProcessUids_.clear();
73 extensionConnectorUids_.clear();
74 }
75
SetPriority(int targetPriority)76 void ProcessPriorityInfo::SetPriority(int targetPriority)
77 {
78 priority_ = targetPriority;
79 HILOGD("set process[%{public}d] priority to %{public}d", pid_, priority_);
80 }
81
ExtensionConnectorsCount()82 int32_t ProcessPriorityInfo::ExtensionConnectorsCount()
83 {
84 return extensionConnectors_.size();
85 }
86
AddExtensionConnector(int32_t pid)87 void ProcessPriorityInfo::AddExtensionConnector(int32_t pid)
88 {
89 extensionConnectors_.insert(pid);
90 }
91
RemoveExtensionConnector(int32_t pid)92 void ProcessPriorityInfo::RemoveExtensionConnector(int32_t pid)
93 {
94 extensionConnectors_.erase(pid);
95 }
96
AddExtensionProcessUid(int32_t uid)97 void ProcessPriorityInfo::AddExtensionProcessUid(int32_t uid)
98 {
99 extensionProcessUids_.insert(uid);
100 }
101
RemoveExtensionProcessUid(int32_t uid)102 void ProcessPriorityInfo::RemoveExtensionProcessUid(int32_t uid)
103 {
104 extensionProcessUids_.erase(uid);
105 }
106
AddExtensionConnectorUid(int32_t uid)107 void ProcessPriorityInfo::AddExtensionConnectorUid(int32_t uid)
108 {
109 extensionConnectorUids_.insert(uid);
110 }
111
RemoveExtensionConnectorUid(int32_t uid)112 void ProcessPriorityInfo::RemoveExtensionConnectorUid(int32_t uid)
113 {
114 extensionConnectorUids_.erase(uid);
115 }
116
ContainsConnector(int32_t pid)117 bool ProcessPriorityInfo::ContainsConnector(int32_t pid)
118 {
119 return extensionConnectors_.count(pid) != 0;
120 }
121
ConnectorsToString()122 std::string ProcessPriorityInfo::ConnectorsToString()
123 {
124 std::stringstream ss;
125 ss << "[";
126 for (auto connector : extensionConnectors_) {
127 ss << connector << " ";
128 }
129 ss << "]";
130 return ss.str();
131 }
132
ExtensionProcessUidToString()133 std::string ProcessPriorityInfo::ExtensionProcessUidToString()
134 {
135 std::stringstream ss;
136 ss << "[";
137 for (auto callerUid : extensionProcessUids_) {
138 ss << callerUid << " ";
139 }
140 ss << "]";
141 return ss.str();
142 }
143
ExtensionConnectorsUidToString()144 std::string ProcessPriorityInfo::ExtensionConnectorsUidToString()
145 {
146 std::stringstream ss;
147 ss << "[";
148 for (auto connectorUid : extensionConnectorUids_) {
149 ss << connectorUid << " ";
150 }
151 ss << "]";
152 return ss.str();
153 }
154 } // namespace Memory
155 } // namespace OHOS
156