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