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