diff --git a/frameworks/innerkitsimpl/media_library_manager/BUILD.gn b/frameworks/innerkitsimpl/media_library_manager/BUILD.gn index 208f34e36955a711cda4156f51a57229b222353e..2248b44e884398bba22f0dff927ac440dfa58f0e 100644 --- a/frameworks/innerkitsimpl/media_library_manager/BUILD.gn +++ b/frameworks/innerkitsimpl/media_library_manager/BUILD.gn @@ -34,6 +34,7 @@ ohos_shared_library("media_library_manager") { "ability_base:zuri", "ability_runtime:ability_manager", "ability_runtime:abilitykit_native", + "access_token:libtokenid_sdk", "bundle_framework:appexecfwk_base", "c_utils:utils", "common_event_service:cesfwk_innerkits", diff --git a/frameworks/innerkitsimpl/media_library_manager/media_library_manager.cpp b/frameworks/innerkitsimpl/media_library_manager/media_library_manager.cpp index 2c4647b227c7178ef23297c5d4afab8dcdbd3f62..ec9d9537aacfadb4ba6d6fd5a1c28c3ac03db897 100644 --- a/frameworks/innerkitsimpl/media_library_manager/media_library_manager.cpp +++ b/frameworks/innerkitsimpl/media_library_manager/media_library_manager.cpp @@ -20,6 +20,7 @@ #include #include +#include "accesstoken_kit.h" #include "album_asset.h" #include "datashare_abs_result_set.h" #include "datashare_predicates.h" @@ -34,6 +35,7 @@ #include "medialibrary_tracer.h" #include "medialibrary_type_const.h" #include "post_proc.h" +#include "permission_utils.h" #include "result_set_utils.h" #include "string_ex.h" #include "thumbnail_const.h" @@ -66,6 +68,97 @@ void MediaLibraryManager::InitMediaLibraryManager(const sptr &tok } } +static void UriAppendKeyValue(string &uri, const string &key, const string &value) +{ + string uriKey = key + '='; + if (uri.find(uriKey) != string::npos) { + return; + } + char queryMark = (uri.find('?') == string::npos) ? '?' : '&'; + string append = queryMark + key + '=' + value; + size_t posJ = uri.find('#'); + if (posJ == string::npos) { + uri += append; + } else { + uri.insert(posJ, append); + } +} + +static void GetCreateUri(string &uri) +{ + uri = PAH_CREATE_PHOTO; + const std::string API_VERSION = "api_version"; + UriAppendKeyValue(uri, API_VERSION, to_string(MEDIA_API_VERSION_V10)); +} + +static int32_t parseCreateArguments(const string &displayName, DataShareValuesBucket &valuesBucket) +{ + MediaType mediaType = MediaFileUtils::GetMediaType(displayName); + if (mediaType != MEDIA_TYPE_IMAGE && mediaType != MEDIA_TYPE_VIDEO) { + MEDIA_ERR_LOG("Failed to create Asset, invalid file type"); + return E_ERR; + } + valuesBucket.Put(MEDIA_DATA_DB_NAME, displayName); + valuesBucket.Put(MEDIA_DATA_DB_MEDIA_TYPE, static_cast(mediaType)); + return E_OK; +} + +string MediaLibraryManager::CreateAsset(const string &displayName) +{ + if (sDataShareHelper_ == nullptr || displayName.empty()) { + MEDIA_ERR_LOG("Failed to create Asset, datashareHelper is nullptr"); + sDataShareHelper_ = DataShare::DataShareHelper::Creator(token_, MEDIALIBRARY_DATA_URI); + } + DataShareValuesBucket valuesBucket; + auto ret = parseCreateArguments(displayName, valuesBucket); + if (ret != NativeRdb::E_OK) { + MEDIA_ERR_LOG("Failed to create Asset, parse create argument fails"); + return ""; + } + string createFileUri; + GetCreateUri(createFileUri); + Uri createUri(createFileUri); + string outUri; + int index = sDataShareHelper_->InsertExt(createUri, valuesBucket, outUri); + if (index < 0) { + MEDIA_ERR_LOG("Failed to create Asset, insert database error!"); + return ""; + } + return outUri; +} + +static bool CheckUri(string &uri) +{ + if (uri.find("..") != string::npos) { + return false; + } + string uriprex = "file://media"; + return uri.substr(0, uriprex.size()) == uriprex; +} + +int32_t MediaLibraryManager::OpenAsset(string &uri, const string openMode) +{ + if (openMode.empty()) { + return E_ERR; + } + if (!CheckUri(uri)) { + MEDIA_ERR_LOG("invalid uri"); + return E_ERR; + } + string originOpenMode = openMode; + std::transform(originOpenMode.begin(), originOpenMode.end(), + originOpenMode.begin(), [](unsigned char c) {return std::tolower(c);}); + if (!MEDIA_OPEN_MODES.count(originOpenMode)) { + return E_ERR; + } + if (sDataShareHelper_ == nullptr) { + MEDIA_ERR_LOG("Failed to open Asset, datashareHelper is nullptr"); + return E_ERR; + } + Uri openUri(uri); + return sDataShareHelper_->OpenFile(openUri, openMode); +} + int32_t MediaLibraryManager::CloseAsset(const string &uri, const int32_t fd) { int32_t retVal = E_FAIL; diff --git a/frameworks/innerkitsimpl/test/BUILD.gn b/frameworks/innerkitsimpl/test/BUILD.gn index 8febc4464168a7c8729f99d6369541f704dc6756..6a6ceb180a7083ec31b621c20d0bf0d8fb5f610f 100644 --- a/frameworks/innerkitsimpl/test/BUILD.gn +++ b/frameworks/innerkitsimpl/test/BUILD.gn @@ -17,6 +17,7 @@ group("test") { deps = [ "unittest/album_count_cover_test:AlbumCountCoverTest", "unittest/media_event_test:unittest", + "unittest/media_library_manager_test:unittest", "unittest/medialib_statistic_test:unittest", "unittest/medialibrary_album_source_test:unittest", "unittest/medialibrary_audio_operations_test:unittest", diff --git a/frameworks/innerkitsimpl/test/unittest/media_library_manager_test/BUILD.gn b/frameworks/innerkitsimpl/test/unittest/media_library_manager_test/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..1d338d9dba1fdf3b3145d5703c01ca23fadc1c21 --- /dev/null +++ b/frameworks/innerkitsimpl/test/unittest/media_library_manager_test/BUILD.gn @@ -0,0 +1,72 @@ +# Copyright (C) 2023 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//foundation/multimedia/media_library/media_library.gni") + +group("unittest") { + testonly = true + + deps = [ ":media_library_manager_test" ] +} + +ohos_unittest("media_library_manager_test") { + module_out_path = "media_library/medialibraryextention" + + include_dirs = [ + "./include", + "../get_self_permissions/include", + "${MEDIALIB_INNERKITS_PATH}/media_library_helper/include", + "${MEDIALIB_SERVICES_PATH}/media_library/include", + "${MEDIALIB_INTERFACES_PATH}/innerkits/native/include", + "${MEDIALIB_INNERKITS_PATH}/medialibrary_data_extension/include", + "${MEDIALIB_INTERFACES_PATH}/inner_api/media_library_helper/include", + "${MEDIALIB_UTILS_PATH}/include", + "${MEDIALIB_SERVICES_PATH}/media_scanner/include/scanner", + "//third_party/json/include", + ] + + sources = [ + "../get_self_permissions/src/get_self_permissions.cpp", + "./src/media_library_manager_test.cpp", + ] + + deps = [ + "${MEDIALIB_INNERKITS_PATH}/media_library_helper:media_library_packages", + "${MEDIALIB_INNERKITS_PATH}/media_library_manager:media_library_manager", + "${MEDIALIB_INTERFACES_PATH}/kits/js:medialibrary", + "${MEDIALIB_INTERFACES_PATH}/kits/js:medialibrary_js", + ] + + external_deps = [ + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_manager", + "ability_runtime:abilitykit_native", + "access_token:libaccesstoken_sdk", + "access_token:libnativetoken", + "access_token:libtoken_setproc", + "c_utils:utils", + "common_event_service:cesfwk_innerkits", + "data_share:datashare_common", + "data_share:datashare_consumer", + "hilog:libhilog", + "hitrace:hitrace_meter", + "ipc:ipc_core", + "relational_store:native_appdatafwk", + "relational_store:native_dataability", + "relational_store:native_rdb", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] +} diff --git a/frameworks/innerkitsimpl/test/unittest/media_library_manager_test/include/media_library_manager_test.h b/frameworks/innerkitsimpl/test/unittest/media_library_manager_test/include/media_library_manager_test.h new file mode 100644 index 0000000000000000000000000000000000000000..35b24ee2e5b874677a88d5f7f42c0a20ed3e7a18 --- /dev/null +++ b/frameworks/innerkitsimpl/test/unittest/media_library_manager_test/include/media_library_manager_test.h @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MEDIA_LIBRARY_MANANGER_TEST_H +#define MEDIA_LIBRARY_MANANGER_TEST_H + +#include "gtest/gtest.h" + +namespace OHOS { +namespace Media { +class MediaLibraryManagerTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; +} // namespace Media +} // namespace OHOS +#endif // MEDIA_LIBRARY_MANANGER_TEST_H diff --git a/frameworks/innerkitsimpl/test/unittest/media_library_manager_test/src/media_library_manager_test.cpp b/frameworks/innerkitsimpl/test/unittest/media_library_manager_test/src/media_library_manager_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a0e097542373734bb6adfbc633ffee6277e00e13 --- /dev/null +++ b/frameworks/innerkitsimpl/test/unittest/media_library_manager_test/src/media_library_manager_test.cpp @@ -0,0 +1,326 @@ +/* + * Copyright (C) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "media_library_manager_test.h" +#include "datashare_helper.h" +#include "fetch_result.h" +#include "file_asset.h" +#include "get_self_permissions.h" +#include "hilog/log.h" +#include "iservice_registry.h" +#include "medialibrary_db_const.h" +#include "medialibrary_errno.h" +#include "media_file_utils.h" +#include "media_library_manager.h" +#include "media_log.h" +#include "media_volume.h" +#include "scanner_utils.h" +#include "system_ability_definition.h" + +using namespace std; +using namespace OHOS; +using namespace testing::ext; +using namespace OHOS::NativeRdb; +using namespace OHOS::AppExecFwk; + +/** + * @FileName MediaLibraryManagerTest + * @Desc Media library manager native function test + * + */ +namespace OHOS { +namespace Media { +std::shared_ptr sDataShareHelper_ = nullptr; +std::unique_ptr GetFile(int mediaTypeId); +void ClearFile(); +void ClearAllFile(); +void CreateDataHelper(int32_t systemAbilityId); + +constexpr int STORAGE_MANAGER_MANAGER_ID = 5003; +int g_albumMediaType = MEDIA_TYPE_ALBUM; +int64_t g_oneImageSize = 0; +const int CLEAN_TIME = 5; +const int SCAN_WAIT_TIME = 10; + +static const unsigned char FILE_CONTENT_JPG[] = { + 0x49, 0x44, 0x33, 0x03, 0x20, 0x20, 0x20, 0x0c, 0x24, 0x5d, 0x54, 0x45, 0x4e, 0x43, 0x20, 0x20, 0x20, 0x0b, + 0x20, 0x20, 0x20, +}; + +static const unsigned char FILE_CONTENT_MP4[] = { + 0x20, 0x20, 0x20, 0x20, 0x66, 0x74, 0x79, 0x70, 0x69, 0x73, 0x6f, 0x6d, 0x20, 0x20, 0x02, 0x20, 0x69, 0x73, 0x6f, + 0x6d, 0x69, 0x73, 0x6f, 0x32, 0x61, 0x76, 0x63, 0x31, 0x6d, 0x70, 0x34, 0x31, 0x20, 0x20, 0x20, 0x08, 0x66, 0x72, + 0x65, 0x65, 0x20, 0x49, 0xdd, 0x01, 0x6d, 0x64, 0x61, 0x74, 0x20, 0x20, 0x02, 0xa0, 0x06, 0x05, 0xff, 0xff, 0x9c, +}; + +MediaLibraryManager* mediaLibraryManager = MediaLibraryManager::GetMediaLibraryManager(); + +void MediaLibraryManagerTest::SetUpTestCase(void) +{ + vector perms; + perms.push_back("ohos.permission.READ_IMAGEVIDEO"); + perms.push_back("ohos.permission.WRITE_IMAGEVIDEO"); + perms.push_back("ohos.permission.MEDIA_LOCATION"); + perms.push_back("ohos.permission.GET_BUNDLE_INFO_PRIVILEGED"); + uint64_t tokenId = 0; + PermissionUtilsUnitTest::SetAccessTokenPermission("MediaLibraryManagerTest", perms, tokenId); + ASSERT_TRUE(tokenId != 0); + + MEDIA_INFO_LOG("MediaLibraryManagerTest::SetUpTestCase:: invoked"); + CreateDataHelper(STORAGE_MANAGER_MANAGER_ID); + if (sDataShareHelper_ == nullptr) { + EXPECT_NE(sDataShareHelper_, nullptr); + return; + } + + // make sure board is empty + ClearAllFile(); + + Uri scanUri(URI_SCANNER); + DataShareValuesBucket valuesBucket; + valuesBucket.Put(MEDIA_DATA_DB_FILE_PATH, ROOT_MEDIA_DIR); + sDataShareHelper_->Insert(scanUri, valuesBucket); + sleep(SCAN_WAIT_TIME); + + MEDIA_INFO_LOG("MediaLibraryManagerTest::SetUpTestCase:: Finish"); +} + +void MediaLibraryManagerTest::TearDownTestCase(void) +{ + MEDIA_ERR_LOG("TearDownTestCase start"); + if (sDataShareHelper_ != nullptr) { + sDataShareHelper_->Release(); + } + sleep(CLEAN_TIME); + ClearAllFile(); + MEDIA_INFO_LOG("TearDownTestCase end"); +} +// SetUp:Execute before each test case +void MediaLibraryManagerTest::SetUp(void) {} + +void MediaLibraryManagerTest::TearDown(void) {} + +void CreateDataHelper(int32_t systemAbilityId) +{ + auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + if (saManager == nullptr) { + MEDIA_ERR_LOG("Get system ability mgr failed."); + return; + } + auto remoteObj = saManager->GetSystemAbility(systemAbilityId); + if (remoteObj == nullptr) { + MEDIA_ERR_LOG("GetSystemAbility Service Failed."); + return; + } + mediaLibraryManager->InitMediaLibraryManager(remoteObj); + MEDIA_INFO_LOG("InitMediaLibraryManager success!"); + + if (sDataShareHelper_ == nullptr) { + const sptr &token = remoteObj; + sDataShareHelper_ = DataShare::DataShareHelper::Creator(token, MEDIALIBRARY_DATA_URI); + } + mediaLibraryManager->InitMediaLibraryManager(remoteObj); +} + +void ClearAllFile() +{ + system("rm -rf /storage/media/100/local/files/.thumbs/*"); + system("rm -rf /storage/cloud/100/files/Audio/*"); + system("rm -rf /storage/cloud/100/files/Audios/*"); + system("rm -rf /storage/cloud/100/files/Camera/*"); + system("rm -rf /storage/cloud/100/files/Documents/*"); + system("rm -rf /storage/cloud/100/files/Photo/*"); + system("rm -rf /storage/cloud/100/files/Pictures/*"); + system("rm -rf /storage/cloud/100/files/Download/*"); + system("rm -rf /storage/cloud/100/files/Videos/*"); + system("rm -rf /storage/cloud/100/files/.*"); + system("rm -rf /data/app/el2/100/database/com.ohos.medialibrary.medialibrarydata/*"); + system("kill -9 `pidof com.ohos.medialibrary.medialibrarydata`"); + system("scanner"); +} + +void DeleteFile(std::string fileUri) +{ + if (sDataShareHelper_ == nullptr) { + return; + } + Uri deleteAssetUri(MEDIALIBRARY_DATA_URI + "/" + MEDIA_FILEOPRN); + DataShare::DataSharePredicates predicates; + predicates.EqualTo(MEDIA_DATA_DB_ID, MediaFileUtils::GetIdFromUri(fileUri)); + int retVal = sDataShareHelper_->Delete(deleteAssetUri, predicates); + MEDIA_INFO_LOG("MediaSpaceStatistics_test DeleteFile::uri :%{private}s", deleteAssetUri.ToString().c_str()); + EXPECT_NE(retVal, E_ERR); +} + +void ClearFile() +{ + if (sDataShareHelper_ == nullptr) { + return; + } + vector columns; + DataSharePredicates predicates; + string prefix = MEDIA_DATA_DB_MEDIA_TYPE + " <> " + to_string(g_albumMediaType); + predicates.SetWhereClause(prefix); + Uri queryFileUri(MEDIALIBRARY_DATA_URI); + shared_ptr resultSet = nullptr; + resultSet = sDataShareHelper_->Query(queryFileUri, predicates, columns); + EXPECT_NE((resultSet == nullptr), true); + + unique_ptr> fetchFileResult = make_unique>(move(resultSet)); + EXPECT_NE((fetchFileResult->GetCount() < 0), true); + unique_ptr fileAsset = fetchFileResult->GetFirstObject(); + while (fileAsset != nullptr) { + DeleteFile(fileAsset->GetUri()); + fileAsset = fetchFileResult->GetNextObject(); + } +} + +static bool CompareIfArraysEquals(const unsigned char originArray[], + const unsigned char targetArray[], int32_t size) +{ + for (int i = 0; i < size - 1; i++) { + if (originArray[i] != targetArray[i]) { + return false; + } + } + return true; +} + +/** + * @tc.number : MediaLibraryManager_test_001 + * @tc.name : create a test.jpg + * @tc.desc : create a image asset to see if error occurs + */ +HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_test_001, TestSize.Level0) +{ + MEDIA_INFO_LOG("MediaLibraryManager_test_001::Start"); + string displayName = "test.jpg"; + string uri = mediaLibraryManager->CreateAsset(displayName); + EXPECT_NE(uri, ""); + int32_t destFd = mediaLibraryManager->OpenAsset(uri, MEDIA_FILEMODE_READWRITE); + EXPECT_NE(destFd <= 0, true); + int32_t resWrite = write(destFd, FILE_CONTENT_JPG, sizeof(FILE_CONTENT_JPG)); + if (resWrite == -1) { + EXPECT_EQ(false, true); + } + auto ret = mediaLibraryManager->CloseAsset(uri, destFd); + EXPECT_EQ(ret, E_SUCCESS); + MEDIA_INFO_LOG("CreateFile:: end Create file: %{public}s", displayName.c_str()); +} + +/** + * @tc.number : MediaLibraryManager_test_002 + * @tc.name : create image again to see if error occurs + * @tc.desc : create same name file to see if error occur and + * : read image msg to see if equals + */ +HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_test_002, TestSize.Level0) +{ + MEDIA_INFO_LOG("MediaLibraryManager_test_002::Start"); + string displayName = "test2.jpg"; + string uri = mediaLibraryManager->CreateAsset(displayName); + MEDIA_INFO_LOG("createFile uri: %{public}s", uri.c_str()); + EXPECT_NE(uri, ""); + int32_t destFd = mediaLibraryManager->OpenAsset(uri, MEDIA_FILEMODE_READWRITE); + EXPECT_NE(destFd <= 0, true); + int32_t resWrite = write(destFd, FILE_CONTENT_JPG, sizeof(FILE_CONTENT_JPG)); + if (resWrite == -1) { + EXPECT_EQ(false, true); + } + mediaLibraryManager->CloseAsset(uri, destFd); + + int32_t srcFd = mediaLibraryManager->OpenAsset(uri, MEDIA_FILEMODE_READWRITE); + int64_t srcLen = lseek(srcFd, 0, SEEK_END); + lseek(srcFd, 0, SEEK_SET); + unsigned char buf[srcLen]; + read(srcFd, buf, srcLen); + EXPECT_EQ(CompareIfArraysEquals(buf, FILE_CONTENT_JPG, sizeof(FILE_CONTENT_JPG)), true); + MEDIA_INFO_LOG("CreateFile:: end Create file: %{public}s", displayName.c_str()); +} + +/** + * @tc.number : MediaLibraryManager_test_003 + * @tc.name : create video to see if error occurs + * @tc.desc : create video file to see if error occur and + * : read video msg to see if equals + */ +HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_test_003, TestSize.Level0) +{ + MEDIA_INFO_LOG("MediaLibraryManager_test_003::Start"); + string displayName = "testVideo.mp4"; + string uri = mediaLibraryManager->CreateAsset(displayName); + MEDIA_INFO_LOG("createFile uri: %{public}s", uri.c_str()); + EXPECT_NE(uri, ""); + int32_t destFd = mediaLibraryManager->OpenAsset(uri, MEDIA_FILEMODE_READWRITE); + EXPECT_NE(destFd <= 0, true); + int32_t resWrite = write(destFd, FILE_CONTENT_MP4, sizeof(FILE_CONTENT_MP4)); + if (resWrite == -1) { + EXPECT_EQ(false, true); + } + mediaLibraryManager->CloseAsset(uri, destFd); + int32_t srcFd = mediaLibraryManager->OpenAsset(uri, MEDIA_FILEMODE_READWRITE); + int64_t srcLen = lseek(srcFd, 0, SEEK_END); + lseek(srcFd, 0, SEEK_SET); + unsigned char buf[srcLen]; + read(srcFd, buf, srcLen); + EXPECT_EQ(CompareIfArraysEquals(buf, FILE_CONTENT_MP4, sizeof(FILE_CONTENT_MP4)), true); + MEDIA_INFO_LOG("CreateFile:: end Create file: %{public}s", displayName.c_str()); +} + +/** + * @tc.number : MediaLibraryManager_test_004 + * @tc.name : create error type asset testVideo.xxx to see if error occurs + * @tc.desc : create error type asset to see if error occurs + */ +HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_test_004, TestSize.Level0) +{ + MEDIA_INFO_LOG("MediaLibraryManager_test_004::Start"); + string displayName = "testVideo.xxx"; + string uri = mediaLibraryManager->CreateAsset(displayName); + MEDIA_INFO_LOG("createFile uri: %{public}s", uri.c_str()); + EXPECT_EQ(uri, ""); + MEDIA_INFO_LOG("CreateFile:: end Create file: %{public}s", displayName.c_str()); +} + +/** + * @tc.number : MediaLibraryManager_test_005 + * @tc.name : create png image again to see if error occurs + * @tc.desc : create png image to see if error occur and + * : read image msg to see if equals + */ +HWTEST_F(MediaLibraryManagerTest, MediaLibraryManager_test_005, TestSize.Level0) +{ + MEDIA_INFO_LOG("MediaLibraryManager_test_005::Start"); + string displayName = "testPNG.png"; + string uri = mediaLibraryManager->CreateAsset(displayName); + MEDIA_INFO_LOG("createFile uri: %{public}s", uri.c_str()); + EXPECT_NE(uri, ""); + int32_t destFd = mediaLibraryManager->OpenAsset(uri, MEDIA_FILEMODE_READWRITE); + EXPECT_NE(destFd <= 0, true); + int32_t resWrite = write(destFd, FILE_CONTENT_JPG, sizeof(FILE_CONTENT_JPG)); + if (resWrite == -1) { + EXPECT_EQ(false, true); + } + mediaLibraryManager->CloseAsset(uri, destFd); + + int32_t srcFd = mediaLibraryManager->OpenAsset(uri, MEDIA_FILEMODE_READWRITE); + int64_t srcLen = lseek(srcFd, 0, SEEK_END); + lseek(srcFd, 0, SEEK_SET); + unsigned char buf[srcLen]; + read(srcFd, buf, srcLen); + MEDIA_INFO_LOG("CreateFile:: end Create file: %{public}s", displayName.c_str()); +} +} // namespace Media +} // namespace OHOS diff --git a/interfaces/inner_api/media_library_helper/include/media_library_manager.h b/interfaces/inner_api/media_library_helper/include/media_library_manager.h index d686ebf2305d5181782832b60232d59b034f9d77..51f063267d41c65d02d3d5085bc89156de8fc9e6 100644 --- a/interfaces/inner_api/media_library_helper/include/media_library_manager.h +++ b/interfaces/inner_api/media_library_helper/include/media_library_manager.h @@ -90,6 +90,27 @@ public: */ int32_t CloseAsset(const string &uri, const int32_t fd); + /** + * @brief create an photo or video asset + * + * @param displayName file displayName + * @return asset uri for success and <""> for fail + * @since 1.0 + * @version 1.0 + */ + string CreateAsset(const string &displayName); + + /** + * @brief open photo or video + * + * @param displayName file displayName + * @param openMode openMode "rw", "w", "r" + * @return fileDescriptor for success and <-1> for fail + * @since 1.0 + * @version 1.0 + */ + int32_t OpenAsset(string &uri, const string openMode); + /** * @brief Obtain a mediaVolume object from MediaAssets can be obtained *