1 /*
2 * Copyright (C) 2021-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 "battery_stats_info.h"
17
18 #include "stats_common.h"
19 #include "stats_log.h"
20
21 namespace OHOS {
22 namespace PowerMgr {
23 constexpr int32_t PARAM_MAX_NUM = 2000;
Marshalling(Parcel & parcel) const24 bool BatteryStatsInfo::Marshalling(Parcel& parcel) const
25 {
26 STATS_RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(COMP_FWK, parcel, Int32, uid_, false);
27 STATS_RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(COMP_FWK, parcel, Int32, static_cast<int32_t>(type_), false);
28 STATS_RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(COMP_FWK, parcel, Double, totalPowerMah_, false);
29 STATS_HILOGD(COMP_FWK, "uid: %{public}d, type: %{public}d, power: %{public}lf", uid_, type_, totalPowerMah_);
30 return true;
31 }
32
Unmarshalling(Parcel & parcel)33 std::shared_ptr<BatteryStatsInfo> BatteryStatsInfo::Unmarshalling(Parcel& parcel)
34 {
35 std::shared_ptr<BatteryStatsInfo> statsInfo = std::make_shared<BatteryStatsInfo>();
36 if (statsInfo == nullptr) {
37 STATS_HILOGW(COMP_FWK, "BatteryStatsInfo object creation failed");
38 return statsInfo;
39 }
40 if (!statsInfo->ReadFromParcel(parcel)) {
41 STATS_HILOGW(COMP_FWK, "Read from parcel failed");
42 statsInfo = nullptr;
43 }
44 return statsInfo;
45 }
46
ReadFromParcel(Parcel & parcel)47 bool BatteryStatsInfo::ReadFromParcel(Parcel &parcel)
48 {
49 STATS_RETURN_IF_READ_PARCEL_FAILED_WITH_RET(COMP_FWK, parcel, Int32, uid_, false);
50 int32_t type = static_cast<int32_t>(0);
51 STATS_RETURN_IF_READ_PARCEL_FAILED_WITH_RET(COMP_FWK, parcel, Int32, type, false);
52 type_ = static_cast<ConsumptionType>(type);
53 STATS_RETURN_IF_READ_PARCEL_FAILED_WITH_RET(COMP_FWK, parcel, Double, totalPowerMah_, false);
54 STATS_HILOGD(COMP_FWK, "uid: %{public}d, type: %{public}d, power: %{public}lf", uid_, type_, totalPowerMah_);
55 return true;
56 }
57
SetUid(int32_t uid)58 void BatteryStatsInfo::SetUid(int32_t uid)
59 {
60 if (uid > StatsUtils::INVALID_VALUE) {
61 uid_ = uid;
62 }
63 STATS_HILOGD(COMP_FWK, "Uid: %{public}d", uid);
64 }
65
SetUserId(int32_t userId)66 void BatteryStatsInfo::SetUserId(int32_t userId)
67 {
68 if (userId > StatsUtils::INVALID_VALUE) {
69 userId_ = userId;
70 }
71 STATS_HILOGD(COMP_FWK, "UserId: %{public}d", userId);
72 }
73
SetConsumptioType(ConsumptionType type)74 void BatteryStatsInfo::SetConsumptioType(ConsumptionType type)
75 {
76 type_ = type;
77 }
78
SetPower(double power)79 void BatteryStatsInfo::SetPower(double power)
80 {
81 if (uid_ > StatsUtils::INVALID_VALUE) {
82 STATS_HILOGD(COMP_FWK, "Set APP power: %{public}lfmAh for uid: %{public}d", totalPowerMah_, uid_);
83 } else {
84 STATS_HILOGD(COMP_FWK, "Set power: %{public}lfmAh for part: %{public}s", totalPowerMah_,
85 ConvertConsumptionType(type_).c_str());
86 }
87 totalPowerMah_ = power;
88 }
89
GetUid()90 int32_t BatteryStatsInfo::GetUid()
91 {
92 return uid_;
93 }
94
GetUserId()95 int32_t BatteryStatsInfo::GetUserId()
96 {
97 return userId_;
98 }
99
GetConsumptionType()100 BatteryStatsInfo::ConsumptionType BatteryStatsInfo::GetConsumptionType()
101 {
102 return type_;
103 }
104
GetPower()105 double BatteryStatsInfo::GetPower()
106 {
107 if (uid_ > StatsUtils::INVALID_VALUE) {
108 STATS_HILOGD(COMP_FWK, "Get app power: %{public}lfmAh for uid: %{public}d", totalPowerMah_, uid_);
109 } else {
110 STATS_HILOGD(COMP_FWK, "Get power: %{public}lfmAh for part: %{public}s", totalPowerMah_,
111 ConvertConsumptionType(type_).c_str());
112 }
113 return totalPowerMah_;
114 }
115
ConvertTypeForPart(ConsumptionType type)116 std::string BatteryStatsInfo::ConvertTypeForPart(ConsumptionType type)
117 {
118 std::string result = "";
119 switch (type) {
120 case CONSUMPTION_TYPE_BLUETOOTH:
121 result = GET_VARIABLE_NAME(CONSUMPTION_TYPE_BLUETOOTH);
122 break;
123 case CONSUMPTION_TYPE_IDLE:
124 result = GET_VARIABLE_NAME(CONSUMPTION_TYPE_IDLE);
125 break;
126 case CONSUMPTION_TYPE_PHONE:
127 result = GET_VARIABLE_NAME(CONSUMPTION_TYPE_PHONE);
128 break;
129 case CONSUMPTION_TYPE_SCREEN:
130 result = GET_VARIABLE_NAME(CONSUMPTION_TYPE_SCREEN);
131 break;
132 case CONSUMPTION_TYPE_WIFI:
133 result = GET_VARIABLE_NAME(CONSUMPTION_TYPE_WIFI);
134 break;
135 default:
136 break;
137 }
138 STATS_HILOGD(COMP_FWK, "Convert to %{public}s", result.c_str());
139 return result;
140 }
141
ConvertTypeForApp(ConsumptionType type)142 std::string BatteryStatsInfo::ConvertTypeForApp(ConsumptionType type)
143 {
144 std::string result = "";
145 switch (type) {
146 case CONSUMPTION_TYPE_USER:
147 result = GET_VARIABLE_NAME(CONSUMPTION_TYPE_USER);
148 break;
149 case CONSUMPTION_TYPE_APP:
150 result = GET_VARIABLE_NAME(CONSUMPTION_TYPE_APP);
151 break;
152 case CONSUMPTION_TYPE_CAMERA:
153 result = GET_VARIABLE_NAME(CONSUMPTION_TYPE_CAMERA);
154 break;
155 case CONSUMPTION_TYPE_FLASHLIGHT:
156 result = GET_VARIABLE_NAME(CONSUMPTION_TYPE_FLASHLIGHT);
157 break;
158 case CONSUMPTION_TYPE_AUDIO:
159 result = GET_VARIABLE_NAME(CONSUMPTION_TYPE_AUDIO);
160 break;
161 case CONSUMPTION_TYPE_SENSOR:
162 result = GET_VARIABLE_NAME(CONSUMPTION_TYPE_SENSOR);
163 break;
164 case CONSUMPTION_TYPE_GNSS:
165 result = GET_VARIABLE_NAME(CONSUMPTION_TYPE_GNSS);
166 break;
167 case CONSUMPTION_TYPE_CPU:
168 result = GET_VARIABLE_NAME(CONSUMPTION_TYPE_CPU);
169 break;
170 case CONSUMPTION_TYPE_WAKELOCK:
171 result = GET_VARIABLE_NAME(CONSUMPTION_TYPE_WAKELOCK);
172 break;
173 case CONSUMPTION_TYPE_ALARM:
174 result = GET_VARIABLE_NAME(CONSUMPTION_TYPE_ALARM);
175 break;
176 default:
177 break;
178 }
179 STATS_HILOGD(COMP_FWK, "Convert to %{public}s", result.c_str());
180 return result;
181 }
182
ConvertConsumptionType(ConsumptionType type)183 std::string BatteryStatsInfo::ConvertConsumptionType(ConsumptionType type)
184 {
185 std::string result = "";
186 switch (type) {
187 case CONSUMPTION_TYPE_BLUETOOTH:
188 case CONSUMPTION_TYPE_IDLE:
189 case CONSUMPTION_TYPE_PHONE:
190 case CONSUMPTION_TYPE_SCREEN:
191 case CONSUMPTION_TYPE_WIFI:
192 result = ConvertTypeForPart(type);
193 break;
194 case CONSUMPTION_TYPE_USER:
195 case CONSUMPTION_TYPE_APP:
196 case CONSUMPTION_TYPE_CAMERA:
197 case CONSUMPTION_TYPE_FLASHLIGHT:
198 case CONSUMPTION_TYPE_AUDIO:
199 case CONSUMPTION_TYPE_SENSOR:
200 case CONSUMPTION_TYPE_GNSS:
201 case CONSUMPTION_TYPE_CPU:
202 case CONSUMPTION_TYPE_WAKELOCK:
203 case CONSUMPTION_TYPE_ALARM:
204 result = ConvertTypeForApp(type);
205 break;
206 default:
207 STATS_HILOGD(COMP_FWK, "Conversion failed because the type was illegal, return empty string");
208 break;
209 }
210 return result;
211 }
212
Marshalling(Parcel & parcel) const213 bool ParcelableBatteryStatsList::Marshalling(Parcel& parcel) const
214 {
215 int32_t size = static_cast<int32_t>(statsList_.size());
216 STATS_RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(COMP_FWK, parcel, Int32, size, false);
217 bool res = true;
218 for (const auto& templateVal : statsList_) {
219 if (templateVal == nullptr) {
220 continue;
221 }
222 res = templateVal->Marshalling(parcel);
223 }
224 return res;
225 }
226
Unmarshalling(Parcel & parcel)227 ParcelableBatteryStatsList* ParcelableBatteryStatsList::Unmarshalling(Parcel& parcel)
228 {
229 constexpr int32_t PARAM_ZERO = 0;
230 auto listPtr = std::make_unique<ParcelableBatteryStatsList>();
231
232 int32_t size = parcel.ReadInt32();
233 if (size < PARAM_ZERO || size > PARAM_MAX_NUM) {
234 STATS_HILOGE(COMP_FWK, "size is invalid, size=%{public}d", size);
235 return nullptr;
236 }
237
238 for (int32_t i = PARAM_ZERO; i < size; ++i) {
239 auto info = std::make_shared<BatteryStatsInfo>();
240 info->ReadFromParcel(parcel);
241 listPtr->statsList_.emplace_back(info);
242 }
243
244 return listPtr.release();
245 }
246 } // namespace PowerMgr
247 } // namespace OHOS
248