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 "get_remaining_delay_time.h"
17
18 #include "singleton.h"
19
20 #include "background_task_manager.h"
21 #include "transient_task_log.h"
22
23 namespace OHOS {
24 namespace BackgroundTaskMgr {
25 static const uint32_t GET_REMAINING_DELAY_TIME_MIN_PARAMS = 1;
26 static const uint32_t GET_REMAINING_DELAY_TIME_PARAMS = 2;
27
28 struct AsyncCallbackInfoGetRemainingDelayTime : public AsyncWorkData {
AsyncCallbackInfoGetRemainingDelayTimeOHOS::BackgroundTaskMgr::AsyncCallbackInfoGetRemainingDelayTime29 explicit AsyncCallbackInfoGetRemainingDelayTime(napi_env env) : AsyncWorkData(env) {}
30 int32_t requestId = 0;
31 int32_t delayTime = 0;
32 };
33
34 struct GetRemainingDelayTimeParamsInfo {
35 int32_t requestId = 0;
36 napi_ref callback = nullptr;
37 };
38
ParseParameters(const napi_env & env,const napi_callback_info & info,GetRemainingDelayTimeParamsInfo & params,bool isThrow)39 napi_value ParseParameters(const napi_env &env, const napi_callback_info &info,
40 GetRemainingDelayTimeParamsInfo ¶ms, bool isThrow)
41 {
42 size_t argc = GET_REMAINING_DELAY_TIME_PARAMS;
43 napi_value argv[GET_REMAINING_DELAY_TIME_PARAMS] = {nullptr};
44 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
45 if (argc != GET_REMAINING_DELAY_TIME_MIN_PARAMS && argc != GET_REMAINING_DELAY_TIME_PARAMS) {
46 Common::HandleParamErr(env, ERR_PARAM_NUMBER_ERR, isThrow);
47 return nullptr;
48 }
49
50 // argv[0] : requestId
51 if (Common::GetInt32NumberValue(env, argv[0], params.requestId) == nullptr) {
52 BGTASK_LOGE("ParseParameters failed, requestId is nullptr.");
53 Common::HandleParamErr(env, ERR_REQUESTID_NULL_OR_ID_TYPE_ERR, isThrow);
54 return nullptr;
55 }
56
57 // argv[1]: callback
58 if (argc == GET_REMAINING_DELAY_TIME_PARAMS) {
59 napi_valuetype valuetype = napi_undefined;
60 NAPI_CALL(env, napi_typeof(env, argv[1], &valuetype));
61 if (valuetype != napi_function) {
62 Common::HandleParamErr(env, ERR_CALLBACK_NULL_OR_TYPE_ERR, isThrow);
63 return nullptr;
64 }
65 NAPI_CALL(env, napi_create_reference(env, argv[1], 1, ¶ms.callback));
66 }
67
68 if (params.requestId <= 0) {
69 BGTASK_LOGI("ParseParameters failed, requestId is illegal.");
70 Common::HandleParamErr(env, ERR_REQUESTID_ILLEGAL, isThrow);
71 return nullptr;
72 }
73 return Common::NapiGetNull(env);
74 }
75
GetRemainingDelayTime(napi_env env,napi_callback_info info,bool isThrow)76 napi_value GetRemainingDelayTime(napi_env env, napi_callback_info info, bool isThrow)
77 {
78 GetRemainingDelayTimeParamsInfo params;
79 if (ParseParameters(env, info, params, isThrow) == nullptr) {
80 return nullptr;
81 }
82
83 napi_value promise = nullptr;
84 AsyncCallbackInfoGetRemainingDelayTime *asyncCallbackInfo =
85 new (std::nothrow) AsyncCallbackInfoGetRemainingDelayTime(env);
86 if (!asyncCallbackInfo) {
87 if (isThrow) {
88 return nullptr;
89 }
90 return Common::JSParaError(env, params.callback);
91 }
92 std::unique_ptr<AsyncCallbackInfoGetRemainingDelayTime> callbackPtr {asyncCallbackInfo};
93 asyncCallbackInfo->requestId = params.requestId;
94 Common::PaddingAsyncWorkData(env, params.callback, *asyncCallbackInfo, promise);
95
96 napi_value resourceName = nullptr;
97 NAPI_CALL(env, napi_create_string_latin1(env, "GetRemainingDelayTime", NAPI_AUTO_LENGTH, &resourceName));
98
99 NAPI_CALL(env, napi_create_async_work(env,
100 nullptr,
101 resourceName,
102 [](napi_env env, void *data) {
103 AsyncCallbackInfoGetRemainingDelayTime *asyncCallbackInfo =
104 static_cast<AsyncCallbackInfoGetRemainingDelayTime *>(data);
105 if (asyncCallbackInfo != nullptr) {
106 asyncCallbackInfo->errCode = DelayedSingleton<BackgroundTaskManager>::GetInstance()->
107 GetRemainingDelayTime(asyncCallbackInfo->requestId, asyncCallbackInfo->delayTime);
108 }
109 },
110 [](napi_env env, napi_status status, void *data) {
111 AsyncCallbackInfoGetRemainingDelayTime *asyncCallbackInfo =
112 static_cast<AsyncCallbackInfoGetRemainingDelayTime *>(data);
113 std::unique_ptr<AsyncCallbackInfoGetRemainingDelayTime> callbackPtr {asyncCallbackInfo};
114 if (asyncCallbackInfo != nullptr) {
115 napi_value result = nullptr;
116 napi_create_int32(env, asyncCallbackInfo->delayTime, &result);
117 Common::ReturnCallbackPromise(env, *asyncCallbackInfo, result);
118 }
119 },
120 static_cast<void *>(asyncCallbackInfo),
121 &asyncCallbackInfo->asyncWork));
122
123 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
124 callbackPtr.release();
125 if (asyncCallbackInfo->isCallback) {
126 return Common::NapiGetNull(env);
127 }
128 return promise;
129 }
130
GetRemainingDelayTime(napi_env env,napi_callback_info info)131 napi_value GetRemainingDelayTime(napi_env env, napi_callback_info info)
132 {
133 return GetRemainingDelayTime(env, info, false);
134 }
135
GetRemainingDelayTimeThrow(napi_env env,napi_callback_info info)136 napi_value GetRemainingDelayTimeThrow(napi_env env, napi_callback_info info)
137 {
138 return GetRemainingDelayTime(env, info, true);
139 }
140 } // namespace BackgroundTaskMgr
141 } // namespace OHOS