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_library_asset_manager_test.h"
17 #include "datashare_helper.h"
18 #include "fetch_result.h"
19 #include "file_asset.h"
20 #include "get_self_permissions.h"
21 #include "file_uri.h"
22 #include "hilog/log.h"
23 #include "iservice_registry.h"
24 #include "medialibrary_db_const.h"
25 #include "medialibrary_errno.h"
26 #include "media_file_utils.h"
27 #include "media_library_manager.h"
28 #include "media_log.h"
29 #include "media_volume.h"
30 #include "scanner_utils.h"
31 #include "system_ability_definition.h"
32 #include "media_asset_base_capi.h"
33 #include "media_asset_manager_capi.h"
34 #include "oh_media_asset.h"
35 #include "media_asset.h"
36
37 using namespace std;
38 using namespace OHOS;
39 using namespace testing::ext;
40 using namespace OHOS::NativeRdb;
41 using namespace OHOS::AppExecFwk;
42
43 /**
44 * @FileName MediaLibraryAssetManagerTest
45 * @Desc Media library asset manager native function test
46 *
47 */
48 namespace OHOS {
49 namespace Media {
50 std::shared_ptr<DataShare::DataShareHelper> sDataShareHelper_ = nullptr;
51 std::unique_ptr<FileAsset> GetFile(int mediaTypeId);
52 void ClearFile();
53 void ClearAllFile();
54 void CreateDataHelper(int32_t systemAbilityId);
55
56 constexpr int STORAGE_MANAGER_MANAGER_ID = 5003;
57 int g_albumMediaType = MEDIA_TYPE_ALBUM;
58 int64_t g_oneImageSize = 0;
59 const int CLEAN_TIME = 1;
60 const int SCAN_WAIT_TIME = 10;
61 const int SCAN_WAIT_TIME_1S = 1;
62 const char ERROR_REQUEST_ID[UUID_STR_MAX_LENGTH] = "00000000-0000-0000-0000-000000000000";
63 const std::string ROOT_TEST_MEDIA_DIR =
64 "/data/app/el2/100/base/com.ohos.medialibrary.medialibrarydata/haps/";
65 const std::string TEST_DISPLAY_NAME = "test_image.png";
66
67 static const unsigned char FILE_CONTENT_JPG[] = {
68 0x49, 0x44, 0x33, 0x03, 0x20, 0x20, 0x20, 0x0c, 0x24, 0x5d, 0x54, 0x45, 0x4e, 0x43, 0x20, 0x20, 0x20, 0x0b,
69 0x20, 0x20, 0x20,
70 };
71
72 static const unsigned char FILE_CONTENT_MP4[] = {
73 0x20, 0x20, 0x20, 0x20, 0x66, 0x74, 0x79, 0x70, 0x69, 0x73, 0x6f, 0x6d, 0x20, 0x20, 0x02, 0x20, 0x69, 0x73, 0x6f,
74 0x6d, 0x69, 0x73, 0x6f, 0x32, 0x61, 0x76, 0x63, 0x31, 0x6d, 0x70, 0x34, 0x31, 0x20, 0x20, 0x20, 0x08, 0x66, 0x72,
75 0x65, 0x65, 0x20, 0x49, 0xdd, 0x01, 0x6d, 0x64, 0x61, 0x74, 0x20, 0x20, 0x02, 0xa0, 0x06, 0x05, 0xff, 0xff, 0x9c,
76 };
77
78 MediaLibraryManager* mediaLibraryManager = MediaLibraryManager::GetMediaLibraryManager();
79
SetUpTestCase(void)80 void MediaLibraryAssetManagerTest::SetUpTestCase(void)
81 {
82 vector<string> perms;
83 perms.push_back("ohos.permission.READ_IMAGEVIDEO");
84 perms.push_back("ohos.permission.WRITE_IMAGEVIDEO");
85 perms.push_back("ohos.permission.MEDIA_LOCATION");
86 perms.push_back("ohos.permission.GET_BUNDLE_INFO_PRIVILEGED");
87 uint64_t tokenId = 0;
88 PermissionUtilsUnitTest::SetAccessTokenPermission("MediaLibraryAssetManagerTest", perms, tokenId);
89 ASSERT_TRUE(tokenId != 0);
90
91 MEDIA_INFO_LOG("MediaLibraryAssetManagerTest::SetUpTestCase:: invoked");
92 CreateDataHelper(STORAGE_MANAGER_MANAGER_ID);
93 if (sDataShareHelper_ == nullptr) {
94 ASSERT_NE(sDataShareHelper_, nullptr);
95 return;
96 }
97
98 // make sure board is empty
99 ClearAllFile();
100
101 Uri scanUri(URI_SCANNER);
102 DataShareValuesBucket valuesBucket;
103 valuesBucket.Put(MEDIA_DATA_DB_FILE_PATH, ROOT_MEDIA_DIR);
104 sDataShareHelper_->Insert(scanUri, valuesBucket);
105 sleep(SCAN_WAIT_TIME);
106
107 MEDIA_INFO_LOG("MediaLibraryAssetManagerTest::SetUpTestCase:: Finish");
108 }
109
TearDownTestCase(void)110 void MediaLibraryAssetManagerTest::TearDownTestCase(void)
111 {
112 MEDIA_ERR_LOG("TearDownTestCase start");
113 if (sDataShareHelper_ != nullptr) {
114 sDataShareHelper_->Release();
115 }
116 sleep(CLEAN_TIME);
117 ClearAllFile();
118 MEDIA_INFO_LOG("TearDownTestCase end");
119 }
120 // SetUp:Execute before each test case
SetUp(void)121 void MediaLibraryAssetManagerTest::SetUp(void)
122 {
123 system("rm -rf /storage/cloud/100/files/Photo/*");
124 }
125
TearDown(void)126 void MediaLibraryAssetManagerTest::TearDown(void) {}
127
CreateDataHelper(int32_t systemAbilityId)128 void CreateDataHelper(int32_t systemAbilityId)
129 {
130 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
131 if (saManager == nullptr) {
132 MEDIA_ERR_LOG("Get system ability mgr failed.");
133 return;
134 }
135 auto remoteObj = saManager->GetSystemAbility(systemAbilityId);
136 if (remoteObj == nullptr) {
137 MEDIA_ERR_LOG("GetSystemAbility Service Failed.");
138 return;
139 }
140 mediaLibraryManager->InitMediaLibraryManager(remoteObj);
141 MEDIA_INFO_LOG("InitMediaLibraryManager success!");
142
143 if (sDataShareHelper_ == nullptr) {
144 const sptr<IRemoteObject> &token = remoteObj;
145 sDataShareHelper_ = DataShare::DataShareHelper::Creator(token, MEDIALIBRARY_DATA_URI);
146 }
147 mediaLibraryManager->InitMediaLibraryManager(remoteObj);
148 }
149
ClearAllFile()150 void ClearAllFile()
151 {
152 system("rm -rf /storage/media/100/local/files/.thumbs/*");
153 system("rm -rf /storage/cloud/100/files/Audio/*");
154 system("rm -rf /storage/cloud/100/files/Audios/*");
155 system("rm -rf /storage/cloud/100/files/Camera/*");
156 system("rm -rf /storage/cloud/100/files/Docs/Documents/*");
157 system("rm -rf /storage/cloud/100/files/Photo/*");
158 system("rm -rf /storage/cloud/100/files/Pictures/*");
159 system("rm -rf /storage/cloud/100/files/Docs/Download/*");
160 system("rm -rf /storage/cloud/100/files/Docs/.*");
161 system("rm -rf /storage/cloud/100/files/Videos/*");
162 system("rm -rf /storage/cloud/100/files/.*");
163 system("rm -rf /data/app/el2/100/database/com.ohos.medialibrary.medialibrarydata/*");
164 system("kill -9 `pidof com.ohos.medialibrary.medialibrarydata`");
165 system("scanner");
166 }
167
DeleteFile(std::string fileUri)168 void DeleteFile(std::string fileUri)
169 {
170 if (sDataShareHelper_ == nullptr) {
171 return;
172 }
173 Uri deleteAssetUri(MEDIALIBRARY_DATA_URI + "/" + MEDIA_FILEOPRN);
174 DataShare::DataSharePredicates predicates;
175 predicates.EqualTo(MEDIA_DATA_DB_ID, MediaFileUtils::GetIdFromUri(fileUri));
176 int retVal = sDataShareHelper_->Delete(deleteAssetUri, predicates);
177 MEDIA_INFO_LOG("MediaSpaceStatistics_test DeleteFile::uri :%{private}s", deleteAssetUri.ToString().c_str());
178 ASSERT_NE(retVal, E_ERR);
179 }
180
ClearFile()181 void ClearFile()
182 {
183 if (sDataShareHelper_ == nullptr) {
184 return;
185 }
186 vector<string> columns;
187 DataSharePredicates predicates;
188 string prefix = MEDIA_DATA_DB_MEDIA_TYPE + " <> " + to_string(g_albumMediaType);
189 predicates.SetWhereClause(prefix);
190 Uri queryFileUri(MEDIALIBRARY_DATA_URI);
191 shared_ptr<DataShareResultSet> resultSet = nullptr;
192 resultSet = sDataShareHelper_->Query(queryFileUri, predicates, columns);
193 ASSERT_NE((resultSet == nullptr), true);
194
195 unique_ptr<FetchResult<FileAsset>> fetchFileResult = make_unique<FetchResult<FileAsset>>(move(resultSet));
196 ASSERT_NE((fetchFileResult->GetCount() < 0), true);
197 unique_ptr<FileAsset> fileAsset = fetchFileResult->GetFirstObject();
198 while (fileAsset != nullptr) {
199 DeleteFile(fileAsset->GetUri());
200 fileAsset = fetchFileResult->GetNextObject();
201 }
202 }
203
CompareIfArraysEquals(const unsigned char originArray[],const unsigned char targetArray[],int32_t size)204 static bool CompareIfArraysEquals(const unsigned char originArray[],
205 const unsigned char targetArray[], int32_t size)
206 {
207 for (int i = 0; i < size - 1; i++) {
208 if (originArray[i] != targetArray[i]) {
209 return false;
210 }
211 }
212 return true;
213 }
214
CallbackFunciton(int32_t result,MediaLibrary_RequestId requestId)215 void CallbackFunciton(int32_t result, MediaLibrary_RequestId requestId)
216 {
217 EXPECT_EQ(result, E_SUCCESS);
218 MEDIA_INFO_LOG("CallbackFunciton::result: %{public}d", result);
219 MEDIA_INFO_LOG("CallbackFunciton::requestId: %{public}s", requestId.requestId);
220 }
221
CallbackFuncitonOnImageDataPrepared(MediaLibrary_ErrorCode result,MediaLibrary_RequestId requestId,MediaLibrary_MediaQuality mediaQuality,MediaLibrary_MediaContentType type,OH_ImageSourceNative * imageSourceNative)222 void CallbackFuncitonOnImageDataPrepared(MediaLibrary_ErrorCode result,
223 MediaLibrary_RequestId requestId, MediaLibrary_MediaQuality mediaQuality,
224 MediaLibrary_MediaContentType type, OH_ImageSourceNative* imageSourceNative)
225 {
226 MEDIA_INFO_LOG("CallbackFuncitonOnImageDataPrepared::result: %{public}d", result);
227 MEDIA_INFO_LOG("CallbackFuncitonOnImageDataPrepared::requestId: %{public}s", requestId.requestId);
228 }
229
CallbackFuncitonOnMovingPhotoDataPrepared(MediaLibrary_ErrorCode result,MediaLibrary_RequestId requestId,MediaLibrary_MediaQuality mediaQuality,MediaLibrary_MediaContentType type,OH_MovingPhoto * movingPhoto)230 void CallbackFuncitonOnMovingPhotoDataPrepared(MediaLibrary_ErrorCode result, MediaLibrary_RequestId requestId,
231 MediaLibrary_MediaQuality mediaQuality, MediaLibrary_MediaContentType type, OH_MovingPhoto* movingPhoto)
232 {
233 MEDIA_INFO_LOG("CallbackFuncitonOnMovingPhotoDataPrepared::result: %{public}d", result);
234 MEDIA_INFO_LOG("CallbackFuncitonOnMovingPhotoDataPrepared::requestId: %{public}s", requestId.requestId);
235 }
236
237 /**
238 * @tc.number : MediaLibraryAssetManager_test_001
239 * @tc.name : copy src image to dest image to see if error occurs
240 * @tc.desc : compare with src image to see if equals
241 */
242 HWTEST_F(MediaLibraryAssetManagerTest, MediaLibraryAssetManager_test_001, TestSize.Level0)
243 {
244 MEDIA_INFO_LOG("MediaLibraryAssetManager_test_001::Start");
245 string srcDisplayName = "request_image_src_1.jpg";
246 string destDisplayName = "request_image_dest_1.jpg";
247 string srcuri = mediaLibraryManager->CreateAsset(srcDisplayName);
248 ASSERT_NE(srcuri, "");
249 int32_t srcFd = mediaLibraryManager->OpenAsset(srcuri, MEDIA_FILEMODE_READWRITE);
250 ASSERT_NE(srcFd <= 0, true);
251 int32_t resWrite = write(srcFd, FILE_CONTENT_JPG, sizeof(FILE_CONTENT_JPG));
252 if (resWrite == -1) {
253 EXPECT_EQ(false, true);
254 }
255 mediaLibraryManager->CloseAsset(srcuri, srcFd);
256
257 string destUri = ROOT_TEST_MEDIA_DIR + destDisplayName;
258 ASSERT_NE(destUri, "");
259 sleep(SCAN_WAIT_TIME_1S);
260 MEDIA_INFO_LOG("createFile uri: %{public}s", destUri.c_str());
261 OH_MediaAssetManager *manager = OH_MediaAssetManager_Create();
262 ASSERT_NE(manager, nullptr);
263 MediaLibrary_RequestOptions requestOptions;
264 requestOptions.deliveryMode = MediaLibrary_DeliveryMode::MEDIA_LIBRARY_FAST_MODE;
265 static OH_MediaLibrary_OnDataPrepared callback = CallbackFunciton;
266 MediaLibrary_RequestId requestID = OH_MediaAssetManager_RequestImageForPath(manager, srcuri.c_str(),
267 requestOptions, destUri.c_str(), callback);
268 MEDIA_INFO_LOG("requestId: %{public}s", requestID.requestId);
269 ASSERT_NE(strcmp(requestID.requestId, ERROR_REQUEST_ID), 0);
270 AppFileService::ModuleFileUri::FileUri destFileUri(destUri);
271 string destPath = destFileUri.GetRealPath();
272 int destFd = MediaFileUtils::OpenFile(destPath, MEDIA_FILEMODE_READWRITE);
273 int64_t destLen = lseek(destFd, 0, SEEK_END);
274 lseek(destFd, 0, SEEK_SET);
275 unsigned char *buf = static_cast<unsigned char*>(malloc(destLen));
276 ASSERT_NE((buf == nullptr), true);
277 read(destFd, buf, destLen);
278 bool result = CompareIfArraysEquals(buf, FILE_CONTENT_JPG, sizeof(FILE_CONTENT_JPG));
279 free(buf);
280 close(destFd);
281 EXPECT_EQ(result, true);
282 MEDIA_INFO_LOG("CreateFile:: end Create file: %{public}s", destDisplayName.c_str());
283 }
284
285 /**
286 * @tc.number : MediaLibraryAssetManager_test_002
287 * @tc.name : copy src image to dest image to see if error occurs
288 * @tc.desc : compare with src image to see if equals
289 */
290 HWTEST_F(MediaLibraryAssetManagerTest, MediaLibraryAssetManager_test_002, TestSize.Level0)
291 {
292 MEDIA_INFO_LOG("MediaLibraryAssetManager_test_002::Start");
293 string srcDisplayName = "request_image_src_2.jpg";
294 string destDisplayName = "request_image_dest_2.jpg";
295 string srcuri = mediaLibraryManager->CreateAsset(srcDisplayName);
296 ASSERT_NE(srcuri, "");
297 int32_t srcFd = mediaLibraryManager->OpenAsset(srcuri, MEDIA_FILEMODE_READWRITE);
298 ASSERT_NE(srcFd <= 0, true);
299 int32_t resWrite = write(srcFd, FILE_CONTENT_JPG, sizeof(FILE_CONTENT_JPG));
300 if (resWrite == -1) {
301 EXPECT_EQ(false, true);
302 }
303 mediaLibraryManager->CloseAsset(srcuri, srcFd);
304
305 string destUri = ROOT_TEST_MEDIA_DIR + destDisplayName;
306 ASSERT_NE(destUri, "");
307 MEDIA_INFO_LOG("createFile uri: %{public}s", destUri.c_str());
308 sleep(SCAN_WAIT_TIME_1S);
309 OH_MediaAssetManager *manager = OH_MediaAssetManager_Create();
310 ASSERT_NE(manager, nullptr);
311 MediaLibrary_RequestOptions requestOptions;
312 requestOptions.deliveryMode = MediaLibrary_DeliveryMode::MEDIA_LIBRARY_HIGH_QUALITY_MODE;
313 static OH_MediaLibrary_OnDataPrepared callback = CallbackFunciton;
314 MediaLibrary_RequestId requestID = OH_MediaAssetManager_RequestImageForPath(manager, srcuri.c_str(),
315 requestOptions, destUri.c_str(), callback);
316 MEDIA_INFO_LOG("requestId: %{public}s", requestID.requestId);
317 ASSERT_NE(strcmp(requestID.requestId, ERROR_REQUEST_ID), 0);
318 AppFileService::ModuleFileUri::FileUri destFileUri(destUri);
319 string destPath = destFileUri.GetRealPath();
320 int destFd = MediaFileUtils::OpenFile(destPath, MEDIA_FILEMODE_READWRITE);
321 int64_t destLen = lseek(destFd, 0, SEEK_END);
322 lseek(destFd, 0, SEEK_SET);
323 unsigned char *buf = static_cast<unsigned char*>(malloc(destLen));
324 ASSERT_NE((buf == nullptr), true);
325 read(destFd, buf, destLen);
326 bool result = CompareIfArraysEquals(buf, FILE_CONTENT_JPG, sizeof(FILE_CONTENT_JPG));
327 free(buf);
328 close(destFd);
329 EXPECT_EQ(result, true);
330 MEDIA_INFO_LOG("CreateFile:: end Create file: %{public}s", destDisplayName.c_str());
331 }
332
333 /**
334 * @tc.number : MediaLibraryAssetManager_test_003
335 * @tc.name : copy src video to dest video to see if error occurs
336 * @tc.desc : compare with src video to see if equals
337 */
338 HWTEST_F(MediaLibraryAssetManagerTest, MediaLibraryAssetManager_test_003, TestSize.Level0)
339 {
340 MEDIA_INFO_LOG("MediaLibraryAssetManager_test_003::Start");
341 string srcDisplayName = "request_video_src_1.mp4";
342 string destDisplayName = "request_video_dest_1.mp4";
343 string srcuri = mediaLibraryManager->CreateAsset(srcDisplayName);
344 ASSERT_NE(srcuri, "");
345 int32_t srcFd = mediaLibraryManager->OpenAsset(srcuri, MEDIA_FILEMODE_READWRITE);
346 ASSERT_NE(srcFd <= 0, true);
347 int32_t resWrite = write(srcFd, FILE_CONTENT_MP4, sizeof(FILE_CONTENT_MP4));
348 if (resWrite == -1) {
349 EXPECT_EQ(false, true);
350 }
351 mediaLibraryManager->CloseAsset(srcuri, srcFd);
352
353 string destUri = ROOT_TEST_MEDIA_DIR + destDisplayName;
354 ASSERT_NE(destUri, "");
355 MEDIA_INFO_LOG("createFile uri: %{public}s", destUri.c_str());
356 sleep(SCAN_WAIT_TIME_1S);
357 OH_MediaAssetManager *manager = OH_MediaAssetManager_Create();
358 ASSERT_NE(manager, nullptr);
359 MediaLibrary_RequestOptions requestOptions;
360 requestOptions.deliveryMode = MediaLibrary_DeliveryMode::MEDIA_LIBRARY_BALANCED_MODE;
361 static OH_MediaLibrary_OnDataPrepared callback = CallbackFunciton;
362 MediaLibrary_RequestId requestID = OH_MediaAssetManager_RequestVideoForPath(manager, srcuri.c_str(),
363 requestOptions, destUri.c_str(), callback);
364 MEDIA_INFO_LOG("requestId: %{public}s", requestID.requestId);
365 ASSERT_NE(strcmp(requestID.requestId, ERROR_REQUEST_ID), 0);
366 AppFileService::ModuleFileUri::FileUri destFileUri(destUri);
367 string destPath = destFileUri.GetRealPath();
368 int destFd = MediaFileUtils::OpenFile(destPath, MEDIA_FILEMODE_READWRITE);
369 int64_t destLen = lseek(destFd, 0, SEEK_END);
370 lseek(destFd, 0, SEEK_SET);
371 unsigned char *buf = static_cast<unsigned char*>(malloc(destLen));
372 ASSERT_NE((buf == nullptr), true);
373 read(destFd, buf, destLen);
374 bool result = CompareIfArraysEquals(buf, FILE_CONTENT_MP4, sizeof(FILE_CONTENT_MP4));
375 free(buf);
376 close(destFd);
377 EXPECT_EQ(result, true);
378 MEDIA_INFO_LOG("CreateFile:: end Create file: %{public}s", destDisplayName.c_str());
379 }
380
381 /**
382 * @tc.number : MediaLibraryAssetManager_test_004
383 * @tc.name : input uri is null to see if error occurs and
384 * @tc.desc : compare requestId with null to see if equals
385 */
386 HWTEST_F(MediaLibraryAssetManagerTest, MediaLibraryAssetManager_test_004, TestSize.Level0)
387 {
388 MEDIA_INFO_LOG("MediaLibraryAssetManager_test_004::Start");
389 string destDisplayName = "request_image_dest_3.jpg";
390 string destUri = ROOT_TEST_MEDIA_DIR + destDisplayName;
391 ASSERT_NE(destUri, "");
392 MEDIA_INFO_LOG("createFile uri: %{public}s", destUri.c_str());
393 sleep(SCAN_WAIT_TIME_1S);
394 OH_MediaAssetManager *manager = OH_MediaAssetManager_Create();
395 ASSERT_NE(manager, nullptr);
396 MediaLibrary_RequestOptions requestOptions;
397 requestOptions.deliveryMode = MediaLibrary_DeliveryMode::MEDIA_LIBRARY_FAST_MODE;
398 static OH_MediaLibrary_OnDataPrepared callback = CallbackFunciton;
399 MediaLibrary_RequestId requestID = OH_MediaAssetManager_RequestImageForPath(manager, nullptr,
400 requestOptions, destUri.c_str(), callback);
401 MEDIA_INFO_LOG("requestId: %{public}s", requestID.requestId);
402 EXPECT_EQ(strcmp(requestID.requestId, ERROR_REQUEST_ID), 0);
403 }
404
405 /**
406 * @tc.number : MediaLibraryAssetManager_test_005
407 * @tc.name : create video again to see if error occurs
408 * @tc.desc : compare with src image to see if equals
409 */
410 HWTEST_F(MediaLibraryAssetManagerTest, MediaLibraryAssetManager_test_005, TestSize.Level0)
411 {
412 MEDIA_INFO_LOG("MediaLibraryAssetManager_test_005::Start");
413 string srcDisplayName = "request_video_src_2.mp4";
414 string destDisplayName = "request_video_dest_2.mp4";
415 string srcuri = mediaLibraryManager->CreateAsset(srcDisplayName);
416 ASSERT_NE(srcuri, "");
417 int32_t srcFd = mediaLibraryManager->OpenAsset(srcuri, MEDIA_FILEMODE_READWRITE);
418 ASSERT_NE(srcFd <= 0, true);
419 int32_t resWrite = write(srcFd, FILE_CONTENT_MP4, sizeof(FILE_CONTENT_MP4));
420 if (resWrite == -1) {
421 EXPECT_EQ(false, true);
422 }
423 mediaLibraryManager->CloseAsset(srcuri, srcFd);
424
425 string destUri = ROOT_TEST_MEDIA_DIR + destDisplayName;
426 ASSERT_NE(destUri, "");
427 MEDIA_INFO_LOG("createFile uri: %{public}s", destUri.c_str());
428 sleep(SCAN_WAIT_TIME_1S);
429 OH_MediaAssetManager *manager = OH_MediaAssetManager_Create();
430 ASSERT_NE(manager, nullptr);
431 MediaLibrary_RequestOptions requestOptions;
432 requestOptions.deliveryMode = MediaLibrary_DeliveryMode::MEDIA_LIBRARY_BALANCED_MODE;
433 static OH_MediaLibrary_OnDataPrepared callback = CallbackFunciton;
434 MediaLibrary_RequestId requestID = OH_MediaAssetManager_RequestVideoForPath(manager, srcuri.c_str(),
435 requestOptions, destUri.c_str(), callback);
436 MEDIA_INFO_LOG("requestId: %{public}s", requestID.requestId);
437 ASSERT_NE(strcmp(requestID.requestId, ERROR_REQUEST_ID), 0);
438 AppFileService::ModuleFileUri::FileUri destFileUri(destUri);
439 string destPath = destFileUri.GetRealPath();
440 int destFd = MediaFileUtils::OpenFile(destPath, MEDIA_FILEMODE_READWRITE);
441 int64_t destLen = lseek(destFd, 0, SEEK_END);
442 lseek(destFd, 0, SEEK_SET);
443 unsigned char *buf = static_cast<unsigned char*>(malloc(destLen));
444 ASSERT_NE((buf == nullptr), true);
445 read(destFd, buf, destLen);
446 bool result = CompareIfArraysEquals(buf, FILE_CONTENT_JPG, sizeof(FILE_CONTENT_JPG));
447 free(buf);
448 close(destFd);
449 ASSERT_NE(result, true);
450 MEDIA_INFO_LOG("CreateFile:: end Create file: %{public}s", destDisplayName.c_str());
451 }
452
453 /**
454 * @tc.number : MediaLibraryAssetManager_test_006
455 * @tc.name : create video again to see if error occurs
456 * @tc.desc : call request image function see if requestId = NULL
457 */
458 HWTEST_F(MediaLibraryAssetManagerTest, MediaLibraryAssetManager_test_006, TestSize.Level0)
459 {
460 MEDIA_INFO_LOG("MediaLibraryAssetManager_test_006::Start");
461 string srcDisplayName = "request_video_src_3.mp4";
462 string destDisplayName = "request_video_dest_3.mp4";
463 string srcuri = mediaLibraryManager->CreateAsset(srcDisplayName);
464 ASSERT_NE(srcuri, "");
465 int32_t srcFd = mediaLibraryManager->OpenAsset(srcuri, MEDIA_FILEMODE_READWRITE);
466 ASSERT_NE(srcFd <= 0, true);
467 int32_t resWrite = write(srcFd, FILE_CONTENT_MP4, sizeof(FILE_CONTENT_MP4));
468 if (resWrite == -1) {
469 EXPECT_EQ(false, true);
470 }
471 mediaLibraryManager->CloseAsset(srcuri, srcFd);
472
473 string destUri = ROOT_TEST_MEDIA_DIR + destDisplayName;
474 ASSERT_NE(destUri, "");
475 MEDIA_INFO_LOG("createFile uri: %{public}s", destUri.c_str());
476 sleep(SCAN_WAIT_TIME_1S);
477 OH_MediaAssetManager *manager = OH_MediaAssetManager_Create();
478 ASSERT_NE(manager, nullptr);
479 MediaLibrary_RequestOptions requestOptions;
480 requestOptions.deliveryMode = MediaLibrary_DeliveryMode::MEDIA_LIBRARY_FAST_MODE;
481 static OH_MediaLibrary_OnDataPrepared callback = CallbackFunciton;
482 MediaLibrary_RequestId requestID = OH_MediaAssetManager_RequestImageForPath(manager, srcuri.c_str(),
483 requestOptions, destUri.c_str(), callback);
484 MEDIA_INFO_LOG("requestId: %{public}s", requestID.requestId);
485 EXPECT_EQ(strcmp(requestID.requestId, ERROR_REQUEST_ID), 0);
486 }
487
488 /**
489 * @tc.number : MediaLibraryAssetManager_test_007
490 * @tc.name : request image by ML_HIGH_QUALITY_MODE, then cancel request
491 * @tc.desc : call request image function see if requestId = NULL
492 */
493 HWTEST_F(MediaLibraryAssetManagerTest, MediaLibraryAssetManager_test_007, TestSize.Level0)
494 {
495 MEDIA_INFO_LOG("MediaLibraryAssetManager_test_007::Start");
496 string srcDisplayName = "request_video_src_4.jpg";
497 string destDisplayName = "request_video_dest_4.jpg";
498 string srcuri = mediaLibraryManager->CreateAsset(srcDisplayName);
499 ASSERT_NE(srcuri, "");
500 int32_t srcFd = mediaLibraryManager->OpenAsset(srcuri, MEDIA_FILEMODE_READWRITE);
501 ASSERT_NE(srcFd <= 0, true);
502 int32_t resWrite = write(srcFd, FILE_CONTENT_MP4, sizeof(FILE_CONTENT_MP4));
503 if (resWrite == -1) {
504 EXPECT_EQ(false, true);
505 }
506 mediaLibraryManager->CloseAsset(srcuri, srcFd);
507
508 string destUri = ROOT_TEST_MEDIA_DIR + destDisplayName;
509 ASSERT_NE(destUri, "");
510 MEDIA_INFO_LOG("createFile uri: %{public}s", destUri.c_str());
511 sleep(SCAN_WAIT_TIME_1S);
512 OH_MediaAssetManager *manager = OH_MediaAssetManager_Create();
513 ASSERT_NE(manager, nullptr);
514 MediaLibrary_RequestOptions requestOptions;
515 requestOptions.deliveryMode = MediaLibrary_DeliveryMode::MEDIA_LIBRARY_HIGH_QUALITY_MODE;
516 static OH_MediaLibrary_OnDataPrepared callback = CallbackFunciton;
517 MediaLibrary_RequestId requestID = OH_MediaAssetManager_RequestImageForPath(manager, srcuri.c_str(),
518 requestOptions, destUri.c_str(), callback);
519 bool ret = OH_MediaAssetManager_CancelRequest(manager, requestID);
520 ASSERT_EQ(ret, false);
521 }
522
523 /**
524 * @tc.number : MediaLibraryAssetManager_test_008
525 * @tc.name : request image by ML_HIGH_QUALITY_MODE, then request image
526 * @tc.desc : call request image function and verify the correct return code and image source
527 */
528 HWTEST_F(MediaLibraryAssetManagerTest, MediaLibraryAssetManager_test_008, TestSize.Level0)
529 {
530 MEDIA_INFO_LOG("MediaLibraryAssetManager_test_008::Start");
531 string srcDisplayName = "request_video_src_4.jpg";
532 string destDisplayName = "request_video_dest_4.jpg";
533 string srcuri = mediaLibraryManager->CreateAsset(srcDisplayName);
534 ASSERT_NE(srcuri, "");
535 int32_t srcFd = mediaLibraryManager->OpenAsset(srcuri, MEDIA_FILEMODE_READWRITE);
536 ASSERT_NE(srcFd <= 0, true);
537 int32_t resWrite = write(srcFd, FILE_CONTENT_MP4, sizeof(FILE_CONTENT_MP4));
538 if (resWrite == -1) {
539 EXPECT_EQ(false, true);
540 }
541 mediaLibraryManager->CloseAsset(srcuri, srcFd);
542
543 string destUri = ROOT_TEST_MEDIA_DIR + destDisplayName;
544 ASSERT_NE(destUri, "");
545 MEDIA_INFO_LOG("createFile uri: %{public}s", destUri.c_str());
546 sleep(SCAN_WAIT_TIME_1S);
547 OH_MediaAssetManager *manager = OH_MediaAssetManager_Create();
548 ASSERT_NE(manager, nullptr);
549 MediaLibrary_RequestOptions requestOptions;
550 requestOptions.deliveryMode = MediaLibrary_DeliveryMode::MEDIA_LIBRARY_HIGH_QUALITY_MODE;
551 static OH_MediaLibrary_OnDataPrepared callback_ = CallbackFunciton;
552 static OH_MediaLibrary_OnImageDataPrepared callback = CallbackFuncitonOnImageDataPrepared;
553 std::shared_ptr<FileAsset> fileAsset = std::make_shared<FileAsset>();
554 fileAsset->SetResultNapiType(OHOS::Media::ResultNapiType::TYPE_MEDIALIBRARY);
555 fileAsset->SetMediaType(OHOS::Media::MEDIA_TYPE_IMAGE);
556 fileAsset->SetDisplayName(TEST_DISPLAY_NAME);
557 auto mediaAssetImpl = MediaAssetFactory::CreateMediaAsset(fileAsset);
558 auto mediaAsset = new OH_MediaAsset(mediaAssetImpl);
559 ASSERT_NE(mediaAsset, nullptr);
560 MediaLibrary_RequestId requestID = OH_MediaAssetManager_RequestImageForPath(manager, srcuri.c_str(),
561 requestOptions, destUri.c_str(), callback_);
562 MediaLibrary_ErrorCode ret = OH_MediaAssetManager_RequestImage(manager, mediaAsset, requestOptions,
563 &requestID, callback);
564 EXPECT_EQ(ret, MEDIA_LIBRARY_OK);
565 ret = OH_MediaAssetManager_RequestImage(nullptr, mediaAsset, requestOptions, &requestID, callback);
566 EXPECT_EQ(ret, MEDIA_LIBRARY_PARAMETER_ERROR);
567 ret = OH_MediaAssetManager_RequestImage(manager, nullptr, requestOptions, &requestID, callback);
568 EXPECT_EQ(ret, MEDIA_LIBRARY_PARAMETER_ERROR);
569 ret = OH_MediaAssetManager_RequestImage(manager, mediaAsset, requestOptions, nullptr, callback);
570 EXPECT_EQ(ret, MEDIA_LIBRARY_PARAMETER_ERROR);
571 ret = OH_MediaAssetManager_RequestImage(manager, mediaAsset, requestOptions, &requestID, nullptr);
572 EXPECT_EQ(ret, MEDIA_LIBRARY_PARAMETER_ERROR);
573 std::shared_ptr<FileAsset> fileAsset_ = mediaAsset->mediaAsset_->GetFileAssetInstance();
574 const string displayName = "";
575 fileAsset_->SetDisplayName(displayName);
576 ret = OH_MediaAssetManager_RequestImage(manager, mediaAsset, requestOptions, &requestID, callback);
577 EXPECT_EQ(ret, MEDIA_LIBRARY_PARAMETER_ERROR);
578 }
579
580 /**
581 * @tc.number : MediaLibraryAssetManager_test_009
582 * @tc.name : request moving photo by ML_HIGH_QUALITY_MODE, then request moving photo
583 * @tc.desc : call request moving photo function and verify the correct return code and moving photo source
584 */
585 HWTEST_F(MediaLibraryAssetManagerTest, MediaLibraryAssetManager_test_009, TestSize.Level0)
586 {
587 MEDIA_INFO_LOG("MediaLibraryAssetManager_test_009::Start");
588 string srcDisplayName = "request_video_src_4.jpg";
589 string destDisplayName = "request_video_dest_4.jpg";
590 string srcuri = mediaLibraryManager->CreateAsset(srcDisplayName);
591 ASSERT_NE(srcuri, "");
592 int32_t srcFd = mediaLibraryManager->OpenAsset(srcuri, MEDIA_FILEMODE_READWRITE);
593 ASSERT_NE(srcFd <= 0, true);
594 int32_t resWrite = write(srcFd, FILE_CONTENT_MP4, sizeof(FILE_CONTENT_MP4));
595 if (resWrite == -1) {
596 EXPECT_EQ(false, true);
597 }
598 mediaLibraryManager->CloseAsset(srcuri, srcFd);
599
600 string destUri = ROOT_TEST_MEDIA_DIR + destDisplayName;
601 ASSERT_NE(destUri, "");
602 MEDIA_INFO_LOG("createFile uri: %{public}s", destUri.c_str());
603 sleep(SCAN_WAIT_TIME_1S);
604 OH_MediaAssetManager *manager = OH_MediaAssetManager_Create();
605 ASSERT_NE(manager, nullptr);
606 MediaLibrary_RequestOptions requestOptions;
607 requestOptions.deliveryMode = MediaLibrary_DeliveryMode::MEDIA_LIBRARY_HIGH_QUALITY_MODE;
608 static OH_MediaLibrary_OnDataPrepared callback_ = CallbackFunciton;
609 static OH_MediaLibrary_OnMovingPhotoDataPrepared callback = CallbackFuncitonOnMovingPhotoDataPrepared;
610 std::shared_ptr<FileAsset> fileAsset = std::make_shared<FileAsset>();
611 fileAsset->SetResultNapiType(OHOS::Media::ResultNapiType::TYPE_MEDIALIBRARY);
612 fileAsset->SetMediaType(OHOS::Media::MEDIA_TYPE_IMAGE);
613 fileAsset->SetDisplayName(TEST_DISPLAY_NAME);
614 auto mediaAssetImpl = MediaAssetFactory::CreateMediaAsset(fileAsset);
615 auto mediaAsset = new OH_MediaAsset(mediaAssetImpl);
616 ASSERT_NE(mediaAsset, nullptr);
617 MediaLibrary_RequestId requestID = OH_MediaAssetManager_RequestImageForPath(manager, srcuri.c_str(),
618 requestOptions, destUri.c_str(), callback_);
619 MediaLibrary_ErrorCode ret = OH_MediaAssetManager_RequestMovingPhoto(manager, mediaAsset, requestOptions,
620 &requestID, callback);
621 EXPECT_EQ(ret, MEDIA_LIBRARY_OK);
622 ret = OH_MediaAssetManager_RequestMovingPhoto(manager, mediaAsset, requestOptions, &requestID, callback);
623 EXPECT_EQ(ret, MEDIA_LIBRARY_OK);
624 ret = OH_MediaAssetManager_RequestMovingPhoto(manager, nullptr, requestOptions, &requestID, callback);
625 EXPECT_EQ(ret, MEDIA_LIBRARY_PARAMETER_ERROR);
626 ret = OH_MediaAssetManager_RequestMovingPhoto(manager, mediaAsset, requestOptions, nullptr, callback);
627 EXPECT_EQ(ret, MEDIA_LIBRARY_PARAMETER_ERROR);
628 ret = OH_MediaAssetManager_RequestMovingPhoto(manager, mediaAsset, requestOptions, &requestID, nullptr);
629 EXPECT_EQ(ret, MEDIA_LIBRARY_PARAMETER_ERROR);
630 std::shared_ptr<FileAsset> fileAsset_ = mediaAsset->mediaAsset_->GetFileAssetInstance();
631 const string displayName = "";
632 fileAsset_->SetDisplayName(displayName);
633 ret = OH_MediaAssetManager_RequestMovingPhoto(manager, mediaAsset, requestOptions, &requestID, callback);
634 EXPECT_EQ(ret, MEDIA_LIBRARY_PARAMETER_ERROR);
635 }
636 } // namespace Media
637 } // namespace OHOS
638