1 /*
2  * Copyright (C) 2021-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 #define MLOG_TAG "MtpMedialibraryManager"
16 #include "mtp_medialibrary_manager.h"
17 
18 #include <unistd.h>
19 #include "datashare_predicates.h"
20 #include "datashare_abs_result_set.h"
21 #include "datashare_result_set.h"
22 #include "directory_ex.h"
23 #include "fetch_result.h"
24 #include "image_format_convert.h"
25 #include "image_packer.h"
26 #include "image_source.h"
27 #include "media_column.h"
28 #include "mtp_data_utils.h"
29 #include "media_file_utils.h"
30 #include "media_mtp_utils.h"
31 #include "mtp_error_utils.h"
32 #include "media_library_manager.h"
33 #include "media_log.h"
34 #include "medialibrary_errno.h"
35 #include "media_smart_map_column.h"
36 #include "moving_photo_file_utils.h"
37 #include "photo_album_column.h"
38 #include "ptp_media_sync_observer.h"
39 #include "pixel_map.h"
40 #include "ptp_album_handles.h"
41 #include "ptp_medialibrary_manager_uri.h"
42 #include "system_ability_definition.h"
43 #include "userfilemgr_uri.h"
44 
45 using namespace std;
46 
47 namespace OHOS {
48 namespace Media {
49 struct CopyNewAssetParams {
50     int32_t fileId;
51     int32_t albumId;
52     string title;
53     string displayName;
54     uint32_t &outObjectHandle;
55     std::shared_ptr<DataShare::DataShareHelper> &dataShareHelper;
56 };
57 
58 sptr<IRemoteObject> MtpMedialibraryManager::getThumbToken_ = nullptr;
59 constexpr int32_t NORMAL_WIDTH = 256;
60 constexpr int32_t NORMAL_HEIGHT = 256;
61 constexpr int32_t COMPRE_SIZE_LEVEL_1 = 256;
62 constexpr int32_t COMPRE_SIZE_LEVEL_2 = 204800;
63 constexpr size_t SIZE_ONE = 1;
64 const string NORMAL_MEDIA_URI = "file://media/Photo/";
65 const string THUMBNAIL_FORMAT = "image/jpeg";
66 static constexpr uint8_t THUMBNAIL_MID = 90;
67 constexpr int32_t PARENT_ID = 0;
68 const string API_VERSION = "api_version";
69 const string POSITION_CLOUD_FLAG = "2";
70 const string IS_LOCAL = "2";
71 const string ALBUM_MEDIA_TYPE = "7";
72 const int64_t DATE_UNTRASHED = 0;
73 const int32_t SPECIAL_PTHOTO_TYPE = 2;
74 const std::string PARENT = "parent";
75 const std::string HIDDEN_ALBUM = ".hiddenAlbum";
76 const string BURST_COVER_LEVEL = "1";
77 const string EMPTY_COLUMN_NAME = "0";
78 const string PARENT_ID_STRING = "0";
79 
80 std::shared_ptr<MtpMedialibraryManager> MtpMedialibraryManager::instance_ = nullptr;
81 std::mutex MtpMedialibraryManager::mutex_;
82 shared_ptr<DataShare::DataShareHelper> MtpMedialibraryManager::dataShareHelper_ = nullptr;
83 std::shared_ptr<MediaSyncObserver> mediaPhotoObserver_ = nullptr;
MtpMedialibraryManager(void)84 MtpMedialibraryManager::MtpMedialibraryManager(void)
85 {
86 }
87 
~MtpMedialibraryManager(void)88 MtpMedialibraryManager::~MtpMedialibraryManager(void)
89 {
90 }
91 
GetInstance()92 std::shared_ptr<MtpMedialibraryManager> MtpMedialibraryManager::GetInstance()
93 {
94     if (instance_ == nullptr) {
95         std::lock_guard<std::mutex> lock(mutex_);
96         if (instance_ == nullptr) {
97             instance_ = std::make_shared<MtpMedialibraryManager>();
98         }
99     }
100     return instance_;
101 }
102 
Init(const sptr<IRemoteObject> & token,const std::shared_ptr<MtpOperationContext> & context)103 void MtpMedialibraryManager::Init(const sptr<IRemoteObject> &token, const std::shared_ptr<MtpOperationContext> &context)
104 {
105     if (dataShareHelper_ == nullptr) {
106         dataShareHelper_ = DataShare::DataShareHelper::Creator(token, MEDIALIBRARY_DATA_URI);
107     }
108     if (mediaPhotoObserver_ == nullptr) {
109         mediaPhotoObserver_ = std::make_shared<MediaSyncObserver>();
110     }
111     getThumbToken_ = token;
112     mediaPhotoObserver_->context_ = context;
113     mediaPhotoObserver_->dataShareHelper_ = dataShareHelper_;
114     mediaPhotoObserver_->StartNotifyThread();
115     dataShareHelper_->RegisterObserverExt(Uri(PhotoColumn::PHOTO_URI_PREFIX), mediaPhotoObserver_, true);
116     dataShareHelper_->RegisterObserverExt(Uri(PhotoAlbumColumns::ALBUM_URI_PREFIX), mediaPhotoObserver_, true);
117 }
118 
Clear()119 void MtpMedialibraryManager::Clear()
120 {
121     MEDIA_INFO_LOG("MtpMediaLibrary::Ptp Clear is called");
122     if (mediaPhotoObserver_ != nullptr) {
123         mediaPhotoObserver_->StopNotifyThread();
124     }
125     if (dataShareHelper_ != nullptr) {
126         dataShareHelper_->UnregisterObserverExt(Uri(PhotoColumn::PHOTO_URI_PREFIX), mediaPhotoObserver_);
127         dataShareHelper_->UnregisterObserverExt(Uri(PhotoAlbumColumns::ALBUM_URI_PREFIX), mediaPhotoObserver_);
128     }
129     mediaPhotoObserver_ = nullptr;
130     dataShareHelper_ = nullptr;
131 }
132 
GetHandles(int32_t parentId,vector<int> & outHandles,MediaType mediaType)133 int32_t MtpMedialibraryManager::GetHandles(int32_t parentId, vector<int> &outHandles, MediaType mediaType)
134 {
135     shared_ptr<DataShare::DataShareResultSet> resultSet;
136     DataShare::DataSharePredicates predicates;
137     vector<string> columns;
138     CHECK_AND_RETURN_RET_LOG(dataShareHelper_ != nullptr,
139         MtpErrorUtils::SolveGetHandlesError(E_HAS_DB_ERROR), "fail to get datasharehelper");
140     if (parentId == PARENT_ID) {
141         Uri uri(PAH_QUERY_PHOTO_ALBUM);
142         columns.push_back(PhotoAlbumColumns::ALBUM_ID + " as " + MEDIA_DATA_DB_ID);
143         columns.push_back(PhotoAlbumColumns::ALBUM_NAME + " as " + MEDIA_DATA_DB_NAME);
144         columns.push_back(ALBUM_MEDIA_TYPE + " as " + MEDIA_DATA_DB_MEDIA_TYPE);
145         columns.push_back(PhotoAlbumColumns::ALBUM_DATE_MODIFIED);
146         columns.push_back(EMPTY_COLUMN_NAME + " as " + MEDIA_DATA_DB_SIZE);
147         columns.push_back(EMPTY_COLUMN_NAME + " as " + MEDIA_DATA_DB_PARENT_ID);
148         columns.push_back(PhotoAlbumColumns::ALBUM_DATE_ADDED);
149         predicates.IsNotNull(MEDIA_DATA_DB_ALBUM_NAME);
150         predicates.NotEqualTo(MEDIA_DATA_DB_ALBUM_NAME, HIDDEN_ALBUM);
151         predicates.NotEqualTo(MEDIA_DATA_DB_IS_LOCAL, IS_LOCAL);
152         resultSet = dataShareHelper_->Query(uri, predicates, columns);
153     } else {
154         Uri uri(PAH_QUERY_PHOTO);
155         columns.push_back(MediaColumn::MEDIA_ID + " + " + to_string(COMMON_PHOTOS_OFFSET) + " as " + MEDIA_DATA_DB_ID);
156         columns.push_back(MediaColumn::MEDIA_SIZE);
157         columns.push_back(MediaColumn::MEDIA_NAME);
158         columns.push_back(PhotoColumn::PHOTO_OWNER_ALBUM_ID +" as " + PARENT);
159         columns.push_back(MediaColumn::MEDIA_DATE_ADDED);
160         columns.push_back(MediaColumn::MEDIA_DURATION);
161         columns.push_back(MediaColumn::MEDIA_TYPE);
162         columns.push_back(PhotoColumn::PHOTO_SUBTYPE);
163         columns.push_back(EMPTY_COLUMN_NAME + " as " + MEDIA_DATA_DB_NAME);
164         DataShare::DataSharePredicates predicates;
165         predicates.EqualTo(PhotoColumn::PHOTO_OWNER_ALBUM_ID, to_string(parentId));
166         predicates.NotEqualTo(PhotoColumn::PHOTO_POSITION, POSITION_CLOUD_FLAG);
167         predicates.EqualTo(MediaColumn::MEDIA_DATE_TRASHED, "0");
168         predicates.EqualTo(MediaColumn::MEDIA_TIME_PENDING, "0");
169         predicates.EqualTo(MediaColumn::MEDIA_HIDDEN, "0");
170         resultSet = dataShareHelper_->Query(uri, predicates, columns);
171     }
172     CHECK_AND_RETURN_RET_LOG(resultSet != nullptr,
173         MtpErrorUtils::SolveGetHandlesError(E_NO_SUCH_FILE), "fail to get handles");
174     CHECK_AND_RETURN_RET_LOG(resultSet->GoToFirstRow() == NativeRdb::E_OK,
175         MtpErrorUtils::SolveGetHandlesError(E_SUCCESS), "have no handles");
176     while (resultSet->GoToNextRow() == NativeRdb::E_OK) {
177         int32_t id = GetInt32Val(MediaColumn::MEDIA_ID, resultSet);
178         outHandles.push_back(id);
179     }
180     resultSet->GoToFirstRow();
181     return MtpErrorUtils::SolveGetHandlesError(E_SUCCESS);
182 }
183 
GetAlbumCloud()184 int32_t MtpMedialibraryManager::GetAlbumCloud()
185 {
186     CHECK_AND_RETURN_RET_LOG(dataShareHelper_ != nullptr,
187         MtpErrorUtils::SolveGetFdError(E_HAS_DB_ERROR), "fail to get datasharehelper");
188     DataShare::DataSharePredicates predicatesCloud;
189     Uri uri(PAH_QUERY_PHOTO_ALBUM);
190     vector<string> columnsCloud;
191     columnsCloud.push_back(PhotoAlbumColumns::ALBUM_ID + " as " + MEDIA_DATA_DB_ID);
192     predicatesCloud.EqualTo(MEDIA_DATA_DB_IS_LOCAL, IS_LOCAL);
193     shared_ptr<DataShare::DataShareResultSet> resultSetcloud = dataShareHelper_->Query(uri, predicatesCloud,
194         columnsCloud);
195     CHECK_AND_RETURN_RET_LOG(resultSetcloud != nullptr,
196         MtpErrorUtils::SolveGetHandlesError(E_HAS_DB_ERROR), "fail to GetAlbumCloud");
197     int cloudCount = 0;
198     resultSetcloud->GetRowCount(cloudCount);
199     MEDIA_INFO_LOG("MtpMedialibraryManager::GetAlbumCloud cloudCount:%{public}d", cloudCount);
200     resultSetcloud->Close();
201     return MTP_SUCCESS;
202 }
203 
GetAlbumCloudDisplay(vector<string> & ownerAlbumIds)204 int32_t MtpMedialibraryManager::GetAlbumCloudDisplay(vector<string> &ownerAlbumIds)
205 {
206     CHECK_AND_RETURN_RET_LOG(dataShareHelper_ != nullptr,
207         MtpErrorUtils::SolveGetFdError(E_HAS_DB_ERROR), "fail to get datasharehelper");
208     DataShare::DataSharePredicates predicatesCloudDisplay;
209     vector<string> columnsCloudDisplay;
210     Uri uri(PAH_QUERY_PHOTO_ALBUM);
211     columnsCloudDisplay.push_back(PhotoAlbumColumns::ALBUM_ID + " as " + MEDIA_DATA_DB_ID);
212     predicatesCloudDisplay.IsNotNull(MEDIA_DATA_DB_ALBUM_NAME);
213     predicatesCloudDisplay.NotEqualTo(MEDIA_DATA_DB_ALBUM_NAME, HIDDEN_ALBUM);
214     predicatesCloudDisplay.EqualTo(MEDIA_DATA_DB_IS_LOCAL, IS_LOCAL);
215     predicatesCloudDisplay.In(PhotoAlbumColumns::ALBUM_ID, ownerAlbumIds);
216     shared_ptr<DataShare::DataShareResultSet> resultSetcloudDisplay = dataShareHelper_->Query(uri,
217         predicatesCloudDisplay, columnsCloudDisplay);
218     CHECK_AND_RETURN_RET_LOG(resultSetcloudDisplay != nullptr,
219         MtpErrorUtils::SolveGetHandlesError(E_HAS_DB_ERROR), "fail to GetAlbumCloudDisplay");
220     int cloudCountDisplay = 0;
221     resultSetcloudDisplay->GetRowCount(cloudCountDisplay);
222     MEDIA_INFO_LOG("MtpMedialibraryManager::GetAlbumCloudDisplay cloudCountDisplay:%{public}d", cloudCountDisplay);
223     resultSetcloudDisplay->Close();
224     return MTP_SUCCESS;
225 }
226 
GetAlbumInfo(const shared_ptr<MtpOperationContext> & context,bool isHandle)227 shared_ptr<DataShare::DataShareResultSet> MtpMedialibraryManager::GetAlbumInfo(
228     const shared_ptr<MtpOperationContext> &context, bool isHandle)
229 {
230     CHECK_AND_RETURN_RET_LOG(context != nullptr, nullptr, "context is nullptr");
231     CHECK_AND_RETURN_RET_LOG(dataShareHelper_ != nullptr, nullptr, "GetAlbumInfo fail to get datasharehelper");
232     DataShare::DataSharePredicates predicates;
233     Uri uri(PAH_QUERY_PHOTO_ALBUM);
234     vector<string> columns;
235     columns.push_back(PhotoAlbumColumns::ALBUM_ID + " as " + MEDIA_DATA_DB_ID);
236     columns.push_back(PhotoAlbumColumns::ALBUM_NAME + " as " + MEDIA_DATA_DB_NAME);
237     columns.push_back(ALBUM_MEDIA_TYPE + " as " + MEDIA_DATA_DB_MEDIA_TYPE);
238     columns.push_back(PhotoAlbumColumns::ALBUM_DATE_MODIFIED);
239     columns.push_back(PARENT_ID_STRING + " as " + PARENT);
240     columns.push_back(EMPTY_COLUMN_NAME + " as " + MEDIA_DATA_DB_SIZE);
241     columns.push_back(PhotoAlbumColumns::ALBUM_DATE_ADDED);
242     if (!isHandle) {
243         predicates.EqualTo(MEDIA_DATA_DB_ALBUM_ID, to_string(context->handle));
244         return dataShareHelper_->Query(uri, predicates, columns);
245     }
246     vector<string> ownerAlbumIds;
247     shared_ptr<DataShare::DataShareResultSet> resultSet = GetOwnerAlbumIdList();
248     CHECK_AND_RETURN_RET_LOG(resultSet != nullptr, nullptr, "fail to GetPhotosInfo");
249     while (resultSet->GoToNextRow() == NativeRdb::E_OK) {
250         string ownerAlbumId = GetStringVal(PhotoColumn::PHOTO_OWNER_ALBUM_ID, resultSet);
251         ownerAlbumIds.push_back(ownerAlbumId);
252     }
253     int32_t errCode = GetAlbumCloud();
254     CHECK_AND_RETURN_RET_LOG(errCode == MTP_SUCCESS, nullptr, "fail to GetAlbumCloud");
255     errCode = GetAlbumCloudDisplay(ownerAlbumIds);
256     CHECK_AND_RETURN_RET_LOG(errCode == MTP_SUCCESS, nullptr, "fail to GetAlbumCloudDisplay");
257     predicates.BeginWrap();
258     predicates.IsNotNull(MEDIA_DATA_DB_ALBUM_NAME);
259     predicates.NotEqualTo(MEDIA_DATA_DB_ALBUM_NAME, HIDDEN_ALBUM);
260     predicates.BeginWrap();
261     predicates.NotEqualTo(MEDIA_DATA_DB_IS_LOCAL, IS_LOCAL);
262     predicates.Or();
263     predicates.IsNull(MEDIA_DATA_DB_IS_LOCAL);
264     predicates.EndWrap();
265     predicates.EndWrap();
266     predicates.Or();
267     predicates.In(PhotoAlbumColumns::ALBUM_ID, ownerAlbumIds);
268     shared_ptr<DataShare::DataShareResultSet> resultSetAll = dataShareHelper_->Query(uri, predicates, columns);
269     CHECK_AND_RETURN_RET_LOG(resultSetAll != nullptr, nullptr, "fail to GetAlbumInfo");
270     int count = 0;
271     resultSetAll->GetRowCount(count);
272     MEDIA_INFO_LOG("MtpMedialibraryManager::GetAlbumInfo count:%{public}d", count);
273     return resultSetAll;
274 }
275 
GetOwnerAlbumIdList()276 std::shared_ptr<DataShare::DataShareResultSet> MtpMedialibraryManager::GetOwnerAlbumIdList()
277 {
278     Uri uri(PAH_QUERY_PHOTO);
279     vector<string> columns;
280     columns.push_back(PhotoColumn::PHOTO_OWNER_ALBUM_ID);
281     DataShare::DataSharePredicates predicates;
282     predicates.NotEqualTo(PhotoColumn::PHOTO_POSITION, POSITION_CLOUD_FLAG);
283     predicates.EqualTo(MediaColumn::MEDIA_DATE_TRASHED, "0");
284     predicates.EqualTo(MediaColumn::MEDIA_TIME_PENDING, "0");
285     predicates.EqualTo(MediaColumn::MEDIA_HIDDEN, "0");
286     predicates.Distinct();
287     return dataShareHelper_->Query(uri, predicates, columns);
288 }
289 
GetPhotosInfo(const shared_ptr<MtpOperationContext> & context,bool isHandle)290 shared_ptr<DataShare::DataShareResultSet> MtpMedialibraryManager::GetPhotosInfo(
291     const shared_ptr<MtpOperationContext> &context, bool isHandle)
292 {
293     CHECK_AND_RETURN_RET_LOG(context != nullptr, nullptr, "context is nullptr");
294     CHECK_AND_RETURN_RET_LOG(dataShareHelper_ != nullptr, nullptr,
295         "MtpMedialibraryManager::GetPhotosInfo fail to get datasharehelper");
296     Uri uri(PAH_QUERY_PHOTO);
297     vector<string> columns;
298     columns.push_back(MediaColumn::MEDIA_ID + " + " + to_string(COMMON_PHOTOS_OFFSET) + " as " + MEDIA_DATA_DB_ID);
299     columns.push_back(MediaColumn::MEDIA_SIZE);
300     columns.push_back(MediaColumn::MEDIA_NAME);
301     columns.push_back(PhotoColumn::PHOTO_OWNER_ALBUM_ID +" as " + PARENT);
302     columns.push_back(MediaColumn::MEDIA_DATE_ADDED);
303     columns.push_back(MediaColumn::MEDIA_DURATION);
304     columns.push_back(MediaColumn::MEDIA_TYPE);
305     columns.push_back(MediaColumn::MEDIA_FILE_PATH);
306     columns.push_back(PhotoColumn::PHOTO_SUBTYPE);
307     columns.push_back(PhotoColumn::MEDIA_DATE_MODIFIED);
308     columns.push_back(PhotoColumn::PHOTO_THUMB_SIZE);
309     DataShare::DataSharePredicates predicates;
310     if (isHandle) {
311         vector<string> burstKeys = GetBurstKeyFromPhotosInfo();
312         predicates.EqualTo(PhotoColumn::PHOTO_OWNER_ALBUM_ID, to_string(context->parent));
313         predicates.NotEqualTo(PhotoColumn::PHOTO_POSITION, POSITION_CLOUD_FLAG);
314         predicates.EqualTo(MediaColumn::MEDIA_DATE_TRASHED, "0");
315         predicates.EqualTo(MediaColumn::MEDIA_TIME_PENDING, "0");
316         predicates.EqualTo(MediaColumn::MEDIA_HIDDEN, "0");
317         if (!burstKeys.empty()) {
318             predicates.BeginWrap()
319                 ->BeginWrap()
320                 ->NotIn(PhotoColumn::PHOTO_BURST_KEY, burstKeys)
321                 ->Or()
322                 ->IsNull(PhotoColumn::PHOTO_BURST_KEY)
323                 ->EndWrap()
324                 ->Or()
325                 ->EqualTo(PhotoColumn::PHOTO_BURST_COVER_LEVEL, BURST_COVER_LEVEL)
326                 ->EndWrap();
327         }
328     } else {
329         int32_t file_id = static_cast<int32_t>(context->handle % COMMON_PHOTOS_OFFSET);
330         predicates.EqualTo(PhotoColumn::MEDIA_ID, to_string(file_id));
331     }
332     return dataShareHelper_->Query(uri, predicates, columns);
333 }
334 
GetBurstKeyFromPhotosInfo()335 vector<string> MtpMedialibraryManager::GetBurstKeyFromPhotosInfo()
336 {
337     CHECK_AND_RETURN_RET_LOG(dataShareHelper_ != nullptr, vector<string>(),
338         "MtpMedialibraryManager::GetBurstKeyFromPhotosInfo fail to get datasharehelper");
339     vector<string> bustKeys;
340     Uri uri(PAH_QUERY_PHOTO);
341     vector<string> columns;
342     columns.push_back(PhotoColumn::PHOTO_BURST_KEY);
343     DataShare::DataSharePredicates predicates;
344     predicates.NotEqualTo(PhotoColumn::MEDIA_DATE_TRASHED, "0");
345     predicates.EqualTo(PhotoColumn::PHOTO_BURST_COVER_LEVEL, BURST_COVER_LEVEL);
346     predicates.IsNotNull(PhotoColumn::PHOTO_BURST_KEY);
347     shared_ptr<DataShare::DataShareResultSet> resultSet = dataShareHelper_->Query(uri, predicates, columns);
348     CHECK_AND_RETURN_RET_LOG(resultSet != nullptr,
349         vector<string>(), "fail to get handles");
350     CHECK_AND_RETURN_RET_LOG(resultSet->GoToFirstRow() == NativeRdb::E_OK,
351         vector<string>(), "have no handles");
352     do {
353         string bustKey = GetStringVal(PhotoColumn::PHOTO_BURST_KEY, resultSet);
354         bustKeys.push_back(bustKey);
355     } while (resultSet->GoToNextRow() == NativeRdb::E_OK);
356     return bustKeys;
357 }
358 
HaveMovingPhotesHandle(const shared_ptr<DataShare::DataShareResultSet> resultSet,shared_ptr<UInt32List> & outHandles,const uint32_t parent)359 int32_t MtpMedialibraryManager::HaveMovingPhotesHandle(const shared_ptr<DataShare::DataShareResultSet> resultSet,
360     shared_ptr<UInt32List> &outHandles, const uint32_t parent)
361 {
362     CHECK_AND_RETURN_RET_LOG(resultSet != nullptr, E_HAS_DB_ERROR, "resultSet is nullptr");
363 
364     CHECK_AND_RETURN_RET_LOG(resultSet->GoToFirstRow() == NativeRdb::E_OK, E_SUCCESS, "have no handles");
365     do {
366         uint32_t id = static_cast<uint32_t>(GetInt32Val(MediaColumn::MEDIA_ID, resultSet));
367         outHandles->push_back(id);
368         if (id < COMMON_PHOTOS_OFFSET) {
369             continue;
370         }
371         int32_t subtype = GetInt32Val(PhotoColumn::PHOTO_SUBTYPE, resultSet);
372         if (subtype == static_cast<int32_t>(PhotoSubType::MOVING_PHOTO)) {
373             uint32_t videoId = id + (COMMON_MOVING_OFFSET - COMMON_PHOTOS_OFFSET);
374             outHandles->push_back(videoId);
375         }
376     } while (resultSet->GoToNextRow() == NativeRdb::E_OK);
377     return E_SUCCESS;
378 }
379 
GetHandles(const shared_ptr<MtpOperationContext> & context,shared_ptr<UInt32List> & outHandles)380 int32_t MtpMedialibraryManager::GetHandles(const shared_ptr<MtpOperationContext> &context,
381     shared_ptr<UInt32List> &outHandles)
382 {
383     string extension;
384     MediaType mediaType;
385     CHECK_AND_RETURN_RET_LOG(context != nullptr,
386         MtpErrorUtils::SolveGetHandlesError(E_HAS_DB_ERROR), "context is nullptr");
387     CHECK_AND_RETURN_RET_LOG(dataShareHelper_ != nullptr,
388         MtpErrorUtils::SolveGetHandlesError(E_HAS_DB_ERROR), "fail to get datasharehelper");
389     int32_t errCode = MtpDataUtils::SolveHandlesFormatData(context->format, extension, mediaType);
390     CHECK_AND_RETURN_RET_LOG(errCode == MTP_SUCCESS,
391         MtpErrorUtils::SolveGetHandlesError(errCode), "fail to SolveHandlesFormatData");
392     shared_ptr<DataShare::DataShareResultSet> resultSet;
393     if (context->parent == PARENT_ID) {
394         resultSet = GetAlbumInfo(context, true);
395         auto albumHandles = PtpAlbumHandles::GetInstance();
396         if (albumHandles != nullptr) {
397             albumHandles->AddAlbumHandles(resultSet);
398         }
399         CHECK_AND_RETURN_RET_LOG(resultSet != nullptr,
400             MtpErrorUtils::SolveGetHandlesError(E_HAS_DB_ERROR), "fail to get handles");
401         CHECK_AND_RETURN_RET_LOG(resultSet->GoToFirstRow() == NativeRdb::E_OK, E_SUCCESS, "have no handles");
402         do {
403             int32_t id = GetInt32Val(MediaColumn::MEDIA_ID, resultSet);
404             outHandles->push_back(id);
405         } while (resultSet->GoToNextRow() == NativeRdb::E_OK);
406         return MtpErrorUtils::SolveGetHandlesError(E_SUCCESS);
407     }
408     resultSet = GetPhotosInfo(context, true);
409     errCode = HaveMovingPhotesHandle(resultSet, outHandles, context->parent);
410     return MtpErrorUtils::SolveGetHandlesError(errCode);
411 }
412 
GetObjectInfo(const shared_ptr<MtpOperationContext> & context,shared_ptr<ObjectInfo> & outObjectInfo)413 int32_t MtpMedialibraryManager::GetObjectInfo(const shared_ptr<MtpOperationContext> &context,
414     shared_ptr<ObjectInfo> &outObjectInfo)
415 {
416     CHECK_AND_RETURN_RET_LOG(context != nullptr,
417         MtpErrorUtils::SolveGetObjectInfoError(E_HAS_DB_ERROR), "context is nullptr");
418     CHECK_AND_RETURN_RET_LOG(dataShareHelper_ != nullptr,
419         MtpErrorUtils::SolveGetObjectInfoError(E_HAS_DB_ERROR), "fail to get datasharehelper");
420     DataShare::DataSharePredicates predicates;
421     MEDIA_INFO_LOG("GetObjectInfo %{public}d,%{public}d", context->handle, context ->parent);
422     shared_ptr<DataShare::DataShareResultSet> resultSet;
423     if (context->parent == PARENT_ID && context->handle < COMMON_PHOTOS_OFFSET) {
424         resultSet = GetAlbumInfo(context, false);
425     } else {
426         resultSet = GetPhotosInfo(context, false);
427     }
428     CHECK_AND_RETURN_RET_LOG(resultSet != nullptr,
429         MtpErrorUtils::SolveGetObjectInfoError(E_NO_SUCH_FILE), "fail to get object set");
430     CHECK_AND_RETURN_RET_LOG(resultSet->GoToFirstRow() == NativeRdb::E_OK,
431         MtpErrorUtils::SolveGetObjectInfoError(E_NO_SUCH_FILE), "have no handles");
432     return SetObject(resultSet, context, outObjectInfo);
433 }
434 
GetSizeFromOfft(const off_t & size)435 uint32_t MtpMedialibraryManager::GetSizeFromOfft(const off_t &size)
436 {
437     return size > std::numeric_limits<uint32_t>::max() ? std::numeric_limits<uint32_t>::max() : size;
438 }
439 
SetObject(const std::shared_ptr<DataShare::DataShareResultSet> & resultSet,const shared_ptr<MtpOperationContext> & context,std::shared_ptr<ObjectInfo> & outObjectInfo)440 int32_t MtpMedialibraryManager::SetObject(const std::shared_ptr<DataShare::DataShareResultSet> &resultSet,
441     const shared_ptr<MtpOperationContext> &context, std::shared_ptr<ObjectInfo> &outObjectInfo)
442 {
443     CHECK_AND_RETURN_RET_LOG(context != nullptr, MTP_ERROR_STORE_NOT_AVAILABLE, "context is nullptr");
444     CHECK_AND_RETURN_RET_LOG(resultSet != nullptr,
445         MtpErrorUtils::SolveGetHandlesError(E_HAS_DB_ERROR), "resultSet is nullptr");
446     do {
447         if (static_cast<int32_t>(context->handle / COMMON_PHOTOS_OFFSET) < SPECIAL_PTHOTO_TYPE) {
448             unique_ptr<FetchResult<FileAsset>> fetchFileResult = make_unique<FetchResult<FileAsset>>(resultSet);
449             CHECK_AND_RETURN_RET_LOG(fetchFileResult != nullptr,
450                 MTP_ERROR_INVALID_OBJECTHANDLE, "fetchFileResult is nullptr");
451             unique_ptr<FileAsset> fileAsset = fetchFileResult->GetFirstObject();
452             return SetObjectInfo(fileAsset, outObjectInfo);
453         }
454         string display_name = GetStringVal(MediaColumn::MEDIA_NAME, resultSet);
455         string data = GetStringVal(MediaColumn::MEDIA_FILE_PATH, resultSet);
456         int32_t subtype = GetInt32Val(PhotoColumn::PHOTO_SUBTYPE, resultSet);
457         string sourcePath = MtpDataUtils::GetMovingOrEnditSourcePath(data, subtype, context);
458         if (sourcePath.empty()) {
459             MEDIA_ERR_LOG("MtpMedialibraryManager::SetObject get sourcePath failed");
460             return MtpErrorUtils::SolveGetObjectInfoError(E_NO_SUCH_FILE);
461         }
462         outObjectInfo->handle = context->handle;
463         outObjectInfo->name = display_name;
464         outObjectInfo->parent = context->parent;
465         outObjectInfo->storageID = context->storageID;
466         struct stat statInfo;
467         CHECK_AND_RETURN_RET_LOG(stat(sourcePath.c_str(), &statInfo) == 0,
468             MtpErrorUtils::SolveGetObjectInfoError(E_NO_SUCH_FILE),
469             "MtpMedialibraryManager::SetObject stat failed");
470         outObjectInfo->size = GetSizeFromOfft(statInfo.st_size);
471         outObjectInfo->dateCreated = statInfo.st_ctime;
472         outObjectInfo->dateModified = statInfo.st_mtime;
473         outObjectInfo->thumbCompressedSize = COMPRE_SIZE_LEVEL_2;
474         outObjectInfo->thumbFormat = MTP_FORMAT_EXIF_JPEG_CODE;
475         outObjectInfo->thumbPixelHeight = NORMAL_HEIGHT;
476         outObjectInfo->thumbPixelWidth = NORMAL_WIDTH;
477     } while (resultSet->GoToNextRow() == NativeRdb::E_OK);
478     return MtpErrorUtils::SolveGetObjectInfoError(E_SUCCESS);
479 }
480 
SetObjectInfo(const unique_ptr<FileAsset> & fileAsset,shared_ptr<ObjectInfo> & outObjectInfo)481 int32_t MtpMedialibraryManager::SetObjectInfo(const unique_ptr<FileAsset> &fileAsset,
482     shared_ptr<ObjectInfo> &outObjectInfo)
483 {
484     CHECK_AND_RETURN_RET_LOG(outObjectInfo != nullptr,
485         MtpErrorUtils::SolveGetObjectInfoError(E_HAS_DB_ERROR), "outObjectInfo is nullptr");
486     outObjectInfo->handle = static_cast<uint32_t>(fileAsset->GetId());
487     outObjectInfo->name = fileAsset->GetDisplayName();
488     outObjectInfo->size = static_cast<uint32_t>(fileAsset->GetSize()); // need support larger than 4GB file
489     outObjectInfo->parent = static_cast<uint32_t>(fileAsset->GetParent());
490     outObjectInfo->dateCreated = fileAsset->GetDateAdded();
491     outObjectInfo->dateModified = fileAsset->GetDateModified();
492     outObjectInfo->storageID = DEFAULT_STORAGE_ID;
493     if (fileAsset->GetMediaType() == MEDIA_TYPE_ALBUM) {
494         outObjectInfo->format = MTP_FORMAT_ASSOCIATION_CODE;
495     } else if (fileAsset->GetMediaType() == MEDIA_TYPE_IMAGE) {
496         outObjectInfo->thumbCompressedSize = COMPRE_SIZE_LEVEL_1;
497         outObjectInfo->format = MTP_FORMAT_EXIF_JPEG_CODE;
498         outObjectInfo->storageID = DEFAULT_STORAGE_ID;
499         outObjectInfo->imagePixelHeight = static_cast<uint32_t>(fileAsset->GetHeight());
500         outObjectInfo->imagePixelWidth = static_cast<uint32_t>(fileAsset->GetWidth());
501         outObjectInfo->thumbCompressedSize = COMPRE_SIZE_LEVEL_2;
502         outObjectInfo->thumbFormat = MTP_FORMAT_EXIF_JPEG_CODE;
503         outObjectInfo->thumbPixelHeight = NORMAL_HEIGHT;
504         outObjectInfo->thumbPixelWidth = NORMAL_WIDTH;
505     } else if (fileAsset->GetMediaType() == MEDIA_TYPE_VIDEO) {
506         MEDIA_INFO_LOG("SetObjectInfo MEDIA_TYPE_VIDEO");
507         outObjectInfo->thumbCompressedSize = COMPRE_SIZE_LEVEL_1;
508         outObjectInfo->format = MTP_FORMAT_MPEG_CODE;
509         outObjectInfo->storageID = DEFAULT_STORAGE_ID;
510         outObjectInfo->imagePixelHeight = static_cast<uint32_t>(fileAsset->GetHeight());
511         outObjectInfo->imagePixelWidth = static_cast<uint32_t>(fileAsset->GetWidth());
512         outObjectInfo->thumbCompressedSize = COMPRE_SIZE_LEVEL_2;
513         outObjectInfo->thumbFormat = MTP_FORMAT_EXIF_JPEG_CODE;
514         outObjectInfo->thumbPixelHeight = NORMAL_HEIGHT;
515         outObjectInfo->thumbPixelWidth = NORMAL_WIDTH;
516     }
517     return MtpErrorUtils::SolveGetObjectInfoError(E_SUCCESS);
518 }
519 
GetFd(const shared_ptr<MtpOperationContext> & context,int32_t & outFd,const std::string & mode)520 int32_t MtpMedialibraryManager::GetFd(const shared_ptr<MtpOperationContext> &context, int32_t &outFd,
521     const std::string &mode)
522 {
523     CHECK_AND_RETURN_RET_LOG(context != nullptr,
524         MtpErrorUtils::SolveGetFdError(E_HAS_DB_ERROR), "context is nullptr");
525     MEDIA_DEBUG_LOG("GetFd  handle::%{public}u", context->handle);
526     CHECK_AND_RETURN_RET_LOG(dataShareHelper_ != nullptr,
527         MtpErrorUtils::SolveGetFdError(E_HAS_DB_ERROR), "fail to get datasharehelper");
528     shared_ptr<DataShare::DataShareResultSet> resultSet = GetPhotosInfo(context, false);
529     CHECK_AND_RETURN_RET_LOG(resultSet != nullptr,
530         MtpErrorUtils::SolveGetFdError(E_HAS_DB_ERROR), "fail to get handles");
531     std::string sourcePath;
532     CHECK_AND_RETURN_RET_LOG(resultSet->GoToFirstRow() == NativeRdb::E_OK,
533         MtpErrorUtils::SolveGetFdError(E_HAS_DB_ERROR), "have no row");
534     string data = GetStringVal(MediaColumn::MEDIA_FILE_PATH, resultSet);
535     if (context->handle > COMMON_MOVING_OFFSET) {
536         sourcePath = MovingPhotoFileUtils::GetMovingPhotoVideoPath(data);
537     } else {
538         sourcePath = data;
539     }
540     std::string realPath;
541     CHECK_AND_RETURN_RET_LOG(PathToRealPath(sourcePath, realPath),
542         MtpErrorUtils::SolveGetFdError(E_HAS_DB_ERROR), "fail to get realPath");
543     MEDIA_DEBUG_LOG("mtp Getfd realPath %{public}s", realPath.c_str());
544     std::error_code ec;
545     int openMode = (mode.compare(MEDIA_FILEMODE_READWRITE) == 0) ? O_RDWR : O_RDONLY;
546     outFd = open(realPath.c_str(), openMode);
547     if (outFd > 0) {
548         MEDIA_DEBUG_LOG("mtp GetFd outhd %{public}d", outFd);
549         return MtpErrorUtils::SolveGetFdError(E_SUCCESS);
550     } else {
551         return MtpErrorUtils::SolveGetFdError(E_HAS_FS_ERROR);
552     }
553 }
554 
GetFdByOpenFile(const shared_ptr<MtpOperationContext> & context,int32_t & outFd)555 int32_t MtpMedialibraryManager::GetFdByOpenFile(const shared_ptr<MtpOperationContext> &context, int32_t &outFd)
556 {
557     CHECK_AND_RETURN_RET_LOG(context != nullptr,
558         MtpErrorUtils::SolveGetFdError(E_HAS_DB_ERROR), "context is nullptr");
559     MEDIA_DEBUG_LOG("GetFdByOpenFile  handle::%{public}u", context->handle);
560     CHECK_AND_RETURN_RET_LOG(dataShareHelper_ != nullptr,
561         MtpErrorUtils::SolveGetFdError(E_HAS_DB_ERROR), "fail to get datasharehelper");
562     uint32_t id = context->handle % COMMON_PHOTOS_OFFSET;
563     string uri = URI_MTP_OPERATION + "/" + to_string(id);
564     MediaFileUtils::UriAppendKeyValue(uri, API_VERSION, to_string(MEDIA_API_VERSION_V10));
565     Uri openUri(uri);
566     outFd = dataShareHelper_->OpenFile(openUri, MEDIA_FILEMODE_READWRITE);
567 
568     if (outFd > 0) {
569         MEDIA_DEBUG_LOG("mtp GetFdByOpenFile outFd %{public}d", outFd);
570         return MtpErrorUtils::SolveGetFdError(E_SUCCESS);
571     } else {
572         return MtpErrorUtils::SolveGetFdError(E_HAS_FS_ERROR);
573     }
574 }
575 
CompressImage(std::unique_ptr<PixelMap> & pixelMap,std::vector<uint8_t> & data)576 bool MtpMedialibraryManager::CompressImage(std::unique_ptr<PixelMap> &pixelMap, std::vector<uint8_t> &data)
577 {
578     PackOption option = {
579         .format = THUMBNAIL_FORMAT,
580         .quality = THUMBNAIL_MID,
581         .numberHint = SIZE_ONE
582     };
583     CHECK_AND_RETURN_RET_LOG(pixelMap != nullptr, MTP_ERROR_NO_THUMBNAIL_PRESENT, "pixelMap is nullptr");
584     data.resize(pixelMap->GetByteCount());
585     ImagePacker imagePacker;
586     uint32_t errorCode = imagePacker.StartPacking(data.data(), data.size(), option);
587     CHECK_AND_RETURN_RET_LOG(errorCode == E_SUCCESS, false, "Failed to StartPacking %{public}d", errorCode);
588     errorCode = imagePacker.AddImage(*pixelMap);
589     CHECK_AND_RETURN_RET_LOG(errorCode == E_SUCCESS, false, "Failed to AddImage %{public}d", errorCode);
590     int64_t packedSize = 0;
591     errorCode = imagePacker.FinalizePacking(packedSize);
592     CHECK_AND_RETURN_RET_LOG(errorCode == E_SUCCESS, false, "Failed to FinalizePacking %{public}d", errorCode);
593 
594     data.resize(packedSize);
595     return true;
596 }
597 
GetThumb(const shared_ptr<MtpOperationContext> & context,shared_ptr<UInt8List> & outThumb)598 int32_t MtpMedialibraryManager::GetThumb(const shared_ptr<MtpOperationContext> &context,
599     shared_ptr<UInt8List> &outThumb)
600 {
601     CHECK_AND_RETURN_RET_LOG(context != nullptr, MTP_ERROR_STORE_NOT_AVAILABLE, "context is nullptr");
602     MEDIA_DEBUG_LOG("GetThumb handle::%{public}u", context->handle);
603     if (context->handle < COMMON_PHOTOS_OFFSET) {
604         MEDIA_INFO_LOG("handle is album");
605         return MTP_SUCCESS;
606     }
607     shared_ptr<DataShare::DataShareResultSet> resultSet = GetPhotosInfo(context, false);
608     CHECK_AND_RETURN_RET_LOG(resultSet != nullptr,
609         MTP_ERROR_STORE_NOT_AVAILABLE, "fail to get handles");
610     CHECK_AND_RETURN_RET_LOG(resultSet->GoToFirstRow() == NativeRdb::E_OK,
611         MTP_ERROR_STORE_NOT_AVAILABLE, "have no row");
612     unique_ptr<FetchResult<FileAsset>> fetchFileResult = make_unique<FetchResult<FileAsset>>(resultSet);
613     CHECK_AND_RETURN_RET_LOG(fetchFileResult != nullptr,
614         MTP_ERROR_INVALID_OBJECTHANDLE, "fetchFileResult is nullptr");
615     unique_ptr<FileAsset> fileAsset = fetchFileResult->GetFirstObject();
616     CHECK_AND_RETURN_RET_LOG(fileAsset != nullptr, MTP_ERROR_INVALID_OBJECTHANDLE, "fileAsset is nullptr");
617 
618     auto mediaLibraryManager = MediaLibraryManager::GetMediaLibraryManager();
619     CHECK_AND_RETURN_RET_LOG(mediaLibraryManager != nullptr,
620         MTP_ERROR_ACCESS_DENIED, "mediaLibraryManager is nullptr");
621     mediaLibraryManager->InitMediaLibraryManager(getThumbToken_);
622     std::string dataPath = fileAsset->GetFilePath();
623     int32_t id = fileAsset->GetId() % COMMON_PHOTOS_OFFSET;
624     auto thumbSizeValue = fileAsset->GetStrMember(PhotoColumn::PHOTO_THUMB_SIZE);
625     std::string path = GetThumbUri(id, thumbSizeValue, dataPath);
626     CHECK_AND_RETURN_RET_LOG(path.size() != 0, MTP_ERROR_NO_THIS_FILE, "path is null");
627     MEDIA_DEBUG_LOG("GetThumb path:%{private}s", path.c_str());
628 
629     Uri resultUri(path);
630     auto pixelMap = mediaLibraryManager->GetThumbnail(resultUri);
631     CHECK_AND_RETURN_RET_LOG(pixelMap != nullptr, MTP_ERROR_NO_THUMBNAIL_PRESENT, "GetThumbnail failed");
632 
633     bool ret = CompressImage(pixelMap, *outThumb);
634     CHECK_AND_RETURN_RET_LOG(ret == true, MTP_ERROR_NO_THUMBNAIL_PRESENT, "CompressImage failed");
635     return MTP_SUCCESS;
636 }
637 
GetThumbUri(const int32_t & id,const std::string & thumbSizeValue,const std::string & dataPath)638 std::string MtpMedialibraryManager::GetThumbUri(const int32_t &id,
639     const std::string &thumbSizeValue, const std::string &dataPath)
640 {
641     std::string startUri = NORMAL_MEDIA_URI;
642     size_t commaPos = dataPath.rfind(".");
643     size_t underlinePos = dataPath.rfind("/");
644     if (commaPos == std::string::npos || underlinePos == std::string::npos || commaPos < underlinePos) {
645         MEDIA_DEBUG_LOG("fail to query datapath");
646         return "";
647     }
648     std::string suffixStr = dataPath.substr(commaPos);
649     std::string lastStr = dataPath.substr(underlinePos, commaPos - underlinePos);
650     startUri += to_string(id);
651     startUri += lastStr;
652     startUri += lastStr;
653     startUri += suffixStr;
654 
655     size_t colonPos = thumbSizeValue.find(':');
656     if (colonPos == std::string::npos || colonPos + SIZE_ONE >= thumbSizeValue.size()) {
657         MEDIA_DEBUG_LOG("fail to query thumbnail size");
658         return startUri + "?oper=thumbnail";
659     }
660     std::string widthStr = thumbSizeValue.substr(0, colonPos);
661     std::string heightStr = thumbSizeValue.substr(colonPos + SIZE_ONE);
662 
663     return startUri + "?oper=thumbnail" + "&width=" +
664         widthStr + "&height=" + heightStr + "&path=" + dataPath;
665 }
666 
CondCloseFd(bool isConditionTrue,const int fd)667 void MtpMedialibraryManager::CondCloseFd(bool isConditionTrue, const int fd)
668 {
669     bool cond = (!isConditionTrue || fd <= 0);
670     CHECK_AND_RETURN_LOG(!cond, "fd error");
671     int32_t ret = close(fd);
672     CHECK_AND_PRINT_LOG(ret == MTP_SUCCESS, "DealFd CloseFd fail!");
673 }
674 
GetPictureThumb(const std::shared_ptr<MtpOperationContext> & context,std::shared_ptr<UInt8List> & outThumb)675 int32_t MtpMedialibraryManager::GetPictureThumb(const std::shared_ptr<MtpOperationContext> &context,
676     std::shared_ptr<UInt8List> &outThumb)
677 {
678     int fd = 0;
679     int error = GetFd(context, fd, MEDIA_FILEMODE_READONLY);
680     CHECK_AND_RETURN_RET_LOG(error == MTP_SUCCESS, MTP_ERROR_NO_THUMBNAIL_PRESENT, "GetFd failed");
681     uint32_t errorCode = 0;
682     SourceOptions opts;
683     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(fd, opts, errorCode);
684     CondCloseFd(imageSource == nullptr, fd);
685     CHECK_AND_RETURN_RET_LOG(imageSource != nullptr, MTP_ERROR_NO_THUMBNAIL_PRESENT, "imageSource is nullptr");
686     DecodeOptions decodeOpts;
687     decodeOpts.desiredSize = {
688         .width = NORMAL_WIDTH,
689         .height = NORMAL_HEIGHT
690     };
691     std::unique_ptr<PixelMap> cropPixelMap = imageSource->CreatePixelMap(decodeOpts, errorCode);
692     CondCloseFd(cropPixelMap == nullptr, fd);
693     CHECK_AND_RETURN_RET_LOG(cropPixelMap != nullptr, MTP_ERROR_NO_THUMBNAIL_PRESENT, "PixelMap is nullptr");
694 
695     bool ret = CompressImage(cropPixelMap, *outThumb);
696     CHECK_AND_RETURN_RET_LOG(ret == true, MTP_ERROR_NO_THUMBNAIL_PRESENT, "CompressImage failed");
697     return MTP_SUCCESS;
698 }
699 
GetVideoThumb(const std::shared_ptr<MtpOperationContext> & context,std::shared_ptr<UInt8List> & outThumb)700 int32_t MtpMedialibraryManager::GetVideoThumb(const std::shared_ptr<MtpOperationContext> &context,
701     std::shared_ptr<UInt8List> &outThumb)
702 {
703     int fd = 0;
704     int error = GetFd(context, fd, MEDIA_FILEMODE_READONLY);
705     CHECK_AND_RETURN_RET_LOG(error == MTP_SUCCESS, MTP_ERROR_NO_THUMBNAIL_PRESENT, "GetFd failed");
706     shared_ptr<AVMetadataHelper> avMetadataHelper = AVMetadataHelperFactory::CreateAVMetadataHelper();
707     CHECK_AND_RETURN_RET_LOG(avMetadataHelper != nullptr,
708         MTP_ERROR_NO_THUMBNAIL_PRESENT, "avMetadataHelper is nullptr");
709     struct stat64 st;
710     int32_t ret = fstat64(fd, &st);
711     CondCloseFd(ret != 0, fd);
712     CHECK_AND_RETURN_RET_LOG(ret == 0, MTP_ERROR_NO_THUMBNAIL_PRESENT, "Get file state failed, err %{public}d", errno);
713     int64_t length = static_cast<int64_t>(st.st_size);
714     ret = avMetadataHelper->SetSource(fd, 0, length, AV_META_USAGE_PIXEL_MAP);
715     CondCloseFd(ret != 0, fd);
716     CHECK_AND_RETURN_RET_LOG(ret == 0, MTP_ERROR_NO_THUMBNAIL_PRESENT, "SetSource failed, ret %{public}d", ret);
717     PixelMapParams param;
718     param.colorFormat = PixelFormat::RGBA_8888;
719     param.dstWidth = NORMAL_WIDTH;
720     param.dstHeight = NORMAL_HEIGHT;
721     shared_ptr<PixelMap> sPixelMap = avMetadataHelper->FetchFrameYuv(0,
722         AVMetadataQueryOption::AV_META_QUERY_NEXT_SYNC, param);
723     CondCloseFd(sPixelMap == nullptr, fd);
724     CHECK_AND_RETURN_RET_LOG(sPixelMap != nullptr, MTP_ERROR_NO_THUMBNAIL_PRESENT, "sPixelMap is nullptr");
725     if (sPixelMap->GetPixelFormat() == PixelFormat::YCBCR_P010) {
726         uint32_t ret = ImageFormatConvert::ConvertImageFormat(sPixelMap, PixelFormat::RGBA_1010102);
727         CondCloseFd(ret != E_OK, fd);
728         CHECK_AND_RETURN_RET_LOG(ret == E_OK, MTP_ERROR_NO_THUMBNAIL_PRESENT,
729             "PixelMapYuv10ToRGBA_1010102: source ConvertImageFormat fail");
730     }
731     InitializationOptions opts = {
732         .pixelFormat = PixelFormat::RGBA_8888,
733         .alphaType = AlphaType::IMAGE_ALPHA_TYPE_UNPREMUL
734     };
735     unique_ptr<PixelMap> compressImage = PixelMap::Create(*sPixelMap, opts);
736     CondCloseFd(sPixelMap == nullptr, fd);
737     CHECK_AND_RETURN_RET_LOG(compressImage != nullptr, MTP_ERROR_NO_THUMBNAIL_PRESENT, "compressImage is nullptr");
738     CloseFdForGet(context, fd);
739     bool retparam = CompressImage(compressImage, *outThumb);
740     CHECK_AND_RETURN_RET_LOG(retparam == true, MTP_ERROR_NO_THUMBNAIL_PRESENT, "CompressVideo failed");
741     return MTP_SUCCESS;
742 }
743 
GetAssetById(const int32_t id,shared_ptr<FileAsset> & outFileAsset)744 int32_t MtpMedialibraryManager::GetAssetById(const int32_t id, shared_ptr<FileAsset> &outFileAsset)
745 {
746     DataShare::DataSharePredicates predicates;
747     string whereClause = MEDIA_DATA_DB_ID + " = ?";
748     uint32_t field_id = id;
749     if (field_id > COMMON_PHOTOS_OFFSET) {
750         field_id = id - COMMON_PHOTOS_OFFSET;
751     }
752     vector<string> whereArgs = {to_string(field_id)};
753     predicates.SetWhereClause(whereClause);
754     predicates.SetWhereArgs(whereArgs);
755     Uri uri(PAH_QUERY_PHOTO);
756     vector<string> columns;
757     CHECK_AND_RETURN_RET_LOG(dataShareHelper_ != nullptr,
758         MtpErrorUtils::SolveGetHandlesError(E_HAS_DB_ERROR), "fail to get datasharehelper");
759     shared_ptr<DataShare::DataShareResultSet> resultSet = dataShareHelper_->Query(uri, predicates, columns);
760     if (resultSet == nullptr) {
761         return E_NO_SUCH_FILE;
762     }
763     unique_ptr<FetchResult<FileAsset>> fetchFileResult = make_unique<FetchResult<FileAsset>>(resultSet);
764     CHECK_AND_RETURN_RET_LOG(fetchFileResult != nullptr,
765         MTP_ERROR_INVALID_OBJECTHANDLE, "fetchFileResult is nullptr");
766     CHECK_AND_RETURN_RET_LOG(resultSet->GoToFirstRow() == NativeRdb::E_OK,
767         E_NO_SUCH_FILE, "no such file");
768     unique_ptr<FileAsset> fileUniAsset = fetchFileResult->GetFirstObject();
769     outFileAsset = move(fileUniAsset);
770     return E_SUCCESS;
771 }
772 
GetPathById(const int32_t id,string & outPath)773 int32_t MtpMedialibraryManager::GetPathById(const int32_t id, string &outPath)
774 {
775     shared_ptr<FileAsset> fileAsset;
776     int errCode = GetAssetById(id, fileAsset);
777     CHECK_AND_RETURN_RET_LOG(fileAsset != nullptr, E_HAS_DB_ERROR, "fileAsset is nullptr, assetId: %{public}d", id);
778     outPath = fileAsset->GetPath();
779     return errCode;
780 }
781 
GetIdByPath(const std::string & path,uint32_t & outId)782 int32_t MtpMedialibraryManager::GetIdByPath(const std::string &path, uint32_t &outId)
783 {
784     DataShare::DataSharePredicates predicates;
785     string whereClause = MEDIA_DATA_DB_FILE_PATH + " = ?";
786     vector<string> whereArgs = {path};
787     predicates.SetWhereClause(whereClause);
788     predicates.SetWhereArgs(whereArgs);
789     Uri uri(PAH_QUERY_PHOTO);
790     vector<string> columns;
791     CHECK_AND_RETURN_RET_LOG(dataShareHelper_ != nullptr,
792         MtpErrorUtils::SolveGetHandlesError(E_HAS_DB_ERROR), "fail to get datasharehelper");
793     shared_ptr<DataShare::DataShareResultSet> resultSet = dataShareHelper_->Query(uri, predicates, columns);
794     if (resultSet == nullptr) {
795         return E_NO_SUCH_FILE;
796     }
797     CHECK_AND_RETURN_RET_LOG(resultSet != nullptr,
798         MTP_ERROR_STORE_NOT_AVAILABLE, "fail to get handles");
799     unique_ptr<FetchResult<FileAsset>> fetchFileResult = make_unique<FetchResult<FileAsset>>(resultSet);
800     CHECK_AND_RETURN_RET_LOG(fetchFileResult != nullptr,
801         MTP_ERROR_INVALID_OBJECTHANDLE, "fetchFileResult is nullptr");
802     CHECK_AND_RETURN_RET_LOG(resultSet->GoToFirstRow() == NativeRdb::E_OK,
803         E_NO_SUCH_FILE, "no such file");
804     unique_ptr<FileAsset> fileUniAsset = fetchFileResult->GetFirstObject();
805     outId = static_cast<uint32_t>(fileUniAsset->GetId());
806     return E_SUCCESS;
807 }
808 
SendObjectInfo(const std::shared_ptr<MtpOperationContext> & context,uint32_t & outStorageID,uint32_t & outParent,uint32_t & outHandle)809 int32_t MtpMedialibraryManager::SendObjectInfo(const std::shared_ptr<MtpOperationContext> &context,
810     uint32_t &outStorageID, uint32_t &outParent, uint32_t &outHandle)
811 {
812     CHECK_AND_RETURN_RET_LOG(context != nullptr, MTP_ERROR_STORE_NOT_AVAILABLE, "context is nullptr");
813     DataShare::DataShareValuesBucket valuesBucket;
814     MediaType mediaType;
815     int errCode = MtpDataUtils::GetMediaTypeByName(context->name, mediaType);
816     CHECK_AND_RETURN_RET_LOG(errCode == MTP_SUCCESS, errCode, "fail to GetMediaTypeByName");
817     bool cond = ((mediaType != MEDIA_TYPE_IMAGE && mediaType != MEDIA_TYPE_VIDEO) || context->parent == uint32_t(-1));
818     CHECK_AND_RETURN_RET_LOG(!cond, MTP_ERROR_INVALID_OBJECTHANDLE, "file type not support");
819     string uri = MEDIALIBRARY_DATA_URI + "/" + PTP_OPERATION + "/" + MEDIA_FILEOPRN_CREATEASSET;
820     MediaFileUtils::UriAppendKeyValue(uri, API_VERSION, to_string(MEDIA_API_VERSION_V10));
821     Uri createFileUri(uri);
822     valuesBucket.Put(MEDIA_DATA_DB_NAME, context->name);
823     valuesBucket.Put(MEDIA_DATA_DB_MEDIA_TYPE, mediaType);
824     CHECK_AND_RETURN_RET_LOG(dataShareHelper_ != nullptr,
825         MtpErrorUtils::SolveGetHandlesError(E_HAS_DB_ERROR), "fail to get datasharehelper");
826     int outRowId = dataShareHelper_->Insert(createFileUri, valuesBucket);
827     CHECK_AND_RETURN_RET_LOG(outRowId > 0,
828         MtpErrorUtils::SolveSendObjectInfoError(E_HAS_DB_ERROR), "fail to create assset");
829     outHandle = static_cast<uint32_t>(outRowId + COMMON_PHOTOS_OFFSET);
830     outStorageID = DEFAULT_STORAGE_ID;
831     outParent = context->parent;
832     return MtpErrorUtils::SolveSendObjectInfoError(E_SUCCESS);
833 }
834 
MoveObject(const std::shared_ptr<MtpOperationContext> & context)835 int32_t MtpMedialibraryManager::MoveObject(const std::shared_ptr<MtpOperationContext> &context)
836 {
837     CHECK_AND_RETURN_RET_LOG(context != nullptr, MTP_ERROR_STORE_NOT_AVAILABLE, "context is nullptr");
838     return MtpErrorUtils::SolveCloseFdError(MTP_STORE_READ_ONLY);
839 }
840 
CopyNewAsset(const CopyNewAssetParams & params)841 int32_t CopyNewAsset(const CopyNewAssetParams &params)
842 {
843     CHECK_AND_RETURN_RET_LOG(params.dataShareHelper != nullptr,
844         MtpErrorUtils::SolveGetHandlesError(E_HAS_DB_ERROR), "fail to get datasharehelper");
845     DataShare::DataShareValuesBucket valuesBucket;
846     valuesBucket.Put(MediaColumn::MEDIA_ID, params.fileId);
847     valuesBucket.Put(MediaColumn::MEDIA_TITLE, params.title);
848     string cloneUri = URI_MTP_OPERATION + "/" + OPRN_CLONE_ASSET;
849     MediaFileUtils::UriAppendKeyValue(cloneUri, API_VERSION, to_string(MEDIA_API_VERSION_V10));
850     Uri cloneAssetUri(cloneUri);
851     int32_t insertId = params.dataShareHelper->Insert(cloneAssetUri, valuesBucket);
852     CHECK_AND_RETURN_RET_LOG(insertId >= 0,
853         MtpErrorUtils::SolveCopyObjectError(E_HAS_DB_ERROR), "fail to clone photo");
854     params.outObjectHandle = static_cast<uint32_t>(insertId) + COMMON_PHOTOS_OFFSET;
855     string updateOwnerAlbumIdUriStr = URI_MTP_OPERATION + "/" + OPRN_UPDATE_OWNER_ALBUM_ID;
856     MediaFileUtils::UriAppendKeyValue(updateOwnerAlbumIdUriStr, API_VERSION, to_string(MEDIA_API_VERSION_V10));
857     Uri updateOwnerAlbumIdUri(updateOwnerAlbumIdUriStr);
858     DataShare::DataSharePredicates predicates;
859     predicates.EqualTo(PhotoColumn::MEDIA_ID, to_string(insertId));
860     DataShare::DataShareValuesBucket valuesBucketUpdate;
861     valuesBucketUpdate.Put(PhotoColumn::MEDIA_TITLE, params.title);
862     valuesBucketUpdate.Put(PhotoColumn::PHOTO_OWNER_ALBUM_ID, params.albumId);
863     valuesBucketUpdate.Put(PhotoColumn::MEDIA_NAME, params.displayName);
864     int32_t changedRows = params.dataShareHelper->Update(updateOwnerAlbumIdUri, predicates, valuesBucketUpdate);
865     return changedRows;
866 }
867 
CopyObject(const std::shared_ptr<MtpOperationContext> & context,uint32_t & outObjectHandle)868 int32_t MtpMedialibraryManager::CopyObject(const std::shared_ptr<MtpOperationContext> &context,
869     uint32_t &outObjectHandle)
870 {
871     CHECK_AND_RETURN_RET_LOG((context != nullptr) && (context->parent != 0),
872         MTP_ERROR_INVALID_OBJECTHANDLE, "context is invailed");
873     CHECK_AND_RETURN_RET_LOG(context->handle > COMMON_PHOTOS_OFFSET, MTP_ERROR_PARAMETER_NOT_SUPPORTED,
874         "not allow to copy folder in PTP");
875     MediaType mediaType;
876     int errCode = MtpDataUtils::SolveSendObjectFormatData(context->format, mediaType);
877     CHECK_AND_RETURN_RET_LOG(errCode == MTP_SUCCESS, errCode, "fail to SolveSendObjectFormatData");
878 
879     int32_t fileId = static_cast<int32_t>(context->handle - COMMON_PHOTOS_OFFSET);
880     string queryUriStr = PAH_QUERY_PHOTO;
881     MediaFileUtils::UriAppendKeyValue(queryUriStr, API_VERSION, to_string(MEDIA_API_VERSION_V10));
882     Uri queryUri(queryUriStr);
883     DataShare::DataSharePredicates idPredicates;
884     string whereClause = MEDIA_DATA_DB_ID + " = ?";
885     vector<string> whereArgs = {to_string(fileId)};
886     idPredicates.SetWhereClause(whereClause);
887     idPredicates.SetWhereArgs(whereArgs);
888 
889     CHECK_AND_RETURN_RET_LOG(dataShareHelper_ != nullptr,
890         MtpErrorUtils::SolveCopyObjectError(E_HAS_DB_ERROR), "dataShareHelper_ is nullptr");
891     vector<string> columns;
892     shared_ptr<DataShare::DataShareResultSet> resultSet = dataShareHelper_->Query(queryUri, idPredicates, columns);
893     CHECK_AND_RETURN_RET_LOG(resultSet != nullptr,
894         MtpErrorUtils::SolveCopyObjectError(E_HAS_DB_ERROR), "fail to get resultset");
895     CHECK_AND_RETURN_RET_LOG(resultSet->GoToFirstRow() == NativeRdb::E_OK,
896         MtpErrorUtils::SolveCopyObjectError(E_NO_SUCH_FILE), "fail to get data");
897     int32_t indexPos = -1;
898     resultSet->GetColumnIndex(MediaColumn::MEDIA_TITLE, indexPos);
899     string title;
900     resultSet->GetString(indexPos, title);
901     string displayName = GetStringVal(MediaColumn::MEDIA_NAME, resultSet);
902     CopyNewAssetParams params = {
903         fileId, static_cast<int32_t>(context->parent), title, displayName, outObjectHandle, dataShareHelper_
904     };
905     int32_t changedRows = CopyNewAsset(params);
906     CHECK_AND_RETURN_RET_LOG(changedRows >= 0 && changedRows != MtpErrorUtils::SolveCopyObjectError(E_HAS_DB_ERROR),
907         MtpErrorUtils::SolveCopyObjectError(E_HAS_DB_ERROR), "fail to update photo");
908     return MTP_SUCCESS;
909 }
910 
DeleteObject(const std::shared_ptr<MtpOperationContext> & context)911 int32_t MtpMedialibraryManager::DeleteObject(const std::shared_ptr<MtpOperationContext> &context)
912 {
913     CHECK_AND_RETURN_RET_LOG(context != nullptr, MTP_ERROR_STORE_NOT_AVAILABLE, "context is nullptr");
914     return MtpErrorUtils::SolveCloseFdError(MTP_STORE_READ_ONLY);
915 }
916 
SetObjectPropValue(const std::shared_ptr<MtpOperationContext> & context)917 int32_t MtpMedialibraryManager::SetObjectPropValue(const std::shared_ptr<MtpOperationContext> &context)
918 {
919     CHECK_AND_RETURN_RET_LOG(context != nullptr, MTP_ERROR_STORE_NOT_AVAILABLE, "context is nullptr");
920     return MtpErrorUtils::SolveCloseFdError(MTP_STORE_READ_ONLY);
921 }
922 
CloseFdForGet(const std::shared_ptr<MtpOperationContext> & context,int32_t fd)923 int32_t MtpMedialibraryManager::CloseFdForGet(const std::shared_ptr<MtpOperationContext> &context, int32_t fd)
924 {
925     CHECK_AND_RETURN_RET_LOG(context != nullptr, MTP_ERROR_STORE_NOT_AVAILABLE, "context is nullptr");
926     MEDIA_INFO_LOG("CloseFd  handle::%{public}u", context->handle);
927     CHECK_AND_RETURN_RET_LOG(fd > 0, E_ERR, "wrong fd");
928     int errCode = close(fd);
929     return MtpErrorUtils::SolveCloseFdError(errCode);
930 }
931 
CloseFd(const shared_ptr<MtpOperationContext> & context,int32_t fd)932 int32_t MtpMedialibraryManager::CloseFd(const shared_ptr<MtpOperationContext> &context, int32_t fd)
933 {
934     CHECK_AND_RETURN_RET_LOG(context != nullptr, MTP_ERROR_STORE_NOT_AVAILABLE, "context is nullptr");
935     MEDIA_INFO_LOG("CloseFd  handle::%{public}u", context->handle);
936     int32_t errCode = E_SUCCESS;
937     CHECK_AND_RETURN_RET_LOG(fd > 0, E_ERR, "wrong fd");
938     if (context->handle > EDITED_PHOTOS_OFFSET) {
939         errCode = close(fd);
940         return MtpErrorUtils::SolveCloseFdError(errCode);
941     }
942     shared_ptr<FileAsset> fileAsset;
943     errCode = GetAssetById(context->handle, fileAsset);
944     CHECK_AND_RETURN_RET_LOG(errCode == E_SUCCESS,
945         MtpErrorUtils::SolveCloseFdError(errCode), "fail to GetAssetById");
946     DataShare::DataShareValuesBucket valuesBucket;
947     valuesBucket.Put(MEDIA_DATA_DB_URI, MEDIALIBRARY_DATA_URI + "/" + PTP_OPERATION + "/" + MEDIA_FILEOPRN_CLOSEASSET +
948         "/" + to_string(context->handle - COMMON_PHOTOS_OFFSET));
949     MEDIA_INFO_LOG("CloseFd %{public}s, FilePath  %{public}s", fileAsset->GetUri().c_str(),
950         fileAsset->GetFilePath().c_str());
951     Uri closeAssetUri(MEDIALIBRARY_DATA_URI + "/" + PTP_OPERATION + "/" + MEDIA_FILEOPRN_CLOSEASSET);
952     CHECK_AND_RETURN_RET_LOG(dataShareHelper_ != nullptr,
953         MtpErrorUtils::SolveGetHandlesError(E_HAS_DB_ERROR), "fail to get datasharehelper");
954     if (close(fd) == MTP_SUCCESS) {
955         errCode = dataShareHelper_->Insert(closeAssetUri, valuesBucket);
956     }
957     CHECK_AND_RETURN_RET_LOG(errCode == MTP_SUCCESS, MTP_ERROR_INVALID_OBJECTHANDLE, "fail to Close file");
958     DataShare::DataShareValuesBucket valuesBucketForOwnerAlbumId;
959     string uri = URI_MTP_OPERATION + "/" + OPRN_UPDATE_OWNER_ALBUM_ID;
960     MediaFileUtils::UriAppendKeyValue(uri, API_VERSION, to_string(MEDIA_API_VERSION_V10));
961     Uri updateOwnerAlbumIdUri(uri);
962     DataShare::DataSharePredicates predicates;
963     predicates.EqualTo(PhotoColumn::MEDIA_ID, to_string(context->handle - COMMON_PHOTOS_OFFSET));
964     valuesBucketForOwnerAlbumId.Put(PhotoColumn::PHOTO_OWNER_ALBUM_ID, static_cast<int32_t>(context->parent));
965     int32_t changedRows = dataShareHelper_->Update(updateOwnerAlbumIdUri, predicates, valuesBucketForOwnerAlbumId);
966     CHECK_AND_RETURN_RET_LOG(changedRows > 0,
967         MtpErrorUtils::SolveCloseFdError(E_HAS_DB_ERROR), "fail to update owneralbumid");
968     return MtpErrorUtils::SolveCloseFdError(E_SUCCESS);
969 }
970 
GetObjectPropList(const std::shared_ptr<MtpOperationContext> & context,std::shared_ptr<std::vector<Property>> & outProps)971 int32_t MtpMedialibraryManager::GetObjectPropList(const std::shared_ptr<MtpOperationContext> &context,
972     std::shared_ptr<std::vector<Property>> &outProps)
973 {
974     CHECK_AND_RETURN_RET_LOG(context != nullptr, MTP_ERROR_STORE_NOT_AVAILABLE, "context is nullptr");
975     if (context->property == 0) {
976         CHECK_AND_RETURN_RET_LOG(context->groupCode != 0, MTP_ERROR_PARAMETER_NOT_SUPPORTED, "groupCode error");
977         MEDIA_ERR_LOG("context property = 0");
978         return MTP_ERROR_SPECIFICATION_BY_GROUP_UNSUPPORTED;
979     }
980     shared_ptr<DataShare::DataShareResultSet> resultSet;
981     if (context->handle < COMMON_PHOTOS_OFFSET) {
982         context->parent = PARENT_ID;
983     }
984     if (context->parent == PARENT_ID && context->handle < COMMON_PHOTOS_OFFSET) {
985         resultSet = GetAlbumInfo(context, false);
986     } else {
987         resultSet = GetPhotosInfo(context, false);
988     }
989     CHECK_AND_RETURN_RET_LOG(resultSet != nullptr,
990         MTP_ERROR_INVALID_OBJECTHANDLE, "fail to getSet");
991     return MtpDataUtils::GetPropListBySet(context, resultSet, outProps);
992 }
993 
GetObjectPropValue(const shared_ptr<MtpOperationContext> & context,uint64_t & outIntVal,uint128_t & outLongVal,string & outStrVal)994 int32_t MtpMedialibraryManager::GetObjectPropValue(const shared_ptr<MtpOperationContext> &context,
995     uint64_t &outIntVal, uint128_t &outLongVal, string &outStrVal)
996 {
997     CHECK_AND_RETURN_RET_LOG(context != nullptr, MTP_ERROR_STORE_NOT_AVAILABLE, "context is nullptr");
998     shared_ptr<DataShare::DataShareResultSet> resultSet;
999     if (context->parent == PARENT_ID) {
1000         resultSet = GetAlbumInfo(context, false);
1001     } else {
1002         resultSet = GetPhotosInfo(context, false);
1003     }
1004     CHECK_AND_RETURN_RET_LOG(resultSet != nullptr, MTP_ERROR_INVALID_OBJECTHANDLE, "fail to getSet");
1005     CHECK_AND_RETURN_RET_LOG(resultSet->GoToFirstRow() == NativeRdb::E_OK,
1006         MTP_ERROR_INVALID_OBJECTHANDLE, "have no row");
1007     PropertyValue propValue;
1008     int32_t errCode = MtpDataUtils::GetPropValueBySet(context->property, resultSet, propValue);
1009     CHECK_AND_RETURN_RET_LOG(errCode == MTP_SUCCESS, MTP_ERROR_INVALID_OBJECTHANDLE, "fail to get GetPropValueBySet");
1010     outIntVal = propValue.outIntVal;
1011     outStrVal = propValue.outStrVal;
1012     return errCode;
1013 }
1014 
DeleteCanceledObject(uint32_t id)1015 void MtpMedialibraryManager::DeleteCanceledObject(uint32_t id)
1016 {
1017     CHECK_AND_RETURN_LOG(dataShareHelper_ != nullptr,
1018         "MtpMedialibraryManager::DeleteCanceledObject fail to get datasharehelpe");
1019 
1020     string trashUri = PAH_TRASH_PHOTO;
1021     MediaFileUtils::UriAppendKeyValue(trashUri, API_VERSION, to_string(MEDIA_API_VERSION_V10));
1022     Uri trashAssetUri(trashUri);
1023     DataShare::DataShareValuesBucket valuesBucketTrashed;
1024     valuesBucketTrashed.Put(MediaColumn::MEDIA_DATE_TRASHED, MediaFileUtils::UTCTimeMilliSeconds());
1025     DataShare::DataSharePredicates predicatesTrashed;
1026     predicatesTrashed.EqualTo(MediaColumn::MEDIA_ID, to_string(id - COMMON_PHOTOS_OFFSET));
1027     dataShareHelper_->Update(trashAssetUri, predicatesTrashed, valuesBucketTrashed);
1028     MEDIA_INFO_LOG("Update file date_trashed SUCCESS");
1029 
1030     std::string deleteUriStr = TOOL_DELETE_PHOTO;
1031     MediaFileUtils::UriAppendKeyValue(deleteUriStr, API_VERSION, to_string(MEDIA_API_VERSION_V10));
1032     Uri deleteUri(deleteUriStr);
1033     DataShare::DataSharePredicates predicates;
1034     predicates.EqualTo(MediaColumn::MEDIA_ID, to_string(id - COMMON_PHOTOS_OFFSET));
1035     DataShare::DataShareValuesBucket valuesBucket;
1036     valuesBucket.Put(PhotoColumn::MEDIA_DATE_TRASHED, DATE_UNTRASHED);
1037     dataShareHelper_->Update(deleteUri, predicates, valuesBucket);
1038     MEDIA_INFO_LOG("DeleteCaneledObject SUCCESS");
1039 }
1040 
1041 }  // namespace Media
1042 }  // namespace OHOS
1043