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