1 /*
2 * Copyright (c) 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
16 #include "cloud_sync_manager_n_exporter.h"
17
18 #include <map>
19
20 #include <sys/types.h>
21
22 #include "cloud_sync_common.h"
23 #include "cloud_sync_manager.h"
24 #include "dfs_error.h"
25 #include "utils_log.h"
26
27 namespace OHOS::FileManagement::CloudSync {
28 using namespace FileManagement::LibN;
29 using namespace std;
30
ChangeAppCloudSwitch(napi_env env,napi_callback_info info)31 napi_value ChangeAppCloudSwitch(napi_env env, napi_callback_info info)
32 {
33 NFuncArg funcArg(env, info);
34 if (!funcArg.InitArgs(static_cast<size_t>(NARG_CNT::THREE), static_cast<size_t>(NARG_CNT::FOUR))) {
35 NError(E_PARAMS).ThrowErr(env, "Number of arguments unmatched");
36 return nullptr;
37 }
38
39 bool succ = false;
40 std::unique_ptr<char []> accoutId;
41 std::unique_ptr<char []> bundleName;
42 bool status;
43
44 tie(succ, accoutId, std::ignore) = NVal(env, funcArg[(int)NARG_POS::FIRST]).ToUTF8String();
45 if (!succ) {
46 NError(E_PARAMS).ThrowErr(env);
47 return nullptr;
48 }
49
50 tie(succ, bundleName, std::ignore) = NVal(env, funcArg[(int)NARG_POS::SECOND]).ToUTF8String();
51 if (!succ) {
52 NError(E_PARAMS).ThrowErr(env);
53 return nullptr;
54 }
55
56 tie(succ, status) = NVal(env, funcArg[(int)NARG_POS::THIRD]).ToBool();
57 if (!succ) {
58 NError(E_PARAMS).ThrowErr(env);
59 return nullptr;
60 }
61
62 string accoutIdStr(accoutId.get());
63 string bundleNameStr(bundleName.get());
64
65 auto cbExec = [accoutIdStr, bundleNameStr, status]() -> NError {
66 int32_t result = CloudSyncManager::GetInstance().ChangeAppSwitch(accoutIdStr, bundleNameStr, status);
67 if (result == E_PERMISSION_DENIED || result == E_PERMISSION_SYSTEM) {
68 return result == E_PERMISSION_DENIED? NError(Convert2JsErrNum(E_PERMISSION_DENIED)) :
69 NError(Convert2JsErrNum(E_PERMISSION_SYSTEM));
70 }
71 return NError(ERRNO_NOERR);
72 };
73 auto cbComplete = [](napi_env env, NError err) -> NVal {
74 if (err) {
75 return { env, err.GetNapiErr(env) };
76 }
77 return { NVal::CreateUndefined(env) };
78 };
79
80 std::string procedureName = "ChangeAppCloudSwitch";
81 NVal thisVar(env, funcArg.GetThisVar());
82 if (funcArg.GetArgc() == (uint)NARG_CNT::THREE) {
83 return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplete).val_;
84 } else {
85 NVal cb(env, funcArg[(int)NARG_POS::FOURTH]);
86 return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_;
87 }
88 }
89
NotifyDataChange(napi_env env,napi_callback_info info)90 napi_value NotifyDataChange(napi_env env, napi_callback_info info)
91 {
92 NFuncArg funcArg(env, info);
93 if (!funcArg.InitArgs(static_cast<size_t>(NARG_CNT::TWO), static_cast<size_t>(NARG_CNT::THREE))) {
94 NError(E_PARAMS).ThrowErr(env, "Number of arguments unmatched");
95 return nullptr;
96 }
97
98 bool succ = false;
99 std::unique_ptr<char []> accoutId;
100 std::unique_ptr<char []> bundleName;
101
102 tie(succ, accoutId, std::ignore) = NVal(env, funcArg[(int)NARG_POS::FIRST]).ToUTF8String();
103 if (!succ) {
104 NError(E_PARAMS).ThrowErr(env);
105 return nullptr;
106 }
107
108 tie(succ, bundleName, std::ignore) = NVal(env, funcArg[(int)NARG_POS::SECOND]).ToUTF8String();
109 if (!succ) {
110 NError(E_PARAMS).ThrowErr(env);
111 return nullptr;
112 }
113
114 string accoutIdStr(accoutId.get());
115 string bundleNameStr(bundleName.get());
116
117 auto cbExec = [accoutIdStr, bundleNameStr]() -> NError {
118 int32_t result = CloudSyncManager::GetInstance().NotifyDataChange(accoutIdStr, bundleNameStr);
119 if (result == E_PERMISSION_DENIED || result == E_PERMISSION_SYSTEM) {
120 return result == E_PERMISSION_DENIED? NError(Convert2JsErrNum(E_PERMISSION_DENIED)) :
121 NError(Convert2JsErrNum(E_PERMISSION_SYSTEM));
122 }
123 return NError(ERRNO_NOERR);
124 };
125 auto cbComplete = [](napi_env env, NError err) -> NVal {
126 if (err) {
127 return { env, err.GetNapiErr(env) };
128 }
129 return { NVal::CreateUndefined(env) };
130 };
131
132 std::string procedureName = "NotifyDataChange";
133 NVal thisVar(env, funcArg.GetThisVar());
134 if (funcArg.GetArgc() == (uint)NARG_CNT::TWO) {
135 return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplete).val_;
136 } else {
137 NVal cb(env, funcArg[(int)NARG_POS::THIRD]);
138 return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_;
139 }
140 }
141
DisableCloud(napi_env env,napi_callback_info info)142 napi_value DisableCloud(napi_env env, napi_callback_info info)
143 {
144 LOGI("DisableCloud");
145 NFuncArg funcArg(env, info);
146 if (!funcArg.InitArgs(static_cast<size_t>(NARG_CNT::ONE), static_cast<size_t>(NARG_CNT::TWO))) {
147 NError(E_PARAMS).ThrowErr(env, "Number of arguments unmatched");
148 return nullptr;
149 }
150
151 bool succ = false;
152 std::unique_ptr<char []> accoutId;
153
154 tie(succ, accoutId, std::ignore) = NVal(env, funcArg[(int)NARG_POS::FIRST]).ToUTF8String();
155 if (!succ) {
156 NError(E_PARAMS).ThrowErr(env);
157 return nullptr;
158 }
159
160 string accoutIdStr(accoutId.get());
161
162 auto cbExec = [accoutIdStr]() -> NError {
163 int32_t result = CloudSyncManager::GetInstance().DisableCloud(accoutIdStr);
164 if (result == E_PERMISSION_DENIED || result == E_PERMISSION_SYSTEM) {
165 return result == E_PERMISSION_DENIED? NError(Convert2JsErrNum(E_PERMISSION_DENIED)) :
166 NError(Convert2JsErrNum(E_PERMISSION_SYSTEM));
167 }
168 return NError(ERRNO_NOERR);
169 };
170 auto cbComplete = [](napi_env env, NError err) -> NVal {
171 if (err) {
172 return { env, err.GetNapiErr(env) };
173 }
174 return { NVal::CreateUndefined(env) };
175 };
176
177 std::string procedureName = "DisableCloud";
178 NVal thisVar(env, funcArg.GetThisVar());
179 if (funcArg.GetArgc() == (uint)NARG_CNT::ONE) {
180 return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplete).val_;
181 } else {
182 NVal cb(env, funcArg[(int)NARG_POS::SECOND]);
183 return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_;
184 }
185 }
186
187
ParseSwitches(napi_env env,napi_value object,SwitchDataObj & data)188 bool ParseSwitches(napi_env env, napi_value object, SwitchDataObj &data)
189 {
190 napi_valuetype valueType = napi_undefined;
191 napi_typeof(env, object, &valueType);
192 if (valueType != napi_object) {
193 LOGE("ParseSwitches failed, not napi object");
194 return false;
195 }
196 napi_value bundleNameArr = nullptr;
197 napi_get_property_names(env, object, &bundleNameArr);
198 uint32_t bundleNameNum = 0;
199 napi_get_array_length(env, bundleNameArr, &bundleNameNum);
200 for (uint32_t i = 0; i < bundleNameNum; ++i) {
201 napi_value item = nullptr;
202 napi_get_element(env, bundleNameArr, i, &item);
203 std::unique_ptr<char []> bundleId;
204 bool succ = false;
205 tie(succ, bundleId, std::ignore) = NVal(env, item).ToUTF8String();
206 if (!succ) {
207 LOGE("fail to get string");
208 return false;
209 }
210
211 napi_value val = nullptr;
212 napi_get_named_property(env, object, bundleId.get(), &val);
213 bool switchVal = false;
214 tie(succ, switchVal) = NVal(env, val).ToBool();
215 if (!succ) {
216 LOGE("fail to get switchVal");
217 return false;
218 }
219 data.switchData.emplace(bundleId.get(), switchVal);
220 }
221 return true;
222 }
223
EnableCloud(napi_env env,napi_callback_info info)224 napi_value EnableCloud(napi_env env, napi_callback_info info)
225 {
226 LOGI("EnableCloud");
227 NFuncArg funcArg(env, info);
228 if (!funcArg.InitArgs(static_cast<size_t>(NARG_CNT::TWO), static_cast<size_t>(NARG_CNT::THREE))) {
229 NError(E_PARAMS).ThrowErr(env, "Number of arguments unmatched");
230 return nullptr;
231 }
232
233 bool succ = false;
234 std::unique_ptr<char []> accoutId;
235
236 tie(succ, accoutId, std::ignore) = NVal(env, funcArg[(int)NARG_POS::FIRST]).ToUTF8String();
237 if (!succ) {
238 NError(E_PARAMS).ThrowErr(env);
239 return nullptr;
240 }
241 SwitchDataObj switchData;
242 if (!ParseSwitches(env, funcArg[(int)NARG_POS::SECOND], switchData)) {
243 NError(E_PARAMS).ThrowErr(env);
244 return nullptr;
245 }
246
247 string accoutIdStr(accoutId.get());
248
249 auto cbExec = [accoutIdStr, switchData]() -> NError {
250 int32_t result = CloudSyncManager::GetInstance().EnableCloud(accoutIdStr, switchData);
251 if (result == E_PERMISSION_DENIED || result == E_PERMISSION_SYSTEM) {
252 return result == E_PERMISSION_DENIED? NError(Convert2JsErrNum(E_PERMISSION_DENIED)) :
253 NError(Convert2JsErrNum(E_PERMISSION_SYSTEM));
254 }
255 return NError(ERRNO_NOERR);
256 };
257 auto cbComplete = [](napi_env env, NError err) -> NVal {
258 if (err) {
259 return { env, err.GetNapiErr(env) };
260 }
261 return { NVal::CreateUndefined(env) };
262 };
263
264 std::string procedureName = "EnableCloud";
265 NVal thisVar(env, funcArg.GetThisVar());
266 if (funcArg.GetArgc() == (uint)NARG_CNT::TWO) {
267 return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplete).val_;
268 } else {
269 NVal cb(env, funcArg[(int)NARG_POS::THIRD]);
270 return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_;
271 }
272 }
273
ParseAppActions(napi_env env,napi_value object,CleanOptions & cleanOptions)274 bool ParseAppActions(napi_env env, napi_value object, CleanOptions &cleanOptions)
275 {
276 napi_valuetype valueType = napi_undefined;
277 napi_typeof(env, object, &valueType);
278 if (valueType != napi_object) {
279 LOGE("ParseAppActions failed, not napi object");
280 return false;
281 }
282 napi_value bundleNameArr = nullptr;
283 napi_get_property_names(env, object, &bundleNameArr);
284 uint32_t bundleNameNum = 0;
285 napi_get_array_length(env, bundleNameArr, &bundleNameNum);
286 for (uint32_t i = 0; i < bundleNameNum; ++i) {
287 napi_value item = nullptr;
288 napi_get_element(env, bundleNameArr, i, &item);
289 std::unique_ptr<char[]> bundleNameStr = nullptr;
290 bool resGetKey = false;
291 tie(resGetKey, bundleNameStr, ignore) = NVal(env, item).ToUTF8String();
292 if (!resGetKey) {
293 LOGE("Fail to get string");
294 return false;
295 }
296 napi_value actionObj = nullptr;
297 napi_get_named_property(env, object, bundleNameStr.get(), &actionObj);
298 int appActionsVal = 0;
299 bool resGetValue = false;
300 tie(resGetValue, appActionsVal) = NVal(env, actionObj).ToInt32();
301 if (!resGetValue) {
302 LOGE("Fail to get appActionsVal");
303 return false;
304 }
305 cleanOptions.appActionsData.emplace(string(bundleNameStr.get()).c_str(), appActionsVal);
306 }
307 return true;
308 }
Clean(napi_env env,napi_callback_info info)309 napi_value Clean(napi_env env, napi_callback_info info)
310 {
311 LOGI("Clean");
312 NFuncArg funcArg(env, info);
313 if (!funcArg.InitArgs(static_cast<size_t>(NARG_CNT::TWO), static_cast<size_t>(NARG_CNT::THREE))) {
314 NError(E_PARAMS).ThrowErr(env, "Number of arguments unmatched");
315 return nullptr;
316 }
317 std::unique_ptr<char []> accoutId = nullptr;
318 bool succ = false;
319 tie(succ, accoutId, ignore) = NVal(env, funcArg[(int)NARG_POS::FIRST]).ToUTF8String();
320 if (!succ) {
321 NError(E_PARAMS).ThrowErr(env);
322 return nullptr;
323 }
324 CleanOptions cleanOptions {};
325 if (!ParseAppActions(env, funcArg[(int)NARG_POS::SECOND], cleanOptions)) {
326 NError(E_PARAMS).ThrowErr(env);
327 return nullptr;
328 }
329
330 std::string accoutIdStr(accoutId.get());
331 auto cbExec = [accoutIdStr, cleanOptions]() -> NError {
332 int32_t result = CloudSyncManager::GetInstance().Clean(accoutIdStr, cleanOptions);
333 if (result == E_PERMISSION_DENIED || result == E_PERMISSION_SYSTEM) {
334 return result == E_PERMISSION_DENIED? NError(Convert2JsErrNum(E_PERMISSION_DENIED)) :
335 NError(Convert2JsErrNum(E_PERMISSION_SYSTEM));
336 }
337 return NError(ERRNO_NOERR);
338 };
339 auto cbComplete = [](napi_env env, NError err) -> NVal {
340 if (err) {
341 return { env, err.GetNapiErr(env) };
342 }
343 return { NVal::CreateUndefined(env) };
344 };
345
346 std::string procedureName = "Clean";
347 NVal thisVar(env, funcArg.GetThisVar());
348 if (funcArg.GetArgc() == (uint)NARG_CNT::TWO) {
349 return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplete).val_;
350 } else {
351 NVal cb(env, funcArg[(int)NARG_POS::THIRD]);
352 return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_;
353 }
354 }
355
356 } // namespace OHOS::FileManagement::CloudSync
357