1 /*
2 * Copyright (C) 2022 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 #include "medialibrary_command.h"
17
18 #include "location_column.h"
19 #include "media_column.h"
20 #include "media_file_uri.h"
21 #include "media_file_utils.h"
22 #include "media_log.h"
23 #include "medialibrary_data_manager_utils.h"
24 #include "medialibrary_db_const.h"
25 #include "medialibrary_unistore_manager.h"
26 #include "photo_album_column.h"
27 #include "photo_map_column.h"
28 #include "medialibrary_errno.h"
29 #include "userfilemgr_uri.h"
30 #include "vision_column.h"
31 #include "form_map.h"
32 #include "search_column.h"
33
34 using namespace std;
35 using namespace OHOS::NativeRdb;
36 using namespace OHOS::DataShare;
37
38 namespace OHOS {
39 namespace Media {
40 namespace {
41 static const map<string, OperationType> OPRN_TYPE_MAP = {
42 { MEDIA_FILEOPRN_CLOSEASSET, OperationType::CLOSE },
43 { MEDIA_FILEOPRN_CREATEASSET, OperationType::CREATE },
44 { MEDIA_ALBUMOPRN_CREATEALBUM, OperationType::CREATE },
45 { MEDIA_FILEOPRN_DELETEASSET, OperationType::DELETE },
46 { MEDIA_ALBUMOPRN_DELETEALBUM, OperationType::DELETE },
47 { MEDIA_FILEOPRN_MODIFYASSET, OperationType::UPDATE },
48 { MEDIA_ALBUMOPRN_MODIFYALBUM, OperationType::UPDATE },
49 { MEDIA_ALBUMOPRN_QUERYALBUM, OperationType::QUERY },
50 { MEDIA_FILEOPRN_GETALBUMCAPACITY, OperationType::QUERY },
51 { MEDIA_QUERYOPRN_QUERYVOLUME, OperationType::QUERY },
52 { MEDIA_BOARDCASTOPRN, OperationType::SCAN },
53 { OPRN_SCAN, OperationType::SCAN },
54 #ifdef MEDIALIBRARY_MEDIATOOL_ENABLE
55 { OPRN_DELETE_BY_TOOL, OperationType::DELETE_TOOL },
56 #endif
57 { MEDIA_FILEOPRN_COPYASSET, OperationType::COPY },
58 { MEDIA_DIROPRN_DELETEDIR, OperationType::DELETE },
59 { MEDIA_DIROPRN_FMS_CREATEDIR, OperationType::CREATE },
60 { MEDIA_DIROPRN_FMS_DELETEDIR, OperationType::DELETE },
61 { MEDIA_DIROPRN_FMS_TRASHDIR, OperationType::TRASH },
62 { MEDIA_SMARTALBUMOPRN_CREATEALBUM, OperationType::CREATE },
63 { MEDIA_SMARTALBUMOPRN_DELETEALBUM, OperationType::DELETE },
64 { MEDIA_SMARTALBUMMAPOPRN_ADDSMARTALBUM, OperationType::CREATE },
65 { MEDIA_SMARTALBUMMAPOPRN_REMOVESMARTALBUM, OperationType::DELETE },
66 { MEDIA_SMARTALBUMMAPOPRN_AGEINGSMARTALBUM, OperationType::AGING },
67 { MEDIA_SMARTALBUMOPRN_MODIFYALBUM, OperationType::UPDATE },
68 { BUNDLE_PERMISSION_INSERT, OperationType::INSERT_PERMISSION },
69 { OPRN_CREATE, OperationType::CREATE },
70 { OPRN_CREATE_COMPONENT, OperationType::CREATE },
71 { OPRN_DELETE, OperationType::DELETE },
72 { OPRN_QUERY, OperationType::QUERY },
73 { OPRN_UPDATE, OperationType::UPDATE },
74 { OPRN_ALBUM_ADD_PHOTOS, OperationType::ALBUM_ADD_PHOTOS },
75 { OPRN_ALBUM_REMOVE_PHOTOS, OperationType::ALBUM_REMOVE_PHOTOS },
76 { OPRN_RECOVER_PHOTOS, OperationType::ALBUM_RECOVER_ASSETS },
77 { OPRN_DELETE_PHOTOS, OperationType::ALBUM_DELETE_ASSETS },
78 { OPRN_COMPAT_DELETE_PHOTOS, OperationType::COMPAT_ALBUM_DELETE_ASSETS },
79 { OPRN_CLOSE, OperationType::CLOSE },
80 { OPRN_TRASH, OperationType::TRASH_PHOTO },
81 { OPRN_PENDING, OperationType::UPDATE_PENDING },
82 { OPRN_SET_USER_COMMENT, OperationType::SET_USER_COMMENT },
83 { OPRN_INDEX, OperationType::INDEX },
84 { OPRN_COMMIT_EDIT, OperationType::COMMIT_EDIT },
85 { OPRN_REVERT_EDIT, OperationType::REVERT_EDIT },
86 { OPRN_HIDE, OperationType::HIDE },
87 { OPRN_QUERY_HIDDEN, OperationType::QUERY_HIDDEN },
88 { OPRN_ORDER_ALBUM, OperationType::ALBUM_ORDER},
89 { OPRN_STORE_FORM_ID, OperationType::OPRN_STORE_FORM_ID },
90 { OPRN_REMOVE_FORM_ID, OperationType::OPRN_REMOVE_FORM_ID },
91 { OPRN_PORTRAIT_DISPLAY_LEVEL, OperationType::PORTRAIT_DISPLAY_LEVEL },
92 { OPRN_PORTRAIT_IS_ME, OperationType::PORTRAIT_IS_ME },
93 { OPRN_PORTRAIT_ALBUM_NAME, OperationType::PORTRAIT_ALBUM_NAME },
94 { OPRN_PORTRAIT_MERGE_ALBUM, OperationType::PORTRAIT_MERGE_ALBUM },
95 { OPRN_DISMISS_ASSET, OperationType::DISMISS_ASSET },
96 { OPRN_PORTRAIT_COVER_URI, OperationType::PORTRAIT_COVER_URI },
97 { OPRN_SUBMIT_CACHE, OperationType::SUBMIT_CACHE },
98 { OPRN_BATCH_UPDATE_FAV, OperationType::BATCH_UPDATE_FAV },
99 { OPRN_BATCH_UPDATE_USER_COMMENT, OperationType::BATCH_UPDATE_USER_COMMENT },
100 { OPRN_SET_PHOTO_QUALITY, OperationType::SET_PHOTO_QUALITY },
101 { OPRN_ADD_IMAGE, OperationType::ADD_IMAGE },
102 { OPRN_PROCESS_IMAGE, OperationType::PROCESS_IMAGE },
103 { OPRN_SET_LOCATION, OperationType::SET_LOCATION },
104 };
105 }
106
MediaLibraryCommand(const Uri & uri)107 MediaLibraryCommand::MediaLibraryCommand(const Uri &uri) : uri_(uri)
108 {
109 ParseOprnObjectFromUri();
110 ParseOprnTypeFromUri();
111 ParseQuerySetMapFromUri();
112 SetApiFromQuerySetMap();
113 ParseOprnObjectFromFileUri();
114 ParseTableName();
115 }
116
MediaLibraryCommand(const Uri & uri,const ValuesBucket & value)117 MediaLibraryCommand::MediaLibraryCommand(const Uri &uri, const ValuesBucket &value) : uri_(uri), insertValue_(value)
118 {
119 ParseOprnObjectFromUri();
120 ParseOprnTypeFromUri();
121 ParseQuerySetMapFromUri();
122 SetApiFromQuerySetMap();
123 ParseOprnObjectFromFileUri();
124 ParseTableName();
125 }
126
MediaLibraryCommand(const Uri & uri,const OperationType & oprnType)127 MediaLibraryCommand::MediaLibraryCommand(const Uri &uri, const OperationType &oprnType) : uri_(uri), oprnType_(oprnType)
128 {
129 ParseOprnObjectFromUri();
130 ParseQuerySetMapFromUri();
131 SetApiFromQuerySetMap();
132 ParseOprnObjectFromFileUri();
133 ParseTableName();
134 }
135
MediaLibraryCommand(const OperationObject & oprnObject,const OperationType & oprnType,MediaLibraryApi api)136 MediaLibraryCommand::MediaLibraryCommand(const OperationObject &oprnObject, const OperationType &oprnType,
137 MediaLibraryApi api) : oprnObject_(oprnObject), oprnType_(oprnType), api_(api)
138 {
139 ParseTableName();
140 }
141
MediaLibraryCommand(const OperationObject & oprnObject,const OperationType & oprnType,const ValuesBucket & value,MediaLibraryApi api)142 MediaLibraryCommand::MediaLibraryCommand(const OperationObject &oprnObject, const OperationType &oprnType,
143 const ValuesBucket &value, MediaLibraryApi api) :insertValue_(value), oprnObject_(oprnObject),
144 oprnType_(oprnType), api_(api)
145 {
146 ParseTableName();
147 }
148
MediaLibraryCommand(const OperationObject & oprnObject,const OperationType & oprnType,const string & networkId,MediaLibraryApi api)149 MediaLibraryCommand::MediaLibraryCommand(const OperationObject &oprnObject, const OperationType &oprnType,
150 const string &networkId, MediaLibraryApi api) : oprnObject_(oprnObject), oprnType_(oprnType),
151 oprnDevice_(networkId), api_(api)
152 {
153 ParseTableName();
154 }
155
~MediaLibraryCommand()156 MediaLibraryCommand::~MediaLibraryCommand() {}
157
158 // set functions
SetOprnObject(OperationObject object)159 void MediaLibraryCommand::SetOprnObject(OperationObject object)
160 {
161 oprnObject_ = object;
162 }
163
SetOprnAssetId(const std::string & oprnId)164 void MediaLibraryCommand::SetOprnAssetId(const std::string &oprnId)
165 {
166 oprnFileId_ = oprnId;
167 }
168
SetValueBucket(const NativeRdb::ValuesBucket & value)169 void MediaLibraryCommand::SetValueBucket(const NativeRdb::ValuesBucket &value)
170 {
171 insertValue_ = value;
172 }
173
SetTableName(const std::string & tableName)174 void MediaLibraryCommand::SetTableName(const std::string &tableName)
175 {
176 tableName_ = tableName;
177 }
178
SetBundleName(const std::string & bundleName)179 void MediaLibraryCommand::SetBundleName(const std::string &bundleName)
180 {
181 bundleName_ = bundleName;
182 }
183
SetDeviceName(const std::string & deviceName)184 void MediaLibraryCommand::SetDeviceName(const std::string &deviceName)
185 {
186 deviceName_ = deviceName;
187 }
188
SetResult(const std::string & result)189 void MediaLibraryCommand::SetResult(const std::string &result)
190 {
191 result_ = result;
192 }
193
194 // get functions
GetOprnObject() const195 OperationObject MediaLibraryCommand::GetOprnObject() const
196 {
197 return oprnObject_;
198 }
199
GetOprnType() const200 OperationType MediaLibraryCommand::GetOprnType() const
201 {
202 return oprnType_;
203 }
204
GetValueBucket()205 ValuesBucket &MediaLibraryCommand::GetValueBucket()
206 {
207 return insertValue_;
208 }
209
GetAbsRdbPredicates()210 AbsRdbPredicates *MediaLibraryCommand::GetAbsRdbPredicates()
211 {
212 if (absRdbPredicates_ == nullptr) {
213 InitAbsRdbPredicates();
214 }
215 return absRdbPredicates_.get();
216 }
217
GetTableName()218 const string &MediaLibraryCommand::GetTableName()
219 {
220 if (tableName_.empty()) {
221 ParseTableName();
222 }
223
224 return tableName_;
225 }
226
GetOprnFileId()227 const string &MediaLibraryCommand::GetOprnFileId()
228 {
229 if (oprnFileId_.empty()) {
230 ParseFileId();
231 }
232
233 return oprnFileId_;
234 }
235
GetOprnDevice()236 const string &MediaLibraryCommand::GetOprnDevice()
237 {
238 if (oprnDevice_.empty()) {
239 oprnDevice_ = MediaFileUtils::GetNetworkIdFromUri(uri_.ToString());
240 }
241 return oprnDevice_;
242 }
243
GetUri() const244 const Uri &MediaLibraryCommand::GetUri() const
245 {
246 return uri_;
247 }
248
GetBundleName()249 const string &MediaLibraryCommand::GetBundleName()
250 {
251 return bundleName_;
252 }
253
GetDeviceName()254 const string &MediaLibraryCommand::GetDeviceName()
255 {
256 return deviceName_;
257 }
258
GetResult()259 const string &MediaLibraryCommand::GetResult()
260 {
261 return result_;
262 }
263
GetUriStringWithoutSegment() const264 string MediaLibraryCommand::GetUriStringWithoutSegment() const
265 {
266 string uriString = uri_.ToString();
267 size_t questionMaskPoint = uriString.rfind('?');
268 size_t hashKeyPoint = uriString.rfind('#');
269 if (questionMaskPoint != string::npos) {
270 return uriString.substr(0, questionMaskPoint);
271 }
272 if (hashKeyPoint != string::npos) {
273 return uriString.substr(0, hashKeyPoint);
274 }
275 return uriString;
276 }
277
GetApi()278 MediaLibraryApi MediaLibraryCommand::GetApi()
279 {
280 return api_;
281 }
282
GetQuerySetParam(const std::string & key)283 string MediaLibraryCommand::GetQuerySetParam(const std::string &key)
284 {
285 if (key.empty() || querySetMap_.find(key) == querySetMap_.end()) {
286 return "";
287 }
288 return querySetMap_[key];
289 }
290
291 static const map<string, OperationObject> OPRN_OBJ_MAP = {
292 // use in Insert...
293 { MEDIA_FILEOPRN, OperationObject::FILESYSTEM_ASSET },
294 { MEDIA_PHOTOOPRN, OperationObject::FILESYSTEM_PHOTO },
295 { MEDIA_AUDIOOPRN, OperationObject::FILESYSTEM_AUDIO },
296 { MEDIA_DIROPRN, OperationObject::FILESYSTEM_DIR },
297 { MEDIA_ALBUMOPRN, OperationObject::FILESYSTEM_ALBUM },
298 { MEDIA_SMARTALBUMOPRN, OperationObject::SMART_ALBUM },
299 { MEDIA_SMARTALBUMMAPOPRN, OperationObject::SMART_ALBUM_MAP },
300 { BUNDLE_PERMISSION_INSERT, OperationObject::BUNDLE_PERMISSION },
301 { PHOTO_ALBUM_OPRN, OperationObject::PHOTO_ALBUM },
302 { PHOTO_MAP_OPRN, OperationObject::PHOTO_MAP },
303 { UFM_PHOTO, OperationObject::UFM_PHOTO },
304 { UFM_AUDIO, OperationObject::UFM_AUDIO },
305 { UFM_ALBUM, OperationObject::UFM_ALBUM },
306 { UFM_MAP, OperationObject::UFM_MAP },
307 { PAH_PHOTO, OperationObject::PAH_PHOTO },
308 { PAH_ALBUM, OperationObject::PAH_ALBUM },
309 { PAH_MAP, OperationObject::PAH_MAP },
310 { PAH_ANA_ALBUM, OperationObject::ANALYSIS_PHOTO_ALBUM },
311 { PAH_ANA_MAP, OperationObject::ANALYSIS_PHOTO_MAP },
312 { TOOL_PHOTO, OperationObject::TOOL_PHOTO },
313 { TOOL_AUDIO, OperationObject::TOOL_AUDIO },
314 { PAH_FORM_MAP, OperationObject::PAH_FORM_MAP },
315
316 // use in Query...
317 { MEDIATYPE_DIRECTORY_TABLE, OperationObject::FILESYSTEM_DIR },
318 { MEDIA_DATA_DB_THUMBNAIL, OperationObject::THUMBNAIL },
319 { SMARTALBUMASSETS_VIEW_NAME, OperationObject::SMART_ALBUM_ASSETS },
320 { ASSETMAP_VIEW_NAME, OperationObject::ASSETMAP },
321 { MEDIA_DEVICE_QUERYALLDEVICE, OperationObject::ALL_DEVICE },
322 { MEDIA_DEVICE_QUERYACTIVEDEVICE, OperationObject::ACTIVE_DEVICE },
323 { MEDIA_ALBUMOPRN_QUERYALBUM, OperationObject::FILESYSTEM_ALBUM },
324 { SMARTALBUM_TABLE, OperationObject::SMART_ALBUM },
325 { SMARTALBUM_MAP_TABLE, OperationObject::SMART_ALBUM_MAP },
326 { MEDIA_QUERYOPRN_QUERYVOLUME, OperationObject::MEDIA_VOLUME },
327 { PAH_MULTISTAGES_CAPTURE, OperationObject::PAH_MULTISTAGES_CAPTURE },
328
329 // use in Vision
330 { PAH_ANA_OCR, OperationObject::VISION_OCR },
331 { PAH_ANA_LABEL, OperationObject::VISION_LABEL },
332 { PAH_ANA_ATTS, OperationObject::VISION_AESTHETICS },
333 { VISION_OBJECT_TABLE, OperationObject::VISION_OBJECT },
334 { VISION_RECOMMENDATION_TABLE, OperationObject::VISION_RECOMMENDATION},
335 { VISION_SEGMENTATION_TABLE, OperationObject::VISION_SEGMENTATION },
336 { VISION_COMPOSITION_TABLE, OperationObject::VISION_COMPOSITION },
337 { PAH_ANA_TOTAL, OperationObject::VISION_TOTAL },
338 { VISION_IMAGE_FACE_TABLE, OperationObject::VISION_IMAGE_FACE },
339 { VISION_FACE_TAG_TABLE, OperationObject::VISION_FACE_TAG },
340 { VISION_SALIENCY_TABLE, OperationObject::VISION_SALIENCY },
341
342 { PAH_ANA_FACE, OperationObject::VISION_IMAGE_FACE },
343 { PAH_ANA_OBJECT, OperationObject::VISION_OBJECT },
344 { PAH_ANA_RECOMMENDATION, OperationObject::VISION_RECOMMENDATION },
345 { PAH_ANA_SEGMENTATION, OperationObject::VISION_SEGMENTATION },
346 { PAH_ANA_COMPOSITION, OperationObject::VISION_COMPOSITION },
347 { PAH_ANA_SALIENCY, OperationObject::VISION_SALIENCY },
348
349 // use in Location Analyse
350 { GEO_DICTIONARY_TABLE, OperationObject::GEO_DICTIONARY },
351 { GEO_KNOWLEDGE_TABLE, OperationObject::GEO_KNOWLEDGE },
352 { PAH_ANA_ADDRESS, OperationObject::GEO_PHOTO },
353 { PAH_GEO_PHOTOS, OperationObject::GEO_PHOTO },
354
355 // use in search
356 { SEARCH_TOTAL_TABLE, OperationObject::SEARCH_TOTAL },
357 };
358
ParseOprnObjectFromUri()359 void MediaLibraryCommand::ParseOprnObjectFromUri()
360 {
361 const string opObject = MediaFileUri::GetPathFirstDentry(uri_);
362 if (OPRN_OBJ_MAP.find(opObject) != OPRN_OBJ_MAP.end()) {
363 oprnObject_ = OPRN_OBJ_MAP.at(opObject);
364 }
365 MEDIA_DEBUG_LOG("Command operation object is %{public}d", oprnObject_);
366 }
367
ParseOprnTypeFromUri()368 void MediaLibraryCommand::ParseOprnTypeFromUri()
369 {
370 const string opType = MediaFileUri::GetPathSecondDentry(uri_);
371 if (OPRN_TYPE_MAP.find(opType) != OPRN_TYPE_MAP.end()) {
372 oprnType_ = OPRN_TYPE_MAP.at(opType);
373 } else {
374 oprnType_ = OperationType::QUERY;
375 }
376 MEDIA_DEBUG_LOG("Command operation type is %{public}d", oprnType_);
377 }
378
GetDistTable(const string & table,const string & networkId)379 static string GetDistTable(const string &table, const string &networkId)
380 {
381 string ret = MEDIALIBRARY_TABLE;
382 auto rdbStore = MediaLibraryUnistoreManager::GetInstance().GetRdbStoreRaw();
383 if (rdbStore == nullptr) {
384 return ret;
385 }
386 auto rdbStorePtr = rdbStore->GetRaw();
387 if (rdbStorePtr == nullptr) {
388 return ret;
389 }
390
391 int errCode = E_ERR;
392 if (table == PhotoColumn::PHOTOS_TABLE || table == AudioColumn::AUDIOS_TABLE) {
393 ret = rdbStorePtr->ObtainDistributedTableName(networkId, table, errCode);
394 } else {
395 ret = rdbStorePtr->ObtainDistributedTableName(networkId, MEDIALIBRARY_TABLE, errCode);
396 }
397 return ret;
398 }
399
400 static const map<OperationObject, map<OperationType, string>> TABLE_NAME_MAP = {
401 { OperationObject::SMART_ALBUM, { { OperationType::UNKNOWN_TYPE, SMARTALBUM_TABLE } } },
402 { OperationObject::SMART_ALBUM_MAP, { { OperationType::UNKNOWN_TYPE, SMARTALBUM_MAP_TABLE } } },
403 { OperationObject::SMART_ALBUM_ASSETS, { { OperationType::UNKNOWN_TYPE, SMARTALBUMASSETS_VIEW_NAME } } },
404 { OperationObject::ASSETMAP, { { OperationType::UNKNOWN_TYPE, ASSETMAP_VIEW_NAME } } },
405 { OperationObject::FILESYSTEM_DIR, { { OperationType::QUERY, MEDIATYPE_DIRECTORY_TABLE } } },
406 #ifdef MEDIALIBRARY_COMPATIBILITY
407 { OperationObject::FILESYSTEM_ALBUM, { { OperationType::QUERY, PhotoAlbumColumns::TABLE } } },
408 #else
409 { OperationObject::FILESYSTEM_ALBUM, { { OperationType::QUERY, ALBUM_VIEW_NAME } } },
410 #endif
411 { OperationObject::ALL_DEVICE, { { OperationType::UNKNOWN_TYPE, DEVICE_TABLE } } },
412 { OperationObject::ACTIVE_DEVICE, { { OperationType::UNKNOWN_TYPE, DEVICE_TABLE } } },
413 { OperationObject::BUNDLE_PERMISSION, { { OperationType::UNKNOWN_TYPE, BUNDLE_PERMISSION_TABLE } } },
414 { OperationObject::FILESYSTEM_PHOTO, { { OperationType::UNKNOWN_TYPE, PhotoColumn::PHOTOS_TABLE } } },
415 { OperationObject::FILESYSTEM_AUDIO, { { OperationType::UNKNOWN_TYPE, AudioColumn::AUDIOS_TABLE } } },
416 { OperationObject::PHOTO_ALBUM, { { OperationType::UNKNOWN_TYPE, PhotoAlbumColumns::TABLE } } },
417 { OperationObject::PHOTO_MAP, { { OperationType::UNKNOWN_TYPE, PhotoMap::TABLE } } },
418 { OperationObject::UFM_PHOTO, { { OperationType::UNKNOWN_TYPE, PhotoColumn::PHOTOS_TABLE } } },
419 { OperationObject::UFM_AUDIO, { { OperationType::UNKNOWN_TYPE, AudioColumn::AUDIOS_TABLE } } },
420 { OperationObject::UFM_ALBUM, { { OperationType::UNKNOWN_TYPE, PhotoAlbumColumns::TABLE } } },
421 { OperationObject::UFM_MAP, { { OperationType::UNKNOWN_TYPE, PhotoMap::TABLE } } },
422 { OperationObject::PAH_PHOTO, { { OperationType::UNKNOWN_TYPE, PhotoColumn::PHOTOS_TABLE } } },
423 { OperationObject::PAH_ALBUM, { { OperationType::UNKNOWN_TYPE, PhotoAlbumColumns::TABLE } } },
424 { OperationObject::PAH_MAP, { { OperationType::UNKNOWN_TYPE, PhotoMap::TABLE } } },
425 #ifdef MEDIALIBRARY_MEDIATOOL_ENABLE
426 { OperationObject::TOOL_PHOTO, { { OperationType::UNKNOWN_TYPE, PhotoColumn::PHOTOS_TABLE } } },
427 { OperationObject::TOOL_AUDIO, { { OperationType::UNKNOWN_TYPE, AudioColumn::AUDIOS_TABLE } } },
428 #endif
429 { OperationObject::VISION_OCR, { { OperationType::UNKNOWN_TYPE, VISION_OCR_TABLE } } },
430 { OperationObject::VISION_LABEL, { { OperationType::UNKNOWN_TYPE, VISION_LABEL_TABLE } } },
431 { OperationObject::VISION_AESTHETICS, { { OperationType::UNKNOWN_TYPE, VISION_AESTHETICS_TABLE } } },
432 { OperationObject::VISION_SALIENCY, { { OperationType::UNKNOWN_TYPE, VISION_SALIENCY_TABLE } } },
433 { OperationObject::VISION_OBJECT, { { OperationType::UNKNOWN_TYPE, VISION_OBJECT_TABLE } } },
434 { OperationObject::VISION_RECOMMENDATION, { { OperationType::UNKNOWN_TYPE, VISION_RECOMMENDATION_TABLE } } },
435 { OperationObject::VISION_SEGMENTATION, { { OperationType::UNKNOWN_TYPE, VISION_SEGMENTATION_TABLE } } },
436 { OperationObject::VISION_COMPOSITION, { { OperationType::UNKNOWN_TYPE, VISION_COMPOSITION_TABLE } } },
437 { OperationObject::VISION_TOTAL, { { OperationType::UNKNOWN_TYPE, VISION_TOTAL_TABLE } } },
438 { OperationObject::VISION_IMAGE_FACE, { { OperationType::UNKNOWN_TYPE, VISION_IMAGE_FACE_TABLE } } },
439 { OperationObject::VISION_FACE_TAG, { { OperationType::UNKNOWN_TYPE, VISION_FACE_TAG_TABLE } } },
440 { OperationObject::GEO_DICTIONARY, { { OperationType::UNKNOWN_TYPE, GEO_DICTIONARY_TABLE } } },
441 { OperationObject::GEO_KNOWLEDGE, { { OperationType::UNKNOWN_TYPE, GEO_KNOWLEDGE_TABLE } } },
442 { OperationObject::GEO_PHOTO, { { OperationType::UNKNOWN_TYPE, PhotoColumn::PHOTOS_TABLE } } },
443 { OperationObject::ANALYSIS_PHOTO_ALBUM, { { OperationType::UNKNOWN_TYPE, ANALYSIS_ALBUM_TABLE } } },
444 { OperationObject::ANALYSIS_PHOTO_MAP, { { OperationType::UNKNOWN_TYPE, ANALYSIS_PHOTO_MAP_TABLE } } },
445 { OperationObject::PAH_FORM_MAP, { { OperationType::UNKNOWN_TYPE, FormMap::FORM_MAP_TABLE } } },
446
447 // search
448 { OperationObject::SEARCH_TOTAL, { { OperationType::UNKNOWN_TYPE, SEARCH_TOTAL_TABLE } } },
449 };
450
ParseTableName()451 void MediaLibraryCommand::ParseTableName()
452 {
453 if (TABLE_NAME_MAP.find(oprnObject_) != TABLE_NAME_MAP.end()) {
454 auto cmdObj = TABLE_NAME_MAP.at(oprnObject_);
455 if (cmdObj.find(oprnType_) != cmdObj.end()) {
456 tableName_ = cmdObj.at(oprnType_);
457 } else if (cmdObj.find(OperationType::UNKNOWN_TYPE) != cmdObj.end()) {
458 tableName_ = cmdObj.at(OperationType::UNKNOWN_TYPE);
459 } else {
460 tableName_ = MEDIALIBRARY_TABLE;
461 }
462 } else {
463 tableName_ = MEDIALIBRARY_TABLE;
464 }
465 // distributed tablename, smartalbum and smartalbumMap can not distributed
466 if ((oprnObject_ == OperationObject::SMART_ALBUM) || (oprnObject_ == OperationObject::SMART_ALBUM_MAP)) {
467 MEDIA_DEBUG_LOG("smart table name is %{public}s", tableName_.c_str());
468 return;
469 }
470 // distributed tablename
471 auto networkId = GetOprnDevice();
472 if (networkId.empty()) {
473 return;
474 }
475 tableName_ = GetDistTable(tableName_, networkId);
476 MEDIA_INFO_LOG("Table name is %{public}s", tableName_.c_str());
477 }
478
InitAbsRdbPredicates()479 void MediaLibraryCommand::InitAbsRdbPredicates()
480 {
481 if (tableName_.empty()) {
482 ParseTableName();
483 }
484 absRdbPredicates_ = make_unique<AbsRdbPredicates>(tableName_);
485 }
486
ParseFileId()487 void MediaLibraryCommand::ParseFileId()
488 {
489 int32_t fileIdInValue = -1;
490 ValueObject valueObject;
491 if (insertValue_.GetObject(MEDIA_DATA_DB_ID, valueObject)) {
492 valueObject.GetInt(fileIdInValue);
493 }
494 if (fileIdInValue != -1) {
495 oprnFileId_ = to_string(fileIdInValue);
496 return;
497 }
498 string uriInValue;
499 if (insertValue_.GetObject(MEDIA_DATA_DB_URI, valueObject)) {
500 valueObject.GetString(uriInValue);
501 }
502 if (uriInValue.empty()) {
503 uriInValue = GetUriStringWithoutSegment();
504 }
505
506 string idFromUri = MediaFileUtils::GetIdFromUri(uriInValue);
507 if (!MediaLibraryDataManagerUtils::IsNumber(idFromUri)) {
508 return;
509 }
510 oprnFileId_ = idFromUri;
511 }
512
ParseQuerySetMapFromUri()513 void MediaLibraryCommand::ParseQuerySetMapFromUri()
514 {
515 // uri format: datashare:///media/photo_operation/create_asset?op1=xxx&op2=yyy&api_version=10#abc
516 // QuerySetMap: {"op1": "xxx", "op2": "yyy", "api_version": "10"}
517 string uriStr = uri_.ToString();
518 size_t cutPoint = uriStr.find('#');
519 if (cutPoint != string::npos) {
520 uriStr = uriStr.substr(0, cutPoint);
521 }
522 MediaFileUri mediaUri(uriStr);
523 querySetMap_ = mediaUri.GetQueryKeys();
524 }
525
SetApiFromQuerySetMap()526 void MediaLibraryCommand::SetApiFromQuerySetMap()
527 {
528 if (querySetMap_.find(URI_PARAM_API_VERSION) == querySetMap_.end()) {
529 api_ = MediaLibraryApi::API_OLD;
530 } else {
531 string apiString = querySetMap_[URI_PARAM_API_VERSION];
532 if (!MediaLibraryDataManagerUtils::IsNumber(apiString)) {
533 api_ = MediaLibraryApi::API_OLD;
534 return;
535 }
536 int32_t apiNum = stoi(apiString);
537 if (apiNum <= static_cast<int32_t>(MediaLibraryApi::API_START) ||
538 apiNum >= static_cast<int32_t>(MediaLibraryApi::API_END)) {
539 MEDIA_ERR_LOG("this api num is wrong: %{public}d", apiNum);
540 api_ = MediaLibraryApi::API_OLD;
541 } else {
542 api_ = static_cast<MediaLibraryApi>(apiNum);
543 }
544 }
545 }
546
ParseOprnObjectFromFileUri()547 void MediaLibraryCommand::ParseOprnObjectFromFileUri()
548 {
549 if (oprnObject_ != OperationObject::UNKNOWN_OBJECT) {
550 return;
551 }
552
553 string uri = uri_.ToString();
554 // parse cache file uri
555 if (MediaFileUtils::StartsWith(uri, PhotoColumn::PHOTO_CACHE_URI_PREFIX)) {
556 oprnObject_ = OperationObject::PAH_PHOTO;
557 return;
558 }
559
560 static const map<string, OperationObject> oprnMap = {
561 { PhotoColumn::PHOTO_URI_PREFIX, OperationObject::FILESYSTEM_PHOTO },
562 { AudioColumn::AUDIO_URI_PREFIX, OperationObject::FILESYSTEM_AUDIO }
563 };
564
565 for (const auto &item : oprnMap) {
566 if (MediaFileUtils::StartsWith(uri, item.first)) {
567 oprnObject_ = item.second;
568 break;
569 }
570 }
571 }
572
SetDataSharePred(const DataSharePredicates & pred)573 void MediaLibraryCommand::SetDataSharePred(const DataSharePredicates &pred)
574 {
575 datasharePred_ = make_unique<const DataSharePredicates>(pred);
576 }
577
578 // Caller is responsible for calling SetDataSharePred() firstly, before calling GetDataSharePred()
GetDataSharePred() const579 const DataSharePredicates &MediaLibraryCommand::GetDataSharePred() const
580 {
581 return *datasharePred_;
582 }
583 } // namespace Media
584 } // namespace OHOS
585