1 /*
2 * Copyright (c) 2023-2024 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 "cloud_sync_n_exporter.h"
16
17 #include "cloud_file_cache_napi.h"
18 #include "cloud_file_napi.h"
19 #include "cloud_file_version_napi.h"
20 #include "cloud_sync_napi.h"
21 #include "file_sync_napi.h"
22 #include "gallery_sync_napi.h"
23 #include "multi_download_progress_napi.h"
24 #include "utils_log.h"
25
26 namespace OHOS::FileManagement::CloudSync {
27 using namespace FileManagement::LibN;
28 using namespace std;
29
InitState(napi_env env,napi_value exports)30 static void InitState(napi_env env, napi_value exports)
31 {
32 char propertyName[] = "State";
33 napi_value obj = nullptr;
34 napi_create_object(env, &obj);
35 napi_property_descriptor desc[] = {
36 DECLARE_NAPI_STATIC_PROPERTY("RUNNING",
37 NVal::CreateInt32(env, (int32_t)State::CLOUD_FILE_DOWNLOAD_RUNNING).val_),
38 DECLARE_NAPI_STATIC_PROPERTY("COMPLETED",
39 NVal::CreateInt32(env, (int32_t)State::CLOUD_FILE_DOWNLOAD_COMPLETED).val_),
40 DECLARE_NAPI_STATIC_PROPERTY("FAILED",
41 NVal::CreateInt32(env, (int32_t)State::CLOUD_FILE_DOWNLOAD_FAILED).val_),
42 DECLARE_NAPI_STATIC_PROPERTY("STOPPED",
43 NVal::CreateInt32(env, (int32_t)State::CLOUD_FILE_DOWNLOAD_STOPPED).val_),
44 };
45 napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
46 napi_set_named_property(env, exports, propertyName, obj);
47 }
48
49 /***********************************************
50 * Module export and register
51 ***********************************************/
CloudSyncExport(napi_env env,napi_value exports)52 napi_value CloudSyncExport(napi_env env, napi_value exports)
53 {
54 InitCloudSyncState(env, exports);
55 InitErrorType(env, exports);
56 InitDownloadErrorType(env, exports);
57 InitState(env, exports);
58 InitFileSyncState(env, exports);
59 InitFileState(env, exports);
60 InitCloudSyncApi(env, exports);
61 InitNotifyType(env, exports);
62 InitCloudSyncFuncs(env, exports);
63 InitOptimizeState(env, exports);
64 InitDownloadFileType(env, exports);
65
66 std::vector<std::unique_ptr<NExporter>> products;
67 products.emplace_back(std::make_unique<MultiDlProgressNapi>(env, exports));
68 products.emplace_back(std::make_unique<CloudFileCacheNapi>(env, exports));
69 products.emplace_back(std::make_unique<CloudFileDownloadNapi>(env, exports));
70 products.emplace_back(std::make_unique<GallerySyncNapi>(env, exports));
71 products.emplace_back(std::make_unique<FileSyncNapi>(env, exports));
72 products.emplace_back(std::make_unique<FileVersionNapi>(env, exports));
73 for (auto &&product : products) {
74 if (!product->Export()) {
75 LOGE("INNER BUG. Failed to export class %{public}s for module cloudSyncDownload ",
76 product->GetClassName().c_str());
77 return nullptr;
78 } else {
79 LOGI("Class %{public}s for module cloudSyncDownload has been exported", product->GetClassName().c_str());
80 }
81 }
82 return exports;
83 }
84
InitCloudSyncState(napi_env env,napi_value exports)85 void InitCloudSyncState(napi_env env, napi_value exports)
86 {
87 char propertyName[] = "SyncState";
88 napi_property_descriptor desc[] = {
89 DECLARE_NAPI_STATIC_PROPERTY("UPLOADING", NVal::CreateInt32(env, UPLOADING).val_),
90 DECLARE_NAPI_STATIC_PROPERTY("UPLOAD_FAILED", NVal::CreateInt32(env, UPLOAD_FAILED).val_),
91 DECLARE_NAPI_STATIC_PROPERTY("DOWNLOADING", NVal::CreateInt32(env, DOWNLOADING).val_),
92 DECLARE_NAPI_STATIC_PROPERTY("DOWNLOAD_FAILED", NVal::CreateInt32(env, DOWNLOAD_FAILED).val_),
93 DECLARE_NAPI_STATIC_PROPERTY("COMPLETED", NVal::CreateInt32(env, COMPLETED).val_),
94 DECLARE_NAPI_STATIC_PROPERTY("STOPPED", NVal::CreateInt32(env, STOPPED).val_),
95 };
96 napi_value obj = nullptr;
97 napi_create_object(env, &obj);
98 napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
99 napi_set_named_property(env, exports, propertyName, obj);
100 }
101
InitOptimizeState(napi_env env,napi_value exports)102 void InitOptimizeState(napi_env env, napi_value exports)
103 {
104 char propertyName[] = "OptimizeState";
105 napi_property_descriptor desc[] = {
106 DECLARE_NAPI_STATIC_PROPERTY("RUNNING", NVal::CreateInt32(env, OPTIMIZE_RUNNING).val_),
107 DECLARE_NAPI_STATIC_PROPERTY("COMPLETED", NVal::CreateInt32(env, OPTIMIZE_COMPLETED).val_),
108 DECLARE_NAPI_STATIC_PROPERTY("FAILED", NVal::CreateInt32(env, OPTIMIZE_FAILED).val_),
109 DECLARE_NAPI_STATIC_PROPERTY("STOPPED", NVal::CreateInt32(env, OPTIMIZE_STOPPED).val_),
110 };
111 napi_value obj = nullptr;
112 napi_create_object(env, &obj);
113 napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
114 napi_set_named_property(env, exports, propertyName, obj);
115 }
116
InitFileSyncState(napi_env env,napi_value exports)117 void InitFileSyncState(napi_env env, napi_value exports)
118 {
119 char propertyName[] = "FileSyncState";
120 napi_property_descriptor desc[] = {
121 DECLARE_NAPI_STATIC_PROPERTY("UPLOADING", NVal::CreateInt32(env, FILESYNCSTATE_UPLOADING).val_),
122 DECLARE_NAPI_STATIC_PROPERTY("DOWNLOADING", NVal::CreateInt32(env, FILESYNCSTATE_DOWNLOADING).val_),
123 DECLARE_NAPI_STATIC_PROPERTY("COMPLETED", NVal::CreateInt32(env, FILESYNCSTATE_COMPLETED).val_),
124 DECLARE_NAPI_STATIC_PROPERTY("STOPPED", NVal::CreateInt32(env, FILESYNCSTATE_STOPPED).val_),
125 DECLARE_NAPI_STATIC_PROPERTY("TO_BE_UPLOADED", NVal::CreateInt32(env, FILESYNCSTATE_TO_BE_UPLOADED).val_),
126 DECLARE_NAPI_STATIC_PROPERTY("UPLOAD_FAILURE", NVal::CreateInt32(env, FILESYNCSTATE_UPLOAD_FAILURE).val_),
127 DECLARE_NAPI_STATIC_PROPERTY("UPLOAD_SUCCESS", NVal::CreateInt32(env, FILESYNCSTATE_UPLOAD_SUCCESS).val_),
128 };
129 napi_value obj = nullptr;
130 napi_create_object(env, &obj);
131 napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
132 napi_set_named_property(env, exports, propertyName, obj);
133 }
134
InitFileState(napi_env env,napi_value exports)135 void InitFileState(napi_env env, napi_value exports)
136 {
137 char propertyName[] = "FileState";
138 napi_property_descriptor desc[] = {
139 DECLARE_NAPI_STATIC_PROPERTY("INITIAL_AFTER_DOWNLOAD",
140 NVal::CreateInt32(env, FILESTATE_INITIAL_AFTER_DOWNLOAD).val_),
141 DECLARE_NAPI_STATIC_PROPERTY("UPLOADING", NVal::CreateInt32(env, FILESTATE_UPLOADING).val_),
142 DECLARE_NAPI_STATIC_PROPERTY("STOPPED", NVal::CreateInt32(env, FILESTATE_STOPPED).val_),
143 DECLARE_NAPI_STATIC_PROPERTY("TO_BE_UPLOADED", NVal::CreateInt32(env, FILESTATE_TO_BE_UPLOADED).val_),
144 DECLARE_NAPI_STATIC_PROPERTY("UPLOAD_SUCCESS", NVal::CreateInt32(env, FILESTATE_UPLOAD_SUCCESS).val_),
145 DECLARE_NAPI_STATIC_PROPERTY("UPLOAD_FAILURE", NVal::CreateInt32(env, FILESTATE_UPLOAD_FAILURE).val_),
146 };
147 napi_value obj = nullptr;
148 napi_create_object(env, &obj);
149 napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
150 napi_set_named_property(env, exports, propertyName, obj);
151 }
152
InitErrorType(napi_env env,napi_value exports)153 void InitErrorType(napi_env env, napi_value exports)
154 {
155 char propertyName[] = "ErrorType";
156 napi_property_descriptor desc[] = {
157 DECLARE_NAPI_STATIC_PROPERTY("NO_ERROR", NVal::CreateInt32(env, NO_ERROR).val_),
158 DECLARE_NAPI_STATIC_PROPERTY("NETWORK_UNAVAILABLE", NVal::CreateInt32(env, NETWORK_UNAVAILABLE).val_),
159 DECLARE_NAPI_STATIC_PROPERTY("WIFI_UNAVAILABLE", NVal::CreateInt32(env, WIFI_UNAVAILABLE).val_),
160 DECLARE_NAPI_STATIC_PROPERTY("BATTERY_LEVEL_LOW", NVal::CreateInt32(env, BATTERY_LEVEL_LOW).val_),
161 DECLARE_NAPI_STATIC_PROPERTY("BATTERY_LEVEL_WARNING", NVal::CreateInt32(env, BATTERY_LEVEL_WARNING).val_),
162 DECLARE_NAPI_STATIC_PROPERTY("CLOUD_STORAGE_FULL", NVal::CreateInt32(env, CLOUD_STORAGE_FULL).val_),
163 DECLARE_NAPI_STATIC_PROPERTY("LOCAL_STORAGE_FULL", NVal::CreateInt32(env, LOCAL_STORAGE_FULL).val_),
164 DECLARE_NAPI_STATIC_PROPERTY("DEVICE_TEMPERATURE_TOO_HIGH",
165 NVal::CreateInt32(env, DEVICE_TEMPERATURE_TOO_HIGH).val_),
166 };
167 napi_value obj = nullptr;
168 napi_create_object(env, &obj);
169 napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
170 napi_set_named_property(env, exports, propertyName, obj);
171 }
172
InitDownloadErrorType(napi_env env,napi_value exports)173 void InitDownloadErrorType(napi_env env, napi_value exports)
174 {
175 char propertyName[] = "DownloadErrorType";
176 napi_property_descriptor desc[] = {
177 DECLARE_NAPI_STATIC_PROPERTY("NO_ERROR", NVal::CreateInt32(env, NO_ERROR).val_),
178 DECLARE_NAPI_STATIC_PROPERTY("UNKNOWN_ERROR",
179 NVal::CreateInt32(env, DownloadProgressObj::UNKNOWN_ERROR).val_),
180 DECLARE_NAPI_STATIC_PROPERTY("NETWORK_UNAVAILABLE",
181 NVal::CreateInt32(env, DownloadProgressObj::NETWORK_UNAVAILABLE).val_),
182 DECLARE_NAPI_STATIC_PROPERTY("LOCAL_STORAGE_FULL",
183 NVal::CreateInt32(env, DownloadProgressObj::LOCAL_STORAGE_FULL).val_),
184 DECLARE_NAPI_STATIC_PROPERTY("CONTENT_NOT_FOUND",
185 NVal::CreateInt32(env, DownloadProgressObj::CONTENT_NOT_FOUND).val_),
186 DECLARE_NAPI_STATIC_PROPERTY("FREQUENT_USER_REQUESTS",
187 NVal::CreateInt32(env, DownloadProgressObj::FREQUENT_USER_REQUESTS).val_),
188 };
189 napi_value obj = nullptr;
190 napi_create_object(env, &obj);
191 napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
192 napi_set_named_property(env, exports, propertyName, obj);
193 }
194
InitCloudSyncApi(napi_env env,napi_value exports)195 void InitCloudSyncApi(napi_env env, napi_value exports)
196 {
197 static napi_property_descriptor desc[] = {
198 DECLARE_NAPI_FUNCTION("getFileSyncState", CloudSyncNapi::GetFileSyncState),
199 DECLARE_NAPI_FUNCTION("getCoreFileSyncState", CloudSyncNapi::GetCoreFileSyncState),
200 DECLARE_NAPI_FUNCTION("optimizeStorage", CloudSyncNapi::OptimizeStorage),
201 DECLARE_NAPI_FUNCTION("startOptimizeSpace", CloudSyncNapi::StartOptimizeStorage),
202 DECLARE_NAPI_FUNCTION("stopOptimizeSpace", CloudSyncNapi::StopOptimizeStorage),
203 };
204 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
205 }
206
InitNotifyType(napi_env env,napi_value exports)207 void InitNotifyType(napi_env env, napi_value exports)
208 {
209 const char propertyName[] = "NotifyType";
210 napi_property_descriptor desc[] = {
211 DECLARE_NAPI_STATIC_PROPERTY("NOTIFY_ADDED", NVal::CreateInt32(env, NotifyType::NOTIFY_ADDED).val_),
212 DECLARE_NAPI_STATIC_PROPERTY("NOTIFY_MODIFIED", NVal::CreateInt32(env, NotifyType::NOTIFY_MODIFIED).val_),
213 DECLARE_NAPI_STATIC_PROPERTY("NOTIFY_DELETED", NVal::CreateInt32(env, NotifyType::NOTIFY_DELETED).val_),
214 DECLARE_NAPI_STATIC_PROPERTY("NOTIFY_RENAMED", NVal::CreateInt32(env, NotifyType::NOTIFY_RENAMED).val_),
215 };
216 napi_value obj = nullptr;
217 napi_create_object(env, &obj);
218 napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
219 napi_set_named_property(env, exports, propertyName, obj);
220 }
221
InitCloudSyncFuncs(napi_env env,napi_value exports)222 void InitCloudSyncFuncs(napi_env env, napi_value exports)
223 {
224 static napi_property_descriptor desc[] = {
225 DECLARE_NAPI_FUNCTION("registerChange", CloudSyncNapi::RegisterChange),
226 DECLARE_NAPI_FUNCTION("unregisterChange", CloudSyncNapi::UnregisterChange),
227 };
228 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
229 }
230
InitDownloadFileType(napi_env env,napi_value exports)231 void InitDownloadFileType(napi_env env, napi_value exports)
232 {
233 char propertyName[] = "DownloadFileType";
234 napi_property_descriptor desc[] = {
235 DECLARE_NAPI_STATIC_PROPERTY("CONTENT", NVal::CreateInt32(env, FieldKey::FIELDKEY_CONTENT).val_),
236 DECLARE_NAPI_STATIC_PROPERTY("THUMBNAIL", NVal::CreateInt32(env, FieldKey::FIELDKEY_THUMB).val_),
237 DECLARE_NAPI_STATIC_PROPERTY("LCD", NVal::CreateInt32(env, FieldKey::FIELDKEY_LCD).val_),
238 };
239 napi_value obj = nullptr;
240 napi_create_object(env, &obj);
241 napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
242 napi_set_named_property(env, exports, propertyName, obj);
243 }
244
245 static napi_module _module = {
246 .nm_version = 1,
247 .nm_flags = 0,
248 .nm_filename = nullptr,
249 .nm_register_func = CloudSyncExport,
250 .nm_modname = "file.cloudSync",
251 .nm_priv = ((void *)0),
252 .reserved = {0}
253 };
254
RegisterModule(void)255 extern "C" __attribute__((constructor)) void RegisterModule(void)
256 {
257 napi_module_register(&_module);
258 }
259 } // namespace OHOS::FileManagement::CloudSync
260