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