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 "fetch_result_impl.h"
17
18 using namespace std;
19 using namespace OHOS::FFI;
20
21 namespace OHOS {
22 namespace Media {
FetchResultImpl(unique_ptr<FfiFetchResultProperty> propertyPtr_)23 FetchResultImpl::FetchResultImpl(unique_ptr<FfiFetchResultProperty> propertyPtr_)
24 {
25 propertyPtr = move(propertyPtr_);
26 }
27
GetFetchFileResultObject()28 std::shared_ptr<FetchResult<FileAsset>> FetchResultImpl::GetFetchFileResultObject()
29 {
30 return propertyPtr->fetchFileResult_;
31 }
32
GetFetchAlbumResultObject()33 std::shared_ptr<FetchResult<AlbumAsset>> FetchResultImpl::GetFetchAlbumResultObject()
34 {
35 return propertyPtr->fetchAlbumResult_;
36 }
37
GetFetchPhotoAlbumResultObject()38 std::shared_ptr<FetchResult<PhotoAlbum>> FetchResultImpl::GetFetchPhotoAlbumResultObject()
39 {
40 return propertyPtr->fetchPhotoAlbumResult_;
41 }
42
GetFetchSmartAlbumResultObject()43 std::shared_ptr<FetchResult<SmartAlbumAsset>> FetchResultImpl::GetFetchSmartAlbumResultObject()
44 {
45 return propertyPtr->fetchSmartAlbumResult_;
46 }
47
GetCount(int32_t & errCode)48 int32_t FetchResultImpl::GetCount(int32_t &errCode)
49 {
50 int32_t count = 0;
51 switch (propertyPtr->fetchResType_) {
52 case FetchResType::TYPE_FILE:
53 count = propertyPtr->fetchFileResult_->GetCount();
54 break;
55 case FetchResType::TYPE_ALBUM:
56 count = propertyPtr->fetchAlbumResult_->GetCount();
57 break;
58 case FetchResType::TYPE_PHOTOALBUM:
59 count = propertyPtr->fetchPhotoAlbumResult_->GetCount();
60 break;
61 case FetchResType::TYPE_SMARTALBUM:
62 count = propertyPtr->fetchSmartAlbumResult_->GetCount();
63 break;
64 default:
65 LOGE("unsupported FetchResType");
66 break;
67 }
68 if (count < 0) {
69 errCode = JS_INNER_FAIL;
70 }
71 return count;
72 }
73
IsAfterLast(int32_t & errCode)74 bool FetchResultImpl::IsAfterLast(int32_t &errCode)
75 {
76 bool isAfterLast = false;
77 switch (propertyPtr->fetchResType_) {
78 case FetchResType::TYPE_FILE:
79 isAfterLast = propertyPtr->fetchFileResult_->IsAtLastRow();
80 break;
81 case FetchResType::TYPE_ALBUM:
82 isAfterLast = propertyPtr->fetchAlbumResult_->IsAtLastRow();
83 break;
84 case FetchResType::TYPE_PHOTOALBUM:
85 isAfterLast = propertyPtr->fetchPhotoAlbumResult_->IsAtLastRow();
86 break;
87 case FetchResType::TYPE_SMARTALBUM:
88 isAfterLast = propertyPtr->fetchSmartAlbumResult_->IsAtLastRow();
89 break;
90 default:
91 LOGE("unsupported FetchResType");
92 errCode = JS_INNER_FAIL;
93 break;
94 }
95 return isAfterLast;
96 }
97
Close()98 void FetchResultImpl::Close()
99 {
100 propertyPtr = nullptr;
101 }
102
GetFileAssetObj(unique_ptr<FileAsset> fileAsset,FetchResultObject & fetchResultObject,int32_t & errCode)103 static void GetFileAssetObj(unique_ptr<FileAsset> fileAsset,
104 FetchResultObject &fetchResultObject, int32_t &errCode)
105 {
106 fetchResultObject.id = -1;
107 fetchResultObject.fetchResType = static_cast<int32_t>(FetchResType::TYPE_FILE);
108 if (fileAsset != nullptr) {
109 auto native = FFIData::Create<PhotoAssetImpl>(move(fileAsset));
110 if (native != nullptr) {
111 fetchResultObject.id = native->GetID();
112 return;
113 }
114 }
115 errCode = JS_INNER_FAIL;
116 }
117
GetPhotoAlbumObj(unique_ptr<PhotoAlbum> photoAlbum,FetchResultObject & fetchResultObject,int32_t & errCode)118 static void GetPhotoAlbumObj(unique_ptr<PhotoAlbum> photoAlbum,
119 FetchResultObject &fetchResultObject, int32_t &errCode)
120 {
121 fetchResultObject.id = -1;
122 fetchResultObject.fetchResType = static_cast<int32_t>(FetchResType::TYPE_PHOTOALBUM);
123 if (photoAlbum != nullptr) {
124 auto native = FFIData::Create<PhotoAlbumImpl>(move(photoAlbum));
125 if (native != nullptr) {
126 fetchResultObject.id = native->GetID();
127 } else {
128 errCode = JS_INNER_FAIL;
129 }
130 } else {
131 errCode = JS_INNER_FAIL;
132 }
133 }
134
GetFirstObject(int32_t & errCode)135 FetchResultObject FetchResultImpl::GetFirstObject(int32_t &errCode)
136 {
137 FetchResultObject fetchResultObject = {
138 .id = -1,
139 .fetchResType = 0
140 };
141 switch (propertyPtr->fetchResType_) {
142 case FetchResType::TYPE_FILE: {
143 fileAsset = propertyPtr->fetchFileResult_->GetFirstObject();
144 GetFileAssetObj(move(fileAsset), fetchResultObject, errCode);
145 break;
146 }
147 case FetchResType::TYPE_PHOTOALBUM: {
148 photoAlbum = propertyPtr->fetchPhotoAlbumResult_->GetFirstObject();
149 GetPhotoAlbumObj(move(photoAlbum), fetchResultObject, errCode);
150 break;
151 }
152 default:
153 LOGE("unsupported FetchResType");
154 errCode = JS_INNER_FAIL;
155 break;
156 }
157 return fetchResultObject;
158 }
159
GetNextObject(int32_t & errCode)160 FetchResultObject FetchResultImpl::GetNextObject(int32_t &errCode)
161 {
162 FetchResultObject fetchResultObject = {
163 .id = -1,
164 .fetchResType = 0
165 };
166 switch (propertyPtr->fetchResType_) {
167 case FetchResType::TYPE_FILE: {
168 fileAsset = propertyPtr->fetchFileResult_->GetNextObject();
169 GetFileAssetObj(move(fileAsset), fetchResultObject, errCode);
170 break;
171 }
172 case FetchResType::TYPE_PHOTOALBUM: {
173 photoAlbum = propertyPtr->fetchPhotoAlbumResult_->GetNextObject();
174 GetPhotoAlbumObj(move(photoAlbum), fetchResultObject, errCode);
175 break;
176 }
177 default:
178 LOGE("unsupported FetchResType");
179 errCode = JS_INNER_FAIL;
180 break;
181 }
182 return fetchResultObject;
183 }
184
GetLastObject(int32_t & errCode)185 FetchResultObject FetchResultImpl::GetLastObject(int32_t &errCode)
186 {
187 FetchResultObject fetchResultObject = {
188 .id = -1,
189 .fetchResType = 0
190 };
191 switch (propertyPtr->fetchResType_) {
192 case FetchResType::TYPE_FILE: {
193 fileAsset = propertyPtr->fetchFileResult_->GetLastObject();
194 GetFileAssetObj(move(fileAsset), fetchResultObject, errCode);
195 break;
196 }
197 case FetchResType::TYPE_PHOTOALBUM: {
198 photoAlbum = propertyPtr->fetchPhotoAlbumResult_->GetLastObject();
199 GetPhotoAlbumObj(move(photoAlbum), fetchResultObject, errCode);
200 break;
201 }
202 default:
203 LOGE("unsupported FetchResType");
204 errCode = JS_INNER_FAIL;
205 break;
206 }
207 return fetchResultObject;
208 }
209
GetObjectAtPosition(int32_t position,int32_t & errCode)210 FetchResultObject FetchResultImpl::GetObjectAtPosition(int32_t position, int32_t &errCode)
211 {
212 FetchResultObject fetchResultObject = {
213 .id = -1,
214 .fetchResType = 0
215 };
216 switch (propertyPtr->fetchResType_) {
217 case FetchResType::TYPE_FILE: {
218 fileAsset = propertyPtr->fetchFileResult_->GetObjectAtPosition(position);
219 GetFileAssetObj(move(fileAsset), fetchResultObject, errCode);
220 break;
221 }
222 case FetchResType::TYPE_PHOTOALBUM: {
223 photoAlbum = propertyPtr->fetchPhotoAlbumResult_->GetObjectAtPosition(position);
224 GetPhotoAlbumObj(move(photoAlbum), fetchResultObject, errCode);
225 break;
226 }
227 default:
228 LOGE("unsupported FetchResType");
229 errCode = JS_INNER_FAIL;
230 break;
231 }
232 return fetchResultObject;
233 }
234
GetArryFileAssetObj(vector<unique_ptr<FileAsset>> & fileAssetArray,const shared_ptr<FetchResult<FileAsset>> & fetchResult,CArrayFetchResultObject & cArrayFetchResultObject,int32_t & errCode)235 static void GetArryFileAssetObj(vector<unique_ptr<FileAsset>> &fileAssetArray,
236 const shared_ptr<FetchResult<FileAsset>> &fetchResult,
237 CArrayFetchResultObject &cArrayFetchResultObject, int32_t &errCode)
238 {
239 errCode = E_SUCCESS;
240 auto file = fetchResult->GetFirstObject();
241 while (file != nullptr) {
242 fileAssetArray.push_back(move(file));
243 file = fetchResult->GetNextObject();
244 }
245 size_t fileAssetArraySize = fileAssetArray.size();
246 if (fileAssetArraySize <= 0) {
247 LOGE("fileAssetArray size error");
248 errCode = JS_INNER_FAIL;
249 return;
250 }
251 FetchResultObject* head =
252 static_cast<FetchResultObject *>(malloc(sizeof(FetchResultObject) * fileAssetArraySize));
253 if (head == nullptr) {
254 LOGE("malloc fileAssetArray failed.");
255 errCode = JS_INNER_FAIL;
256 return;
257 }
258 int32_t count = 0;
259 for (size_t i = 0; i < fileAssetArraySize; i++) {
260 if (errCode != E_SUCCESS) {
261 LOGE("GetFileAssetObj failed.");
262 for (int32_t j = 0; j < count; j++) {
263 FfiOHOSFFIFFIDataRelease(head[j].id);
264 }
265 free(head);
266 return;
267 }
268 GetFileAssetObj(move(fileAssetArray[i]), head[count], errCode);
269 count++;
270 }
271 cArrayFetchResultObject.head = head;
272 cArrayFetchResultObject.size = static_cast<int64_t>(count);
273 }
274
GetArryPhotoAlbumObj(vector<unique_ptr<PhotoAlbum>> & filePhotoAlbumArray,const shared_ptr<FetchResult<PhotoAlbum>> & fetchResult,CArrayFetchResultObject & cArrayFetchResultObject,int32_t & errCode)275 static void GetArryPhotoAlbumObj(vector<unique_ptr<PhotoAlbum>> &filePhotoAlbumArray,
276 const shared_ptr<FetchResult<PhotoAlbum>> &fetchResult,
277 CArrayFetchResultObject &cArrayFetchResultObject, int32_t &errCode)
278 {
279 errCode = E_SUCCESS;
280 auto file = fetchResult->GetFirstObject();
281 while (file != nullptr) {
282 filePhotoAlbumArray.push_back(move(file));
283 file = fetchResult->GetNextObject();
284 }
285 size_t filePhotoAlbumArraySize = filePhotoAlbumArray.size();
286 if (filePhotoAlbumArraySize < 0) {
287 LOGE("filePhotoAlbumArray size error");
288 errCode = JS_INNER_FAIL;
289 return;
290 }
291 FetchResultObject* head =
292 static_cast<FetchResultObject *>(malloc(sizeof(FetchResultObject) * filePhotoAlbumArraySize));
293 if (head == nullptr) {
294 LOGE("malloc filePhotoAlbumArray failed.");
295 errCode = JS_INNER_FAIL;
296 return;
297 }
298 int32_t count = 0;
299 for (size_t i = 0; i < filePhotoAlbumArraySize; i++) {
300 if (errCode != E_SUCCESS) {
301 LOGE("GetPhotoAlbumObj failed.");
302 for (int32_t j = 0; j < count; j++) {
303 FfiOHOSFFIFFIDataRelease(head[j].id);
304 }
305 free(head);
306 return;
307 }
308 GetPhotoAlbumObj(move(filePhotoAlbumArray[i]), head[count], errCode);
309 count++;
310 }
311 cArrayFetchResultObject.head = head;
312 cArrayFetchResultObject.size = static_cast<int64_t>(count);
313 }
314
GetAllObjects(int32_t & errCode)315 CArrayFetchResultObject FetchResultImpl::GetAllObjects(int32_t &errCode)
316 {
317 CArrayFetchResultObject cArrayFetchResultObject = {
318 .head = nullptr,
319 .size = 0
320 };
321 switch (propertyPtr->fetchResType_) {
322 case FetchResType::TYPE_FILE: {
323 auto fetchResult = propertyPtr->fetchFileResult_;
324 fileAssetArray.clear();
325 GetArryFileAssetObj(fileAssetArray, fetchResult, cArrayFetchResultObject, errCode);
326 break;
327 }
328 case FetchResType::TYPE_PHOTOALBUM: {
329 auto fetchResult = propertyPtr->fetchPhotoAlbumResult_;
330 filePhotoAlbumArray.clear();
331 GetArryPhotoAlbumObj(filePhotoAlbumArray, fetchResult, cArrayFetchResultObject, errCode);
332 break;
333 }
334 default:
335 LOGE("unsupported FetchResType");
336 errCode = JS_INNER_FAIL;
337 break;
338 }
339 return cArrayFetchResultObject;
340 }
341 }
342 }