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
62 std::vector<std::unique_ptr<NExporter>> products;
63 products.emplace_back(std::make_unique<CloudFileCacheNapi>(env, exports));
64 products.emplace_back(std::make_unique<CloudFileDownloadNapi>(env, exports));
65 products.emplace_back(std::make_unique<GallerySyncNapi>(env, exports));
66 products.emplace_back(std::make_unique<FileSyncNapi>(env, exports));
67 for (auto &&product : products) {
68 if (!product->Export()) {
69 LOGE("INNER BUG. Failed to export class %{public}s for module cloudSyncDownload ",
70 product->GetClassName().c_str());
71 return nullptr;
72 } else {
73 LOGI("Class %{public}s for module cloudSyncDownload has been exported", product->GetClassName().c_str());
74 }
75 }
76 return exports;
77 }
78
InitCloudSyncState(napi_env env,napi_value exports)79 void InitCloudSyncState(napi_env env, napi_value exports)
80 {
81 char propertyName[] = "SyncState";
82 napi_property_descriptor desc[] = {
83 DECLARE_NAPI_STATIC_PROPERTY("UPLOADING", NVal::CreateInt32(env, UPLOADING).val_),
84 DECLARE_NAPI_STATIC_PROPERTY("UPLOAD_FAILED", NVal::CreateInt32(env, UPLOAD_FAILED).val_),
85 DECLARE_NAPI_STATIC_PROPERTY("DOWNLOADING", NVal::CreateInt32(env, DOWNLOADING).val_),
86 DECLARE_NAPI_STATIC_PROPERTY("DOWNLOAD_FAILED", NVal::CreateInt32(env, DOWNLOAD_FAILED).val_),
87 DECLARE_NAPI_STATIC_PROPERTY("COMPLETED", NVal::CreateInt32(env, COMPLETED).val_),
88 DECLARE_NAPI_STATIC_PROPERTY("STOPPED", NVal::CreateInt32(env, STOPPED).val_),
89 };
90 napi_value obj = nullptr;
91 napi_create_object(env, &obj);
92 napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
93 napi_set_named_property(env, exports, propertyName, obj);
94 }
95
InitFileSyncState(napi_env env,napi_value exports)96 void InitFileSyncState(napi_env env, napi_value exports)
97 {
98 char propertyName[] = "FileSyncState";
99 napi_property_descriptor desc[] = {
100 DECLARE_NAPI_STATIC_PROPERTY("UPLOADING", NVal::CreateInt32(env, FILESYNCSTATE_UPLOADING).val_),
101 DECLARE_NAPI_STATIC_PROPERTY("DOWNLOADING", NVal::CreateInt32(env, FILESYNCSTATE_DOWNLOADING).val_),
102 DECLARE_NAPI_STATIC_PROPERTY("COMPLETED", NVal::CreateInt32(env, FILESYNCSTATE_COMPLETED).val_),
103 DECLARE_NAPI_STATIC_PROPERTY("STOPPED", NVal::CreateInt32(env, FILESYNCSTATE_STOPPED).val_),
104 DECLARE_NAPI_STATIC_PROPERTY("TO_BE_UPLOADED", NVal::CreateInt32(env, FILESYNCSTATE_TO_BE_UPLOADED).val_),
105 DECLARE_NAPI_STATIC_PROPERTY("UPLOAD_FAILURE", NVal::CreateInt32(env, FILESYNCSTATE_UPLOAD_FAILURE).val_),
106 DECLARE_NAPI_STATIC_PROPERTY("UPLOAD_SUCCESS", NVal::CreateInt32(env, FILESYNCSTATE_UPLOAD_SUCCESS).val_),
107 };
108 napi_value obj = nullptr;
109 napi_create_object(env, &obj);
110 napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
111 napi_set_named_property(env, exports, propertyName, obj);
112 }
113
InitErrorType(napi_env env,napi_value exports)114 void InitErrorType(napi_env env, napi_value exports)
115 {
116 char propertyName[] = "ErrorType";
117 napi_property_descriptor desc[] = {
118 DECLARE_NAPI_STATIC_PROPERTY("NO_ERROR", NVal::CreateInt32(env, NO_ERROR).val_),
119 DECLARE_NAPI_STATIC_PROPERTY("NETWORK_UNAVAILABLE", NVal::CreateInt32(env, NETWORK_UNAVAILABLE).val_),
120 DECLARE_NAPI_STATIC_PROPERTY("WIFI_UNAVAILABLE", NVal::CreateInt32(env, WIFI_UNAVAILABLE).val_),
121 DECLARE_NAPI_STATIC_PROPERTY("BATTERY_LEVEL_LOW", NVal::CreateInt32(env, BATTERY_LEVEL_LOW).val_),
122 DECLARE_NAPI_STATIC_PROPERTY("BATTERY_LEVEL_WARNING", NVal::CreateInt32(env, BATTERY_LEVEL_WARNING).val_),
123 DECLARE_NAPI_STATIC_PROPERTY("CLOUD_STORAGE_FULL", NVal::CreateInt32(env, CLOUD_STORAGE_FULL).val_),
124 DECLARE_NAPI_STATIC_PROPERTY("LOCAL_STORAGE_FULL", NVal::CreateInt32(env, LOCAL_STORAGE_FULL).val_),
125 };
126 napi_value obj = nullptr;
127 napi_create_object(env, &obj);
128 napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
129 napi_set_named_property(env, exports, propertyName, obj);
130 }
131
InitDownloadErrorType(napi_env env,napi_value exports)132 void InitDownloadErrorType(napi_env env, napi_value exports)
133 {
134 char propertyName[] = "DownloadErrorType";
135 napi_property_descriptor desc[] = {
136 DECLARE_NAPI_STATIC_PROPERTY("NO_ERROR", NVal::CreateInt32(env, NO_ERROR).val_),
137 DECLARE_NAPI_STATIC_PROPERTY("UNKNOWN_ERROR",
138 NVal::CreateInt32(env, DownloadProgressObj::UNKNOWN_ERROR).val_),
139 DECLARE_NAPI_STATIC_PROPERTY("NETWORK_UNAVAILABLE",
140 NVal::CreateInt32(env, DownloadProgressObj::NETWORK_UNAVAILABLE).val_),
141 DECLARE_NAPI_STATIC_PROPERTY("LOCAL_STORAGE_FULL",
142 NVal::CreateInt32(env, DownloadProgressObj::LOCAL_STORAGE_FULL).val_),
143 DECLARE_NAPI_STATIC_PROPERTY("CONTENT_NOT_FOUND",
144 NVal::CreateInt32(env, DownloadProgressObj::CONTENT_NOT_FOUND).val_),
145 DECLARE_NAPI_STATIC_PROPERTY("FREQUENT_USER_REQUESTS",
146 NVal::CreateInt32(env, DownloadProgressObj::FREQUENT_USER_REQUESTS).val_),
147 };
148 napi_value obj = nullptr;
149 napi_create_object(env, &obj);
150 napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
151 napi_set_named_property(env, exports, propertyName, obj);
152 }
153
InitCloudSyncApi(napi_env env,napi_value exports)154 void InitCloudSyncApi(napi_env env, napi_value exports)
155 {
156 static napi_property_descriptor desc[] = {
157 DECLARE_NAPI_FUNCTION("getFileSyncState", CloudSyncNapi::GetFileSyncState),
158 DECLARE_NAPI_FUNCTION("optimizeStorage", CloudSyncNapi::OptimizeStorage),
159 };
160 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
161 }
162
InitNotifyType(napi_env env,napi_value exports)163 void InitNotifyType(napi_env env, napi_value exports)
164 {
165 const char propertyName[] = "NotifyType";
166 napi_property_descriptor desc[] = {
167 DECLARE_NAPI_STATIC_PROPERTY("NOTIFY_ADDED", NVal::CreateInt32(env, NotifyType::NOTIFY_ADDED).val_),
168 DECLARE_NAPI_STATIC_PROPERTY("NOTIFY_MODIFIED", NVal::CreateInt32(env, NotifyType::NOTIFY_MODIFIED).val_),
169 DECLARE_NAPI_STATIC_PROPERTY("NOTIFY_DELETED", NVal::CreateInt32(env, NotifyType::NOTIFY_DELETED).val_),
170 DECLARE_NAPI_STATIC_PROPERTY("NOTIFY_RENAMED", NVal::CreateInt32(env, NotifyType::NOTIFY_RENAMED).val_),
171 };
172 napi_value obj = nullptr;
173 napi_create_object(env, &obj);
174 napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
175 napi_set_named_property(env, exports, propertyName, obj);
176 }
177
InitCloudSyncFuncs(napi_env env,napi_value exports)178 void InitCloudSyncFuncs(napi_env env, napi_value exports)
179 {
180 static napi_property_descriptor desc[] = {
181 DECLARE_NAPI_FUNCTION("registerChange", CloudSyncNapi::RegisterChange),
182 DECLARE_NAPI_FUNCTION("unregisterChange", CloudSyncNapi::UnregisterChange),
183 };
184 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
185 }
186
187 static napi_module _module = {
188 .nm_version = 1,
189 .nm_flags = 0,
190 .nm_filename = nullptr,
191 .nm_register_func = CloudSyncExport,
192 .nm_modname = "file.cloudSync",
193 .nm_priv = ((void *)0),
194 .reserved = {0}
195 };
196
RegisterModule(void)197 extern "C" __attribute__((constructor)) void RegisterModule(void)
198 {
199 napi_module_register(&_module);
200 }
201 } // namespace OHOS::FileManagement::CloudSync
202