1 /*
2  * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include "datetime_manager_addon.h"
16 #include "edm_log.h"
17 
18 using namespace OHOS::EDM;
19 
Init(napi_env env,napi_value exports)20 napi_value DatetimeManagerAddon::Init(napi_env env, napi_value exports)
21 {
22     napi_property_descriptor property[] = {
23         DECLARE_NAPI_FUNCTION("setDateTime", SetDateTime),
24         DECLARE_NAPI_FUNCTION("disallowModifyDateTime", DisallowModifyDateTime),
25         DECLARE_NAPI_FUNCTION("isModifyDateTimeDisallowed", IsModifyDateTimeDisallowed),
26     };
27     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
28     return exports;
29 }
30 
SetDateTime(napi_env env,napi_callback_info info)31 napi_value DatetimeManagerAddon::SetDateTime(napi_env env, napi_callback_info info)
32 {
33     EDMLOGI("NAPI_SetDateTime called");
34     size_t argc = ARGS_SIZE_THREE;
35     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
36     napi_value thisArg = nullptr;
37     void *data = nullptr;
38     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
39     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
40     bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) &&
41         MatchValueType(env, argv[ARR_INDEX_ONE], napi_number);
42     if (argc > ARGS_SIZE_TWO) {
43         matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_TWO], napi_function);
44     }
45     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
46     auto asyncCallbackInfo = new (std::nothrow) AsyncSetDateTimeCallbackInfo();
47     if (asyncCallbackInfo == nullptr) {
48         return nullptr;
49     }
50     std::unique_ptr<AsyncSetDateTimeCallbackInfo> callbackPtr {asyncCallbackInfo};
51     bool ret = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
52     ASSERT_AND_THROW_PARAM_ERROR(env, ret, "element name param error");
53     EDMLOGD("SetDateTime: asyncCallbackInfo->elementName.bundlename %{public}s, "
54         "asyncCallbackInfo->abilityname:%{public}s",
55         asyncCallbackInfo->elementName.GetBundleName().c_str(),
56         asyncCallbackInfo->elementName.GetAbilityName().c_str());
57     ret = ParseLong(env, asyncCallbackInfo->time, argv[ARR_INDEX_ONE]);
58     ASSERT_AND_THROW_PARAM_ERROR(env, ret, "time param error");
59     if (argc > ARGS_SIZE_TWO) {
60         EDMLOGD("NAPI_SetDateTime argc == ARGS_SIZE_THREE");
61         napi_create_reference(env, argv[ARR_INDEX_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
62     }
63 
64     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "SetDateTime",
65         NativeSetDateTime, NativeVoidCallbackComplete);
66     callbackPtr.release();
67     return asyncWorkReturn;
68 }
69 
NativeSetDateTime(napi_env env,void * data)70 void DatetimeManagerAddon::NativeSetDateTime(napi_env env, void *data)
71 {
72     EDMLOGI("NAPI_NativeSetDateTime called");
73     if (data == nullptr) {
74         EDMLOGE("data is nullptr");
75         return;
76     }
77     AsyncSetDateTimeCallbackInfo *asyncCallbackInfo = static_cast<AsyncSetDateTimeCallbackInfo *>(data);
78     auto dateTimeManagerProxy = DatetimeManagerProxy::GetDatetimeManagerProxy();
79     if (dateTimeManagerProxy == nullptr) {
80         EDMLOGE("can not get DatetimeManagerProxy");
81         return;
82     }
83     asyncCallbackInfo->ret = dateTimeManagerProxy->SetDateTime(asyncCallbackInfo->elementName,
84         asyncCallbackInfo->time);
85 }
86 
DisallowModifyDateTime(napi_env env,napi_callback_info info)87 napi_value DatetimeManagerAddon::DisallowModifyDateTime(napi_env env, napi_callback_info info)
88 {
89     EDMLOGI("NAPI_DisallowModifyDateTime called");
90     size_t argc = ARGS_SIZE_THREE;
91     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
92     napi_value thisArg = nullptr;
93     void *data = nullptr;
94     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
95     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
96     bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) &&
97         MatchValueType(env, argv[ARR_INDEX_ONE], napi_boolean);
98     if (argc > ARGS_SIZE_TWO) {
99         matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_TWO], napi_function);
100     }
101     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
102     auto asyncCallbackInfo = new (std::nothrow) AsyncDisallowModifyDateTimeCallbackInfo();
103     if (asyncCallbackInfo == nullptr) {
104         return nullptr;
105     }
106     std::unique_ptr<AsyncDisallowModifyDateTimeCallbackInfo> callbackPtr {asyncCallbackInfo};
107     bool ret = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
108     ASSERT_AND_THROW_PARAM_ERROR(env, ret, "element name param error");
109     EDMLOGD("DisallowModifyDateTime: asyncCallbackInfo->elementName.bundlename %{public}s, "
110         "asyncCallbackInfo->abilityname:%{public}s",
111         asyncCallbackInfo->elementName.GetBundleName().c_str(),
112         asyncCallbackInfo->elementName.GetAbilityName().c_str());
113     ret = ParseBool(env, asyncCallbackInfo->disallow, argv[ARR_INDEX_ONE]);
114     ASSERT_AND_THROW_PARAM_ERROR(env, ret, "disallow param error");
115     if (argc > ARGS_SIZE_TWO) {
116         EDMLOGD("NAPI_DisallowModifyDateTime argc == ARGS_SIZE_THREE");
117         napi_create_reference(env, argv[ARR_INDEX_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
118     }
119 
120     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "DisallowModifyDateTime",
121         NativeDisallowModifyDateTime, NativeVoidCallbackComplete);
122     callbackPtr.release();
123     return asyncWorkReturn;
124 }
125 
NativeDisallowModifyDateTime(napi_env env,void * data)126 void DatetimeManagerAddon::NativeDisallowModifyDateTime(napi_env env, void *data)
127 {
128     EDMLOGI("NAPI_NativeDisallowModifyDateTime called");
129     if (data == nullptr) {
130         EDMLOGE("data is nullptr");
131         return;
132     }
133     AsyncDisallowModifyDateTimeCallbackInfo *asyncCallbackInfo =
134         static_cast<AsyncDisallowModifyDateTimeCallbackInfo *>(data);
135     auto dateTimeManagerProxy = DatetimeManagerProxy::GetDatetimeManagerProxy();
136     if (dateTimeManagerProxy == nullptr) {
137         EDMLOGE("can not get DatetimeManagerProxy");
138         return;
139     }
140     asyncCallbackInfo->ret = dateTimeManagerProxy->DisallowModifyDateTime(asyncCallbackInfo->elementName,
141         asyncCallbackInfo->disallow);
142 }
143 
IsModifyDateTimeDisallowed(napi_env env,napi_callback_info info)144 napi_value DatetimeManagerAddon::IsModifyDateTimeDisallowed(napi_env env, napi_callback_info info)
145 {
146     EDMLOGI("NAPI_IsModifyDateTimeDisallowed called");
147     size_t argc = ARGS_SIZE_TWO;
148     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
149     napi_value thisArg = nullptr;
150     void *data = nullptr;
151     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
152     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
153     auto asyncCallbackInfo = new (std::nothrow) AsyncDisallowModifyDateTimeCallbackInfo();
154     if (asyncCallbackInfo == nullptr) {
155         return nullptr;
156     }
157     std::unique_ptr<AsyncDisallowModifyDateTimeCallbackInfo> callbackPtr {asyncCallbackInfo};
158     bool matchFlag = false;
159     if (MatchValueType(env, argv[ARR_INDEX_ZERO], napi_null)) {
160         asyncCallbackInfo->hasAdmin = false;
161         matchFlag = true;
162     } else if (MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object)) {
163         matchFlag = true;
164         asyncCallbackInfo->hasAdmin = true;
165         bool ret = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
166         ASSERT_AND_THROW_PARAM_ERROR(env, ret, "element name param error");
167         EDMLOGD("IsModifyDateTimeDisallowed: asyncCallbackInfo->elementName.bundlename %{public}s, "
168             "asyncCallbackInfo->abilityname:%{public}s",
169             asyncCallbackInfo->elementName.GetBundleName().c_str(),
170             asyncCallbackInfo->elementName.GetAbilityName().c_str());
171     }
172     if (argc > ARGS_SIZE_ONE) {
173         matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_ONE], napi_function);
174     }
175     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
176     if (argc > ARGS_SIZE_ONE) {
177         EDMLOGD("NAPI_IsModifyDateTimeDisallowed argc == ARGS_SIZE_TWO");
178         napi_create_reference(env, argv[ARR_INDEX_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
179     }
180     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "IsModifyDateTimeDisallowed",
181         NativeIsModifyDateTimeDisallowed, NativeBoolCallbackComplete);
182     callbackPtr.release();
183     return asyncWorkReturn;
184 }
185 
NativeIsModifyDateTimeDisallowed(napi_env env,void * data)186 void DatetimeManagerAddon::NativeIsModifyDateTimeDisallowed(napi_env env, void *data)
187 {
188     EDMLOGI("NativeIsModifyDateTimeDisallowed called");
189     if (data == nullptr) {
190         EDMLOGE("data is nullptr");
191         return;
192     }
193     AsyncDisallowModifyDateTimeCallbackInfo *asyncCallbackInfo =
194         static_cast<AsyncDisallowModifyDateTimeCallbackInfo *>(data);
195     auto dateTimeManagerProxy = DatetimeManagerProxy::GetDatetimeManagerProxy();
196     if (dateTimeManagerProxy == nullptr) {
197         EDMLOGE("can not get DatetimeManagerProxy");
198         return;
199     }
200     if (asyncCallbackInfo->hasAdmin) {
201         asyncCallbackInfo->ret = dateTimeManagerProxy->IsModifyDateTimeDisallowed(&(asyncCallbackInfo->elementName),
202             asyncCallbackInfo->boolRet);
203     } else {
204         asyncCallbackInfo->ret = dateTimeManagerProxy->IsModifyDateTimeDisallowed(nullptr, asyncCallbackInfo->boolRet);
205     }
206 }
207 
208 static napi_module g_dateTimeManagerModule = {
209     .nm_version = 1,
210     .nm_flags = 0,
211     .nm_filename = nullptr,
212     .nm_register_func = DatetimeManagerAddon::Init,
213     .nm_modname = "enterprise.dateTimeManager",
214     .nm_priv = ((void *)0),
215     .reserved = { 0 },
216 };
217 
DateTimeManagerRegister()218 extern "C" __attribute__((constructor)) void DateTimeManagerRegister()
219 {
220     napi_module_register(&g_dateTimeManagerModule);
221 }