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_file_utils.h"
19 #include "media_log.h"
20 #include "medialibrary_data_manager_utils.h"
21 #include "medialibrary_unistore_manager.h"
22 #include "medialibrary_errno.h"
23
24 using namespace std;
25 using namespace OHOS::NativeRdb;
26
27 namespace OHOS {
28 namespace Media {
MediaLibraryCommand(const Uri & uri)29 MediaLibraryCommand::MediaLibraryCommand(const Uri &uri)
30 {
31 uri_ = uri;
32 ParseOprnObjectFromUri();
33 ParseOprnTypeFromUri();
34 ParseTableName();
35 }
36
MediaLibraryCommand(const Uri & uri,const ValuesBucket & value)37 MediaLibraryCommand::MediaLibraryCommand(const Uri &uri, const ValuesBucket &value)
38 {
39 uri_ = uri;
40 ParseOprnObjectFromUri();
41 ParseOprnTypeFromUri();
42 ParseTableName();
43 insertValue_ = value;
44 }
45
MediaLibraryCommand(const Uri & uri,const OperationType & oprnType)46 MediaLibraryCommand::MediaLibraryCommand(const Uri &uri, const OperationType &oprnType)
47 {
48 uri_ = uri;
49 ParseOprnObjectFromUri();
50 SetOprnType(oprnType);
51 ParseTableName();
52 }
53
MediaLibraryCommand(const OperationObject & oprnObject,const OperationType & oprnType)54 MediaLibraryCommand::MediaLibraryCommand(const OperationObject &oprnObject, const OperationType &oprnType)
55 {
56 SetOprnObject(oprnObject);
57 SetOprnType(oprnType);
58 ParseTableName();
59 }
60
MediaLibraryCommand(const OperationObject & oprnObject,const OperationType & oprnType,const ValuesBucket & value)61 MediaLibraryCommand::MediaLibraryCommand(const OperationObject &oprnObject, const OperationType &oprnType,
62 const ValuesBucket &value)
63 {
64 SetOprnObject(oprnObject);
65 SetOprnType(oprnType);
66 ParseTableName();
67 insertValue_ = value;
68 }
69
MediaLibraryCommand(const OperationObject & oprnObject,const OperationType & oprnType,const string & networkId)70 MediaLibraryCommand::MediaLibraryCommand(const OperationObject &oprnObject, const OperationType &oprnType,
71 const string &networkId)
72 {
73 SetOprnObject(oprnObject);
74 SetOprnType(oprnType);
75 SetOprnDevice(networkId);
76 ParseTableName();
77 }
78
~MediaLibraryCommand()79 MediaLibraryCommand::~MediaLibraryCommand() {}
80
81 // set functions
SetOprnObject(const OperationObject & oprnObject)82 void MediaLibraryCommand::SetOprnObject(const OperationObject &oprnObject)
83 {
84 oprnObject_ = oprnObject;
85 }
86
SetOprnType(const OperationType & oprnType)87 void MediaLibraryCommand::SetOprnType(const OperationType &oprnType)
88 {
89 oprnType_ = oprnType;
90 }
91
SetOprnAssetId(const std::string & oprnId)92 void MediaLibraryCommand::SetOprnAssetId(const std::string &oprnId)
93 {
94 oprnFileId_ = oprnId;
95 }
96
SetOprnDevice(const std::string & networkId)97 void MediaLibraryCommand::SetOprnDevice(const std::string &networkId)
98 {
99 oprnDevice_ = networkId;
100 }
101
SetValueBucket(const NativeRdb::ValuesBucket & value)102 void MediaLibraryCommand::SetValueBucket(const NativeRdb::ValuesBucket &value)
103 {
104 insertValue_ = value;
105 }
106
SetTableName(const std::string & tableName)107 void MediaLibraryCommand::SetTableName(const std::string &tableName)
108 {
109 tableName_ = tableName;
110 }
111
112 // get functions
GetOprnObject() const113 OperationObject MediaLibraryCommand::GetOprnObject() const
114 {
115 return oprnObject_;
116 }
117
GetOprnType() const118 OperationType MediaLibraryCommand::GetOprnType() const
119 {
120 return oprnType_;
121 }
122
GetValueBucket()123 ValuesBucket &MediaLibraryCommand::GetValueBucket()
124 {
125 return insertValue_;
126 }
127
GetAbsRdbPredicates()128 AbsRdbPredicates *MediaLibraryCommand::GetAbsRdbPredicates()
129 {
130 if (absRdbPredicates_ == nullptr) {
131 InitAbsRdbPredicates();
132 }
133 return absRdbPredicates_.get();
134 }
135
GetTableName()136 const string &MediaLibraryCommand::GetTableName()
137 {
138 if (tableName_.empty()) {
139 ParseTableName();
140 }
141
142 return tableName_;
143 }
144
GetOprnFileId()145 const string &MediaLibraryCommand::GetOprnFileId()
146 {
147 if (oprnFileId_.empty()) {
148 ParseFileId();
149 }
150
151 return oprnFileId_;
152 }
153
GetOprnDevice()154 const string &MediaLibraryCommand::GetOprnDevice()
155 {
156 if (oprnDevice_.empty()) {
157 oprnDevice_ = MediaLibraryDataManagerUtils::GetNetworkIdFromUri(uri_.ToString());
158 MEDIA_INFO_LOG("oprnDevice_: %{private}s", oprnDevice_.c_str());
159 }
160 return oprnDevice_;
161 }
162
GetUri() const163 const Uri &MediaLibraryCommand::GetUri() const
164 {
165 return uri_;
166 }
167
ParseOprnObjectFromUri()168 void MediaLibraryCommand::ParseOprnObjectFromUri()
169 {
170 string uri = uri_.ToString();
171
172 const static map<string, OperationObject> oprnMap = {
173 // use in Insert...
174 { MEDIA_FILEOPRN, OperationObject::FILESYSTEM_ASSET },
175 { MEDIA_DIROPRN, OperationObject::FILESYSTEM_DIR },
176 { MEDIA_ALBUMOPRN, OperationObject::FILESYSTEM_ALBUM },
177 { MEDIA_SMARTALBUMOPRN, OperationObject::SMART_ALBUM },
178 { MEDIA_SMARTALBUMMAPOPRN, OperationObject::SMART_ALBUM_MAP },
179 { THU_OPRN_GENERATES, OperationObject::THUMBNAIL },
180 { THU_OPRN_AGING, OperationObject::THUMBNAIL },
181 { DISTRIBUTE_THU_OPRN_AGING, OperationObject::THUMBNAIL },
182 { DISTRIBUTE_THU_OPRN_CREATE, OperationObject::THUMBNAIL },
183 { BUNDLE_PERMISSION_INSERT, OperationObject::BUNDLE_PERMISSION },
184
185 // use in Query...
186 { MEDIATYPE_DIRECTORY_TABLE, OperationObject::FILESYSTEM_DIR },
187 { MEDIA_DATA_DB_THUMBNAIL, OperationObject::THUMBNAIL },
188 { SMARTABLUMASSETS_VIEW_NAME, OperationObject::SMART_ABLUM_ASSETS },
189 { ASSETMAP_VIEW_NAME, OperationObject::ASSETMAP },
190 { MEDIA_DEVICE_QUERYALLDEVICE, OperationObject::ALL_DEVICE },
191 { MEDIA_DEVICE_QUERYACTIVEDEVICE, OperationObject::ACTIVE_DEVICE },
192 { MEDIA_ALBUMOPRN_QUERYALBUM, OperationObject::FILESYSTEM_ALBUM },
193 { SMARTALBUM_TABLE, OperationObject::SMART_ALBUM },
194 { SMARTALBUM_MAP_TABLE, OperationObject::SMART_ALBUM_MAP },
195 { MEDIA_QUERYOPRN_QUERYVOLUME, OperationObject::MEDIA_VOLUME },
196 { BUNDLE_PERMISSION_TABLE, OperationObject::BUNDLE_PERMISSION },
197 };
198
199 for (const auto &item : oprnMap) {
200 if (uri.find(item.first) != string::npos) {
201 oprnObject_ = item.second;
202 break;
203 }
204 }
205 }
206
ParseOprnTypeFromUri()207 void MediaLibraryCommand::ParseOprnTypeFromUri()
208 {
209 string insertUri = uri_.ToString();
210 auto found = insertUri.rfind('/');
211 if (found == string::npos) {
212 return;
213 }
214 string oprnName = insertUri.substr(found + 1);
215 const static map<string, OperationType> oprnTypeMap = {
216 { MEDIA_FILEOPRN_CLOSEASSET, OperationType::CLOSE },
217 { MEDIA_FILEOPRN_CREATEASSET, OperationType::CREATE },
218 { MEDIA_ALBUMOPRN_CREATEALBUM, OperationType::CREATE },
219 { MEDIA_FILEOPRN_DELETEASSET, OperationType::DELETE },
220 { MEDIA_ALBUMOPRN_DELETEALBUM, OperationType::DELETE },
221 { MEDIA_FILEOPRN_MODIFYASSET, OperationType::UPDATE },
222 { MEDIA_ALBUMOPRN_MODIFYALBUM, OperationType::UPDATE },
223 { MEDIA_ALBUMOPRN_QUERYALBUM, OperationType::QUERY },
224 { MEDIA_FILEOPRN_ISDIRECTORY, OperationType::ISDICTIONARY },
225 { MEDIA_FILEOPRN_GETALBUMCAPACITY, OperationType::QUERY },
226 { MEDIA_QUERYOPRN_QUERYVOLUME, OperationType::QUERY },
227 { MEDIA_BOARDCASTOPRN, OperationType::SCAN },
228 { THU_OPRN_GENERATES, OperationType::GENERATE },
229 { THU_OPRN_AGING, OperationType::AGING },
230 { DISTRIBUTE_THU_OPRN_AGING, OperationType::DISTRIBUTE_AGING },
231 { DISTRIBUTE_THU_OPRN_CREATE, OperationType::DISTRIBUTE_CREATE },
232 { BUNDLE_PERMISSION_INSERT, OperationType::INSERT_PERMISSION }
233 };
234
235 if (oprnTypeMap.find(oprnName) != oprnTypeMap.end()) {
236 oprnType_ = oprnTypeMap.at(oprnName);
237 }
238 MEDIA_DEBUG_LOG("Command operation type is %{public}d", oprnType_);
239 }
240
ParseTableName()241 void MediaLibraryCommand::ParseTableName()
242 {
243 static const map<OperationObject, map<OperationType, string>> tableNameMap = {
244 { OperationObject::SMART_ALBUM, { { OperationType::UNKNOWN_TYPE, SMARTALBUM_TABLE } } },
245 { OperationObject::SMART_ALBUM_MAP, { { OperationType::UNKNOWN_TYPE, SMARTALBUM_MAP_TABLE } } },
246 { OperationObject::SMART_ABLUM_ASSETS, { { OperationType::UNKNOWN_TYPE, SMARTABLUMASSETS_VIEW_NAME } } },
247 { OperationObject::ASSETMAP, { { OperationType::UNKNOWN_TYPE, ASSETMAP_VIEW_NAME } } },
248 { OperationObject::FILESYSTEM_DIR, { { OperationType::QUERY, MEDIATYPE_DIRECTORY_TABLE } } },
249 { OperationObject::FILESYSTEM_ALBUM, { { OperationType::QUERY, ABLUM_VIEW_NAME } } },
250 { OperationObject::ALL_DEVICE, { { OperationType::UNKNOWN_TYPE, DEVICE_TABLE } } },
251 { OperationObject::ACTIVE_DEVICE, { { OperationType::UNKNOWN_TYPE, DEVICE_TABLE } } },
252 { OperationObject::BUNDLE_PERMISSION, { { OperationType::UNKNOWN_TYPE, BUNDLE_PERMISSION_TABLE } } },
253 };
254
255 if (tableNameMap.find(oprnObject_) != tableNameMap.end()) {
256 auto cmdObj = tableNameMap.at(oprnObject_);
257 if (cmdObj.find(oprnType_) != cmdObj.end()) {
258 tableName_ = cmdObj.at(oprnType_);
259 } else if (cmdObj.find(OperationType::UNKNOWN_TYPE) != cmdObj.end()) {
260 tableName_ = cmdObj.at(OperationType::UNKNOWN_TYPE);
261 } else {
262 tableName_ = MEDIALIBRARY_TABLE;
263 }
264 } else {
265 tableName_ = MEDIALIBRARY_TABLE;
266 }
267
268 // distributed tablename
269 auto networkId = GetOprnDevice();
270 if (networkId.empty()) {
271 return;
272 }
273 auto rdbStore = MediaLibraryUnistoreManager::GetInstance().GetRdbStoreRaw();
274 if (rdbStore != nullptr) {
275 auto rdbStorePtr = rdbStore->GetRaw();
276 int errCode = E_ERR;
277 if (rdbStorePtr != nullptr) {
278 tableName_ = rdbStorePtr->ObtainDistributedTableName(networkId, MEDIALIBRARY_TABLE, errCode);
279 }
280 }
281 MEDIA_INFO_LOG("Table name is %{public}s", tableName_.c_str());
282 }
283
InitAbsRdbPredicates()284 void MediaLibraryCommand::InitAbsRdbPredicates()
285 {
286 if (tableName_.empty()) {
287 ParseTableName();
288 }
289 absRdbPredicates_ = make_unique<AbsRdbPredicates>(tableName_);
290 }
291
ParseFileId()292 void MediaLibraryCommand::ParseFileId()
293 {
294 int32_t fileIdInValue = -1;
295 ValueObject valueObject;
296 if (insertValue_.GetObject(MEDIA_DATA_DB_ID, valueObject)) {
297 valueObject.GetInt(fileIdInValue);
298 }
299 if (fileIdInValue != -1) {
300 oprnFileId_ = to_string(fileIdInValue);
301 return;
302 }
303 string uriInValue;
304 if (insertValue_.GetObject(MEDIA_DATA_DB_URI, valueObject)) {
305 valueObject.GetString(uriInValue);
306 }
307 if (uriInValue.empty()) {
308 uriInValue = uri_.ToString();
309 }
310 MediaLibraryDataManagerUtils::RemoveTypeValueFromUri(uriInValue);
311 string idFromUri = MediaLibraryDataManagerUtils::GetIdFromUri(uriInValue);
312 if (!MediaLibraryDataManagerUtils::IsNumber(idFromUri)) {
313 return;
314 }
315 oprnFileId_ = idFromUri;
316 }
317 } // namespace Media
318 } // namespace OHOS
319