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 "media_column.h"
19 #include "media_file_uri.h"
20 #include "media_file_utils.h"
21 #include "media_log.h"
22 #include "medialibrary_data_manager_utils.h"
23 #include "medialibrary_db_const.h"
24 #include "medialibrary_unistore_manager.h"
25 #include "photo_album_column.h"
26 #include "photo_map_column.h"
27 #include "medialibrary_errno.h"
28 #include "userfilemgr_uri.h"
29
30 using namespace std;
31 using namespace OHOS::NativeRdb;
32 using namespace OHOS::DataShare;
33
34 namespace OHOS {
35 namespace Media {
MediaLibraryCommand(const Uri & uri)36 MediaLibraryCommand::MediaLibraryCommand(const Uri &uri) : uri_(uri)
37 {
38 ParseOprnObjectFromUri();
39 ParseOprnTypeFromUri();
40 ParseQuerySetMapFromUri();
41 SetApiFromQuerySetMap();
42 ParseOprnObjectFromFileUri();
43 ParseTableName();
44 }
45
MediaLibraryCommand(const Uri & uri,const ValuesBucket & value)46 MediaLibraryCommand::MediaLibraryCommand(const Uri &uri, const ValuesBucket &value) : uri_(uri), insertValue_(value)
47 {
48 ParseOprnObjectFromUri();
49 ParseOprnTypeFromUri();
50 ParseQuerySetMapFromUri();
51 SetApiFromQuerySetMap();
52 ParseOprnObjectFromFileUri();
53 ParseTableName();
54 }
55
MediaLibraryCommand(const Uri & uri,const OperationType & oprnType)56 MediaLibraryCommand::MediaLibraryCommand(const Uri &uri, const OperationType &oprnType) : uri_(uri), oprnType_(oprnType)
57 {
58 ParseOprnObjectFromUri();
59 ParseQuerySetMapFromUri();
60 SetApiFromQuerySetMap();
61 ParseOprnObjectFromFileUri();
62 ParseTableName();
63 }
64
MediaLibraryCommand(const OperationObject & oprnObject,const OperationType & oprnType,MediaLibraryApi api)65 MediaLibraryCommand::MediaLibraryCommand(const OperationObject &oprnObject, const OperationType &oprnType,
66 MediaLibraryApi api) : oprnObject_(oprnObject), oprnType_(oprnType), api_(api)
67 {
68 ParseTableName();
69 }
70
MediaLibraryCommand(const OperationObject & oprnObject,const OperationType & oprnType,const ValuesBucket & value,MediaLibraryApi api)71 MediaLibraryCommand::MediaLibraryCommand(const OperationObject &oprnObject, const OperationType &oprnType,
72 const ValuesBucket &value, MediaLibraryApi api) :insertValue_(value), oprnObject_(oprnObject),
73 oprnType_(oprnType), api_(api)
74 {
75 ParseTableName();
76 }
77
MediaLibraryCommand(const OperationObject & oprnObject,const OperationType & oprnType,const string & networkId,MediaLibraryApi api)78 MediaLibraryCommand::MediaLibraryCommand(const OperationObject &oprnObject, const OperationType &oprnType,
79 const string &networkId, MediaLibraryApi api) : oprnObject_(oprnObject), oprnType_(oprnType),
80 oprnDevice_(networkId), api_(api)
81 {
82 ParseTableName();
83 }
84
~MediaLibraryCommand()85 MediaLibraryCommand::~MediaLibraryCommand() {}
86
87 // set functions
SetOprnObject(OperationObject object)88 void MediaLibraryCommand::SetOprnObject(OperationObject object)
89 {
90 oprnObject_ = object;
91 }
92
SetOprnAssetId(const std::string & oprnId)93 void MediaLibraryCommand::SetOprnAssetId(const std::string &oprnId)
94 {
95 oprnFileId_ = oprnId;
96 }
97
SetValueBucket(const NativeRdb::ValuesBucket & value)98 void MediaLibraryCommand::SetValueBucket(const NativeRdb::ValuesBucket &value)
99 {
100 insertValue_ = value;
101 }
102
SetTableName(const std::string & tableName)103 void MediaLibraryCommand::SetTableName(const std::string &tableName)
104 {
105 tableName_ = tableName;
106 }
107
SetBundleName(const std::string & bundleName)108 void MediaLibraryCommand::SetBundleName(const std::string &bundleName)
109 {
110 bundleName_ = bundleName;
111 }
112
SetDeviceName(const std::string & deviceName)113 void MediaLibraryCommand::SetDeviceName(const std::string &deviceName)
114 {
115 deviceName_ = deviceName;
116 }
117
SetResult(const std::string & result)118 void MediaLibraryCommand::SetResult(const std::string &result)
119 {
120 result_ = result;
121 }
122
123 // get functions
GetOprnObject() const124 OperationObject MediaLibraryCommand::GetOprnObject() const
125 {
126 return oprnObject_;
127 }
128
GetOprnType() const129 OperationType MediaLibraryCommand::GetOprnType() const
130 {
131 return oprnType_;
132 }
133
GetValueBucket()134 ValuesBucket &MediaLibraryCommand::GetValueBucket()
135 {
136 return insertValue_;
137 }
138
GetAbsRdbPredicates()139 AbsRdbPredicates *MediaLibraryCommand::GetAbsRdbPredicates()
140 {
141 if (absRdbPredicates_ == nullptr) {
142 InitAbsRdbPredicates();
143 }
144 return absRdbPredicates_.get();
145 }
146
GetTableName()147 const string &MediaLibraryCommand::GetTableName()
148 {
149 if (tableName_.empty()) {
150 ParseTableName();
151 }
152
153 return tableName_;
154 }
155
GetOprnFileId()156 const string &MediaLibraryCommand::GetOprnFileId()
157 {
158 if (oprnFileId_.empty()) {
159 ParseFileId();
160 }
161
162 return oprnFileId_;
163 }
164
GetOprnDevice()165 const string &MediaLibraryCommand::GetOprnDevice()
166 {
167 if (oprnDevice_.empty()) {
168 oprnDevice_ = MediaLibraryDataManagerUtils::GetNetworkIdFromUri(uri_.ToString());
169 }
170 return oprnDevice_;
171 }
172
GetUri() const173 const Uri &MediaLibraryCommand::GetUri() const
174 {
175 return uri_;
176 }
177
GetBundleName()178 const string &MediaLibraryCommand::GetBundleName()
179 {
180 return bundleName_;
181 }
182
GetDeviceName()183 const string &MediaLibraryCommand::GetDeviceName()
184 {
185 return deviceName_;
186 }
187
GetResult()188 const string &MediaLibraryCommand::GetResult()
189 {
190 return result_;
191 }
192
GetUriStringWithoutSegment() const193 string MediaLibraryCommand::GetUriStringWithoutSegment() const
194 {
195 string uriString = uri_.ToString();
196 size_t questionMaskPoint = uriString.rfind('?');
197 size_t hashKeyPoint = uriString.rfind('#');
198 if (questionMaskPoint != string::npos) {
199 return uriString.substr(0, questionMaskPoint);
200 }
201 if (hashKeyPoint != string::npos) {
202 return uriString.substr(0, hashKeyPoint);
203 }
204 return uriString;
205 }
206
GetApi()207 MediaLibraryApi MediaLibraryCommand::GetApi()
208 {
209 return api_;
210 }
211
GetQuerySetParam(const std::string & key)212 string MediaLibraryCommand::GetQuerySetParam(const std::string &key)
213 {
214 if (key.empty() || querySetMap_.find(key) == querySetMap_.end()) {
215 return "";
216 }
217 return querySetMap_[key];
218 }
219
ParseOprnObjectFromUri()220 void MediaLibraryCommand::ParseOprnObjectFromUri()
221 {
222 static const map<string, OperationObject> OPRN_OBJ_MAP = {
223 // use in Insert...
224 { MEDIA_FILEOPRN, OperationObject::FILESYSTEM_ASSET },
225 { MEDIA_PHOTOOPRN, OperationObject::FILESYSTEM_PHOTO },
226 { MEDIA_AUDIOOPRN, OperationObject::FILESYSTEM_AUDIO },
227 { MEDIA_DIROPRN, OperationObject::FILESYSTEM_DIR },
228 { MEDIA_ALBUMOPRN, OperationObject::FILESYSTEM_ALBUM },
229 { MEDIA_SMARTALBUMOPRN, OperationObject::SMART_ALBUM },
230 { MEDIA_SMARTALBUMMAPOPRN, OperationObject::SMART_ALBUM_MAP },
231 { BUNDLE_PERMISSION_INSERT, OperationObject::BUNDLE_PERMISSION },
232 { PHOTO_ALBUM_OPRN, OperationObject::PHOTO_ALBUM },
233 { PHOTO_MAP_OPRN, OperationObject::PHOTO_MAP },
234 { UFM_PHOTO, OperationObject::UFM_PHOTO },
235 { UFM_AUDIO, OperationObject::UFM_AUDIO },
236 { UFM_ALBUM, OperationObject::UFM_ALBUM },
237 { UFM_MAP, OperationObject::UFM_MAP },
238 { PAH_PHOTO, OperationObject::PAH_PHOTO },
239 { PAH_ALBUM, OperationObject::PAH_ALBUM },
240 { PAH_MAP, OperationObject::PAH_MAP },
241
242 // use in Query...
243 { MEDIATYPE_DIRECTORY_TABLE, OperationObject::FILESYSTEM_DIR },
244 { MEDIA_DATA_DB_THUMBNAIL, OperationObject::THUMBNAIL },
245 { SMARTALBUMASSETS_VIEW_NAME, OperationObject::SMART_ALBUM_ASSETS },
246 { ASSETMAP_VIEW_NAME, OperationObject::ASSETMAP },
247 { MEDIA_DEVICE_QUERYALLDEVICE, OperationObject::ALL_DEVICE },
248 { MEDIA_DEVICE_QUERYACTIVEDEVICE, OperationObject::ACTIVE_DEVICE },
249 { MEDIA_ALBUMOPRN_QUERYALBUM, OperationObject::FILESYSTEM_ALBUM },
250 { SMARTALBUM_TABLE, OperationObject::SMART_ALBUM },
251 { SMARTALBUM_MAP_TABLE, OperationObject::SMART_ALBUM_MAP },
252 { MEDIA_QUERYOPRN_QUERYVOLUME, OperationObject::MEDIA_VOLUME },
253 };
254
255 const string opObject = MediaFileUri::GetPathFirstDentry(uri_);
256 if (OPRN_OBJ_MAP.find(opObject) != OPRN_OBJ_MAP.end()) {
257 oprnObject_ = OPRN_OBJ_MAP.at(opObject);
258 }
259 MEDIA_DEBUG_LOG("Command operation object is %{public}d", oprnObject_);
260 }
261
ParseOprnTypeFromUri()262 void MediaLibraryCommand::ParseOprnTypeFromUri()
263 {
264 static const map<string, OperationType> OPRN_TYPE_MAP = {
265 { MEDIA_FILEOPRN_CLOSEASSET, OperationType::CLOSE },
266 { MEDIA_FILEOPRN_CREATEASSET, OperationType::CREATE },
267 { MEDIA_ALBUMOPRN_CREATEALBUM, OperationType::CREATE },
268 { MEDIA_FILEOPRN_DELETEASSET, OperationType::DELETE },
269 { MEDIA_ALBUMOPRN_DELETEALBUM, OperationType::DELETE },
270 { MEDIA_FILEOPRN_MODIFYASSET, OperationType::UPDATE },
271 { MEDIA_ALBUMOPRN_MODIFYALBUM, OperationType::UPDATE },
272 { MEDIA_ALBUMOPRN_QUERYALBUM, OperationType::QUERY },
273 { MEDIA_FILEOPRN_GETALBUMCAPACITY, OperationType::QUERY },
274 { MEDIA_QUERYOPRN_QUERYVOLUME, OperationType::QUERY },
275 { MEDIA_BOARDCASTOPRN, OperationType::SCAN },
276 { OPRN_SCAN, OperationType::SCAN },
277 { OPRN_DELETE_BY_TOOL, OperationType::DELETE_TOOL },
278 { MEDIA_FILEOPRN_COPYASSET, OperationType::COPY },
279 { MEDIA_DIROPRN_DELETEDIR, OperationType::DELETE },
280 { MEDIA_DIROPRN_FMS_CREATEDIR, OperationType::CREATE },
281 { MEDIA_DIROPRN_FMS_DELETEDIR, OperationType::DELETE },
282 { MEDIA_DIROPRN_FMS_TRASHDIR, OperationType::TRASH },
283 { MEDIA_SMARTALBUMOPRN_CREATEALBUM, OperationType::CREATE },
284 { MEDIA_SMARTALBUMOPRN_DELETEALBUM, OperationType::DELETE },
285 { MEDIA_SMARTALBUMMAPOPRN_ADDSMARTALBUM, OperationType::CREATE },
286 { MEDIA_SMARTALBUMMAPOPRN_REMOVESMARTALBUM, OperationType::DELETE },
287 { MEDIA_SMARTALBUMMAPOPRN_AGEINGSMARTALBUM, OperationType::AGING },
288 { MEDIA_SMARTALBUMOPRN_MODIFYALBUM, OperationType::UPDATE },
289 { BUNDLE_PERMISSION_INSERT, OperationType::INSERT_PERMISSION },
290 { OPRN_CREATE, OperationType::CREATE },
291 { OPRN_CREATE_COMPONENT, OperationType::CREATE },
292 { OPRN_DELETE, OperationType::DELETE },
293 { OPRN_QUERY, OperationType::QUERY },
294 { OPRN_UPDATE, OperationType::UPDATE },
295 { OPRN_ALBUM_ADD_PHOTOS, OperationType::ALBUM_ADD_PHOTOS },
296 { OPRN_ALBUM_REMOVE_PHOTOS, OperationType::ALBUM_REMOVE_PHOTOS },
297 { OPRN_RECOVER_PHOTOS, OperationType::ALBUM_RECOVER_ASSETS },
298 { OPRN_DELETE_PHOTOS, OperationType::ALBUM_DELETE_ASSETS },
299 { OPRN_CLOSE, OperationType::CLOSE },
300 { OPRN_TRASH, OperationType::TRASH_PHOTO },
301 { OPRN_PENDING, OperationType::UPDATE_PENDING },
302 { OPRN_SET_USER_COMMENT, OperationType::SET_USER_COMMENT },
303 { OPRN_INDEX, OperationType::INDEX },
304 };
305
306 const string opType = MediaFileUri::GetPathSecondDentry(uri_);
307 if (OPRN_TYPE_MAP.find(opType) != OPRN_TYPE_MAP.end()) {
308 oprnType_ = OPRN_TYPE_MAP.at(opType);
309 } else {
310 oprnType_ = OperationType::QUERY;
311 }
312 MEDIA_DEBUG_LOG("Command operation type is %{public}d", oprnType_);
313 }
314
GetDistTable(const string & table,const string & networkId)315 static string GetDistTable(const string &table, const string &networkId)
316 {
317 string ret = MEDIALIBRARY_TABLE;
318 auto rdbStore = MediaLibraryUnistoreManager::GetInstance().GetRdbStoreRaw();
319 if (rdbStore == nullptr) {
320 return ret;
321 }
322 auto rdbStorePtr = rdbStore->GetRaw();
323 if (rdbStorePtr == nullptr) {
324 return ret;
325 }
326
327 int errCode = E_ERR;
328 if (table == PhotoColumn::PHOTOS_TABLE || table == AudioColumn::AUDIOS_TABLE) {
329 ret = rdbStorePtr->ObtainDistributedTableName(networkId, table, errCode);
330 } else {
331 ret = rdbStorePtr->ObtainDistributedTableName(networkId, MEDIALIBRARY_TABLE, errCode);
332 }
333 return ret;
334 }
335
ParseTableName()336 void MediaLibraryCommand::ParseTableName()
337 {
338 static const map<OperationObject, map<OperationType, string>> TABLE_NAME_MAP = {
339 { OperationObject::SMART_ALBUM, { { OperationType::UNKNOWN_TYPE, SMARTALBUM_TABLE } } },
340 { OperationObject::SMART_ALBUM_MAP, { { OperationType::UNKNOWN_TYPE, SMARTALBUM_MAP_TABLE } } },
341 { OperationObject::SMART_ALBUM_ASSETS, { { OperationType::UNKNOWN_TYPE, SMARTALBUMASSETS_VIEW_NAME } } },
342 { OperationObject::ASSETMAP, { { OperationType::UNKNOWN_TYPE, ASSETMAP_VIEW_NAME } } },
343 { OperationObject::FILESYSTEM_DIR, { { OperationType::QUERY, MEDIATYPE_DIRECTORY_TABLE } } },
344 #ifdef MEDIALIBRARY_COMPATIBILITY
345 { OperationObject::FILESYSTEM_ALBUM, { { OperationType::QUERY, PhotoAlbumColumns::TABLE } } },
346 #else
347 { OperationObject::FILESYSTEM_ALBUM, { { OperationType::QUERY, ALBUM_VIEW_NAME } } },
348 #endif
349 { OperationObject::ALL_DEVICE, { { OperationType::UNKNOWN_TYPE, DEVICE_TABLE } } },
350 { OperationObject::ACTIVE_DEVICE, { { OperationType::UNKNOWN_TYPE, DEVICE_TABLE } } },
351 { OperationObject::BUNDLE_PERMISSION, { { OperationType::UNKNOWN_TYPE, BUNDLE_PERMISSION_TABLE } } },
352 { OperationObject::FILESYSTEM_PHOTO, { { OperationType::UNKNOWN_TYPE, PhotoColumn::PHOTOS_TABLE } } },
353 { OperationObject::FILESYSTEM_AUDIO, { { OperationType::UNKNOWN_TYPE, AudioColumn::AUDIOS_TABLE } } },
354 { OperationObject::PHOTO_ALBUM, { { OperationType::UNKNOWN_TYPE, PhotoAlbumColumns::TABLE } } },
355 { OperationObject::PHOTO_MAP, { { OperationType::UNKNOWN_TYPE, PhotoMap::TABLE } } },
356 { OperationObject::UFM_PHOTO, { { OperationType::UNKNOWN_TYPE, PhotoColumn::PHOTOS_TABLE } } },
357 { OperationObject::UFM_AUDIO, { { OperationType::UNKNOWN_TYPE, AudioColumn::AUDIOS_TABLE } } },
358 { OperationObject::UFM_ALBUM, { { OperationType::UNKNOWN_TYPE, PhotoAlbumColumns::TABLE } } },
359 { OperationObject::UFM_MAP, { { OperationType::UNKNOWN_TYPE, PhotoMap::TABLE } } },
360 { OperationObject::PAH_PHOTO, { { OperationType::UNKNOWN_TYPE, PhotoColumn::PHOTOS_TABLE } } },
361 { OperationObject::PAH_ALBUM, { { OperationType::UNKNOWN_TYPE, PhotoAlbumColumns::TABLE } } },
362 { OperationObject::PAH_MAP, { { OperationType::UNKNOWN_TYPE, PhotoMap::TABLE } } },
363 };
364
365 if (TABLE_NAME_MAP.find(oprnObject_) != TABLE_NAME_MAP.end()) {
366 auto cmdObj = TABLE_NAME_MAP.at(oprnObject_);
367 if (cmdObj.find(oprnType_) != cmdObj.end()) {
368 tableName_ = cmdObj.at(oprnType_);
369 } else if (cmdObj.find(OperationType::UNKNOWN_TYPE) != cmdObj.end()) {
370 tableName_ = cmdObj.at(OperationType::UNKNOWN_TYPE);
371 } else {
372 tableName_ = MEDIALIBRARY_TABLE;
373 }
374 } else {
375 tableName_ = MEDIALIBRARY_TABLE;
376 }
377 // distributed tablename, smartalbum and smartalbumMap can not distributed
378 if ((oprnObject_ == OperationObject::SMART_ALBUM) || (oprnObject_ == OperationObject::SMART_ALBUM_MAP)) {
379 MEDIA_DEBUG_LOG("smart table name is %{public}s", tableName_.c_str());
380 return;
381 }
382 // distributed tablename
383 auto networkId = GetOprnDevice();
384 if (networkId.empty()) {
385 return;
386 }
387 tableName_ = GetDistTable(tableName_, networkId);
388 MEDIA_INFO_LOG("Table name is %{public}s", tableName_.c_str());
389 }
390
InitAbsRdbPredicates()391 void MediaLibraryCommand::InitAbsRdbPredicates()
392 {
393 if (tableName_.empty()) {
394 ParseTableName();
395 }
396 absRdbPredicates_ = make_unique<AbsRdbPredicates>(tableName_);
397 }
398
ParseFileId()399 void MediaLibraryCommand::ParseFileId()
400 {
401 int32_t fileIdInValue = -1;
402 ValueObject valueObject;
403 if (insertValue_.GetObject(MEDIA_DATA_DB_ID, valueObject)) {
404 valueObject.GetInt(fileIdInValue);
405 }
406 if (fileIdInValue != -1) {
407 oprnFileId_ = to_string(fileIdInValue);
408 return;
409 }
410 string uriInValue;
411 if (insertValue_.GetObject(MEDIA_DATA_DB_URI, valueObject)) {
412 valueObject.GetString(uriInValue);
413 }
414 if (uriInValue.empty()) {
415 uriInValue = GetUriStringWithoutSegment();
416 }
417
418 string idFromUri = MediaLibraryDataManagerUtils::GetIdFromUri(uriInValue);
419 if (!MediaLibraryDataManagerUtils::IsNumber(idFromUri)) {
420 return;
421 }
422 oprnFileId_ = idFromUri;
423 }
424
ParseQuerySetMapFromUri()425 void MediaLibraryCommand::ParseQuerySetMapFromUri()
426 {
427 // uri format: datashare:///media/photo_operation/create_asset?op1=xxx&op2=yyy&api_version=10#abc
428 // QuerySetMap: {"op1": "xxx", "op2": "yyy", "api_version": "10"}
429 string uriStr = uri_.ToString();
430 size_t cutPoint = uriStr.find('#');
431 if (cutPoint != string::npos) {
432 uriStr = uriStr.substr(0, cutPoint);
433 }
434 MediaFileUri mediaUri(uriStr);
435 querySetMap_ = mediaUri.GetQueryKeys();
436 }
437
SetApiFromQuerySetMap()438 void MediaLibraryCommand::SetApiFromQuerySetMap()
439 {
440 if (querySetMap_.find(URI_PARAM_API_VERSION) == querySetMap_.end()) {
441 api_ = MediaLibraryApi::API_OLD;
442 } else {
443 string apiString = querySetMap_[URI_PARAM_API_VERSION];
444 if (!MediaLibraryDataManagerUtils::IsNumber(apiString)) {
445 api_ = MediaLibraryApi::API_OLD;
446 return;
447 }
448 int32_t apiNum = stoi(apiString);
449 if (apiNum <= static_cast<int32_t>(MediaLibraryApi::API_START) ||
450 apiNum >= static_cast<int32_t>(MediaLibraryApi::API_END)) {
451 MEDIA_ERR_LOG("this api num is wrong: %{public}d", apiNum);
452 api_ = MediaLibraryApi::API_OLD;
453 } else {
454 api_ = static_cast<MediaLibraryApi>(apiNum);
455 }
456 }
457 }
458
ParseOprnObjectFromFileUri()459 void MediaLibraryCommand::ParseOprnObjectFromFileUri()
460 {
461 if (oprnObject_ != OperationObject::UNKNOWN_OBJECT) {
462 return;
463 }
464
465 string uri = uri_.ToString();
466 static const map<string, OperationObject> oprnMap = {
467 { PhotoColumn::PHOTO_TYPE_URI, OperationObject::FILESYSTEM_PHOTO },
468 { AudioColumn::AUDIO_TYPE_URI, OperationObject::FILESYSTEM_AUDIO }
469 };
470
471 for (const auto &item : oprnMap) {
472 if (uri.find(item.first) != string::npos) {
473 oprnObject_ = item.second;
474 break;
475 }
476 }
477 }
478
SetDataSharePred(const DataSharePredicates & pred)479 void MediaLibraryCommand::SetDataSharePred(const DataSharePredicates &pred)
480 {
481 datasharePred_ = make_unique<const DataSharePredicates>(pred);
482 }
483
484 // Caller is responsible for calling SetDataSharePred() firstly, before calling GetDataSharePred()
GetDataSharePred() const485 const DataSharePredicates &MediaLibraryCommand::GetDataSharePred() const
486 {
487 return *datasharePred_;
488 }
489 } // namespace Media
490 } // namespace OHOS
491