1 /*
2 * Copyright (c) 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
16 #define LOG_TAG "RdUtils"
17 #include "rd_utils.h"
18
19 #include "grd_api_manager.h"
20 #include "grd_error.h"
21
22 namespace OHOS::CollaborationEdit {
23
24 static GRD_APIInfo GRD_ApiInfo;
25
26 // 1. Database open/close library interface encapsulation
RdDbOpen(const char * dbFile,const char * configStr,uint32_t flags,GRD_DB ** db)27 int RdUtils::RdDbOpen(const char *dbFile, const char *configStr, uint32_t flags, GRD_DB **db)
28 {
29 if (GRD_ApiInfo.DBOpenApi == nullptr) {
30 GRD_ApiInfo = GetApiInfoInstance();
31 }
32 if (GRD_ApiInfo.DBOpenApi == nullptr) {
33 return GRD_NOT_SUPPORT;
34 }
35 return GRD_ApiInfo.DBOpenApi(dbFile, configStr, flags, db);
36 }
37
RdDbClose(GRD_DB * db,uint32_t flags)38 int RdUtils::RdDbClose(GRD_DB *db, uint32_t flags)
39 {
40 if (GRD_ApiInfo.DBCloseApi == nullptr) {
41 GRD_ApiInfo = GetApiInfoInstance();
42 }
43 if (GRD_ApiInfo.DBCloseApi == nullptr) {
44 return GRD_NOT_SUPPORT;
45 }
46 return GRD_ApiInfo.DBCloseApi(db, flags);
47 }
48
RdSetLocalId(GRD_DB * db,const char * equipId)49 int RdUtils::RdSetLocalId(GRD_DB *db, const char *equipId)
50 {
51 if (GRD_ApiInfo.SetLocalIdApi == nullptr) {
52 GRD_ApiInfo = GetApiInfoInstance();
53 }
54 if (GRD_ApiInfo.SetLocalIdApi == nullptr) {
55 return GRD_NOT_SUPPORT;
56 }
57 return GRD_ApiInfo.SetLocalIdApi(db, equipId);
58 }
59
RdGetLocalId(GRD_DB * db,char ** localId)60 int RdUtils::RdGetLocalId(GRD_DB *db, char **localId)
61 {
62 if (GRD_ApiInfo.GetLocalIdApi == nullptr) {
63 GRD_ApiInfo = GetApiInfoInstance();
64 }
65 if (GRD_ApiInfo.GetLocalIdApi == nullptr) {
66 return GRD_NOT_SUPPORT;
67 }
68 return GRD_ApiInfo.GetLocalIdApi(db, localId);
69 }
70
RdApplyUpdate(GRD_DB * db,char ** applyInfo)71 int RdUtils::RdApplyUpdate(GRD_DB *db, char **applyInfo)
72 {
73 if (GRD_ApiInfo.ApplyUpdateApi == nullptr) {
74 GRD_ApiInfo = GetApiInfoInstance();
75 }
76 if (GRD_ApiInfo.ApplyUpdateApi == nullptr) {
77 return GRD_NOT_SUPPORT;
78 }
79 return GRD_ApiInfo.ApplyUpdateApi(db, nullptr, applyInfo);
80 }
81
RdWriteUpdate(GRD_DB * db,const char * equipId,const uint8_t * data,uint32_t size,const std::string & watermark)82 int RdUtils::RdWriteUpdate(
83 GRD_DB *db, const char *equipId, const uint8_t *data, uint32_t size, const std::string &watermark)
84 {
85 if (GRD_ApiInfo.WriteUpdateApi == nullptr) {
86 GRD_ApiInfo = GetApiInfoInstance();
87 }
88 if (GRD_ApiInfo.WriteUpdateApi == nullptr) {
89 return GRD_NOT_SUPPORT;
90 }
91 return GRD_ApiInfo.WriteUpdateApi(db, equipId, data, size, watermark.c_str());
92 }
93
RdGetRelativePos(GRD_DB * db,const char * tableName,const char * nodeSize,uint32_t pos,char ** relPos)94 int RdUtils::RdGetRelativePos(
95 GRD_DB *db, const char *tableName, const char *nodeSize, uint32_t pos, char **relPos)
96 {
97 if (GRD_ApiInfo.GetRelativePosApi == nullptr) {
98 GRD_ApiInfo = GetApiInfoInstance();
99 }
100 if (GRD_ApiInfo.GetRelativePosApi == nullptr) {
101 return GRD_NOT_SUPPORT;
102 }
103 return GRD_ApiInfo.GetRelativePosApi(db, tableName, nodeSize, pos, relPos);
104 }
105
RdGetAbsolutePos(GRD_DB * db,const char * tableName,const char * relPos,const char * nodeSize,uint32_t * pos)106 int RdUtils::RdGetAbsolutePos(
107 GRD_DB *db, const char *tableName, const char *relPos, const char *nodeSize, uint32_t *pos)
108 {
109 if (GRD_ApiInfo.GetAbsolutePosApi == nullptr) {
110 GRD_ApiInfo = GetApiInfoInstance();
111 }
112 if (GRD_ApiInfo.GetAbsolutePosApi == nullptr) {
113 return GRD_NOT_SUPPORT;
114 }
115 return GRD_ApiInfo.GetAbsolutePosApi(db, tableName, relPos, nodeSize, pos);
116 }
117
118 // 2. Node operation interface encapsulation
RdInsertElements(GRD_DB * db,GRD_XmlOpPositionT * elementAddr,uint32_t index,GRD_DocNodeInfoT * nodeInfo,GRD_ElementIdT ** outElementId)119 int32_t RdUtils::RdInsertElements(GRD_DB *db, GRD_XmlOpPositionT *elementAddr, uint32_t index,
120 GRD_DocNodeInfoT *nodeInfo, GRD_ElementIdT **outElementId)
121 {
122 if (GRD_ApiInfo.InsertElementsApi == nullptr) {
123 GRD_ApiInfo = GetApiInfoInstance();
124 }
125 if (GRD_ApiInfo.InsertElementsApi == nullptr) {
126 return GRD_NOT_SUPPORT;
127 }
128 return GRD_ApiInfo.InsertElementsApi(db, elementAddr, index, nodeInfo, outElementId);
129 }
130
RdDeleteElements(GRD_DB * db,const char * tableName,const GRD_ElementIdT * elementId,uint32_t index,uint32_t length)131 int32_t RdUtils::RdDeleteElements(GRD_DB *db, const char *tableName, const GRD_ElementIdT *elementId, uint32_t index,
132 uint32_t length)
133 {
134 if (GRD_ApiInfo.DeleteElementsApi == nullptr) {
135 GRD_ApiInfo = GetApiInfoInstance();
136 }
137 if (GRD_ApiInfo.DeleteElementsApi == nullptr) {
138 return GRD_NOT_SUPPORT;
139 }
140 return GRD_ApiInfo.DeleteElementsApi(db, tableName, elementId, index, length);
141 }
142
RdGetElements(GRD_DB * db,GRD_XmlOpPositionT * elementAddr,uint32_t index,uint32_t length,char ** respXml)143 int32_t RdUtils::RdGetElements(GRD_DB *db, GRD_XmlOpPositionT *elementAddr, uint32_t index, uint32_t length,
144 char **respXml)
145 {
146 if (GRD_ApiInfo.GetElementsApi == nullptr) {
147 GRD_ApiInfo = GetApiInfoInstance();
148 }
149 if (GRD_ApiInfo.GetElementsApi == nullptr) {
150 return GRD_NOT_SUPPORT;
151 }
152 return GRD_ApiInfo.GetElementsApi(db, elementAddr, index, length, respXml);
153 }
154
RdFragmentToString(GRD_DB * db,const char * tableName,const GRD_ElementIdT * elementId,char ** replyJson)155 int32_t RdUtils::RdFragmentToString(GRD_DB *db, const char *tableName, const GRD_ElementIdT *elementId,
156 char **replyJson)
157 {
158 if (GRD_ApiInfo.FragmentToStringApi == nullptr) {
159 GRD_ApiInfo = GetApiInfoInstance();
160 }
161 if (GRD_ApiInfo.FragmentToStringApi == nullptr) {
162 return GRD_NOT_SUPPORT;
163 }
164 return GRD_ApiInfo.FragmentToStringApi(db, tableName, elementId, replyJson);
165 }
166
167 // 3. XmlElement attribute operation interface encapsulation
RdElementSetAttribute(GRD_DB * db,GRD_XmlOpPositionT * elementAddr,const char * attributeName,const char * attributeValue,uint32_t flags)168 int32_t RdUtils::RdElementSetAttribute(
169 GRD_DB *db, GRD_XmlOpPositionT *elementAddr, const char *attributeName, const char *attributeValue, uint32_t flags)
170 {
171 if (GRD_ApiInfo.ElementSetAttrApi == nullptr) {
172 GRD_ApiInfo = GetApiInfoInstance();
173 }
174 if (GRD_ApiInfo.ElementSetAttrApi == nullptr) {
175 return GRD_NOT_SUPPORT;
176 }
177 return GRD_ApiInfo.ElementSetAttrApi(db, elementAddr, attributeName, attributeValue, flags);
178 }
179
RdElementRemoveAttribute(GRD_DB * db,GRD_XmlOpPositionT * elementAddr,const char * attributeName)180 int32_t RdUtils::RdElementRemoveAttribute(GRD_DB *db, GRD_XmlOpPositionT *elementAddr, const char *attributeName)
181 {
182 if (GRD_ApiInfo.ElementRemoveAttrApi == nullptr) {
183 GRD_ApiInfo = GetApiInfoInstance();
184 }
185 if (GRD_ApiInfo.ElementRemoveAttrApi == nullptr) {
186 return GRD_NOT_SUPPORT;
187 }
188 return GRD_ApiInfo.ElementRemoveAttrApi(db, elementAddr, attributeName);
189 }
190
RdElementGetAttributes(GRD_DB * db,GRD_XmlOpPositionT * elementAddr,char ** allAttributes)191 int32_t RdUtils::RdElementGetAttributes(GRD_DB *db, GRD_XmlOpPositionT *elementAddr, char **allAttributes)
192 {
193 if (GRD_ApiInfo.ElementGetAttrsApi == nullptr) {
194 GRD_ApiInfo = GetApiInfoInstance();
195 }
196 if (GRD_ApiInfo.ElementGetAttrsApi == nullptr) {
197 return GRD_NOT_SUPPORT;
198 }
199 return GRD_ApiInfo.ElementGetAttrsApi(db, elementAddr, allAttributes);
200 }
201
202 // 4. Text operation interface encapsulation
RdTextInsert(GRD_DB * db,GRD_XmlOpPositionT * opPos,uint32_t index,const char * content,const char * formatStr)203 int32_t RdUtils::RdTextInsert(
204 GRD_DB *db, GRD_XmlOpPositionT *opPos, uint32_t index, const char *content, const char *formatStr)
205 {
206 if (GRD_ApiInfo.TextInsertApi == nullptr) {
207 GRD_ApiInfo = GetApiInfoInstance();
208 }
209 if (GRD_ApiInfo.TextInsertApi == nullptr) {
210 return GRD_NOT_SUPPORT;
211 }
212 return GRD_ApiInfo.TextInsertApi(db, opPos, index, content, formatStr);
213 }
214
RdTextDelete(GRD_DB * db,GRD_XmlOpPositionT * opPos,uint32_t index,uint32_t length)215 int32_t RdUtils::RdTextDelete(GRD_DB *db, GRD_XmlOpPositionT *opPos, uint32_t index, uint32_t length)
216 {
217 if (GRD_ApiInfo.TextDeleteApi == nullptr) {
218 GRD_ApiInfo = GetApiInfoInstance();
219 }
220 if (GRD_ApiInfo.TextDeleteApi == nullptr) {
221 return GRD_NOT_SUPPORT;
222 }
223 return GRD_ApiInfo.TextDeleteApi(db, opPos, index, length);
224 }
225
RdTextFormat(GRD_DB * db,GRD_XmlOpPositionT * opPos,uint32_t index,uint32_t length,const char * formatStr)226 int32_t RdUtils::RdTextFormat(
227 GRD_DB *db, GRD_XmlOpPositionT *opPos, uint32_t index, uint32_t length, const char *formatStr)
228 {
229 if (GRD_ApiInfo.TextFormatApi == nullptr) {
230 GRD_ApiInfo = GetApiInfoInstance();
231 }
232 if (GRD_ApiInfo.TextFormatApi == nullptr) {
233 return GRD_NOT_SUPPORT;
234 }
235 return GRD_ApiInfo.TextFormatApi(db, opPos, index, length, formatStr);
236 }
237
RdTextGetLength(GRD_DB * db,GRD_XmlOpPositionT * opPos,uint32_t * length)238 int32_t RdUtils::RdTextGetLength(GRD_DB *db, GRD_XmlOpPositionT *opPos, uint32_t *length)
239 {
240 if (GRD_ApiInfo.TextGetLengthApi == nullptr) {
241 GRD_ApiInfo = GetApiInfoInstance();
242 }
243 if (GRD_ApiInfo.TextGetLengthApi == nullptr) {
244 return GRD_NOT_SUPPORT;
245 }
246 return GRD_ApiInfo.TextGetLengthApi(db, opPos, length);
247 }
248
RdTextReadInStrMode(GRD_DB * db,GRD_XmlOpPositionT * opPos,char ** value)249 int32_t RdUtils::RdTextReadInStrMode(GRD_DB *db, GRD_XmlOpPositionT *opPos, char **value)
250 {
251 if (GRD_ApiInfo.TextReadInStrModeApi == nullptr) {
252 GRD_ApiInfo = GetApiInfoInstance();
253 }
254 if (GRD_ApiInfo.TextReadInStrModeApi == nullptr) {
255 return GRD_NOT_SUPPORT;
256 }
257 return GRD_ApiInfo.TextReadInStrModeApi(db, opPos, value);
258 }
259
RdTextReadInDeltaMode(GRD_DB * db,GRD_XmlOpPositionT * opPos,const char * snapshot,const char * snapshotPerv,char ** delta)260 int32_t RdUtils::RdTextReadInDeltaMode(
261 GRD_DB *db, GRD_XmlOpPositionT *opPos, const char *snapshot, const char *snapshotPerv, char **delta)
262 {
263 if (GRD_ApiInfo.TextReadInDeltaModeApi == nullptr) {
264 GRD_ApiInfo = GetApiInfoInstance();
265 }
266 if (GRD_ApiInfo.TextReadInDeltaModeApi == nullptr) {
267 return GRD_NOT_SUPPORT;
268 }
269 return GRD_ApiInfo.TextReadInDeltaModeApi(db, opPos, snapshot, snapshotPerv, delta);
270 }
271
272 // 5. Undo/Redo operation interface encapsulation
RdDocUndoManager(GRD_DB * db,GRD_XmlOpPositionT * elementAddr,GRD_UndoParamT * param)273 int32_t RdUtils::RdDocUndoManager(GRD_DB *db, GRD_XmlOpPositionT *elementAddr, GRD_UndoParamT *param)
274 {
275 if (GRD_ApiInfo.DocUndoManagerApi == nullptr) {
276 GRD_ApiInfo = GetApiInfoInstance();
277 if (GRD_ApiInfo.DocUndoManagerApi == nullptr) {
278 return GRD_NOT_SUPPORT;
279 }
280 }
281
282 return GRD_ApiInfo.DocUndoManagerApi(db, elementAddr, param);
283 }
284
RdDocCloseUndoManager(GRD_DB * db,GRD_XmlOpPositionT * elementAddr)285 int32_t RdUtils::RdDocCloseUndoManager(GRD_DB *db, GRD_XmlOpPositionT *elementAddr)
286 {
287 if (GRD_ApiInfo.DocCloseUndoManagerApi == nullptr) {
288 GRD_ApiInfo = GetApiInfoInstance();
289 if (GRD_ApiInfo.DocCloseUndoManagerApi == nullptr) {
290 return GRD_NOT_SUPPORT;
291 }
292 }
293
294 return GRD_ApiInfo.DocCloseUndoManagerApi(db, elementAddr);
295 }
296
RdDocUndo(GRD_DB * db,GRD_XmlOpPositionT * elementAddr,char ** modify)297 int32_t RdUtils::RdDocUndo(GRD_DB *db, GRD_XmlOpPositionT *elementAddr, char **modify)
298 {
299 if (GRD_ApiInfo.DocUndoApi == nullptr) {
300 GRD_ApiInfo = GetApiInfoInstance();
301 if (GRD_ApiInfo.DocUndoApi == nullptr) {
302 return GRD_NOT_SUPPORT;
303 }
304 }
305
306 return GRD_ApiInfo.DocUndoApi(db, elementAddr, modify);
307 }
308
RdDocRedo(GRD_DB * db,GRD_XmlOpPositionT * elementAddr,char ** modify)309 int32_t RdUtils::RdDocRedo(GRD_DB *db, GRD_XmlOpPositionT *elementAddr, char **modify)
310 {
311 if (GRD_ApiInfo.DocRedoApi == nullptr) {
312 GRD_ApiInfo = GetApiInfoInstance();
313 if (GRD_ApiInfo.DocRedoApi == nullptr) {
314 return GRD_NOT_SUPPORT;
315 }
316 }
317
318 return GRD_ApiInfo.DocRedoApi(db, elementAddr, modify);
319 }
320
RdDocStopCapturing(GRD_DB * db,GRD_XmlOpPositionT * elementAddr)321 int32_t RdUtils::RdDocStopCapturing(GRD_DB *db, GRD_XmlOpPositionT *elementAddr)
322 {
323 if (GRD_ApiInfo.DocStopCapturingApi == nullptr) {
324 GRD_ApiInfo = GetApiInfoInstance();
325 if (GRD_ApiInfo.DocStopCapturingApi == nullptr) {
326 return GRD_NOT_SUPPORT;
327 }
328 }
329
330 return GRD_ApiInfo.DocStopCapturingApi(db, elementAddr);
331 }
332
333 // 6. Sync operation interface encapsulation
RdSync(GRD_DB * db,GRD_SyncConfig * config)334 int32_t RdUtils::RdSync(GRD_DB *db, GRD_SyncConfig *config)
335 {
336 if (GRD_ApiInfo.SyncApi == nullptr) {
337 GRD_ApiInfo = GetApiInfoInstance();
338 }
339 if (GRD_ApiInfo.SyncApi == nullptr) {
340 return GRD_NOT_SUPPORT;
341 }
342 return GRD_ApiInfo.SyncApi(db, config);
343 }
344
RdRegistryThreadPool(GRD_DB * db,GRD_ThreadPoolT * threadPool)345 int32_t RdUtils::RdRegistryThreadPool(GRD_DB *db, GRD_ThreadPoolT *threadPool)
346 {
347 if (GRD_ApiInfo.RegistryThreadPoolApi == nullptr) {
348 GRD_ApiInfo = GetApiInfoInstance();
349 }
350 if (GRD_ApiInfo.RegistryThreadPoolApi == nullptr) {
351 return GRD_NOT_SUPPORT;
352 }
353 return GRD_ApiInfo.RegistryThreadPoolApi(db, threadPool);
354 }
355
356 // Last. Memory free and others
RdFreeElementId(GRD_ElementIdT * outElementId)357 void RdUtils::RdFreeElementId(GRD_ElementIdT *outElementId)
358 {
359 if (GRD_ApiInfo.FreeElementIdApi == nullptr) {
360 GRD_ApiInfo = GetApiInfoInstance();
361 }
362 if (GRD_ApiInfo.FreeElementIdApi == nullptr) {
363 return;
364 }
365 GRD_ApiInfo.FreeElementIdApi(outElementId);
366 }
367
RdFreeValue(char * value)368 int32_t RdUtils::RdFreeValue(char *value)
369 {
370 if (GRD_ApiInfo.FreeValueApi == nullptr) {
371 GRD_ApiInfo = GetApiInfoInstance();
372 }
373 if (GRD_ApiInfo.FreeValueApi == nullptr) {
374 return GRD_NOT_SUPPORT;
375 }
376 return GRD_ApiInfo.FreeValueApi(value);
377 }
378
RdSetCloudDb(GRD_DB * db,GRD_ICloudDBT * iCloud)379 int32_t RdUtils::RdSetCloudDb(GRD_DB *db, GRD_ICloudDBT *iCloud)
380 {
381 if (GRD_ApiInfo.SetCloudDbApi == nullptr) {
382 GRD_ApiInfo = GetApiInfoInstance();
383 }
384 if (GRD_ApiInfo.SetCloudDbApi == nullptr) {
385 return GRD_NOT_SUPPORT;
386 }
387 return GRD_ApiInfo.SetCloudDbApi(db, iCloud);
388 }
389
TransferToNapiErrNo(int32_t originNo)390 int32_t RdUtils::TransferToNapiErrNo(int32_t originNo)
391 {
392 auto it = g_errMap.find(originNo);
393 if (it == g_errMap.end()) {
394 return Status::DB_ERROR;
395 }
396 return it->second;
397 }
398 } // namespace OHOS::CollaborationEdit
399