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 #define LOG_TAG "ExtensionUtil"
17 #include "extension_util.h"
18 #include "log_print.h"
19
20 namespace OHOS::CloudData {
Convert(DBVBuckets && buckets)21 std::pair<OhCloudExtVector *, size_t> ExtensionUtil::Convert(DBVBuckets &&buckets)
22 {
23 OhCloudExtVector *datas = OhCloudExtVectorNew(OhCloudExtRustType::VALUETYPE_HASHMAP_VALUE);
24 if (datas == nullptr) {
25 return { nullptr, 0 };
26 }
27 size_t datasLen = 0;
28 for (auto &bucket : buckets) {
29 auto value = Convert(bucket);
30 if (value.first == nullptr) {
31 return { nullptr, 0 };
32 }
33 auto status = OhCloudExtVectorPush(datas, value.first, value.second);
34 if (status != ERRNO_SUCCESS) {
35 return { nullptr, 0 };
36 }
37 datasLen += 1;
38 }
39 return { datas, datasLen };
40 }
41
Convert(const DBVBucket & bucket)42 std::pair<OhCloudExtHashMap *, size_t> ExtensionUtil::Convert(const DBVBucket &bucket)
43 {
44 OhCloudExtHashMap *values = OhCloudExtHashMapNew(OhCloudExtRustType::VALUETYPE_VALUE);
45 if (values == nullptr) {
46 return { nullptr, 0 };
47 }
48 size_t valuesLen = 0;
49 for (auto &[col, dbValue] : bucket) {
50 void *value = nullptr;
51 size_t valueLen = 0;
52 if (dbValue.index() == TYPE_INDEX<DBAsset>) {
53 DBAsset dbAsset = std::get<DBAsset>(dbValue);
54 auto data = Convert(dbAsset);
55 OhCloudExtValue *asset = OhCloudExtValueNew(
56 OhCloudExtValueType::VALUEINNERTYPE_ASSET, data.first, data.second);
57 value = asset;
58 valueLen = data.second;
59 } else if (dbValue.index() == TYPE_INDEX<DBAssets>) {
60 DBAssets dbAssets = std::get<DBAssets>(dbValue);
61 auto data = Convert(dbAssets);
62 OhCloudExtValue *assets = OhCloudExtValueNew(
63 OhCloudExtValueType::VALUEINNERTYPE_ASSETS, data.first, data.second);
64 value = assets;
65 valueLen = data.second;
66 } else {
67 auto data = Convert(dbValue);
68 value = data.first;
69 valueLen = data.second;
70 }
71 if (value == nullptr) {
72 return { nullptr, 0 };
73 }
74 auto status = OhCloudExtHashMapInsert(values,
75 const_cast<void *>(reinterpret_cast<const void *>(col.c_str())), col.size(), value, valueLen);
76 if (status != ERRNO_SUCCESS) {
77 return { nullptr, 0 };
78 }
79 valuesLen += valueLen;
80 }
81 return { values, valuesLen };
82 }
83
Convert(const DBValue & dbValue)84 std::pair<OhCloudExtValue *, size_t> ExtensionUtil::Convert(const DBValue &dbValue)
85 {
86 OhCloudExtValue *value = nullptr;
87 size_t valueLen = 0;
88 if (dbValue.index() == TYPE_INDEX<int64_t>) {
89 int64_t val = std::get<int64_t>(dbValue);
90 value = OhCloudExtValueNew(OhCloudExtValueType::VALUEINNERTYPE_INT, &val, sizeof(int64_t));
91 valueLen = sizeof(int64_t);
92 } else if (dbValue.index() == TYPE_INDEX<std::string>) {
93 std::string val = std::get<std::string>(dbValue);
94 value = OhCloudExtValueNew(OhCloudExtValueType::VALUEINNERTYPE_STRING,
95 const_cast<void *>(reinterpret_cast<const void *>(val.c_str())), val.size());
96 valueLen = val.size();
97 } else if (dbValue.index() == TYPE_INDEX<bool>) {
98 bool val = std::get<bool>(dbValue);
99 value = OhCloudExtValueNew(OhCloudExtValueType::VALUEINNERTYPE_BOOL, &val, sizeof(bool));
100 valueLen = sizeof(bool);
101 } else if (dbValue.index() == TYPE_INDEX<DBBytes>) {
102 DBBytes val = std::get<DBBytes>(dbValue);
103 if (!val.empty()) {
104 value = OhCloudExtValueNew(OhCloudExtValueType::VALUEINNERTYPE_BYTES, &val[0], val.size());
105 valueLen = val.size() * sizeof(uint8_t);
106 }
107 } else {
108 value = OhCloudExtValueNew(OhCloudExtValueType::VALUEINNERTYPE_EMPTY, nullptr, 0);
109 valueLen = 0;
110 }
111 return { value, valueLen };
112 }
113
Convert(const DBMeta & dbMeta)114 std::pair<OhCloudExtDatabase *, size_t> ExtensionUtil::Convert(const DBMeta &dbMeta)
115 {
116 OhCloudExtHashMap *databases = OhCloudExtHashMapNew(OhCloudExtRustType::VALUETYPE_TABLE);
117 if (databases == nullptr) {
118 return { nullptr, 0 };
119 }
120 size_t dbLen = 0;
121 for (auto &table : dbMeta.tables) {
122 auto [fields, tbLen] = Convert(table);
123 if (fields == nullptr) {
124 return { nullptr, 0 };
125 }
126 OhCloudExtTable *tb = OhCloudExtTableNew(reinterpret_cast<const unsigned char *>(table.name.c_str()),
127 table.name.size(), reinterpret_cast<const unsigned char *>(table.alias.c_str()),
128 table.alias.size(), fields);
129 if (tb == nullptr) {
130 return { nullptr, 0 };
131 }
132 tbLen = tbLen + table.name.size() + table.alias.size();
133 auto status = OhCloudExtHashMapInsert(databases,
134 const_cast<void *>(reinterpret_cast<const void *>(table.name.c_str())), table.name.size(), tb, tbLen);
135 if (status != ERRNO_SUCCESS) {
136 return { nullptr, 0 };
137 }
138 }
139 dbLen = dbLen + dbMeta.name.size() + dbMeta.alias.size();
140 OhCloudExtDatabase *db = OhCloudExtDatabaseNew(reinterpret_cast<const unsigned char *>(dbMeta.name.c_str()),
141 dbMeta.name.size(), reinterpret_cast<const unsigned char *>(dbMeta.alias.c_str()),
142 dbMeta.alias.size(), databases);
143 if (db == nullptr) {
144 return { nullptr, 0 };
145 }
146 return { db, dbLen };
147 }
148
Convert(const DBTable & dbTable)149 std::pair<OhCloudExtVector *, size_t> ExtensionUtil::Convert(const DBTable &dbTable)
150 {
151 size_t tbLen = 0;
152 OhCloudExtVector *fields = OhCloudExtVectorNew(OhCloudExtRustType::VALUETYPE_FIELD);
153 if (fields == nullptr) {
154 return { nullptr, 0 };
155 }
156 for (auto &field : dbTable.fields) {
157 size_t fdLen = field.colName.size() + field.alias.size() + sizeof(int) + sizeof(bool) * 2;
158 OhCloudExtFieldBuilder builder {
159 .colName = reinterpret_cast<const unsigned char *>(field.colName.c_str()),
160 .colNameLen = field.colName.size(),
161 .alias = reinterpret_cast<const unsigned char *>(field.alias.c_str()),
162 .aliasLen = field.alias.size(),
163 .typ = static_cast<unsigned int>(field.type),
164 .primary = field.primary,
165 .nullable = field.nullable
166 };
167 OhCloudExtField *fd = OhCloudExtFieldNew(&builder);
168 if (fd == nullptr) {
169 return { nullptr, 0 };
170 }
171 OhCloudExtVectorPush(fields, fd, fdLen);
172 tbLen += fdLen;
173 }
174 return { fields, tbLen };
175 }
176
ConvertBuckets(OhCloudExtVector * values)177 DBVBuckets ExtensionUtil::ConvertBuckets(OhCloudExtVector *values)
178 {
179 DBVBuckets buckets;
180 size_t len = 0;
181 auto status = OhCloudExtVectorGetLength(values, reinterpret_cast<unsigned int *>(&len));
182 if (status != ERRNO_SUCCESS || len == 0) {
183 return buckets;
184 }
185 buckets.reserve(len);
186 for (size_t i = 0; i < len; i++) {
187 void *value = nullptr;
188 size_t valueLen = 0;
189 status = OhCloudExtVectorGet(values, i, &value, reinterpret_cast<unsigned int *>(&valueLen));
190 if (status != ERRNO_SUCCESS || value == nullptr) {
191 return buckets;
192 }
193 auto pValues = std::shared_ptr<OhCloudExtHashMap>(reinterpret_cast<OhCloudExtHashMap *>(value),
194 [](auto *val) {
195 OhCloudExtHashMapFree(val);
196 });
197 buckets.emplace_back(ConvertBucket(pValues.get()));
198 }
199 return buckets;
200 }
201
ConvertBucket(OhCloudExtHashMap * value)202 DBVBucket ExtensionUtil::ConvertBucket(OhCloudExtHashMap *value)
203 {
204 DBVBucket bucket;
205 OhCloudExtVector *valKeys = nullptr;
206 OhCloudExtVector *valValues = nullptr;
207 auto status = OhCloudExtHashMapIterGetKeyValuePair(value, &valKeys, &valValues);
208 if (status != ERRNO_SUCCESS || valKeys == nullptr || valValues == nullptr) {
209 return bucket;
210 }
211 auto pValKeys = std::shared_ptr<OhCloudExtVector>(valKeys, [](auto *valkey) { OhCloudExtVectorFree(valkey); });
212 auto pValValues = std::shared_ptr<OhCloudExtVector>(valValues, [](auto *valValue) {
213 OhCloudExtVectorFree(valValue);
214 });
215 size_t valKeysLen = 0;
216 size_t valValuesLen = 0;
217 OhCloudExtVectorGetLength(pValKeys.get(), reinterpret_cast<unsigned int *>(&valKeysLen));
218 OhCloudExtVectorGetLength(pValValues.get(), reinterpret_cast<unsigned int *>(&valValuesLen));
219 if (valKeysLen == 0 || valKeysLen != valValuesLen) {
220 return bucket;
221 }
222 for (size_t j = 0; j < valKeysLen; j++) {
223 void *keyItem = nullptr;
224 size_t keyItemLen = 0;
225 status = OhCloudExtVectorGet(pValKeys.get(), j, &keyItem, reinterpret_cast<unsigned int *>(&keyItemLen));
226 if (status != ERRNO_SUCCESS || keyItem == nullptr) {
227 return bucket;
228 }
229 void *valueItem = nullptr;
230 size_t valueItemLen = 0;
231 status = OhCloudExtVectorGet(pValValues.get(), j, &valueItem, reinterpret_cast<unsigned int *>(&valueItemLen));
232 if (status != ERRNO_SUCCESS || valueItem == nullptr) {
233 return bucket;
234 }
235 OhCloudExtValue *valueOut = reinterpret_cast<OhCloudExtValue *>(valueItem);
236 std::string keyOut(reinterpret_cast<char *>(keyItem), keyItemLen);
237 bucket[keyOut] = ConvertValue(valueOut);
238 OhCloudExtValueFree(valueOut);
239 }
240 return bucket;
241 }
242
ConvertValue(OhCloudExtValue * value)243 DBValue ExtensionUtil::ConvertValue(OhCloudExtValue *value)
244 {
245 DBValue result;
246 OhCloudExtValueType type = OhCloudExtValueType::VALUEINNERTYPE_EMPTY;
247 void *content = nullptr;
248 size_t ctLen = 0;
249 auto status = OhCloudExtValueGetContent(value, &type, &content, reinterpret_cast<unsigned int *>(&ctLen));
250 if (status != ERRNO_SUCCESS || content == nullptr) {
251 return result;
252 }
253 DoConvertValue(content, ctLen, type, result);
254 return result;
255 }
256
ConvertValues(OhCloudExtValueBucket * bucket,const std::string & key)257 DBValue ExtensionUtil::ConvertValues(OhCloudExtValueBucket *bucket, const std::string &key)
258 {
259 DBValue result;
260 auto keyStr = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(key.c_str()));
261 OhCloudExtKeyName keyName = OhCloudExtKeyNameNew(keyStr, key.size());
262 OhCloudExtValueType type = OhCloudExtValueType::VALUEINNERTYPE_EMPTY;
263 void *content = nullptr;
264 unsigned int ctLen = 0;
265 auto status = OhCloudExtValueBucketGetValue(bucket, keyName, &type, &content, &ctLen);
266 if (status != ERRNO_SUCCESS || content == nullptr) {
267 return result;
268 }
269 DoConvertValue(content, ctLen, type, result);
270 return result;
271 }
272
DoConvertValue(void * content,unsigned int ctLen,OhCloudExtValueType type,DBValue & dbvalue)273 void ExtensionUtil::DoConvertValue(void *content, unsigned int ctLen, OhCloudExtValueType type, DBValue &dbvalue)
274 {
275 switch (type) {
276 case OhCloudExtValueType::VALUEINNERTYPE_EMPTY:
277 break;
278 case OhCloudExtValueType::VALUEINNERTYPE_INT:
279 dbvalue = *reinterpret_cast<int64_t *>(content);
280 break;
281 case OhCloudExtValueType::VALUEINNERTYPE_BOOL:
282 dbvalue = *reinterpret_cast<bool *>(content);
283 break;
284 case OhCloudExtValueType::VALUEINNERTYPE_STRING:
285 dbvalue = std::string(reinterpret_cast<char *>(content), ctLen);
286 break;
287 case OhCloudExtValueType::VALUEINNERTYPE_BYTES: {
288 std::vector<uint8_t> bytes;
289 uint8_t *begin = reinterpret_cast<uint8_t *>(content);
290 for (size_t i = 0; i < ctLen; i++) {
291 uint8_t bt = *begin;
292 bytes.emplace_back(bt);
293 begin = begin + 1;
294 }
295 dbvalue = bytes;
296 break;
297 }
298 case OhCloudExtValueType::VALUEINNERTYPE_ASSET: {
299 OhCloudExtCloudAsset *asset = reinterpret_cast<OhCloudExtCloudAsset *>(content);
300 dbvalue = ConvertAsset(asset);
301 OhCloudExtCloudAssetFree(asset);
302 break;
303 }
304 case OhCloudExtValueType::VALUEINNERTYPE_ASSETS: {
305 OhCloudExtVector *assets = reinterpret_cast<OhCloudExtVector *>(content);
306 dbvalue = ConvertAssets(assets);
307 OhCloudExtVectorFree(assets);
308 break;
309 }
310 default:
311 break;
312 }
313 }
314
ConvertAssets(OhCloudExtVector * values)315 DBAssets ExtensionUtil::ConvertAssets(OhCloudExtVector *values)
316 {
317 DBAssets result;
318 size_t assetsLen = 0;
319 auto status = OhCloudExtVectorGetLength(values, reinterpret_cast<unsigned int *>(&assetsLen));
320 if (status != ERRNO_SUCCESS || assetsLen == 0) {
321 return result;
322 }
323 result.reserve(assetsLen);
324 for (size_t i = 0; i < assetsLen; i++) {
325 void *value = nullptr;
326 size_t valueLen = 0;
327 status = OhCloudExtVectorGet(values, i, &value, reinterpret_cast<unsigned int *>(&valueLen));
328 if (status != ERRNO_SUCCESS || value == nullptr) {
329 return result;
330 }
331 OhCloudExtCloudAsset *asset = reinterpret_cast<OhCloudExtCloudAsset *>(value);
332 result.push_back(ConvertAsset(asset));
333 OhCloudExtCloudAssetFree(asset);
334 }
335 return result;
336 }
337
ConvertAsset(OhCloudExtCloudAsset * asset)338 DBAsset ExtensionUtil::ConvertAsset(OhCloudExtCloudAsset *asset)
339 {
340 DBAsset result;
341 unsigned char *id = nullptr;
342 size_t idLen = 0;
343 auto status = OhCloudExtCloudAssetGetId(asset, &id, reinterpret_cast<unsigned int *>(&idLen));
344 if (status != ERRNO_SUCCESS || id == nullptr) {
345 return result;
346 }
347 result.id = std::string(reinterpret_cast<char *>(id), idLen);
348 unsigned char *name = nullptr;
349 size_t nameLen = 0;
350 status = OhCloudExtCloudAssetGetName(asset, &name, reinterpret_cast<unsigned int *>(&nameLen));
351 if (status != ERRNO_SUCCESS || name == nullptr) {
352 return result;
353 }
354 result.name = std::string(reinterpret_cast<char *>(name), nameLen);
355 unsigned char *uri = nullptr;
356 size_t uriLen = 0;
357 status = OhCloudExtCloudAssetGetUri(asset, &uri, reinterpret_cast<unsigned int *>(&uriLen));
358 if (status != ERRNO_SUCCESS || uri == nullptr) {
359 return result;
360 }
361 result.uri = std::string(reinterpret_cast<char *>(uri), uriLen);
362 unsigned char *crtTime = nullptr;
363 size_t crtTimeLen = 0;
364 status = OhCloudExtCloudAssetGetCreateTime(asset, &crtTime, reinterpret_cast<unsigned int *>(&crtTimeLen));
365 if (status != ERRNO_SUCCESS || crtTime == nullptr) {
366 return result;
367 }
368 result.createTime = std::string(reinterpret_cast<char *>(crtTime), crtTimeLen);
369 ConvertAssetLeft(asset, result);
370 return result;
371 }
372
ConvertAssetLeft(OhCloudExtCloudAsset * asset,DBAsset & dbAsset)373 void ExtensionUtil::ConvertAssetLeft(OhCloudExtCloudAsset *asset, DBAsset &dbAsset)
374 {
375 unsigned char *mdTime = nullptr;
376 size_t mdTimeLen = 0;
377 auto status = OhCloudExtCloudAssetGetModifiedTime(asset, &mdTime, reinterpret_cast<unsigned int *>(&mdTimeLen));
378 if (status != ERRNO_SUCCESS || mdTime == nullptr) {
379 return;
380 }
381 dbAsset.modifyTime = std::string(reinterpret_cast<char *>(mdTime), mdTimeLen);
382 unsigned char *size = nullptr;
383 size_t sizeLen = 0;
384 status = OhCloudExtCloudAssetGetSize(asset, &size, reinterpret_cast<unsigned int *>(&sizeLen));
385 if (status != ERRNO_SUCCESS || size == nullptr) {
386 return;
387 }
388 dbAsset.size = std::string(reinterpret_cast<char *>(size), sizeLen);
389 unsigned char *hash = nullptr;
390 size_t hashLen = 0;
391 status = OhCloudExtCloudAssetGetHash(asset, &hash, reinterpret_cast<unsigned int *>(&hashLen));
392 if (status != ERRNO_SUCCESS || hash == nullptr) {
393 return;
394 }
395 dbAsset.hash = std::string(reinterpret_cast<char *>(hash), hashLen);
396 unsigned char *path = nullptr;
397 size_t pathLen = 0;
398 status = OhCloudExtCloudAssetGetLocalPath(asset, &path, reinterpret_cast<unsigned int *>(&pathLen));
399 if (status != ERRNO_SUCCESS || path == nullptr) {
400 return;
401 }
402 dbAsset.path = std::string(reinterpret_cast<char *>(path), pathLen);
403 }
404
ConvertAppInfo(OhCloudExtAppInfo * appInfo)405 DBInfo ExtensionUtil::ConvertAppInfo(OhCloudExtAppInfo *appInfo)
406 {
407 DBInfo info;
408 unsigned char *appId = nullptr;
409 size_t appIdLen = 0;
410 auto status = OhCloudExtAppInfoGetAppId(appInfo, &appId, reinterpret_cast<unsigned int *>(&appIdLen));
411 if (status != ERRNO_SUCCESS || appId == nullptr) {
412 return info;
413 }
414 info.appId = std::string(reinterpret_cast<char *>(appId), appIdLen);
415 unsigned char *bundle = nullptr;
416 size_t bundleLen = 0;
417 status = OhCloudExtAppInfoGetBundleName(appInfo, &bundle, reinterpret_cast<unsigned int *>(&bundleLen));
418 if (status != ERRNO_SUCCESS || bundle == nullptr) {
419 return info;
420 }
421 info.bundleName = std::string(reinterpret_cast<char *>(bundle), bundleLen);
422 OhCloudExtAppInfoGetCloudSwitch(appInfo, &info.cloudSwitch);
423 OhCloudExtAppInfoGetInstanceId(appInfo, &info.instanceId);
424 return info;
425 }
426
ContainNullChar(const std::string & path)427 bool ExtensionUtil::ContainNullChar(const std::string &path)
428 {
429 uint32_t pathLength = path.length();
430 const char *cStrPath = path.c_str();
431 uint32_t cStrLength = strlen(cStrPath);
432 if (pathLength != cStrLength) {
433 ZLOGW("The string contains null characters.");
434 return true;
435 }
436 return false;
437 }
438
Convert(const DBAsset & dbAsset)439 std::pair<OhCloudExtCloudAsset *, size_t> ExtensionUtil::Convert(const DBAsset &dbAsset)
440 {
441 if (ContainNullChar(dbAsset.path) || ContainNullChar(dbAsset.uri)) {
442 return { nullptr, 0 };
443 }
444 OhCloudExtCloudAssetBuilder builder {
445 .version = dbAsset.version,
446 .status = ConvertAssetStatus(static_cast<DBAssetStatus>(dbAsset.status)),
447 .expiresTime = dbAsset.expiresTime,
448 .id = reinterpret_cast<const unsigned char *>(dbAsset.id.c_str()),
449 .idLen = dbAsset.id.size(),
450 .name = reinterpret_cast<const unsigned char *>(dbAsset.name.c_str()),
451 .nameLen = dbAsset.name.size(),
452 .uri = reinterpret_cast<const unsigned char *>(dbAsset.uri.c_str()),
453 .uriLen = dbAsset.uri.size(),
454 .localPath = reinterpret_cast<const unsigned char *>(dbAsset.path.c_str()),
455 .localPathLen = dbAsset.path.size(),
456 .createTime = reinterpret_cast<const unsigned char *>(dbAsset.createTime.c_str()),
457 .createTimeLen = dbAsset.createTime.size(),
458 .modifyTime = reinterpret_cast<const unsigned char *>(dbAsset.modifyTime.c_str()),
459 .modifyTimeLen = dbAsset.modifyTime.size(),
460 .size = reinterpret_cast<const unsigned char *>(dbAsset.size.c_str()),
461 .sizeLen = dbAsset.size.size(),
462 .hash = reinterpret_cast<const unsigned char *>(dbAsset.hash.c_str()),
463 .hashLen = dbAsset.hash.size()
464 };
465 OhCloudExtCloudAsset *asset = OhCloudExtCloudAssetNew(&builder);
466 size_t assetLen = sizeof(uint64_t) * 2 + sizeof(OhCloudExtAssetStatus) + dbAsset.id.size()
467 + dbAsset.name.size() + dbAsset.uri.size() + dbAsset.createTime.size() + dbAsset.modifyTime.size()
468 + dbAsset.size.size() + dbAsset.hash.size() + dbAsset.path.size();
469 if (asset == nullptr) {
470 return { nullptr, 0 };
471 }
472 return { asset, assetLen };
473 }
474
Convert(const DBAssets & dbAssets)475 std::pair<OhCloudExtVector *, size_t> ExtensionUtil::Convert(const DBAssets &dbAssets)
476 {
477 OhCloudExtVector *assets = OhCloudExtVectorNew(OhCloudExtRustType::VALUETYPE_CLOUD_ASSET);
478 if (assets == nullptr) {
479 return { nullptr, 0 };
480 }
481 size_t assetsLen = 0;
482 for (const auto &dbAsset : dbAssets) {
483 auto data = Convert(dbAsset);
484 if (data.first == nullptr) {
485 return { nullptr, 0 };
486 }
487 auto status = OhCloudExtVectorPush(assets, data.first, data.second);
488 if (status != ERRNO_SUCCESS) {
489 return { nullptr, 0 };
490 }
491 assetsLen += 1;
492 }
493 return { assets, assetsLen };
494 }
495
ConvertAssetStatus(DBAssetStatus status)496 OhCloudExtAssetStatus ExtensionUtil::ConvertAssetStatus(DBAssetStatus status)
497 {
498 switch (status) {
499 case DBAssetStatus::STATUS_UNKNOWN:
500 return OhCloudExtAssetStatus::ASSETSTATUS_UNKNOWN;
501 case DBAssetStatus::STATUS_NORMAL:
502 return OhCloudExtAssetStatus::ASSETSTATUS_NORMAL;
503 case DBAssetStatus::STATUS_INSERT:
504 return OhCloudExtAssetStatus::ASSETSTATUS_INSERT;
505 case DBAssetStatus::STATUS_UPDATE:
506 return OhCloudExtAssetStatus::ASSETSTATUS_UPDATE;
507 case DBAssetStatus::STATUS_DELETE:
508 return OhCloudExtAssetStatus::ASSETSTATUS_DELETE;
509 case DBAssetStatus::STATUS_ABNORMAL:
510 return OhCloudExtAssetStatus::ASSETSTATUS_ABNORMAL;
511 case DBAssetStatus::STATUS_DOWNLOADING:
512 return OhCloudExtAssetStatus::ASSETSTATUS_DOWNLOADING;
513 case DBAssetStatus::STATUS_BUTT:
514 return OhCloudExtAssetStatus::ASSETSTATUS_BUTT;
515 default:
516 ZLOGI("err: 0x%{public}x", status);
517 break;
518 }
519 return OhCloudExtAssetStatus::ASSETSTATUS_UNKNOWN;
520 }
521
ConvertStatus(int status)522 DBErr ExtensionUtil::ConvertStatus(int status)
523 {
524 switch (status) {
525 case ERRNO_SUCCESS:
526 return DBErr::E_OK;
527 case ERRNO_NETWORK_ERROR:
528 return DBErr::E_NETWORK_ERROR;
529 case ERRNO_LOCKED_BY_OTHERS:
530 return DBErr::E_LOCKED_BY_OTHERS;
531 case ERRNO_RECORD_LIMIT_EXCEEDED:
532 return DBErr::E_RECODE_LIMIT_EXCEEDED;
533 case ERRNO_NO_SPACE_FOR_ASSET:
534 return DBErr::E_NO_SPACE_FOR_ASSET;
535 case ERRNO_UNSUPPORTED:
536 return DBErr::E_NOT_SUPPORT;
537 default:
538 ZLOGI("err: 0x%{public}x", status);
539 break;
540 }
541 return DBErr::E_ERROR;
542 }
543 } // namespace OHOS::CloudData