1 /*
2  * Copyright (c) 2022-2024 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 #include "work_info.h"
16 
17 #include "work_sched_hilog.h"
18 
19 namespace OHOS {
20 namespace WorkScheduler {
21 const int32_t INVALID_VALUE = -1;
22 const int32_t INVALID_TIME_VALUE = 0;
23 const uint32_t MAX_SIZE = 1024;
24 const int32_t APPINDEX_INIT_VALUE = 0;
25 
WorkInfo()26 WorkInfo::WorkInfo()
27 {
28     workId_ = INVALID_VALUE;
29     uid_ = INVALID_VALUE;
30     persisted_ = false;
31     extras_ = nullptr;
32     appIndex_ = APPINDEX_INIT_VALUE;
33     extension_ = true;
34     saId_ = INVALID_VALUE;
35     residentSa_ = false;
36 }
37 
~WorkInfo()38 WorkInfo::~WorkInfo() {}
39 
SetWorkId(int32_t workId)40 void WorkInfo::SetWorkId(int32_t workId)
41 {
42     workId_ = workId;
43 }
44 
SetElement(std::string bundleName,std::string abilityName)45 void WorkInfo::SetElement(std::string bundleName, std::string abilityName)
46 {
47     bundleName_ = bundleName;
48     abilityName_ = abilityName;
49 }
50 
RequestPersisted(bool persisted)51 void WorkInfo::RequestPersisted(bool persisted)
52 {
53     persisted_ = persisted;
54 }
55 
RequestNetworkType(WorkCondition::Network condition)56 void WorkInfo::RequestNetworkType(WorkCondition::Network condition)
57 {
58     std::shared_ptr<Condition> networkCondition = std::make_shared<Condition>();
59     networkCondition->enumVal = static_cast<int32_t>(condition);
60     conditionMap_.emplace(WorkCondition::Type::NETWORK, networkCondition);
61 }
62 
RequestChargerType(bool isCharging,WorkCondition::Charger condition)63 void WorkInfo::RequestChargerType(bool isCharging, WorkCondition::Charger condition)
64 {
65     std::shared_ptr<Condition> chargerCondition = std::make_shared<Condition>();
66     chargerCondition->boolVal = isCharging;
67     chargerCondition->enumVal = static_cast<int32_t>(condition);
68     conditionMap_.emplace(WorkCondition::Type::CHARGER, chargerCondition);
69 }
70 
RequestBatteryLevel(int32_t battLevel)71 void WorkInfo::RequestBatteryLevel(int32_t battLevel)
72 {
73     std::shared_ptr<Condition> batteryLevelCondition = std::make_shared<Condition>();
74     batteryLevelCondition->intVal = battLevel;
75     conditionMap_.emplace(WorkCondition::Type::BATTERY_LEVEL, batteryLevelCondition);
76 }
77 
RequestBatteryStatus(WorkCondition::BatteryStatus condition)78 void WorkInfo::RequestBatteryStatus(WorkCondition::BatteryStatus condition)
79 {
80     std::shared_ptr<Condition> batteryCondition = std::make_shared<Condition>();
81     batteryCondition->enumVal = static_cast<int32_t>(condition);
82     conditionMap_.emplace(WorkCondition::Type::BATTERY_STATUS, batteryCondition);
83 }
84 
RequestStorageLevel(WorkCondition::Storage condition)85 void WorkInfo::RequestStorageLevel(WorkCondition::Storage condition)
86 {
87     std::shared_ptr<Condition> storageCondition = std::make_shared<Condition>();
88     storageCondition->enumVal = static_cast<int32_t>(condition);
89     conditionMap_.emplace(WorkCondition::Type::STORAGE, storageCondition);
90 }
91 
RequestRepeatCycle(uint32_t timeInterval,int32_t cycle)92 void WorkInfo::RequestRepeatCycle(uint32_t timeInterval, int32_t cycle)
93 {
94     std::shared_ptr<Condition> repeatCycle = std::make_shared<Condition>();
95     repeatCycle->uintVal = timeInterval;
96     repeatCycle->intVal = cycle;
97     repeatCycle->boolVal = false;
98     conditionMap_.emplace(WorkCondition::Type::TIMER, repeatCycle);
99 }
100 
RequestRepeatCycle(uint32_t timeInterval)101 void WorkInfo::RequestRepeatCycle(uint32_t timeInterval)
102 {
103     std::shared_ptr<Condition> repeatCycle = std::make_shared<Condition>();
104     repeatCycle->uintVal = timeInterval;
105     repeatCycle->boolVal = true;
106     conditionMap_.emplace(WorkCondition::Type::TIMER, repeatCycle);
107 }
108 
RequestBaseTimeAndCycle(time_t baseTime,int32_t cycle)109 void WorkInfo::RequestBaseTimeAndCycle(time_t baseTime, int32_t cycle)
110 {
111     if (conditionMap_.count(WorkCondition::Type::TIMER) > 0) {
112         conditionMap_.at(WorkCondition::Type::TIMER)->timeVal = baseTime;
113         conditionMap_.at(WorkCondition::Type::TIMER)->intVal = cycle;
114     }
115 }
116 
RequestBaseTime(time_t baseTime)117 void WorkInfo::RequestBaseTime(time_t baseTime)
118 {
119     if (conditionMap_.count(WorkCondition::Type::TIMER) > 0) {
120         conditionMap_.at(WorkCondition::Type::TIMER)->timeVal = baseTime;
121     }
122 }
123 
RequestExtras(AAFwk::WantParams extras)124 void WorkInfo::RequestExtras(AAFwk::WantParams extras)
125 {
126     extras_ = std::make_shared<AAFwk::WantParams>(extras);
127 }
128 
RefreshUid(int32_t uid)129 void WorkInfo::RefreshUid(int32_t uid)
130 {
131     uid_ = uid;
132 }
133 
RefreshAppIndex(int32_t appIndex)134 void WorkInfo::RefreshAppIndex(int32_t appIndex)
135 {
136     appIndex_ = appIndex;
137 }
138 
RefreshExtension(bool extension)139 void WorkInfo::RefreshExtension(bool extension)
140 {
141     extension_ = extension;
142 }
143 
RequestDeepIdle(bool deepIdle)144 void WorkInfo::RequestDeepIdle(bool deepIdle)
145 {
146     std::shared_ptr<Condition> deepIdleCondition = std::make_shared<Condition>();
147     deepIdleCondition->boolVal = deepIdle;
148     conditionMap_.emplace(WorkCondition::Type::DEEP_IDLE, deepIdleCondition);
149 }
150 
SetCallBySystemApp(bool callBySystemApp)151 void WorkInfo::SetCallBySystemApp(bool callBySystemApp)
152 {
153     callBySystemApp_ = callBySystemApp;
154 }
155 
SetPreinstalled(bool preinstalled)156 void WorkInfo::SetPreinstalled(bool preinstalled)
157 {
158     preinstalled_ = preinstalled;
159 }
160 
IsPreinstalled()161 bool WorkInfo::IsPreinstalled()
162 {
163     return preinstalled_;
164 }
165 
GetUriKey()166 std::string WorkInfo::GetUriKey()
167 {
168     return uriKey_;
169 }
170 
GetUid()171 int32_t WorkInfo::GetUid()
172 {
173     return uid_;
174 }
175 
GetWorkId()176 int32_t WorkInfo::GetWorkId()
177 {
178     return workId_;
179 }
180 
GetBundleName()181 std::string WorkInfo::GetBundleName()
182 {
183     return bundleName_;
184 }
185 
GetAbilityName()186 std::string WorkInfo::GetAbilityName()
187 {
188     return abilityName_;
189 }
190 
IsPersisted()191 bool WorkInfo::IsPersisted()
192 {
193     return persisted_;
194 }
195 
GetAppIndex() const196 int32_t WorkInfo::GetAppIndex() const
197 {
198     return appIndex_;
199 }
200 
GetExtension() const201 bool WorkInfo::GetExtension() const
202 {
203     return extension_;
204 }
205 
GetNetworkType()206 WorkCondition::Network WorkInfo::GetNetworkType()
207 {
208     if (conditionMap_.count(WorkCondition::Type::NETWORK) > 0) {
209         int32_t enumVal = conditionMap_.at(WorkCondition::Type::NETWORK)->enumVal;
210         WorkCondition::Network network = WorkCondition::Network(enumVal);
211         return WorkCondition::Network(network);
212     }
213     return WorkCondition::Network::NETWORK_UNKNOWN;
214 }
215 
GetChargerType()216 WorkCondition::Charger WorkInfo::GetChargerType()
217 {
218     if (conditionMap_.count(WorkCondition::Type::CHARGER) > 0) {
219         int32_t enumVal = conditionMap_.at(WorkCondition::Type::CHARGER)->enumVal;
220         WorkCondition::Charger charger = WorkCondition::Charger(enumVal);
221         return WorkCondition::Charger(charger);
222     }
223     return WorkCondition::Charger::CHARGING_UNKNOWN;
224 }
225 
GetBatteryLevel()226 int32_t WorkInfo::GetBatteryLevel()
227 {
228     if (conditionMap_.count(WorkCondition::Type::BATTERY_LEVEL) > 0) {
229         return conditionMap_.at(WorkCondition::Type::BATTERY_LEVEL)->intVal;
230     }
231     return INVALID_VALUE;
232 }
233 
GetBatteryStatus()234 WorkCondition::BatteryStatus WorkInfo::GetBatteryStatus()
235 {
236     if (conditionMap_.count(WorkCondition::Type::BATTERY_STATUS) > 0) {
237         int32_t enumVal = conditionMap_.at(WorkCondition::Type::BATTERY_STATUS)->enumVal;
238         WorkCondition::BatteryStatus battery = WorkCondition::BatteryStatus(enumVal);
239         return WorkCondition::BatteryStatus(battery);
240     }
241     return WorkCondition::BatteryStatus::BATTERY_UNKNOWN;
242 }
243 
GetStorageLevel()244 WorkCondition::Storage WorkInfo::GetStorageLevel()
245 {
246     if (conditionMap_.count(WorkCondition::Type::STORAGE) > 0) {
247         int32_t enumVal = conditionMap_.at(WorkCondition::Type::STORAGE)->enumVal;
248         WorkCondition::Storage storage = WorkCondition::Storage(enumVal);
249         return WorkCondition::Storage(storage);
250     }
251     return WorkCondition::Storage::STORAGE_UNKNOWN;
252 }
253 
IsRepeat()254 bool WorkInfo::IsRepeat()
255 {
256     if (conditionMap_.count(WorkCondition::Type::TIMER) > 0) {
257         return conditionMap_.at(WorkCondition::Type::TIMER)->boolVal;
258     }
259     return false;
260 }
261 
GetTimeInterval()262 uint32_t WorkInfo::GetTimeInterval()
263 {
264     if (conditionMap_.count(WorkCondition::Type::TIMER) > 0) {
265         return conditionMap_.at(WorkCondition::Type::TIMER)->uintVal;
266     }
267     return INVALID_TIME_VALUE;
268 }
269 
GetCycleCount()270 int32_t WorkInfo::GetCycleCount()
271 {
272     if (conditionMap_.count(WorkCondition::Type::TIMER) > 0) {
273         if (IsRepeat()) {
274             return INVALID_VALUE;
275         }
276         return conditionMap_.at(WorkCondition::Type::TIMER)->intVal;
277     }
278     return INVALID_VALUE;
279 }
280 
GetBaseTime()281 time_t WorkInfo::GetBaseTime()
282 {
283     if (conditionMap_.count(WorkCondition::Type::TIMER) > 0) {
284         return conditionMap_.at(WorkCondition::Type::TIMER)->timeVal;
285     }
286     time_t result;
287     time(&result);
288     return result;
289 }
290 
GetDeepIdle()291 WorkCondition::DeepIdle WorkInfo::GetDeepIdle()
292 {
293     if (conditionMap_.count(WorkCondition::Type::DEEP_IDLE) <= 0) {
294         return WorkCondition::DeepIdle::DEEP_IDLE_UNKNOWN;
295     }
296     return conditionMap_.at(WorkCondition::Type::DEEP_IDLE)->boolVal ?
297         WorkCondition::DeepIdle::DEEP_IDLE_IN : WorkCondition::DeepIdle::DEEP_IDLE_OUT;
298 }
299 
GetConditionMap()300 std::shared_ptr<std::map<WorkCondition::Type, std::shared_ptr<Condition>>> WorkInfo::GetConditionMap()
301 {
302     return std::make_shared<std::map<WorkCondition::Type, std::shared_ptr<Condition>>>(conditionMap_);
303 }
304 
GetExtras() const305 std::shared_ptr<AAFwk::WantParams> WorkInfo::GetExtras() const
306 {
307     return extras_;
308 }
309 
IsCallBySystemApp()310 bool WorkInfo::IsCallBySystemApp()
311 {
312     return callBySystemApp_;
313 }
314 
Marshalling(Parcel & parcel) const315 bool WorkInfo::Marshalling(Parcel &parcel) const
316 {
317     bool ret = false;
318     ret = parcel.WriteInt32(workId_);
319     ret = ret && parcel.WriteString(bundleName_);
320     ret = ret && parcel.WriteString(abilityName_);
321     ret = ret && parcel.WriteBool(persisted_);
322     ret = ret && parcel.WriteInt32(uid_);
323     ret = ret && parcel.WriteUint32(conditionMap_.size());
324     for (auto it : conditionMap_) {
325         switch (it.first) {
326             case WorkCondition::Type::NETWORK:
327             case WorkCondition::Type::BATTERY_STATUS:
328             case WorkCondition::Type::STORAGE: {
329                 ret = ret && parcel.WriteInt32(it.first);
330                 ret = ret && parcel.WriteInt32(it.second->enumVal);
331                 break;
332             }
333             case WorkCondition::Type::CHARGER:
334             case WorkCondition::Type::DEEP_IDLE: {
335                 ret = ret && parcel.WriteInt32(it.first);
336                 ret = ret && parcel.WriteBool(it.second->boolVal);
337                 ret = ret && parcel.WriteInt32(it.second->enumVal);
338                 break;
339             }
340             case WorkCondition::Type::BATTERY_LEVEL: {
341                 ret = ret && parcel.WriteInt32(it.first);
342                 ret = ret && parcel.WriteInt32(it.second->intVal);
343                 break;
344             }
345             case WorkCondition::Type::TIMER: {
346                 ret = ret && parcel.WriteInt32(it.first);
347                 ret = ret && parcel.WriteUint32(it.second->uintVal);
348                 ret = ret && parcel.WriteBool(it.second->boolVal);
349                 if (!it.second->boolVal) {
350                     ret = ret && parcel.WriteInt32(it.second->intVal);
351                 }
352                 break;
353             }
354             default: {
355                 ret = false;
356             }
357         }
358     }
359     ret = ret && parcel.WriteBool(extras_ ? true : false);
360     if (extras_) {
361         ret = ret && extras_->Marshalling(parcel);
362     }
363     return ret;
364 }
365 
Unmarshalling(Parcel & parcel)366 sptr<WorkInfo> WorkInfo::Unmarshalling(Parcel &parcel)
367 {
368     sptr<WorkInfo> read = new (std::nothrow) WorkInfo();
369     if (read == nullptr) {
370         WS_HILOGE("read is nullptr.");
371         return nullptr;
372     }
373     if (!parcel.ReadInt32(read->workId_) || !parcel.ReadString(read->bundleName_) ||
374         !parcel.ReadString(read->abilityName_)) {
375         WS_HILOGE("Failed to read the workId or bundleName or abilityName.");
376         return nullptr;
377     }
378     if (!parcel.ReadBool(read->persisted_)) {
379         WS_HILOGE("Failed to read the persisted.");
380         return nullptr;
381     }
382     if (!parcel.ReadInt32(read->uid_)) {
383         WS_HILOGE("Failed to read the uid.");
384         return nullptr;
385     }
386     uint32_t mapsize;
387     if (!parcel.ReadUint32(mapsize) || mapsize >= MAX_SIZE) {
388         WS_HILOGE("Failed to read the mapsize or mapsize is too big.");
389         return nullptr;
390     }
391     if (!UnmarshallCondition(parcel, read, mapsize)) {
392         WS_HILOGE("Failed to read the work condition map.");
393         return nullptr;
394     }
395     bool hasExtras;
396     if (!parcel.ReadBool(hasExtras)) {
397         WS_HILOGE("Failed to read the extras existence.");
398         return nullptr;
399     }
400     if (!hasExtras) {
401         return read;
402     }
403     AAFwk::WantParams *wantParams = AAFwk::WantParams::Unmarshalling(parcel);
404     if (wantParams != nullptr) {
405         read->extras_ = std::make_shared<AAFwk::WantParams>(*wantParams);
406     }
407     return read;
408 }
409 
UnmarshallCondition(Parcel & parcel,sptr<WorkInfo> & read,uint32_t mapsize)410 bool WorkInfo::UnmarshallCondition(Parcel &parcel, sptr<WorkInfo> &read, uint32_t mapsize)
411 {
412     read->conditionMap_ = std::map<WorkCondition::Type, std::shared_ptr<Condition>>();
413     for (uint32_t i = 0; i < mapsize; i++) {
414         int32_t key;
415         if (!parcel.ReadInt32(key)) {
416             return false;
417         }
418         auto condition = std::make_shared<Condition>();
419         switch (key) {
420             case WorkCondition::Type::NETWORK:
421             case WorkCondition::Type::BATTERY_STATUS:
422             case WorkCondition::Type::STORAGE: {
423                 if (!parcel.ReadInt32(condition->enumVal)) {
424                     return false;
425                 }
426                 break;
427             }
428             case WorkCondition::Type::DEEP_IDLE:
429             case WorkCondition::Type::CHARGER: {
430                 if (!parcel.ReadBool(condition->boolVal) || !parcel.ReadInt32(condition->enumVal)) {
431                     return false;
432                 }
433                 break;
434             }
435             case WorkCondition::Type::BATTERY_LEVEL: {
436                 if (!parcel.ReadInt32(condition->intVal)) {
437                     return false;
438                 }
439                 break;
440             }
441             case WorkCondition::Type::TIMER: {
442                 if (!parcel.ReadUint32(condition->uintVal) || !parcel.ReadBool(condition->boolVal)) {
443                     return false;
444                 }
445                 if (!condition->boolVal && !parcel.ReadInt32(condition->intVal)) {
446                     return false;
447                 }
448                 break;
449             }
450             default: {
451             }
452         }
453         read->conditionMap_.emplace(WorkCondition::Type(key), condition);
454     }
455     return true;
456 }
457 
ParseToJsonStr()458 std::string WorkInfo::ParseToJsonStr()
459 {
460     Json::Value root;
461     if (uid_ != INVALID_VALUE) {
462         root["uid"] = uid_;
463     }
464     root["workId"] = workId_;
465     root["bundleName"] = bundleName_;
466     root["abilityName"] = abilityName_;
467     root["persisted"] = persisted_;
468     root["preinstalled"] = preinstalled_;
469     root["uriKey"] = uriKey_;
470     root["callBySystemApp"] = callBySystemApp_;
471     root["appIndex"] = appIndex_;
472     root["extension"] = extension_;
473     ParseConditionToJsonStr(root);
474     if (extras_) {
475         Json::Value extras;
476         Json::Value extrasType;
477         std::map<std::string, sptr<AAFwk::IInterface>> extrasMap = extras_->GetParams();
478         int typeId = INVALID_VALUE;
479         for (auto it : extrasMap) {
480             typeId = AAFwk::WantParams::GetDataType(it.second);
481             extrasType[it.first] = typeId;
482             if (typeId != INVALID_VALUE) {
483                 std::string value = AAFwk::WantParams::GetStringByType(it.second, typeId);
484                 extras[it.first] = value;
485             } else {
486                 WS_HILOGE("parameters: type error.");
487             }
488         }
489         root["parameters"] = extras;
490         root["parametersType"] = extrasType;
491     }
492     Json::StreamWriterBuilder writerBuilder;
493     std::ostringstream os;
494     std::unique_ptr<Json::StreamWriter> jsonWriter(writerBuilder.newStreamWriter());
495     jsonWriter->write(root, &os);
496     std::string result = os.str();
497     return result;
498 }
499 
ParseConditionToJsonStr(Json::Value & root)500 void WorkInfo::ParseConditionToJsonStr(Json::Value &root)
501 {
502     Json::Value conditions;
503     for (auto it : conditionMap_) {
504         switch (it.first) {
505             case WorkCondition::Type::NETWORK: {
506                 conditions["network"] = it.second->enumVal;
507                 break;
508             }
509             case WorkCondition::Type::CHARGER: {
510                 conditions["isCharging"] = it.second->boolVal;
511                 conditions["chargerType"] = it.second->enumVal;
512                 break;
513             }
514             case WorkCondition::Type::BATTERY_LEVEL: {
515                 conditions["batteryLevel"] = it.second->intVal;
516                 break;
517             }
518             case WorkCondition::Type::BATTERY_STATUS: {
519                 conditions["batteryStatus"] = it.second->enumVal;
520                 break;
521             }
522             case WorkCondition::Type::STORAGE: {
523                 conditions["storage"] = it.second->enumVal;
524                 break;
525             }
526             case WorkCondition::Type::TIMER: {
527                 conditions["timer"] = it.second->uintVal;
528                 conditions["repeat"] = it.second->boolVal;
529                 conditions["baseTime"] = it.second->timeVal;
530                 if (!it.second->boolVal) {
531                     conditions["cycle"] = it.second->intVal;
532                 }
533                 break;
534             }
535             case WorkCondition::Type::DEEP_IDLE: {
536                 conditions["isDeepIdle"] = it.second->boolVal;
537                 break;
538             }
539             default: {}
540         }
541     }
542     root["conditions"] = conditions;
543 }
544 
ParseFromJson(const Json::Value & value)545 bool WorkInfo::ParseFromJson(const Json::Value &value)
546 {
547     if (value.empty()) {
548         WS_HILOGE("workinfo json is empty");
549         return false;
550     }
551     if ((value.isMember("saId") && value["saId"].isInt()) && IsHasBoolProp(value, "residentSa")) {
552         this->saId_ = value["saId"].asInt();
553         this->residentSa_ = value["residentSa"].asBool();
554         return true;
555     }
556     if (!value.isMember("workId") || !value["workId"].isInt() ||
557         !value.isMember("bundleName") || !value["bundleName"].isString() ||
558         !value.isMember("abilityName") || !value["abilityName"].isString()) {
559         WS_HILOGE("workinfo json is invalid");
560         return false;
561     }
562     this->workId_ = value["workId"].asInt();
563     this->bundleName_ = value["bundleName"].asString();
564     this->abilityName_ = value["abilityName"].asString();
565     if (IsHasBoolProp(value, "persisted")) {
566         this->persisted_ = value["persisted"].asBool();
567     }
568     if (IsHasBoolProp(value, "preinstalled")) {
569         this->preinstalled_ = value["preinstalled"].asBool();
570     }
571     if (value.isMember("uriKey") && value["uriKey"].isString()) {
572         this->uriKey_ = value["uriKey"].asString();
573     }
574     if (IsHasBoolProp(value, "callBySystemApp")) {
575         this->callBySystemApp_ = value["callBySystemApp"].asBool();
576     }
577     if (value.isMember("appIndex") && value["appIndex"].isInt()) {
578         this->appIndex_ = value["appIndex"].asInt();
579     }
580     if (IsHasBoolProp(value, "extension")) {
581         this->extension_ = value["extension"].asBool();
582     }
583     ParseConditionFromJsonStr(value);
584     if (!value.isMember("parameters")) {
585         return true;
586     }
587     ParseParametersFromJsonStr(value);
588     return true;
589 }
590 
ParseParametersFromJsonStr(const Json::Value & value)591 void WorkInfo::ParseParametersFromJsonStr(const Json::Value &value)
592 {
593     Json::Value extrasJson = value["parameters"];
594     Json::Value extrasType = value["parametersType"];
595     AAFwk::WantParams extras;
596     Json::Value::Members keyList = extrasJson.getMemberNames();
597     int typeId = INVALID_VALUE;
598     for (auto key : keyList) {
599         if (extrasType[key].isInt()) {
600             typeId = extrasType[key].asInt();
601         }
602         if (typeId != INVALID_VALUE && extrasJson[key].isString()) {
603             sptr<AAFwk::IInterface> exInterface = AAFwk::WantParams::GetInterfaceByType(typeId,
604                 extrasJson[key].asString());
605             extras.SetParam(key, exInterface);
606         }
607     }
608     this->RequestExtras(extras);
609 }
610 
ParseConditionFromJsonStr(const Json::Value & value)611 void WorkInfo::ParseConditionFromJsonStr(const Json::Value &value)
612 {
613     if (value.isMember("uid") && value["uid"].isInt()) {
614         this->uid_ = value["uid"].asInt();
615     }
616     Json::Value conditions = value["conditions"];
617     if (conditions.isMember("network") && conditions["network"].isInt()) {
618         this->RequestNetworkType(WorkCondition::Network(conditions["network"].asInt()));
619     }
620     if (conditions.isMember("isCharging") && conditions["isCharging"].isBool() &&
621         conditions.isMember("chargerType") && conditions["chargerType"].isInt()) {
622         this->RequestChargerType(conditions["isCharging"].asBool(),
623             WorkCondition::Charger(conditions["chargerType"].asInt()));
624     }
625     if (conditions.isMember("batteryLevel") && conditions["batteryLevel"].isInt()) {
626         this->RequestBatteryLevel(conditions["batteryLevel"].asInt());
627     }
628     if (conditions.isMember("batteryStatus") && conditions["batteryStatus"].isInt()) {
629         this->RequestBatteryStatus(WorkCondition::BatteryStatus(conditions["batteryStatus"].asInt()));
630     }
631     if (conditions.isMember("storage") && conditions["storage"].isInt()) {
632         this->RequestStorageLevel(WorkCondition::Storage(conditions["storage"].asInt()));
633     }
634     if (conditions.isMember("isDeepIdle") && conditions["isDeepIdle"].isBool()) {
635         this->RequestDeepIdle(conditions["isDeepIdle"].asBool());
636     }
637     ParseTimerFormJsonStr(conditions);
638 }
639 
ParseTimerFormJsonStr(const Json::Value & conditions)640 void WorkInfo::ParseTimerFormJsonStr(const Json::Value &conditions)
641 {
642     if (conditions.isMember("timer") && conditions["timer"].isInt() &&
643         conditions.isMember("repeat") && conditions["repeat"].isBool()) {
644         if (conditions["repeat"].asBool()) {
645             this->RequestRepeatCycle(conditions["timer"].asInt());
646         } else {
647             if (conditions.isMember("cycle") && conditions["cycle"].isInt()) {
648                 this->RequestRepeatCycle(conditions["timer"].asInt(), conditions["cycle"].asInt());
649             }
650         }
651         if (conditions.isMember("baseTime") && conditions["baseTime"].isInt64()) {
652             time_t baseTime = (time_t)(conditions["baseTime"].asInt64());
653             this->RequestBaseTime(baseTime);
654         }
655     }
656 }
657 
Dump(std::string & result)658 void WorkInfo::Dump(std::string &result)
659 {
660     result.append(ParseToJsonStr());
661 }
662 
IsHasBoolProp(const Json::Value & value,const std::string & key)663 bool WorkInfo::IsHasBoolProp(const Json::Value &value, const std::string &key)
664 {
665     if (value.isMember(key) && value[key].isBool()) {
666         return true;
667     }
668     return false;
669 }
670 
GetSaId() const671 int32_t WorkInfo::GetSaId() const
672 {
673     return saId_;
674 }
675 
RefreshSaId(int32_t saId)676 void WorkInfo::RefreshSaId(int32_t saId)
677 {
678     saId_ = saId;
679 }
680 
IsResidentSa() const681 bool WorkInfo::IsResidentSa() const
682 {
683     return residentSa_;
684 }
685 } // namespace WorkScheduler
686 } // namespace OHOS
687