• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 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 <string>
17 #include "securec.h"
18 
19 #include "bundle_active_log.h"
20 #include "bundle_state_common.h"
21 #include "bundle_state_data.h"
22 #include "bundle_state_query_napi.h"
23 #include "app_group_observer_napi.h"
24 #include "bundle_state_inner_errors.h"
25 
26 namespace OHOS {
27 namespace DeviceUsageStats {
28 const uint32_t IS_IDLE_STATE_MIN_PARAMS = 1;
29 const uint32_t IS_IDLE_STATE_PARAMS = 2;
30 const uint32_t STATES_MIN_PARAMS = 2;
31 const uint32_t STATES_PARAMS = 3;
32 const uint32_t APP_USAGE_MIN_PARAMS_BY_INTERVAL = 3;
33 const uint32_t APP_USAGE_PARAMS_BY_INTERVAL = 4;
34 const uint32_t APP_USAGE_MIN_PARAMS = 2;
35 const uint32_t APP_USAGE_PARAMS = 3;
36 const uint32_t MODULE_RECORDS_MIN_PARAMS = 0;
37 const uint32_t MODULE_RECORDS_MIDDLE_PARAMS = 1;
38 const uint32_t MODULE_RECORDS_PARAMS = 2;
39 const uint32_t SECOND_ARG = 2;
40 const uint32_t THIRD_ARG = 3;
41 const int32_t MAXNUM_UP_LIMIT = 1000;
42 const std::vector<int32_t> GROUP_TYPE {10, 20, 30, 40, 50, 60};
43 const uint32_t EVENT_STATES_MIN_PARAMS = 2;
44 const uint32_t EVENT_STATES_PARAMS = 3;
45 
ParseQueryModuleUsageRecords(const napi_env & env,const napi_callback_info & info,ModuleRecordParamsInfo & params,AsyncCallbackInfoModuleRecord * & asyncCallbackInfo)46 napi_value ParseQueryModuleUsageRecords(const napi_env &env, const napi_callback_info &info,
47     ModuleRecordParamsInfo &params, AsyncCallbackInfoModuleRecord*& asyncCallbackInfo)
48 {
49     size_t argc = MODULE_RECORDS_PARAMS;
50     napi_value argv[MODULE_RECORDS_PARAMS] = {nullptr};
51     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
52     if ((argc != MODULE_RECORDS_MIN_PARAMS) && (argc != MODULE_RECORDS_MIDDLE_PARAMS) &&
53         (argc != MODULE_RECORDS_PARAMS)) {
54         params.errorCode = ERR_PARAMETERS_NUMBER;
55         return BundleStateCommon::HandleParamErr(env, ERR_PARAMETERS_NUMBER, "");
56     }
57 
58     if (argc == MODULE_RECORDS_MIN_PARAMS) {
59         params.maxNum = MAXNUM_UP_LIMIT;
60     }
61     if (argc == MODULE_RECORDS_MIDDLE_PARAMS) {
62         if (BundleStateCommon::GetInt32NumberValue(env, argv[0], params.maxNum) == nullptr) {
63             BUNDLE_ACTIVE_LOGI("get module info has only one callback param");
64             napi_valuetype valuetype = napi_undefined;
65             NAPI_CALL(env, napi_typeof(env, argv[0], &valuetype));
66             if (valuetype != napi_function) {
67                 params.errorCode = ERR_CALL_BACK_TYPE;
68                 return BundleStateCommon::HandleParamErr(env, ERR_CALL_BACK_TYPE, "");
69             }
70             params.maxNum = MAXNUM_UP_LIMIT;
71             napi_create_reference(env, argv[0], 1, &params.callback);
72         } else if (params.maxNum > MAXNUM_UP_LIMIT || params.maxNum <= 0) {
73             BUNDLE_ACTIVE_LOGI("get module info has only one maxNum param");
74             BUNDLE_ACTIVE_LOGE("ParseQueryModuleUsageRecords failed, maxNum is larger than 1000 or less/equal than 0");
75             params.errorCode = ERR_MAX_RECORDS_NUM_BIGER_THEN_ONE_THOUSAND;
76             return BundleStateCommon::HandleParamErr(env, ERR_MAX_RECORDS_NUM_BIGER_THEN_ONE_THOUSAND, "");
77         }
78     }
79     if (argc == MODULE_RECORDS_PARAMS) {
80         // argv[0] : maxNum
81         if (BundleStateCommon::GetInt32NumberValue(env, argv[0], params.maxNum) == nullptr) {
82             BUNDLE_ACTIVE_LOGE("ParseQueryModuleUsageRecords failed, maxNum type is invalid.");
83             params.errorCode = ERR_MAX_RECORDS_NUM_TYPE;
84             return BundleStateCommon::HandleParamErr(env, ERR_MAX_RECORDS_NUM_TYPE, "");
85         }
86 
87         if (params.maxNum > MAXNUM_UP_LIMIT || params.maxNum <= 0) {
88             BUNDLE_ACTIVE_LOGE("ParseQueryModuleUsageRecords failed, maxNum is larger than 1000 or less/equal than 0");
89             params.errorCode = ERR_MAX_RECORDS_NUM_BIGER_THEN_ONE_THOUSAND;
90             return BundleStateCommon::HandleParamErr(env, ERR_MAX_RECORDS_NUM_BIGER_THEN_ONE_THOUSAND, "");
91         }
92 
93         // argv[1] : callback
94         napi_valuetype valuetype = napi_undefined;
95         NAPI_CALL(env, napi_typeof(env, argv[1], &valuetype));
96         if (valuetype != napi_function) {
97             params.errorCode = ERR_CALL_BACK_TYPE;
98             return BundleStateCommon::HandleParamErr(env, ERR_CALL_BACK_TYPE, "");
99         }
100         napi_create_reference(env, argv[1], 1, &params.callback);
101     }
102     BundleStateCommon::AsyncInit(env, params, asyncCallbackInfo);
103     return BundleStateCommon::NapiGetNull(env);
104 }
105 
QueryModuleUsageRecords(napi_env env,napi_callback_info info)106 napi_value QueryModuleUsageRecords(napi_env env, napi_callback_info info)
107 {
108     ModuleRecordParamsInfo params;
109     AsyncCallbackInfoModuleRecord *asyncCallbackInfo = nullptr;
110     ParseQueryModuleUsageRecords(env, info, params, asyncCallbackInfo);
111     if (params.errorCode != ERR_OK) {
112         return BundleStateCommon::NapiGetNull(env);
113     }
114     napi_value promise = nullptr;
115     std::unique_ptr<AsyncCallbackInfoModuleRecord> callbackPtr {asyncCallbackInfo};
116     callbackPtr->maxNum = params.maxNum;
117     BundleStateCommon::SettingAsyncWorkData(env, params.callback, *asyncCallbackInfo, promise);
118     napi_value resourceName = nullptr;
119     NAPI_CALL(env, napi_create_string_latin1(env, "QueryModuleUsageRecords", NAPI_AUTO_LENGTH, &resourceName));
120     NAPI_CALL(env, napi_create_async_work(env,
121         nullptr,
122         resourceName,
123         [](napi_env env, void *data) {
124             AsyncCallbackInfoModuleRecord *asyncCallbackInfo = (AsyncCallbackInfoModuleRecord *)data;
125             if (asyncCallbackInfo != nullptr) {
126                 asyncCallbackInfo->errorCode =
127                     BundleActiveClient::GetInstance().QueryModuleUsageRecords(asyncCallbackInfo->maxNum,
128                     asyncCallbackInfo->moduleRecords);
129             } else {
130                 BUNDLE_ACTIVE_LOGE("QueryBundleStatsInfoByInterval, asyncCallbackInfo == nullptr");
131             }
132         },
133         [](napi_env env, napi_status status, void *data) {
134             AsyncCallbackInfoModuleRecord *asyncCallbackInfo = (AsyncCallbackInfoModuleRecord *)data;
135             if (asyncCallbackInfo != nullptr) {
136                 napi_value result = nullptr;
137                 napi_create_array(env, &result);
138                 BundleStateCommon::GetModuleRecordForResult(env, asyncCallbackInfo->moduleRecords, result);
139                 BundleStateCommon::GetCallbackPromiseResult(env, *asyncCallbackInfo, result);
140             }
141         },
142         static_cast<void*>(asyncCallbackInfo),
143         &asyncCallbackInfo->asyncWork));
144     NAPI_CALL(env, napi_queue_async_work(env, callbackPtr->asyncWork));
145     if (callbackPtr->isCallback) {
146         callbackPtr.release();
147         return BundleStateCommon::NapiGetNull(env);
148     } else {
149         callbackPtr.release();
150         return promise;
151     }
152 }
153 
ParseIsIdleStateParameters(const napi_env & env,const napi_callback_info & info,IsIdleStateParamsInfo & params,AsyncCallbackInfoIsIdleState * & asyncCallbackInfo)154 napi_value ParseIsIdleStateParameters(const napi_env &env, const napi_callback_info &info,
155     IsIdleStateParamsInfo &params, AsyncCallbackInfoIsIdleState*& asyncCallbackInfo)
156 {
157     size_t argc = IS_IDLE_STATE_PARAMS;
158     napi_value argv[IS_IDLE_STATE_PARAMS] = {nullptr};
159     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
160     NAPI_ASSERT(env, argc == IS_IDLE_STATE_MIN_PARAMS || argc == IS_IDLE_STATE_PARAMS,
161         "Invalid number of parameters");
162     if ((argc != IS_IDLE_STATE_MIN_PARAMS) && (argc != IS_IDLE_STATE_PARAMS)) {
163         params.errorCode = ERR_PARAMETERS_NUMBER;
164         return BundleStateCommon::HandleParamErr(env, ERR_PARAMETERS_NUMBER, "");
165     }
166 
167     // argv[0] : bundleName
168     std::string result = "";
169     napi_valuetype valuetype;
170     NAPI_CALL(env, napi_typeof(env, argv[0], &valuetype));
171     if ((valuetype != napi_string) && (params.errorCode == ERR_OK)) {
172         BUNDLE_ACTIVE_LOGE("Wrong argument type, string expected.");
173         params.errorCode = ERR_BUNDLE_NAME_TYPE;
174         return BundleStateCommon::HandleParamErr(env, ERR_PARAMETERS_NUMBER, "");
175     }
176 
177     params.bundleName = BundleStateCommon::GetTypeStringValue(env, argv[0], result);
178     if (params.bundleName.empty()) {
179         BUNDLE_ACTIVE_LOGE("ParseIsIdleStateParameters failed, bundleName is empty.");
180         params.errorCode = ERR_PARAMETERS_EMPTY;
181         return BundleStateCommon::HandleParamErr(env, ERR_PARAMETERS_NUMBER, "bundleName");
182     }
183 
184     // argv[1]: callback
185     if (argc == IS_IDLE_STATE_PARAMS) {
186         napi_valuetype inputValueType = napi_undefined;
187         NAPI_CALL(env, napi_typeof(env, argv[1], &inputValueType));
188         if (inputValueType != napi_function) {
189             params.errorCode = ERR_CALL_BACK_TYPE;
190             return BundleStateCommon::HandleParamErr(env, ERR_CALL_BACK_TYPE, "");
191         }
192         napi_create_reference(env, argv[1], 1, &params.callback);
193     }
194     BundleStateCommon::AsyncInit(env, params, asyncCallbackInfo);
195     return BundleStateCommon::NapiGetNull(env);
196 }
197 
IsIdleState(napi_env env,napi_callback_info info)198 napi_value IsIdleState(napi_env env, napi_callback_info info)
199 {
200     IsIdleStateParamsInfo params;
201     AsyncCallbackInfoIsIdleState *asyncCallbackInfo = nullptr;
202     ParseIsIdleStateParameters(env, info, params, asyncCallbackInfo);
203     if (params.errorCode != ERR_OK) {
204         return BundleStateCommon::NapiGetNull(env);
205     }
206     napi_value promise = nullptr;
207     std::unique_ptr<AsyncCallbackInfoIsIdleState> callbackPtr {asyncCallbackInfo};
208     callbackPtr->bundleName = params.bundleName;
209     BundleStateCommon::SettingAsyncWorkData(env, params.callback, *asyncCallbackInfo, promise);
210     napi_value resourceName = nullptr;
211     NAPI_CALL(env, napi_create_string_latin1(env, "IsIdleState", NAPI_AUTO_LENGTH, &resourceName));
212     NAPI_CALL(env, napi_create_async_work(env,
213         nullptr,
214         resourceName,
215         [](napi_env env, void *data) {
216             AsyncCallbackInfoIsIdleState *asyncCallbackInfo = (AsyncCallbackInfoIsIdleState *)data;
217             if (asyncCallbackInfo != nullptr) {
218                 asyncCallbackInfo->errorCode = BundleActiveClient::GetInstance().IsBundleIdle(
219                     asyncCallbackInfo->state, asyncCallbackInfo->bundleName);
220             } else {
221                 BUNDLE_ACTIVE_LOGE("IsIdleState, asyncCallbackInfo == nullptr");
222             }
223         },
224         [](napi_env env, napi_status status, void *data) {
225             AsyncCallbackInfoIsIdleState *asyncCallbackInfo = (AsyncCallbackInfoIsIdleState *)data;
226             if (asyncCallbackInfo != nullptr) {
227                 napi_value result = nullptr;
228                 napi_get_boolean(env, asyncCallbackInfo->state, &result);
229                 BundleStateCommon::GetCallbackPromiseResult(env, *asyncCallbackInfo, result);
230             }
231         },
232         static_cast<void*>(asyncCallbackInfo),
233         &asyncCallbackInfo->asyncWork));
234     NAPI_CALL(env, napi_queue_async_work(env, callbackPtr->asyncWork));
235     if (callbackPtr->isCallback) {
236         callbackPtr.release();
237         return BundleStateCommon::NapiGetNull(env);
238     } else {
239         callbackPtr.release();
240         return promise;
241     }
242 }
243 
ParseQueryCurrentBundleEventsParameters(const napi_env & env,const napi_callback_info & info,StatesParamsInfo & params,AsyncCallbackInfoStates * & asyncCallbackInfo)244 napi_value ParseQueryCurrentBundleEventsParameters(const napi_env &env, const napi_callback_info &info,
245     StatesParamsInfo &params, AsyncCallbackInfoStates*& asyncCallbackInfo)
246 {
247     size_t argc = STATES_PARAMS;
248     napi_value argv[STATES_PARAMS] = {nullptr};
249     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
250     if ((argc != STATES_MIN_PARAMS) && (argc != STATES_PARAMS)) {
251         params.errorCode = ERR_PARAMETERS_NUMBER;
252         return BundleStateCommon::HandleParamErr(env, ERR_PARAMETERS_NUMBER, "");
253     }
254 
255     // argv[0] : beginTime
256     if (BundleStateCommon::GetInt64NumberValue(env, argv[0], params.beginTime) == nullptr) {
257         BUNDLE_ACTIVE_LOGE("ParseQueryCurrentBundleEventsParameters failed, beginTime type is invalid.");
258         params.errorCode = ERR_BEGIN_TIME_TYPE;
259         return BundleStateCommon::HandleParamErr(env, ERR_BEGIN_TIME_TYPE, "");
260     }
261     if ((params.errorCode == ERR_OK)
262         && (params.beginTime < TIME_NUMBER_MIN)) {
263         BUNDLE_ACTIVE_LOGE("ParseQueryCurrentBundleEventsParameters failed, beginTime value is invalid.");
264         params.errorCode = ERR_BEGIN_TIME_LESS_THEN_ZERO;
265         return BundleStateCommon::HandleParamErr(env, ERR_BEGIN_TIME_LESS_THEN_ZERO, "");
266     }
267 
268     // argv[1] : endTime
269     if ((params.errorCode == ERR_OK)
270         && (BundleStateCommon::GetInt64NumberValue(env, argv[1], params.endTime) == nullptr)) {
271         BUNDLE_ACTIVE_LOGE("ParseQueryCurrentBundleEventsParameters failed, endTime type is invalid.");
272         params.errorCode = ERR_END_TIME_TYPE;
273         return BundleStateCommon::HandleParamErr(env, ERR_END_TIME_TYPE, "");
274     }
275     if ((params.errorCode == ERR_OK) && (params.endTime <= params.beginTime)) {
276         BUNDLE_ACTIVE_LOGE("ParseQueryCurrentBundleEventsParameters endTime(%{public}lld) <= beginTime(%{public}lld)",
277             (long long)params.endTime, (long long)params.beginTime);
278         params.errorCode = ERR_END_TIME_LESS_THEN_BEGIN_TIME;
279         return BundleStateCommon::HandleParamErr(env, ERR_END_TIME_LESS_THEN_BEGIN_TIME, "");
280     }
281 
282     // argv[SECOND_ARG]: callback
283     if (argc == STATES_PARAMS) {
284         napi_valuetype valuetype = napi_undefined;
285         NAPI_CALL(env, napi_typeof(env, argv[SECOND_ARG], &valuetype));
286         if (valuetype != napi_function) {
287             params.errorCode = ERR_CALL_BACK_TYPE;
288             return BundleStateCommon::HandleParamErr(env, ERR_CALL_BACK_TYPE, "");
289         }
290         napi_create_reference(env, argv[SECOND_ARG], 1, &params.callback);
291     }
292     BundleStateCommon::AsyncInit(env, params, asyncCallbackInfo);
293     return BundleStateCommon::NapiGetNull(env);
294 }
295 
QueryCurrentBundleEvents(napi_env env,napi_callback_info info)296 napi_value QueryCurrentBundleEvents(napi_env env, napi_callback_info info)
297 {
298     StatesParamsInfo params;
299     AsyncCallbackInfoStates *asyncCallbackInfo = nullptr;
300     ParseQueryCurrentBundleEventsParameters(env, info, params, asyncCallbackInfo);
301     if (params.errorCode != ERR_OK) {
302         return BundleStateCommon::NapiGetNull(env);
303     }
304     napi_value promise = nullptr;
305     std::unique_ptr<AsyncCallbackInfoStates> callbackPtr {asyncCallbackInfo};
306     callbackPtr->beginTime = params.beginTime;
307     BUNDLE_ACTIVE_LOGD("QueryCurrentBundleEvents callbackPtr->beginTime: %{public}lld",
308         (long long)callbackPtr->beginTime);
309     callbackPtr->endTime = params.endTime;
310     BUNDLE_ACTIVE_LOGD("QueryCurrentBundleEvents callbackPtr->endTime: %{public}lld",
311         (long long)callbackPtr->endTime);
312     BundleStateCommon::SettingAsyncWorkData(env, params.callback, *asyncCallbackInfo, promise);
313 
314     napi_value resourceName = nullptr;
315     NAPI_CALL(env, napi_create_string_latin1(env, "QueryCurrentBundleEvents", NAPI_AUTO_LENGTH, &resourceName));
316     NAPI_CALL(env, napi_create_async_work(env,
317         nullptr,
318         resourceName,
319         [](napi_env env, void *data) {
320             AsyncCallbackInfoStates *asyncCallbackInfo = (AsyncCallbackInfoStates *)data;
321             if (asyncCallbackInfo != nullptr) {
322                 asyncCallbackInfo->errorCode =
323                     BundleActiveClient::GetInstance().QueryCurrentBundleEvents(asyncCallbackInfo->BundleActiveState,
324                         asyncCallbackInfo->beginTime, asyncCallbackInfo->endTime);
325             } else {
326                 BUNDLE_ACTIVE_LOGE("QueryCurrentBundleEvents, asyncCallbackInfo == nullptr");
327             }
328         },
329         [](napi_env env, napi_status status, void *data) {
330             AsyncCallbackInfoStates *asyncCallbackInfo = (AsyncCallbackInfoStates *)data;
331             if (asyncCallbackInfo != nullptr) {
332                 napi_value result = nullptr;
333                 napi_create_array(env, &result);
334                 BundleStateCommon::GetBundleActiveEventForResult(
335                     env, asyncCallbackInfo->BundleActiveState, result, true);
336                 BundleStateCommon::GetCallbackPromiseResult(env, *asyncCallbackInfo, result);
337             }
338         },
339         static_cast<void*>(asyncCallbackInfo),
340         &asyncCallbackInfo->asyncWork));
341     NAPI_CALL(env, napi_queue_async_work(env, callbackPtr->asyncWork));
342     if (callbackPtr->isCallback) {
343         callbackPtr.release();
344         return BundleStateCommon::NapiGetNull(env);
345     } else {
346         callbackPtr.release();
347         return promise;
348     }
349 }
350 
QueryBundleEvents(napi_env env,napi_callback_info info)351 napi_value QueryBundleEvents(napi_env env, napi_callback_info info)
352 {
353     StatesParamsInfo params;
354     AsyncCallbackInfoStates *asyncCallbackInfo = nullptr;
355     ParseQueryCurrentBundleEventsParameters(env, info, params, asyncCallbackInfo);
356     if (params.errorCode != ERR_OK) {
357         return BundleStateCommon::NapiGetNull(env);
358     }
359     napi_value promise = nullptr;
360     std::unique_ptr<AsyncCallbackInfoStates> callbackPtr {asyncCallbackInfo};
361     callbackPtr->beginTime = params.beginTime;
362     BUNDLE_ACTIVE_LOGD("QueryBundleEvents callbackPtr->beginTime: %{public}lld",
363         (long long)callbackPtr->beginTime);
364     callbackPtr->endTime = params.endTime;
365     BUNDLE_ACTIVE_LOGD("QueryBundleEvents callbackPtr->endTime: %{public}lld",
366         (long long)callbackPtr->endTime);
367     BundleStateCommon::SettingAsyncWorkData(env, params.callback, *asyncCallbackInfo, promise);
368 
369     napi_value resourceName = nullptr;
370     NAPI_CALL(env, napi_create_string_latin1(env, "QueryBundleEvents", NAPI_AUTO_LENGTH, &resourceName));
371 
372     NAPI_CALL(env, napi_create_async_work(env,
373         nullptr,
374         resourceName,
375         [](napi_env env, void *data) {
376             AsyncCallbackInfoStates *asyncCallbackInfo = (AsyncCallbackInfoStates *)data;
377             if (asyncCallbackInfo != nullptr) {
378                 asyncCallbackInfo->errorCode =
379                     BundleActiveClient::GetInstance().QueryBundleEvents(asyncCallbackInfo->BundleActiveState,
380                         asyncCallbackInfo->beginTime, asyncCallbackInfo->endTime);
381             } else {
382                 BUNDLE_ACTIVE_LOGE("QueryBundleEvents, asyncCallbackInfo == nullptr");
383             }
384         },
385         [](napi_env env, napi_status status, void *data) {
386             AsyncCallbackInfoStates *asyncCallbackInfo = (AsyncCallbackInfoStates *)data;
387             if (asyncCallbackInfo != nullptr) {
388                 napi_value result = nullptr;
389                 napi_create_array(env, &result);
390                 BundleStateCommon::GetBundleActiveEventForResult(
391                     env, asyncCallbackInfo->BundleActiveState, result, true);
392                 BundleStateCommon::GetCallbackPromiseResult(env, *asyncCallbackInfo, result);
393             }
394         },
395         static_cast<void*>(asyncCallbackInfo),
396         &asyncCallbackInfo->asyncWork));
397     NAPI_CALL(env, napi_queue_async_work(env, callbackPtr->asyncWork));
398     if (callbackPtr->isCallback) {
399         callbackPtr.release();
400         return BundleStateCommon::NapiGetNull(env);
401     } else {
402         callbackPtr.release();
403         return promise;
404     }
405 }
406 
ParseQueryBundleStatsInfoByInterval(const napi_env & env,const napi_callback_info & info,AppUsageParamsByIntervalInfo & params,AsyncCallbackInfoAppUsageByInterval * & asyncCallbackInfo)407 napi_value ParseQueryBundleStatsInfoByInterval(const napi_env &env, const napi_callback_info &info,
408     AppUsageParamsByIntervalInfo &params, AsyncCallbackInfoAppUsageByInterval*& asyncCallbackInfo)
409 {
410     size_t argc = APP_USAGE_PARAMS_BY_INTERVAL;
411     napi_value argv[APP_USAGE_PARAMS_BY_INTERVAL] = {nullptr};
412     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
413     if ((argc != APP_USAGE_MIN_PARAMS_BY_INTERVAL) && (argc != APP_USAGE_PARAMS_BY_INTERVAL)) {
414         params.errorCode = ERR_PARAMETERS_NUMBER;
415         return BundleStateCommon::HandleParamErr(env, ERR_PARAMETERS_NUMBER, "");
416     }
417 
418     // argv[0] : intervalType
419     if (BundleStateCommon::GetInt32NumberValue(env, argv[0], params.intervalType) == nullptr) {
420         BUNDLE_ACTIVE_LOGE("ParseQueryBundleStatsInfoByInterval failed, intervalType is invalid.");
421         params.errorCode = ERR_INTERVAL_TYPE;
422         return BundleStateCommon::HandleParamErr(env, ERR_INTERVAL_TYPE, "");
423     }
424     if ((params.errorCode == ERR_OK) && ((params.intervalType < INTERVAL_NUMBER_MIN)
425         || (params.intervalType > INTERVAL_NUMBER_MAX))) {
426         BUNDLE_ACTIVE_LOGE("ParseQueryBundleStatsInfoByInterval failed, intervalType number is invalid.");
427         params.errorCode = ERR_INTERVAL_OUT_OF_RANGE;
428         return BundleStateCommon::HandleParamErr(env, ERR_INTERVAL_OUT_OF_RANGE, "");
429     }
430 
431     // argv[1] : beginTime
432     if ((params.errorCode == ERR_OK)
433         && (BundleStateCommon::GetInt64NumberValue(env, argv[1], params.beginTime) == nullptr)) {
434         BUNDLE_ACTIVE_LOGE("ParseQueryBundleStatsInfoByInterval failed, beginTime type is invalid.");
435         params.errorCode = ERR_BEGIN_TIME_TYPE;
436         return BundleStateCommon::HandleParamErr(env, ERR_BEGIN_TIME_TYPE, "");
437     }
438     if ((params.errorCode == ERR_OK)
439         && (params.beginTime < TIME_NUMBER_MIN)) {
440         BUNDLE_ACTIVE_LOGE("ParseQueryBundleStatsInfoByInterval failed, beginTime value is invalid.");
441         params.errorCode = ERR_BEGIN_TIME_LESS_THEN_ZERO;
442         return BundleStateCommon::HandleParamErr(env, ERR_BEGIN_TIME_LESS_THEN_ZERO, "");
443     }
444 
445     // argv[SECOND_ARG] : endTime
446     if ((params.errorCode == ERR_OK)
447         && (BundleStateCommon::GetInt64NumberValue(env, argv[SECOND_ARG], params.endTime) == nullptr)) {
448         BUNDLE_ACTIVE_LOGE("ParseQueryBundleStatsInfoByInterval failed, endTime type is invalid.");
449         params.errorCode = ERR_END_TIME_TYPE;
450         return BundleStateCommon::HandleParamErr(env, ERR_END_TIME_TYPE, "");
451     }
452     if ((params.errorCode == ERR_OK) && (params.endTime <= params.beginTime)) {
453         BUNDLE_ACTIVE_LOGE("ParseQueryBundleStatsInfoByInterval endTime(%{public}lld) <= beginTime(%{public}lld)",
454             (long long)params.endTime, (long long)params.beginTime);
455         params.errorCode = ERR_END_TIME_LESS_THEN_BEGIN_TIME;
456         return BundleStateCommon::HandleParamErr(env, ERR_END_TIME_LESS_THEN_BEGIN_TIME, "");
457     }
458 
459     // argv[THIRD_ARG]: callback
460     if (argc == APP_USAGE_PARAMS_BY_INTERVAL) {
461         napi_valuetype valuetype = napi_undefined;
462         NAPI_CALL(env, napi_typeof(env, argv[THIRD_ARG], &valuetype));
463         if (valuetype != napi_function) {
464             params.errorCode = ERR_CALL_BACK_TYPE;
465             return BundleStateCommon::HandleParamErr(env, ERR_CALL_BACK_TYPE, "");
466         }
467         napi_create_reference(env, argv[THIRD_ARG], 1, &params.callback);
468     }
469     BundleStateCommon::AsyncInit(env, params, asyncCallbackInfo);
470     return BundleStateCommon::NapiGetNull(env);
471 }
472 
QueryBundleStatsInfoByInterval(napi_env env,napi_callback_info info)473 napi_value QueryBundleStatsInfoByInterval(napi_env env, napi_callback_info info)
474 {
475     AppUsageParamsByIntervalInfo params;
476     AsyncCallbackInfoAppUsageByInterval *asyncCallbackInfo = nullptr;
477     ParseQueryBundleStatsInfoByInterval(env, info, params, asyncCallbackInfo);
478     if (params.errorCode != ERR_OK) {
479         return BundleStateCommon::NapiGetNull(env);
480     }
481     napi_value promise = nullptr;
482     std::unique_ptr<AsyncCallbackInfoAppUsageByInterval> callbackPtr {asyncCallbackInfo};
483     callbackPtr->intervalType = params.intervalType;
484     callbackPtr->beginTime = params.beginTime;
485     callbackPtr->endTime = params.endTime;
486     BundleStateCommon::SettingAsyncWorkData(env, params.callback, *asyncCallbackInfo, promise);
487     napi_value resourceName = nullptr;
488     NAPI_CALL(env, napi_create_string_latin1(env, "QueryBundleStatsInfoByInterval", NAPI_AUTO_LENGTH, &resourceName));
489     NAPI_CALL(env, napi_create_async_work(env,
490         nullptr,
491         resourceName,
492         [](napi_env env, void *data) {
493             AsyncCallbackInfoAppUsageByInterval *asyncCallbackInfo = (AsyncCallbackInfoAppUsageByInterval *)data;
494             if (asyncCallbackInfo != nullptr) {
495                 asyncCallbackInfo->errorCode =
496                     BundleActiveClient::GetInstance().QueryBundleStatsInfoByInterval(asyncCallbackInfo->packageStats,
497                         asyncCallbackInfo->intervalType, asyncCallbackInfo->beginTime, asyncCallbackInfo->endTime);
498             } else {
499                 BUNDLE_ACTIVE_LOGE("QueryBundleStatsInfoByInterval, asyncCallbackInfo == nullptr");
500             }
501         },
502         [](napi_env env, napi_status status, void *data) {
503             AsyncCallbackInfoAppUsageByInterval *asyncCallbackInfo = (AsyncCallbackInfoAppUsageByInterval *)data;
504             if (asyncCallbackInfo != nullptr) {
505                 napi_value result = nullptr;
506                 napi_create_array(env, &result);
507                 BundleStateCommon::GetBundleStateInfoByIntervalForResult(env, asyncCallbackInfo->packageStats, result);
508                 BundleStateCommon::GetCallbackPromiseResult(env, *asyncCallbackInfo, result);
509             }
510         },
511         static_cast<void*>(asyncCallbackInfo),
512         &asyncCallbackInfo->asyncWork));
513     NAPI_CALL(env, napi_queue_async_work(env, callbackPtr->asyncWork));
514     if (callbackPtr->isCallback) {
515         callbackPtr.release();
516         return BundleStateCommon::NapiGetNull(env);
517     } else {
518         callbackPtr.release();
519         return promise;
520     }
521 }
522 
ParseQueryBundleStatsInfos(const napi_env & env,const napi_callback_info & info,QueryBundleStatsParamsInfo & params,AsyncCallbackInfoAppUsage * & asyncCallbackInfo)523 napi_value ParseQueryBundleStatsInfos(const napi_env &env, const napi_callback_info &info,
524     QueryBundleStatsParamsInfo &params, AsyncCallbackInfoAppUsage*& asyncCallbackInfo)
525 {
526     size_t argc = APP_USAGE_PARAMS;
527     napi_value argv[APP_USAGE_PARAMS] = {nullptr};
528     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
529     if ((argc != APP_USAGE_MIN_PARAMS) && (argc != APP_USAGE_PARAMS)) {
530         params.errorCode = ERR_PARAMETERS_NUMBER;
531         return BundleStateCommon::HandleParamErr(env, ERR_PARAMETERS_NUMBER, "");
532     }
533 
534     // argv[0] : beginTime
535     if (BundleStateCommon::GetInt64NumberValue(env, argv[0], params.beginTime) == nullptr) {
536         BUNDLE_ACTIVE_LOGE("ParseQueryBundleStatsInfos failed, beginTime type is invalid.");
537         params.errorCode = ERR_BEGIN_TIME_TYPE;
538         return BundleStateCommon::HandleParamErr(env, ERR_BEGIN_TIME_TYPE, "");
539     }
540     if ((params.errorCode == ERR_OK) && (params.beginTime < TIME_NUMBER_MIN)) {
541         BUNDLE_ACTIVE_LOGE("ParseQueryBundleStatsInfos failed failed, beginTime value is invalid.");
542         params.errorCode = ERR_BEGIN_TIME_LESS_THEN_ZERO;
543         return BundleStateCommon::HandleParamErr(env, ERR_BEGIN_TIME_LESS_THEN_ZERO, "");
544     }
545 
546     // argv[1] : endTime
547     if ((params.errorCode == ERR_OK)
548         && (BundleStateCommon::GetInt64NumberValue(env, argv[1], params.endTime) == nullptr)) {
549         BUNDLE_ACTIVE_LOGE("ParseQueryBundleStatsInfos failed, endTime type is invalid.");
550         params.errorCode = ERR_END_TIME_TYPE;
551     }
552     if ((params.errorCode == ERR_OK) && (params.endTime <= params.beginTime)) {
553         BUNDLE_ACTIVE_LOGE("ParseQueryBundleStatsInfos endTime(%{public}lld) <= beginTime(%{public}lld)",
554             (long long)params.endTime, (long long)params.beginTime);
555         params.errorCode = ERR_END_TIME_LESS_THEN_BEGIN_TIME;
556         return BundleStateCommon::HandleParamErr(env, ERR_BEGIN_TIME_LESS_THEN_ZERO, "");
557     }
558 
559     // argv[SECOND_ARG]: callback
560     if (argc == APP_USAGE_PARAMS) {
561         napi_valuetype valuetype = napi_undefined;
562         NAPI_CALL(env, napi_typeof(env, argv[SECOND_ARG], &valuetype));
563         if (valuetype != napi_function) {
564             params.errorCode = ERR_CALL_BACK_TYPE;
565             return BundleStateCommon::HandleParamErr(env, ERR_CALL_BACK_TYPE, "");
566         }
567         napi_create_reference(env, argv[SECOND_ARG], 1, &params.callback);
568     }
569     BundleStateCommon::AsyncInit(env, params, asyncCallbackInfo);
570     return BundleStateCommon::NapiGetNull(env);
571 }
572 
QueryBundleStatsInfos(napi_env env,napi_callback_info info)573 napi_value QueryBundleStatsInfos(napi_env env, napi_callback_info info)
574 {
575     QueryBundleStatsParamsInfo params;
576     AsyncCallbackInfoAppUsage *asyncCallbackInfo = nullptr;
577     ParseQueryBundleStatsInfos(env, info, params, asyncCallbackInfo);
578     if (params.errorCode != ERR_OK) {
579         return BundleStateCommon::NapiGetNull(env);
580     }
581     napi_value promise = nullptr;
582     std::unique_ptr<AsyncCallbackInfoAppUsage> callbackPtr {asyncCallbackInfo};
583     callbackPtr->beginTime = params.beginTime;
584     BUNDLE_ACTIVE_LOGD("queryBundleStatsInfos callbackPtr->beginTime: %{public}lld",
585         (long long)callbackPtr->beginTime);
586     callbackPtr->endTime = params.endTime;
587     BUNDLE_ACTIVE_LOGD("queryBundleStatsInfos callbackPtr->endTime: %{public}lld",
588         (long long)callbackPtr->endTime);
589     BundleStateCommon::SettingAsyncWorkData(env, params.callback, *asyncCallbackInfo, promise);
590     napi_value resourceName = nullptr;
591     NAPI_CALL(env, napi_create_string_latin1(env, "queryBundleStatsInfos", NAPI_AUTO_LENGTH, &resourceName));
592     NAPI_CALL(env, napi_create_async_work(env,
593         nullptr,
594         resourceName,
595         [](napi_env env, void *data) {
596             AsyncCallbackInfoAppUsage *asyncCallbackInfo = (AsyncCallbackInfoAppUsage *)data;
597             if (asyncCallbackInfo != nullptr) {
598                 asyncCallbackInfo->packageStats = BundleStateCommon::QueryBundleStatsInfos(asyncCallbackInfo->beginTime,
599                     asyncCallbackInfo->endTime, asyncCallbackInfo->errorCode);
600             } else {
601                 BUNDLE_ACTIVE_LOGE("queryBundleStatsInfos asyncCallbackInfo == nullptr");
602             }
603         },
604         [](napi_env env, napi_status status, void *data) {
605             AsyncCallbackInfoAppUsage *asyncCallbackInfo = (AsyncCallbackInfoAppUsage *)data;
606             if (asyncCallbackInfo != nullptr) {
607                 napi_value result = nullptr;
608                 napi_create_object(env, &result);
609                 BundleStateCommon::GetBundleStateInfoForResult(env, asyncCallbackInfo->packageStats, result);
610                 BundleStateCommon::GetCallbackPromiseResult(env, *asyncCallbackInfo, result);
611             }
612         },
613         static_cast<void*>(asyncCallbackInfo),
614         &asyncCallbackInfo->asyncWork));
615     NAPI_CALL(env, napi_queue_async_work(env, callbackPtr->asyncWork));
616     if (callbackPtr->isCallback) {
617         callbackPtr.release();
618         return BundleStateCommon::NapiGetNull(env);
619     } else {
620         callbackPtr.release();
621         return promise;
622     }
623 }
624 
ParseDeviceEventStates(const napi_env & env,const napi_callback_info & info,EventStatesParamsInfo & params)625 napi_value ParseDeviceEventStates(const napi_env &env, const napi_callback_info &info,
626     EventStatesParamsInfo &params)
627 {
628     size_t argc = EVENT_STATES_PARAMS;
629     napi_value argv[EVENT_STATES_PARAMS] = {nullptr};
630     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
631     if ((argc != EVENT_STATES_MIN_PARAMS) && (argc != EVENT_STATES_PARAMS)) {
632         params.errorCode = ERR_PARAMETERS_NUMBER;
633         return BundleStateCommon::HandleParamErr(env, ERR_PARAMETERS_NUMBER, "");
634     }
635 
636     // argv[0] : beginTime
637     if ((params.errorCode == ERR_OK)
638         && BundleStateCommon::GetInt64NumberValue(env, argv[0], params.beginTime) == nullptr) {
639         BUNDLE_ACTIVE_LOGE("ParseDeviceEventStates failed, beginTime is invalid.");
640         params.errorCode = ERR_BEGIN_TIME_TYPE;
641         return BundleStateCommon::HandleParamErr(env, ERR_BEGIN_TIME_TYPE, "");
642     }
643     if ((params.errorCode == ERR_OK) && (params.beginTime < TIME_NUMBER_MIN)) {
644         BUNDLE_ACTIVE_LOGE("ParseDeviceEventStates failed, beginTime less then 0.");
645         params.errorCode = ERR_BEGIN_TIME_LESS_THEN_ZERO;
646         return BundleStateCommon::HandleParamErr(env, ERR_BEGIN_TIME_LESS_THEN_ZERO, "");
647     }
648 
649     // argv[1] : endTime
650     if ((params.errorCode == ERR_OK)
651         && (BundleStateCommon::GetInt64NumberValue(env, argv[1], params.endTime) == nullptr)) {
652         BUNDLE_ACTIVE_LOGE("ParseDeviceEventStates failed, endTime is invalid.");
653         params.errorCode = ERR_END_TIME_TYPE;
654         return BundleStateCommon::HandleParamErr(env, ERR_END_TIME_TYPE, "");
655     }
656     if ((params.errorCode == ERR_OK) && (params.endTime <= params.beginTime)) {
657         BUNDLE_ACTIVE_LOGE("ParseDeviceEventStates endTime(%{public}lld) <= beginTime(%{public}lld)",
658             (long long)params.endTime, (long long)params.beginTime);
659         params.errorCode = ERR_END_TIME_LESS_THEN_BEGIN_TIME;
660         return BundleStateCommon::HandleParamErr(env, ERR_END_TIME_LESS_THEN_BEGIN_TIME, "");
661     }
662 
663     // argv[SECOND_ARG]: callback
664     if (argc == EVENT_STATES_PARAMS) {
665         napi_valuetype valuetype = napi_undefined;
666         NAPI_CALL(env, napi_typeof(env, argv[SECOND_ARG], &valuetype));
667         if (valuetype != napi_function) {
668             params.errorCode = ERR_CALL_BACK_TYPE;
669             return BundleStateCommon::HandleParamErr(env, ERR_CALL_BACK_TYPE, "");
670         }
671         napi_create_reference(env, argv[SECOND_ARG], 1, &params.callback);
672     }
673     return BundleStateCommon::NapiGetNull(env);
674 }
675 
QueryDeviceEventStats(napi_env env,napi_callback_info info)676 napi_value QueryDeviceEventStats(napi_env env, napi_callback_info info)
677 {
678     EventStatesParamsInfo params;
679     ParseDeviceEventStates(env, info, params);
680     if (params.errorCode != ERR_OK) {
681         return BundleStateCommon::NapiGetNull(env);
682     }
683     napi_value promise = nullptr;
684     AsyncCallbackInfoEventStats *asyncCallbackInfo =
685         new (std::nothrow) AsyncCallbackInfoEventStats(env);
686     std::unique_ptr<AsyncCallbackInfoEventStats> callbackPtr =
687         BundleStateCommon::HandleEventStatsInfo(env, asyncCallbackInfo, params);
688     if (!callbackPtr) {
689         return BundleStateCommon::NapiGetNull(env);
690     }
691     BundleStateCommon::SettingAsyncWorkData(env, params.callback, *asyncCallbackInfo, promise);
692     napi_value resourceName = nullptr;
693     NAPI_CALL(env, napi_create_string_latin1(env, "QueryDeviceEventStats", NAPI_AUTO_LENGTH, &resourceName));
694     NAPI_CALL(env, napi_create_async_work(env,
695         nullptr,
696         resourceName,
697         [](napi_env env, void *data) {
698             AsyncCallbackInfoEventStats *asyncCallbackInfo = (AsyncCallbackInfoEventStats *)data;
699             if (asyncCallbackInfo != nullptr) {
700                 asyncCallbackInfo->errorCode = BundleActiveClient::GetInstance()
701                     .QueryDeviceEventStats(asyncCallbackInfo->beginTime,
702                     asyncCallbackInfo->endTime, asyncCallbackInfo->eventStats);
703             } else {
704                 BUNDLE_ACTIVE_LOGE("QueryDeviceEventStats, asyncCallbackInfo == nullptr");
705             }
706         },
707         [](napi_env env, napi_status status, void *data) {
708             AsyncCallbackInfoEventStats *asyncCallbackInfo = (AsyncCallbackInfoEventStats *)data;
709             if (asyncCallbackInfo != nullptr) {
710                 napi_value result = nullptr;
711                 napi_create_array(env, &result);
712                 BundleStateCommon::GetBundleActiveEventStatsForResult(env, asyncCallbackInfo->eventStats, result);
713                 BundleStateCommon::GetCallbackPromiseResult(env, *asyncCallbackInfo, result);
714             }
715         },
716         static_cast<void*>(asyncCallbackInfo),
717         &asyncCallbackInfo->asyncWork));
718     NAPI_CALL(env, napi_queue_async_work(env, callbackPtr->asyncWork));
719     if (callbackPtr->isCallback) {
720         callbackPtr.release();
721         return BundleStateCommon::NapiGetNull(env);
722     } else {
723         callbackPtr.release();
724         return promise;
725     }
726 }
727 
QueryNotificationEventStats(napi_env env,napi_callback_info info)728 napi_value QueryNotificationEventStats(napi_env env, napi_callback_info info)
729 {
730     EventStatesParamsInfo params;
731     ParseDeviceEventStates(env, info, params);
732     if (params.errorCode != ERR_OK) {
733         return BundleStateCommon::NapiGetNull(env);
734     }
735     napi_value promise = nullptr;
736     AsyncCallbackInfoEventStats *asyncCallbackInfo =
737         new (std::nothrow) AsyncCallbackInfoEventStats(env);
738     std::unique_ptr<AsyncCallbackInfoEventStats> callbackPtr =
739         BundleStateCommon::HandleEventStatsInfo(env, asyncCallbackInfo, params);
740     if (!callbackPtr) {
741         return BundleStateCommon::NapiGetNull(env);
742     }
743     BundleStateCommon::SettingAsyncWorkData(env, params.callback, *asyncCallbackInfo, promise);
744     napi_value resourceName = nullptr;
745     NAPI_CALL(env, napi_create_string_latin1(env, "QueryNotificationEventStats", NAPI_AUTO_LENGTH, &resourceName));
746     NAPI_CALL(env, napi_create_async_work(env,
747         nullptr,
748         resourceName,
749         [](napi_env env, void *data) {
750             AsyncCallbackInfoEventStats *asyncCallbackInfo = (AsyncCallbackInfoEventStats *)data;
751             if (asyncCallbackInfo != nullptr) {
752                 asyncCallbackInfo->errorCode = BundleActiveClient::GetInstance()
753                     .QueryNotificationEventStats(asyncCallbackInfo->beginTime,
754                     asyncCallbackInfo->endTime, asyncCallbackInfo->eventStats);
755             } else {
756                 BUNDLE_ACTIVE_LOGE("QueryNotificationEventStats, asyncCallbackInfo == nullptr");
757             }
758         },
759         [](napi_env env, napi_status status, void *data) {
760             AsyncCallbackInfoEventStats *asyncCallbackInfo = (AsyncCallbackInfoEventStats *)data;
761             if (asyncCallbackInfo != nullptr) {
762                 napi_value result = nullptr;
763                 napi_create_array(env, &result);
764                 BundleStateCommon::GetBundleActiveNotificationNumberForResult(env,
765                     asyncCallbackInfo->eventStats, result);
766                 BundleStateCommon::GetCallbackPromiseResult(env, *asyncCallbackInfo, result);
767             }
768         },
769         static_cast<void*>(asyncCallbackInfo),
770         &asyncCallbackInfo->asyncWork));
771     NAPI_CALL(env, napi_queue_async_work(env, callbackPtr->asyncWork));
772     if (callbackPtr->isCallback) {
773         callbackPtr.release();
774         return BundleStateCommon::NapiGetNull(env);
775     } else {
776         callbackPtr.release();
777         return promise;
778     }
779 }
780 }  // namespace DeviceUsageStats
781 }  // namespace OHOS