1 /*
2 * Copyright (C) 2024 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 "media_asset_helper_impl.h"
17
18 #include "media_file_utils.h"
19 #include "media_log.h"
20 #include "media_userfile_client.h"
21 #include "media_column.h"
22 #include "medialibrary_errno.h"
23 #include "userfilemgr_uri.h"
24 #include "oh_media_asset.h"
25 #include "result_set_utils.h"
26
27 namespace OHOS {
28 namespace Media {
29
CreateMediaAssetHelper()30 std::shared_ptr<MediaAssetHelper> MediaAssetHelperFactory::CreateMediaAssetHelper()
31 {
32 std::shared_ptr<MediaAssetHelperImpl> impl = std::make_shared<MediaAssetHelperImpl>();
33 CHECK_AND_PRINT_LOG(impl != nullptr, "Failed to create MediaAssetHelperImpl instance.");
34
35 return impl;
36 }
37
MediaAssetHelperImpl()38 MediaAssetHelperImpl::MediaAssetHelperImpl() {}
39
~MediaAssetHelperImpl()40 MediaAssetHelperImpl::~MediaAssetHelperImpl() {}
41
CheckUri(const std::string & uri)42 static bool CheckUri(const std::string &uri)
43 {
44 if (uri.find("../") != std::string::npos) {
45 return false;
46 }
47 std::string uriprex = "file://media";
48 return uri.substr(0, uriprex.size()) == uriprex;
49 }
50
GetOhMediaAsset(const std::string & uri)51 OH_MediaAsset *MediaAssetHelperImpl::GetOhMediaAsset(const std::string &uri)
52 {
53 CHECK_AND_RETURN_RET_LOG(CheckUri(uri), nullptr, "invalid uri");
54 if (!UserFileClient::IsValid()) {
55 MEDIA_ERR_LOG("UserFileClient is not valid, executing initialization.");
56 UserFileClient::Init();
57 }
58 std::string fileId = MediaFileUtils::GetIdFromUri(uri);
59 CHECK_AND_RETURN_RET_LOG(!fileId.empty(), nullptr, "Failed to extract file ID from URI: %{public}s", uri.c_str());
60 DataShare::DataSharePredicates predicates;
61 predicates.EqualTo(MediaColumn::MEDIA_ID, fileId);
62 std::vector<std::string> columns = {PhotoColumn::MEDIA_SIZE,
63 PhotoColumn::MEDIA_DATE_MODIFIED,
64 PhotoColumn::PHOTO_WIDTH,
65 PhotoColumn::PHOTO_HEIGHT,
66 PhotoColumn::MEDIA_TITLE,
67 PhotoColumn::PHOTO_ORIENTATION,
68 PhotoColumn::MEDIA_DATE_ADDED,
69 PhotoColumn::MEDIA_DATE_TAKEN,
70 PhotoColumn::MEDIA_DURATION,
71 PhotoColumn::MEDIA_IS_FAV,
72 PhotoColumn::MEDIA_TYPE};
73
74 Uri queryUri(PAH_QUERY_PHOTO);
75 int errCode;
76 auto resultSet = UserFileClient::Query(queryUri, predicates, columns, errCode);
77 CHECK_AND_RETURN_RET_LOG(
78 TryToGoToFirstRow(resultSet), nullptr, "try to go to first row failed, errCode: %{public}d", errCode);
79 std::shared_ptr<FileAsset> fileAsset = std::make_shared<FileAsset>();
80 CHECK_AND_RETURN_RET_LOG(fileAsset != nullptr, nullptr, "create file asset failed");
81 fileAsset->SetUri(uri);
82 fileAsset->SetId(stoi(fileId));
83 fileAsset->SetDisplayName(MediaFileUtils::GetFileName(uri));
84 fileAsset->SetSize(GetInt64Val(PhotoColumn::MEDIA_SIZE, resultSet));
85 fileAsset->SetDateModified(GetInt64Val(PhotoColumn::MEDIA_DATE_MODIFIED, resultSet));
86 fileAsset->SetWidth(GetInt32Val(PhotoColumn::PHOTO_WIDTH, resultSet));
87 fileAsset->SetHeight(GetInt32Val(PhotoColumn::PHOTO_HEIGHT, resultSet));
88 fileAsset->SetOrientation(GetInt32Val(PhotoColumn::PHOTO_ORIENTATION, resultSet));
89 fileAsset->SetDateAdded(GetInt64Val(PhotoColumn::MEDIA_DATE_ADDED, resultSet));
90 fileAsset->SetDateTaken(GetInt64Val(PhotoColumn::MEDIA_DATE_TAKEN, resultSet));
91 fileAsset->SetDuration(GetInt32Val(PhotoColumn::MEDIA_DURATION, resultSet));
92 fileAsset->SetFavorite(GetInt32Val(PhotoColumn::MEDIA_IS_FAV, resultSet));
93 fileAsset->SetTitle(GetStringVal(PhotoColumn::MEDIA_TITLE, resultSet));
94 fileAsset->SetMediaType(static_cast<MediaType>(GetInt32Val(PhotoColumn::MEDIA_TYPE, resultSet)));
95 fileAsset->SetResultNapiType(ResultNapiType::TYPE_MEDIALIBRARY);
96 auto mediaAsset = MediaAssetFactory::CreateMediaAsset(fileAsset);
97 CHECK_AND_RETURN_RET_LOG(mediaAsset != nullptr, nullptr, "create media asset failed");
98 auto ohMediaAsset = new OH_MediaAsset(mediaAsset);
99 CHECK_AND_RETURN_RET_LOG(ohMediaAsset != nullptr, nullptr, "create ohMediaAsset failed");
100 return ohMediaAsset;
101 }
102
GetMediaAsset(std::string uri,int32_t cameraShotType,std::string burstKey)103 OH_MediaAsset* MediaAssetHelperImpl::GetMediaAsset(std::string uri, int32_t cameraShotType, std::string burstKey)
104 {
105 std::shared_ptr<FileAsset> fileAsset = std::make_shared<FileAsset>();
106 CHECK_AND_RETURN_RET_LOG(fileAsset != nullptr, nullptr, "create file asset failed");
107
108 fileAsset->SetUri(uri);
109 std::string fileId = MediaFileUtils::GetIdFromUri(uri);
110 if (!fileId.empty()) {
111 fileAsset->SetId(stoi(fileId));
112 }
113 fileAsset->SetDisplayName(MediaFileUtils::GetFileName(uri));
114 if (cameraShotType == static_cast<int32_t>(Media::CameraShotType::IMAGE)) {
115 fileAsset->SetPhotoSubType(static_cast<int32_t>(PhotoSubType::CAMERA));
116 fileAsset->SetMediaType(Media::MediaType::MEDIA_TYPE_IMAGE);
117 } else if (cameraShotType == static_cast<int32_t>(CameraShotType::MOVING_PHOTO)) {
118 fileAsset->SetPhotoSubType(static_cast<int32_t>(PhotoSubType::MOVING_PHOTO));
119 fileAsset->SetMediaType(Media::MediaType::MEDIA_TYPE_IMAGE);
120 } else if (cameraShotType == static_cast<int32_t>(CameraShotType::BURST)) {
121 fileAsset->SetPhotoSubType(static_cast<int32_t>(PhotoSubType::BURST));
122 fileAsset->SetMediaType(Media::MediaType::MEDIA_TYPE_IMAGE);
123 fileAsset->SetBurstKey(burstKey);
124 } else {
125 MEDIA_INFO_LOG("invalid cameraShotKey: %{public}d", cameraShotType);
126 }
127
128 InitFileAsset(fileAsset);
129 auto mediaAssetObj = MediaAssetFactory::CreateMediaAsset(fileAsset);
130 auto mediaAsset = new OH_MediaAsset(mediaAssetObj);
131 CHECK_AND_RETURN_RET_LOG(mediaAsset != nullptr, nullptr, "create media asset failed");
132 return mediaAsset;
133 }
134
InitFileAsset(std::shared_ptr<FileAsset> fileAsset)135 void MediaAssetHelperImpl::InitFileAsset(std::shared_ptr<FileAsset> fileAsset)
136 {
137 auto resultSet = QueryFileAsset(fileAsset->GetId());
138 CHECK_AND_RETURN_LOG(resultSet != nullptr, "query resultSet is nullptr");
139
140 int indexPos = -1;
141 resultSet->GetColumnIndex(PhotoColumn::MEDIA_SIZE, indexPos);
142 int64_t size = 0;
143 resultSet->GetLong(indexPos, size);
144 fileAsset->SetSize(size);
145 MEDIA_INFO_LOG("init file asset, query Size: %{public}ld", static_cast<long>(size));
146
147 indexPos = -1;
148 resultSet->GetColumnIndex(PhotoColumn::MEDIA_DATE_MODIFIED, indexPos);
149 int64_t dateMmodified = 0;
150 resultSet->GetLong(indexPos, dateMmodified);
151 fileAsset->SetDateModified(dateMmodified);
152 MEDIA_INFO_LOG("init file asset, query dateMmodified: %{public}ld", static_cast<long>(dateMmodified));
153
154 indexPos = -1;
155 resultSet->GetColumnIndex(PhotoColumn::PHOTO_WIDTH, indexPos);
156 int32_t width = 0;
157 resultSet->GetInt(indexPos, width);
158 fileAsset->SetWidth(width);
159 MEDIA_INFO_LOG("init file asset, query width: %{public}d", width);
160
161 indexPos = -1;
162 resultSet->GetColumnIndex(PhotoColumn::PHOTO_HEIGHT, indexPos);
163 int32_t height = 0;
164 resultSet->GetInt(indexPos, height);
165 fileAsset->SetHeight(height);
166 MEDIA_INFO_LOG("init file asset, query height: %{public}d", height);
167
168 UpdateFileAsset(resultSet, fileAsset);
169 return;
170 }
171
QueryFileAsset(int32_t mediaId)172 std::shared_ptr<DataShare::DataShareResultSet> MediaAssetHelperImpl::QueryFileAsset(int32_t mediaId)
173 {
174 if (!UserFileClient::IsValid()) {
175 UserFileClient::Init();
176 }
177
178 DataShare::DataSharePredicates predicates;
179 predicates.EqualTo(MediaColumn::MEDIA_ID, mediaId);
180 std::vector<std::string> fetchColumn {
181 PhotoColumn::MEDIA_SIZE,
182 PhotoColumn::MEDIA_DATE_MODIFIED,
183 PhotoColumn::PHOTO_WIDTH,
184 PhotoColumn::PHOTO_HEIGHT,
185 PhotoColumn::PHOTO_ORIENTATION,
186 PhotoColumn::MEDIA_DATE_ADDED,
187 PhotoColumn::MEDIA_DATE_TAKEN,
188 PhotoColumn::MEDIA_DURATION,
189 PhotoColumn::MEDIA_IS_FAV,
190 PhotoColumn::MEDIA_TITLE
191 };
192 Uri uri(PAH_QUERY_PHOTO);
193 int errCode;
194 auto resultSet = UserFileClient::Query(uri, predicates, fetchColumn, errCode);
195 if (resultSet == nullptr || resultSet->GoToFirstRow() != E_OK) {
196 MEDIA_ERR_LOG("init file asset failed, query resultSet is nullptr");
197 return nullptr;
198 }
199 return resultSet;
200 }
201
UpdateFileAsset(std::shared_ptr<DataShare::DataShareResultSet> resultSet,std::shared_ptr<FileAsset> fileAsset)202 void MediaAssetHelperImpl::UpdateFileAsset(std::shared_ptr<DataShare::DataShareResultSet> resultSet,
203 std::shared_ptr<FileAsset> fileAsset)
204 {
205 int indexPos = -1;
206 resultSet->GetColumnIndex(PhotoColumn::PHOTO_ORIENTATION, indexPos);
207 int32_t orientation = 0;
208 resultSet->GetInt(indexPos, orientation);
209 fileAsset->SetOrientation(orientation);
210 MEDIA_INFO_LOG("init file asset, query orientation: %{public}d", orientation);
211
212 indexPos = -1;
213 resultSet->GetColumnIndex(PhotoColumn::MEDIA_DATE_ADDED, indexPos);
214 int64_t dateAdded = 0;
215 resultSet->GetLong(indexPos, dateAdded);
216 fileAsset->SetDateAdded(dateAdded);
217 MEDIA_INFO_LOG("init file asset, query dateAdded: %{public}ld", static_cast<long>(dateAdded));
218
219 indexPos = -1;
220 resultSet->GetColumnIndex(PhotoColumn::MEDIA_DATE_TAKEN, indexPos);
221 int64_t dateTaken = 0;
222 resultSet->GetLong(indexPos, dateTaken);
223 fileAsset->SetDateTaken(dateTaken);
224 MEDIA_INFO_LOG("init file asset, query dateTaken: %{public}ld", static_cast<long>(dateTaken));
225
226 indexPos = -1;
227 resultSet->GetColumnIndex(PhotoColumn::MEDIA_DURATION, indexPos);
228 int32_t duration = 0;
229 resultSet->GetInt(indexPos, duration);
230 fileAsset->SetDuration(duration);
231 MEDIA_INFO_LOG("init file asset, query duration: %{public}d", duration);
232
233 indexPos = -1;
234 resultSet->GetColumnIndex(PhotoColumn::MEDIA_IS_FAV, indexPos);
235 int32_t isFav = 0;
236 resultSet->GetInt(indexPos, isFav);
237 fileAsset->SetFavorite(isFav);
238 MEDIA_INFO_LOG("init file asset, query isFav: %{public}d", isFav);
239
240 indexPos = -1;
241 resultSet->GetColumnIndex(PhotoColumn::MEDIA_TITLE, indexPos);
242 std::string title;
243 resultSet->GetString(indexPos, title);
244 fileAsset->SetTitle(title);
245 MEDIA_INFO_LOG("init file asset, query title: %{public}s", title.c_str());
246
247 return;
248 }
249
250 }
251 }