OpenHarmony-v5.1.0-Release/s

/*
 * Copyright (c) 2022-2025 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 "file_access_helper.h"


#include <nlohmann/json.hpp>
#include "bundle_constants.h"
#include "bundle_mgr_proxy.h"
#include "file_access_framework_errno.h"
#include "file_access_extension_info.h"
#include "file_access_service_client.h"
#include "hilog_wrapper.h"
#include "hitrace_meter.h"
#include "user_access_tracer.h"
#include "if_system_ability_manager.h"
#include "ifile_access_ext_base.h"
#include "ipc_skeleton.h"
#include "iservice_registry.h"
#include "system_ability_definition.h"
#include "tokenid_kit.h"
#include "n_error.h"
#include "uri_ext.h"

namespace OHOS {
namespace FileAccessFwk {
using json = nlohmann::json;
namespace {
    constexpr int COPY_EXCEPTION = -1;
    constexpr int COPY_NOEXCEPTION = -2;
    constexpr uint32_t MAX_COPY_ERROR_COUNT = 1000;
}

sptr<IFileAccessExtBase> g_sourceExtProxy;
sptr<IFileAccessExtBase> g_destExtProxy;

std::vector<Uri> deviceUris(DEVICE_ROOTS.begin(), DEVICE_ROOTS.end());

static int GetUserId()
{
    int uid = IPCSkeleton::GetCallingUid();
    int userId = uid / AppExecFwk::Constants::BASE_USER_RANGE;
    return userId;
}

static bool GetBundleNameFromPath(const std::string &path, std::string &bundleName)
{
    if (path.size() == 0) {
        HILOG_ERROR("Uri path error.");
        return false;
    }

    if (path.front() != '/') {
        HILOG_ERROR("Uri path format error.");
        return false;
    }

    auto tmpPath = path.substr(1);
    auto index = tmpPath.find_first_of("/");
    bundleName = tmpPath.substr(0, index);
    if (bundleName.compare(MEDIA_BNUDLE_NAME_ALIAS) == 0) {
        bundleName = MEDIA_BNUDLE_NAME;
        return true;
    }
    if (bundleName.compare(EXTERNAL_BNUDLE_NAME_ALIAS) == 0) {
        bundleName = EXTERNAL_BNUDLE_NAME;
        return true;
    }
    HILOG_INFO("Uri-authority true.");
    return true;
}

static bool CheckUri(Uri &uri)
{
    HILOG_DEBUG("Uri : %{private}s.", uri.ToString().c_str());
    std::string schemeStr = std::string(uri.GetScheme());
    if (schemeStr.compare(FILE_SCHEME_NAME) != 0) {
        HILOG_ERROR("Uri scheme error.");
        return false;
    }
    return true;
}

sptr<AppExecFwk::IBundleMgr> FileAccessHelper::GetBundleMgrProxy()
{
    sptr<ISystemAbilityManager> systemAbilityManager =
        SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
    if (!systemAbilityManager) {
        return nullptr;
    }

    sptr<IRemoteObject> remoteObject = systemAbilityManager->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
    if (!remoteObject) {
        return nullptr;
    }

    return iface_cast<AppExecFwk::IBundleMgr>(remoteObject);
}

FileAccessHelper::FileAccessHelper(const std::shared_ptr<OHOS::AbilityRuntime::Context> &context,
    const std::unordered_map<std::string, std::shared_ptr<ConnectInfo>> &cMap)
{
    if (context != nullptr) {
        HILOG_INFO("Create FileAccessHelper by context");
        token_ = context->GetToken();
        cMap_ = cMap;
    } else {
        HILOG_ERROR("Context is null");
    }
}

FileAccessHelper::FileAccessHelper(const sptr<IRemoteObject> &token,
    const std::unordered_map<std::string, std::shared_ptr<ConnectInfo>> &cMap)
{
    HILOG_INFO("Create FileAccessHelper by token");
    token_ = token;
    cMap_ = cMap;
}

FileAccessHelper::~FileAccessHelper()
{
    Release();
}

std::shared_ptr<ConnectInfo> FileAccessHelper::GetConnectInfo(const std::string &bundleName)
{
    auto iterator = cMap_.find(bundleName);
    if (iterator != cMap_.end()) {
        return iterator->second;
    }
    HILOG_ERROR("GetConnectInfo called with bundleName return nullptr");
    return nullptr;
}

std::shared_ptr<ConnectExtensionInfo> FileAccessHelper::GetConnectExtensionInfo(Uri &uri)
{
    std::string scheme = uri.GetScheme();
    std::string bundleName;
    if (scheme == FILE_SCHEME_NAME) {
        std::string path = "/" + uri.GetAuthority() + uri.GetPath();
        if (!GetBundleNameFromPath(path, bundleName)) {
            HILOG_ERROR("Get BundleName failed.");
        }
    }
    auto connectInfo = GetConnectInfo(bundleName);
    if (connectInfo == nullptr) {
        HILOG_ERROR("Get connectInfo failed.");
        return nullptr;
    }
    std::shared_ptr<ConnectExtensionInfo> connectExtensionInfo =
        std::make_shared<ConnectExtensionInfo>(connectInfo->want, token_);
    return connectExtensionInfo;
}

static bool IsSystemApp()
{
    uint64_t accessTokenIDEx = OHOS::IPCSkeleton::GetCallingFullTokenID();
    return OHOS::Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(accessTokenIDEx);
}

bool FileAccessHelper::CompareWant(const AAFwk::Want& lhs, const AAFwk::Want& rhs)
{
    auto lhsElement = lhs.GetElement();
    auto rhsElement = rhs.GetElement();
    return lhsElement.GetBundleName() < rhsElement.GetBundleName()
        && lhsElement.GetAbilityName() < rhsElement.GetAbilityName();
}

bool FileAccessHelper::IsEffectiveWants(const std::vector<AAFwk::Want> &wants)
{
    std::vector<AAFwk::Want> allWants;
    if (GetRegisteredFileAccessExtAbilityInfo(allWants) != ERR_OK) {
        HILOG_ERROR("GetRegisteredFileAccessExtAbilityInfo failed");
        return false;
    }
    std::set<AAFwk::Want, bool(*)(const AAFwk::Want&, const AAFwk::Want&)> allWantSet(FileAccessHelper::CompareWant);
    allWantSet.insert(allWants.begin(), allWants.end());
    for (auto iter = wants.begin(); iter != wants.end(); ++iter) {
        if (allWantSet.count(*iter) == 0) {
            return false;
        }
    }
    return true;
}

std::pair<std::shared_ptr<FileAccessHelper>, int> FileAccessHelper::DoCreatorHelper(
    const sptr<IRemoteObject> &token, const std::vector<AAFwk::Want> &wants)
{
    std::unordered_map<std::string, std::shared_ptr<ConnectInfo>> cMap;
    for (size_t i = 0; i < wants.size(); i++) {
        sptr<AppFileAccessExtConnection> fileAccessExtConnection(new(std::nothrow) AppFileAccessExtConnection());
        if (fileAccessExtConnection == nullptr) {
            HILOG_ERROR("new fileAccessExtConnection fail");
            return {nullptr, E_GETRESULT};
        }
        if (!fileAccessExtConnection->IsExtAbilityConnected()) {
            fileAccessExtConnection->ConnectFileExtAbility(wants[i]);
        }
        sptr<IFileAccessExtBase> fileExtProxy = fileAccessExtConnection->GetFileExtProxy();
        if (fileExtProxy == nullptr) {
            HILOG_ERROR("Creator get invalid fileExtProxy");
            return {nullptr, E_CONNECT};
        }
        std::shared_ptr<ConnectInfo> connectInfo = std::make_shared<ConnectInfo>();
        if (!connectInfo) {
            HILOG_ERROR("Creator, connectInfo == nullptr");
            return {nullptr, E_GETRESULT};
        }
        connectInfo->want = wants[i];
        connectInfo->fileAccessExtConnection = fileAccessExtConnection;
        std::string bundleName = wants[i].GetElement().GetBundleName();
        HILOG_INFO("DoCreatorHelper bundleName is %{public}s", bundleName.c_str());
        cMap.insert(std::pair<std::string, std::shared_ptr<ConnectInfo>>(bundleName, connectInfo));
    }

    FileAccessHelper *ptrFileAccessHelper = new (std::nothrow) FileAccessHelper(token, cMap);
    if (ptrFileAccessHelper == nullptr) {
        HILOG_ERROR("Creator failed, create FileAccessHelper failed");
        return {nullptr, E_GETRESULT};
    }

    return {std::shared_ptr<FileAccessHelper>(ptrFileAccessHelper), ERR_OK};
}

std::pair<std::shared_ptr<FileAccessHelper>, int> FileAccessHelper::Creator(
    const std::shared_ptr<OHOS::AbilityRuntime::Context> &context)
{
    UserAccessTracer trace;
    trace.Start("Creator");
    std::vector<AAFwk::Want> allWants;
    if (context == nullptr) {
        HILOG_ERROR("FileAccessHelper::Creator failed, context == nullptr");
        return {nullptr, EINVAL};
    }
    if (!IsSystemApp()) {
        HILOG_ERROR("FileAccessHelper::Creator check IsSystemAppByFullTokenID failed");
        return {nullptr, E_PERMISSION_SYS};
    }
    if (GetRegisteredFileAccessExtAbilityInfo(allWants) != ERR_OK) {
        HILOG_ERROR("GetRegisteredFileAccessExtAbilityInfo failed");
        return {nullptr, E_GETINFO};
    }

    return DoCreatorHelper(context->GetToken(), allWants);
}

std::pair<std::shared_ptr<FileAccessHelper>, int> FileAccessHelper::Creator(
    const std::shared_ptr<OHOS::AbilityRuntime::Context> &context, const std::vector<AAFwk::Want> &wants)
{
    UserAccessTracer trace;
    trace.Start("Creator");
    if (context == nullptr) {
        HILOG_ERROR("FileAccessHelper::Creator failed, context == nullptr");
        return {nullptr, EINVAL};
    }
    if (wants.size() == 0) {
        HILOG_ERROR("FileAccessHelper::Creator failed, wants is empty");
        return {nullptr, EINVAL};
    }
    if (!IsSystemApp()) {
        HILOG_ERROR("FileAccessHelper::Creator check IsSystemAppByFullTokenID failed");
        return {nullptr, E_PERMISSION_SYS};
    }
    // 传入的wants信息是否有效
    if (!IsEffectiveWants(wants)) {
        HILOG_ERROR("FileAccessHelper::Creator effectiveWants is empty");
        return {nullptr, EINVAL};
    }

    return DoCreatorHelper(context->GetToken(), wants);
}

std::shared_ptr<FileAccessHelper> FileAccessHelper::Creator(const sptr<IRemoteObject> &token,
    const std::vector<AAFwk::Want> &wants)
{
    UserAccessTracer trace;
    trace.Start("Creator");
    if (token == nullptr) {
        HILOG_ERROR("FileAccessHelper::Creator failed, token == nullptr");
        return nullptr;
    }
    if (wants.size() == 0) {
        HILOG_ERROR("FileAccessHelper::Creator failed, wants is empty");
        return nullptr;
    }
    if (!IsSystemApp()) {
        HILOG_ERROR("FileAccessHelper::Creator check IsSystemAppByFullTokenID failed");
        return nullptr;
    }
    // 传入的wants信息是否有效
    if (!IsEffectiveWants(wants)) {
        HILOG_ERROR("FileAccessHelper::Creator wants is not effective");
        return nullptr;
    }

    std::pair<std::shared_ptr<FileAccessHelper>, int> ptrFileAccessHelper = DoCreatorHelper(token, wants);
    if (ptrFileAccessHelper.second != ERR_OK) {
        return nullptr;
    }

    return ptrFileAccessHelper.first;
}

bool FileAccessHelper::Release()
{
    for (auto iter = cMap_.begin(); iter != cMap_.end(); iter++) {
        if (iter->second->fileAccessExtConnection->IsExtAbilityConnected()) {
            iter->second->fileAccessExtConnection->DisconnectFileExtAbility();
        }
    }
    cMap_.clear();
    token_ = nullptr;
    return true;
}

sptr<IFileAccessExtBase> FileAccessHelper::GetProxyByUri(Uri &uri)
{
    std::string scheme = uri.GetScheme();
    std::string bundleName;
    if (scheme == FILE_SCHEME_NAME) {
        std::string path = "/" + uri.GetAuthority() + uri.GetPath();
        if (!GetBundleNameFromPath(path, bundleName)) {
            HILOG_ERROR("Get BundleName failed.");
            return nullptr;
        }
    }

    auto fileAccessExtBaseProxy = GetProxyByBundleName(bundleName);
    return fileAccessExtBaseProxy;
}

sptr<IFileAccessExtBase> FileAccessHelper::GetProxyByBundleName(const std::string &bundleName)
{
    auto connectInfo = GetConnectInfo(bundleName);
    HILOG_INFO("GetProxyByBundleName start %{public}s", bundleName.c_str());
    if (connectInfo == nullptr) {
        HILOG_ERROR("GetProxyByUri failed with invalid connectInfo");
        return nullptr;
    }
    if (!connectInfo->fileAccessExtConnection->IsExtAbilityConnected()) {
        connectInfo->fileAccessExtConnection->ConnectFileExtAbility(connectInfo->want);
    }
    auto fileAccessExtBaseProxy = connectInfo->fileAccessExtConnection->GetFileExtProxy();
    if (fileAccessExtBaseProxy == nullptr) {
        HILOG_ERROR("GetProxyByUri failed with invalid FileAccessExtBaseProxy");
        return nullptr;
    }
    return fileAccessExtBaseProxy;
}

bool FileAccessHelper::GetProxy()
{
    for (auto iter = cMap_.begin(); iter != cMap_.end(); ++iter) {
        auto connectInfo = iter->second;
        if (connectInfo == nullptr || connectInfo->fileAccessExtConnection == nullptr) {
            HILOG_ERROR("connectInfo is nullptr");
            return false;
        }
        if (!connectInfo->fileAccessExtConnection->IsExtAbilityConnected()) {
            connectInfo->fileAccessExtConnection->ConnectFileExtAbility(connectInfo->want);
        }
        auto fileAccessExtBaseProxy = connectInfo->fileAccessExtConnection->GetFileExtProxy();
        if (fileAccessExtBaseProxy == nullptr) {
            HILOG_ERROR("GetProxy failed with invalid FileAccessExtBaseProxy");
            return false;
        }
    }
    return true;
}

int FileAccessHelper::OpenFile(Uri &uri, int flags, int &fd)
{
    UserAccessTracer trace;
    trace.Start("OpenFile");
    if (!IsSystemApp()) {
        HILOG_ERROR("FileAccessHelper::OpenFile check IsSystemAppByFullTokenID failed");
        return E_PERMISSION_SYS;
    }

    if (!CheckUri(uri)) {
        HILOG_ERROR("Uri format check error.");
        return E_URIS;
    }

    if (flags != READ && flags != WRITE && flags != WRITE_READ) {
        HILOG_ERROR("flags type error.");
        return EINVAL;
    }

    sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(uri);
    if (fileExtProxy == nullptr) {
        HILOG_ERROR("failed with invalid FileAccessExtBaseProxy");
        return E_IPCS;
    }

    Urie uriConvert(uri.ToString());
    int ret = fileExtProxy->OpenFile(uriConvert, flags, fd);
    if (ret != ERR_OK) {
        HILOG_ERROR("OpenFile get result error, code:%{public}d", ret);
        return ret;
    }

    return ERR_OK;
}

int FileAccessHelper::CreateFile(Uri &parent, const std::string &displayName, Uri &newFile)
{
    UserAccessTracer trace;
    trace.Start("CreateFile");
    if (!IsSystemApp()) {
        HILOG_ERROR("FileAccessHelper::CreateFile check IsSystemAppByFullTokenID failed");
        return E_PERMISSION_SYS;
    }

    if (!CheckUri(parent)) {
        HILOG_ERROR("Uri format check error.");
        return E_URIS;
    }

    sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(parent);
    if (fileExtProxy == nullptr) {
        HILOG_ERROR("failed with invalid FileAccessExtBaseProxy");
        return E_IPCS;
    }

    Urie parentConvert(parent.ToString());
    Urie newFileConvert("");
    int ret = fileExtProxy->CreateFile(parentConvert, displayName, newFileConvert);
    if (ret != ERR_OK) {
        HILOG_ERROR("CreateFile get result error, code:%{public}d", ret);
        return ret;
    }
    newFile = Uri(newFileConvert.ToString());

    return ERR_OK;
}

int FileAccessHelper::Mkdir(Uri &parent, const std::string &displayName, Uri &newDir)
{
    UserAccessTracer trace;
    trace.Start("Mkdir");
    if (!IsSystemApp()) {
        HILOG_ERROR("FileAccessHelper::Mkdir check IsSystemAppByFullTokenID failed");
        return E_PERMISSION_SYS;
    }

    if (!CheckUri(parent)) {
        HILOG_ERROR("Uri format check error.");
        return E_URIS;
    }

    sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(parent);
    if (fileExtProxy == nullptr) {
        HILOG_ERROR("failed with invalid FileAccessExtBaseProxy");
        return E_IPCS;
    }

    Urie parentConvert(parent.ToString());
    Urie newDirConvert("");
    int ret = fileExtProxy->Mkdir(parentConvert, displayName, newDirConvert);
    if (ret != ERR_OK) {
        HILOG_ERROR("Mkdir get result error, code:%{public}d", ret);
        return ret;
    }
    newDir = Uri(newDirConvert.ToString());

    return ERR_OK;
}

int FileAccessHelper::Delete(Uri &selectFile)
{
    UserAccessTracer trace;
    trace.Start("Delete");
    if (!IsSystemApp()) {
        HILOG_ERROR("FileAccessHelper::Delete check IsSystemAppByFullTokenID failed");
        return E_PERMISSION_SYS;
    }

    if (!CheckUri(selectFile)) {
        HILOG_ERROR("Uri format check error.");
        return E_URIS;
    }

    sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(selectFile);
    if (fileExtProxy == nullptr) {
        HILOG_ERROR("failed with invalid FileAccessExtBaseProxy");
        return E_IPCS;
    }

    Urie selectFileConvert(selectFile.ToString());
    int ret = fileExtProxy->Delete(selectFileConvert);
    if (ret != ERR_OK) {
        HILOG_ERROR("Delete get result error, code:%{public}d", ret);
        return ret;
    }

    return ERR_OK;
}

int FileAccessHelper::Move(Uri &sourceFile, Uri &targetParent, Uri &newFile)
{
    UserAccessTracer trace;
    trace.Start("Move");
    if (!IsSystemApp()) {
        HILOG_ERROR("FileAccessHelper::Move check IsSystemAppByFullTokenID failed");
        return E_PERMISSION_SYS;
    }

    Uri sourceFileUri(sourceFile.ToString());
    Uri targetParentUri(targetParent.ToString());
    if (!CheckUri(sourceFile) || !CheckUri(targetParent)) {
        HILOG_ERROR("uri format check error.");
        return E_URIS;
    }

    if (sourceFileUri.GetAuthority() != targetParentUri.GetAuthority()) {
        HILOG_WARN("Operation failed, move not supported");
        return EPERM;
    }

    sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(sourceFile);
    if (fileExtProxy == nullptr) {
        HILOG_ERROR("failed with invalid FileAccessExtBaseProxy");
        return E_IPCS;
    }

    Urie sourceFileConvert(sourceFile.ToString());
    Urie targetParentConvert(targetParent.ToString());
    Urie newFileConvert("");
    int ret = fileExtProxy->Move(sourceFileConvert, targetParentConvert, newFileConvert);
    if (ret != ERR_OK) {
        HILOG_ERROR("Move get result error, code:%{public}d", ret);
        return ret;
    }
    newFile = Uri(newFileConvert.ToString());

    return ERR_OK;
}

int FileAccessHelper::IsDirectory(Uri &uri, bool &isDir)
{
    sptr<IFileAccessExtBase> proxy = FileAccessHelper::GetProxyByUri(uri);
    if (proxy == nullptr) {
        HILOG_ERROR("failed with invalid FileAccessExtBaseProxy");
        return E_IPCS;
    }

    FileInfo fileInfo;
    Urie uriConvert(uri.ToString());
    int ret = proxy->GetFileInfoFromUri(uriConvert, fileInfo);
    if (ret != ERR_OK) {
        HILOG_ERROR("get FileInfo from uri error, code:%{public}d", ret);
        return ret;
    }

    isDir = fileInfo.mode >= 0 && (static_cast<uint32_t>(fileInfo.mode) & DOCUMENT_FLAG_REPRESENTS_DIR) != 0;

    return ret;
}

static int TranslateResult(int errCode, Result &result)
{
    if (errCode == COPY_EXCEPTION || errCode == ERR_OK) {
        return errCode;
    }

    int ret = ERR_OK;
    switch (errCode) {
        case E_IPCS:
        case E_URIS:
        case ERR_NOMEM:
        case E_PERMISSION_SYS:
        case ERR_PERM: {
            HILOG_ERROR("Operate exception, terminate");
            ret = COPY_EXCEPTION;
            break;
        }
        default: {
            HILOG_ERROR("Operate exception, continue");
            ret = COPY_NOEXCEPTION;
            break;
        }
    }
    if (OHOS::FileManagement::LibN::errCodeTable.find(errCode) !=
        OHOS::FileManagement::LibN::errCodeTable.end()) {
        result.errCode = OHOS::FileManagement::LibN::errCodeTable.at(errCode).first;
        result.errMsg = OHOS::FileManagement::LibN::errCodeTable.at(errCode).second;
    }
    return ret;
}

static int GetResult(const std::string &sourceUri, const std::string &destUri, int errCode,
    const std::string &errMsg, std::vector<Result> &result)
{
    Result tmpResult { sourceUri, destUri, errCode, errMsg };
    int ret = TranslateResult(errCode, tmpResult);
    result.clear();
    result.push_back(tmpResult);
    return ret;
}

int FileAccessHelper::CopyOperation(Uri &sourceUri, Uri &destUri, std::vector<Result> &copyResult, bool force)
{
    UserAccessTracer trace;
    trace.Start("CopyOperation");
    int ret = COPY_EXCEPTION;
    sptr<IFileAccessExtBase> proxy = GetProxyByUri(sourceUri);
    if (proxy == nullptr) {
        HILOG_ERROR("Failed with invalid FileAccessExtBaseProxy");
        Result result;
        ret = TranslateResult(E_IPCS, result);
        copyResult.push_back(result);
        return ret;
    }

    Urie sourceUriConvert(sourceUri.ToString());
    Urie destUriConvert(destUri.ToString());
    copyResult.clear();
    int retCode;
    ret = proxy->Copy(sourceUriConvert, destUriConvert, copyResult, retCode, force);
    if (ret == ERR_OK) {
        ret = retCode;
    }
    if (copyResult.size() > MAX_COPY_ERROR_COUNT) {
        HILOG_ERROR("Copy operation failed, count value greater than max count");
        Result result { "", "", E_COUNT, "Count value greater than max count"};
        copyResult.clear();
        copyResult.push_back(result);
        ret = COPY_EXCEPTION;
    }
    if (ret != ERR_OK) {
        if ((ret == COPY_EXCEPTION) || (ret == COPY_NOEXCEPTION)) {
            HILOG_ERROR("Copy exception, code:%{public}d", ret);
            return ret;
        }
        HILOG_ERROR("Copy error, code:%{public}d", ret);
        Result result { "", "", ret, "" };
        ret = TranslateResult(ret, result);
        copyResult.push_back(result);
        return ret;
    }
    return ret;
}

int FileAccessHelper::CopyFileOperation(Uri &sourceUri, Uri &destUri, const std::string &fileName, Uri &newFileUri)
{
    UserAccessTracer trace;
    trace.Start("CopyFileOperation");
    sptr<IFileAccessExtBase> proxy = GetProxyByUri(sourceUri);
    if (proxy == nullptr) {
        HILOG_ERROR("Failed with invalid FileAccessExtBaseProxy");
        return E_IPCS;
    }

    Urie sourceUriConvert(sourceUri.ToString());
    Urie destUriConvert(destUri.ToString());
    Urie newFileUriConvert("");
    int ret = proxy->CopyFile(sourceUriConvert, destUriConvert, fileName, newFileUriConvert);
    if (ret != ERR_OK) {
        HILOG_ERROR("Copy file error, code:%{public}d", ret);
        return ret;
    }
    newFileUri = Uri(newFileUriConvert.ToString());
    return ret;
}

int FileAccessHelper::Copy(Uri &sourceUri, Uri &destUri, std::vector<Result> &copyResult, bool force)
{
    UserAccessTracer trace;
    trace.Start("Copy");
    if (!IsSystemApp()) {
        HILOG_ERROR("Copy check IsSystemAppByFullTokenID failed");
        return GetResult("", "", E_PERMISSION_SYS, "", copyResult);
    }

    if (!CheckUri(sourceUri) || !CheckUri(destUri)) {
        HILOG_ERROR("Uri format check error");
        return GetResult("", "", E_URIS, "", copyResult);
    }

    bool isDir = false;
    int ret = IsDirectory(destUri, isDir);
    if (ret != ERR_OK) {
        HILOG_ERROR("Get uri type error");
        GetResult("", "", ret, "", copyResult);
        return COPY_EXCEPTION;
    }
    if (!isDir) {
        HILOG_ERROR("Destination uri is not directory");
        return GetResult("", "", E_URIS, "", copyResult);
    }

    ret = CopyOperation(sourceUri, destUri, copyResult, force);
    return ret;
}

int FileAccessHelper::CopyFile(Uri &sourceUri, Uri &destUri, const std::string &fileName, Uri &newFileUri)
{
    UserAccessTracer trace;
    trace.Start("CopyFile");
    if (!IsSystemApp()) {
        HILOG_ERROR("Copy check IsSystemAppByFullTokenID failed");
        return E_PERMISSION_SYS;
    }

    if (!CheckUri(sourceUri) || !CheckUri(destUri)) {
        HILOG_ERROR("Uri format check error");
        return E_URIS;
    }

    bool isDir = false;
    int ret = IsDirectory(destUri, isDir);
    if (ret != ERR_OK) {
        HILOG_ERROR("Get uri type error");
        return E_GETRESULT;
    }
    if (!isDir) {
        HILOG_ERROR("Destination uri is not directory");
        return E_URIS;
    }
    ret = CopyFileOperation(sourceUri, destUri, fileName, newFileUri);
    return ret;
}

int FileAccessHelper::Rename(Uri &sourceFile, const std::string &displayName, Uri &newFile)
{
    UserAccessTracer trace;
    trace.Start("Rename");
    if (!IsSystemApp()) {
        HILOG_ERROR("FileAccessHelper::Rename check IsSystemAppByFullTokenID failed");
        return E_PERMISSION_SYS;
    }

    if (!CheckUri(sourceFile)) {
        HILOG_ERROR("sourceFile format check error.");
        return E_URIS;
    }

    sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(sourceFile);
    if (fileExtProxy == nullptr) {
        HILOG_ERROR("failed with invalid FileAccessExtBaseProxy");
        return E_IPCS;
    }

    Urie sourceFileConvert(sourceFile.ToString());
    Urie newFileConvert("");
    int ret = fileExtProxy->Rename(sourceFileConvert, displayName, newFileConvert);
    if (ret != ERR_OK) {
        HILOG_ERROR("Rename get result error, code:%{public}d", ret);
        return ret;
    }
    newFile = Uri(newFileConvert.ToString());

    return ERR_OK;
}

int FileAccessHelper::ListFile(const FileInfo &fileInfo, const int64_t offset, const FileFilter &filter,
    SharedMemoryInfo &memInfo)
{
    UserAccessTracer trace;
    trace.Start("ListFile");
    if (!IsSystemApp()) {
        HILOG_ERROR("FileAccessHelper::ListFile check IsSystemAppByFullTokenID failed");
        return E_PERMISSION_SYS;
    }

    Uri sourceFile(fileInfo.uri);
    if (!CheckUri(sourceFile)) {
        HILOG_ERROR("sourceFile format check error.");
        return E_URIS;
    }

    sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(sourceFile);
    if (fileExtProxy == nullptr) {
        HILOG_ERROR("failed with invalid FileAccessExtBaseProxy");
        return E_IPCS;
    }

    memInfo.Clear();
    SharedMemoryInfo memInfoTemp = memInfo;
    int ret = fileExtProxy->ListFile(fileInfo, offset, filter, memInfo);
    if (ret != ERR_OK) {
        HILOG_ERROR("ListFile get result error, code:%{public}d", ret);
        return ret;
    }
    memInfo.totalDataCounts = memInfo.dataCounts;
    memInfo.memName = memInfoTemp.memName;
    memInfo.memHead = memInfoTemp.memHead;
    memInfo.memTail = memInfoTemp.memTail;
    memInfo.dataPtr = memInfoTemp.dataPtr;
    return ERR_OK;
}

int FileAccessHelper::ScanFile(const FileInfo &fileInfo, const int64_t offset, const int64_t maxCount,
    const FileFilter &filter, std::vector<FileInfo> &fileInfoVec)
{
    UserAccessTracer trace;
    trace.Start("ScanFile");
    if (!IsSystemApp()) {
        HILOG_ERROR("FileAccessHelper::ScanFile check IsSystemAppByFullTokenID failed");
        return E_PERMISSION_SYS;
    }

    Uri sourceFile(fileInfo.uri);
    if (!CheckUri(sourceFile)) {
        HILOG_ERROR("sourceFile format check error.");
        return E_URIS;
    }

    sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(sourceFile);
    if (fileExtProxy == nullptr) {
        HILOG_ERROR("failed with invalid FileAccessExtBaseProxy");
        return E_IPCS;
    }
    fileInfoVec.clear();

    int ret = fileExtProxy->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec);
    if (ret != ERR_OK) {
        HILOG_ERROR("ScanFile get result error, code:%{public}d", ret);
        return ret;
    }

    return ERR_OK;
}

static int GetQueryColumns(std::string &uri, std::string &metaJson, std::vector<std::string> &columns)
{
    if (!json::accept(metaJson)) {
        HILOG_ERROR("metaJson format check error.");
        return EINVAL;
    }

    auto jsonObject = json::parse(metaJson);
    for (json::iterator it = jsonObject.begin(); it != jsonObject.end(); ++it) {
        auto iterator = FILE_RESULT_TYPE.find(it.key());
        if (iterator == FILE_RESULT_TYPE.end()) {
            HILOG_ERROR("columns format check error.");
            return EINVAL;
        }
        columns.push_back(it.key());
    }

    if (columns.empty()) {
        HILOG_ERROR("columns is empty.");
        return EINVAL;
    }
    return ERR_OK;
}

static int GetQueryResult(std::string &uri, std::vector<std::string> &columns, std::vector<std::string> &results,
    std::string &metaJson)
{
    json jsonObject;
    for (size_t i = 0; i < columns.size(); i++) {
        auto memberType = FILE_RESULT_TYPE.at(columns.at(i));
        // Assign a default value based on the type, When fileIo obtains an invalid value.
        switch (memberType) {
            case STRING_TYPE:
                if (results[i].empty()) {
                    results[i] = " ";
                }
                jsonObject[columns[i]] = results[i];
                break;
            case INT32_TYPE:
                if (results[i].empty()) {
                    results[i] = "0";
                }
                jsonObject[columns[i]] = std::atoi(results[i].c_str());
                break;
            case INT64_TYPE:
                if (results[i].empty()) {
                    results[i] = "0";
                }
                jsonObject[columns[i]] = std::stol(results[i]);
                break;
            default:
                jsonObject[columns[i]] = " ";
                HILOG_ERROR("not match  memberType %{public}d", memberType);
                break;
        }
    }
    metaJson = jsonObject.dump();
    return ERR_OK;
}

int FileAccessHelper::Query(Uri &uri, std::string &metaJson)
{
    UserAccessTracer trace;
    trace.Start("Query");
    if (!IsSystemApp()) {
        HILOG_ERROR("FileAccessHelper::Query check IsSystemAppByFullTokenID failed");
        return E_PERMISSION_SYS;
    }

    if (!CheckUri(uri)) {
        HILOG_ERROR("Uri format check error.");
        return E_URIS;
    }

    std::string uriString(uri.ToString());
    std::vector<std::string> columns;
    std::vector<std::string> results;
    int ret = GetQueryColumns(uriString, metaJson, columns);
    if (ret != ERR_OK) {
        HILOG_ERROR("Query get columns error, code:%{public}d", ret);
        return ret;
    }

    sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(uri);
    if (fileExtProxy == nullptr) {
        HILOG_ERROR("failed with invalid FileAccessExtBaseProxy");
        return E_IPCS;
    }

    Urie uriConvert(uri.ToString());
    results.clear();
    ret = fileExtProxy->Query(uriConvert, columns, results);
    if (ret != ERR_OK) {
        HILOG_ERROR("Query get result error, code:%{public}d", ret);
        return ret;
    }

    ret = GetQueryResult(uriString, columns, results, metaJson);
    if (ret != ERR_OK) {
        HILOG_ERROR("Query get result error, code:%{public}d", ret);
        return ret;
    }

    return ERR_OK;
}

int FileAccessHelper::GetRoots(std::vector<RootInfo> &rootInfoVec)
{
    UserAccessTracer trace;
    trace.Start("GetRoots");
    if (!IsSystemApp()) {
        HILOG_ERROR("FileAccessHelper::GetRoots check IsSystemAppByFullTokenID failed");
        return E_PERMISSION_SYS;
    }

    if (!GetProxy()) {
        HILOG_ERROR("failed with invalid FileAccessExtBaseProxy");
        return E_IPCS;
    }

    int ret = ERR_OK;
    for (auto iter = cMap_.begin(); iter != cMap_.end(); ++iter) {
        auto connectInfo = iter->second;
        if (connectInfo == nullptr || connectInfo->fileAccessExtConnection == nullptr) {
            HILOG_ERROR("connectInfo is nullptr");
            return E_IPCS;
        }
        auto fileAccessExtBaseProxy = connectInfo->fileAccessExtConnection->GetFileExtProxy();
        std::vector<RootInfo> results;
        if (!fileAccessExtBaseProxy) {
            HILOG_ERROR("GetFileExtProxy return nullptr, bundle name is %{public}s", iter->first.c_str());
            continue;
        }

        ret = fileAccessExtBaseProxy->GetRoots(results);
        if (ret != ERR_OK) {
            HILOG_ERROR("getRoots get fail ret:%{public}d", ret);
            return ret;
        }

        rootInfoVec.insert(rootInfoVec.end(), results.begin(), results.end());
    }

    return ERR_OK;
}

int FileAccessHelper::GetRegisteredFileAccessExtAbilityInfo(std::vector<AAFwk::Want> &wantVec)
{
    UserAccessTracer trace;
    trace.Start("GetRegisteredFileAccessExtAbilityInfo");
    HILOG_INFO("GetRegisteredFileAccessExtAbilityInfo start.");
    if (!IsSystemApp()) {
        HILOG_ERROR("FileAccessHelper::GetRoots check IsSystemAppByFullTokenID failed");
        return E_PERMISSION_SYS;
    }

    std::vector<AppExecFwk::ExtensionAbilityInfo> extensionInfos;
    sptr<AppExecFwk::IBundleMgr> bm = FileAccessHelper::GetBundleMgrProxy();
    if (bm == nullptr) {
        HILOG_ERROR("GetBundleMgrProxy nullptr.");
        return E_GETINFO;
    }
    bool ret = bm->QueryExtensionAbilityInfos(
        AppExecFwk::ExtensionAbilityType::FILEACCESS_EXTENSION, GetUserId(), extensionInfos);
    HILOG_INFO("QueryExtensionAbilityInfos end.");
    if (!ret) {
        HILOG_ERROR("FileAccessHelper::GetRegisteredFileAccessExtAbilityInfo QueryExtensionAbilityInfos error");
        return E_GETINFO;
    }

    wantVec.clear();
    for (size_t i = 0; i < extensionInfos.size(); i++) {
        if (extensionInfos[i].bundleName.empty()) {
            HILOG_ERROR("GetRegisteredFileAccessExtAbilityInfo extensionInfos.bundleName empty");
            return E_GETINFO;
        }
        AAFwk::Want want;
        want.SetElementName(extensionInfos[i].bundleName, extensionInfos[i].name);
        wantVec.push_back(want);
    }

    return ERR_OK;
}

int FileAccessHelper::Access(Uri &uri, bool &isExist)
{
    UserAccessTracer trace;
    trace.Start("Access");
    if (!IsSystemApp()) {
        HILOG_ERROR("FileAccessHelper::Access check IsSystemAppByFullTokenID failed");
        return E_PERMISSION_SYS;
    }

    if (!CheckUri(uri)) {
        HILOG_ERROR("uri format check error.");
        return E_URIS;
    }

    sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(uri);
    if (fileExtProxy == nullptr) {
        HILOG_ERROR("failed with invalid FileAccessExtBaseProxy");
        return E_IPCS;
    }

    Urie uriConvert(uri.ToString());
    int ret = fileExtProxy->Access(uriConvert, isExist);
    if (ret != ERR_OK) {
        HILOG_ERROR("Access get result error, code:%{public}d", ret);
        return ret;
    }

    return ERR_OK;
}

int FileAccessHelper::GetFileInfoFromUri(Uri &selectFile, FileInfo &fileInfo)
{
    UserAccessTracer trace;
    trace.Start("GetFileInfoFromUri");
    if (!IsSystemApp()) {
        HILOG_ERROR("FileAccessHelper::GetFileInfoFromUri check IsSystemAppByFullTokenID failed");
        return E_PERMISSION_SYS;
    }

    if (!CheckUri(selectFile)) {
        HILOG_ERROR("selectFile uri format check error.");
        return E_URIS;
    }

    sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(selectFile);
    if (fileExtProxy == nullptr) {
        HILOG_ERROR("failed with invalid FileAccessExtBaseProxy");
        return E_IPCS;
    }

    Urie selectFileConvert(selectFile.ToString());
    int ret = fileExtProxy->GetFileInfoFromUri(selectFileConvert, fileInfo);
    if (ret != ERR_OK) {
        HILOG_ERROR("GetFileInfoFromUri get result error, code:%{public}d", ret);
        return ret;
    }

    return ERR_OK;
}

int FileAccessHelper::GetFileInfoFromRelativePath(std::string &selectFile, FileInfo &fileInfo)
{
    UserAccessTracer trace;
    trace.Start("GetFileInfoFromRelativePath");
    if (!IsSystemApp()) {
        HILOG_ERROR("FileAccessHelper::GetFileInfoFromRelativePath check IsSystemAppByFullTokenID failed");
        return E_PERMISSION_SYS;
    }

    sptr<IFileAccessExtBase> fileExtProxy = GetProxyByBundleName(EXTERNAL_BNUDLE_NAME);
    if (fileExtProxy == nullptr) {
        HILOG_ERROR("failed with invalid FileAccessExtBaseProxy");
        return E_IPCS;
    }

    int ret = fileExtProxy->GetFileInfoFromRelativePath(selectFile, fileInfo);
    if (ret != ERR_OK) {
        HILOG_ERROR("GetFileInfoFromRelativePath get result error, code:%{public}d", ret);
        return ret;
    }

    return ERR_OK;
}

int FileAccessHelper::RegisterNotify(Uri uri, bool notifyForDescendants, sptr<IFileAccessObserver> &observer)
{
    UserAccessTracer trace;
    trace.Start("RegisterNotify");
    if (!IsSystemApp()) {
        HILOG_ERROR("FileAccessHelper::RegisterNotify check IsSystemAppByFullTokenID failed");
        return E_PERMISSION_SYS;
    }

    if (!CheckUri(uri) || observer == nullptr) {
        HILOG_ERROR("parameter check error.");
        return EINVAL;
    }

    auto proxy = FileAccessServiceClient::GetInstance();
    if (proxy == nullptr) {
        HILOG_ERROR("RegisterNotify get SA failed");
        return E_LOAD_SA;
    }

    std::shared_ptr<ConnectExtensionInfo> info = GetConnectExtensionInfo(uri);
    if (!info) {
        HILOG_ERROR("FileAccessHelper::RegisterNotify check ConnectExtensionInfo failed");
        return EINVAL;
    }

    int ret = proxy->RegisterNotify(uri, notifyForDescendants, observer, *info);
    return ret;
}

int FileAccessHelper::UnregisterNotify(Uri uri, sptr<IFileAccessObserver> &observer)
{
    UserAccessTracer trace;
    trace.Start("UnregisterNotify");
    if (!IsSystemApp()) {
        HILOG_ERROR("FileAccessHelper::UnregisterNotify check IsSystemAppByFullTokenID failed");
        return E_PERMISSION_SYS;
    }

    if (!CheckUri(uri) || observer == nullptr) {
        HILOG_ERROR("parameter check error.");
        return EINVAL;
    }

    auto proxy = FileAccessServiceClient::GetInstance();
    if (proxy == nullptr) {
        HILOG_ERROR("UnregisterNotify get SA failed");
        return E_LOAD_SA;
    }

    std::shared_ptr<ConnectExtensionInfo> info = GetConnectExtensionInfo(uri);
    if (!info) {
        HILOG_ERROR("FileAccessHelper::UnregisterNotify check ConnectExtensionInfo failed");
        return EINVAL;
    }

    int ret = proxy->UnregisterNotify(uri, observer, *info);
    return ret;
}

int FileAccessHelper::UnregisterNotify(Uri uri)
{
    UserAccessTracer trace;
    trace.Start("UnregisterNotify");
    if (!IsSystemApp()) {
        HILOG_ERROR("FileAccessHelper::UnregisterNotify check IsSystemAppByFullTokenID failed");
        return E_PERMISSION_SYS;
    }

    if (!CheckUri(uri)) {
        HILOG_ERROR("parameter check error.");
        return EINVAL;
    }
    auto proxy = FileAccessServiceClient::GetInstance();
    if (proxy == nullptr) {
        HILOG_ERROR("UnregisterNotify get SA failed");
        return E_LOAD_SA;
    }

    std::shared_ptr<ConnectExtensionInfo> info = GetConnectExtensionInfo(uri);
    if (!info) {
        HILOG_ERROR("FileAccessHelper::UnregisterNotify check ConnectExtensionInfo failed");
        return EINVAL;
    }

    int ret = proxy->UnregisterNotifyNoObserver(uri, *info);
    return ret;
}

int FileAccessHelper::MoveItem(Uri &sourceFile, Uri &targetParent, std::vector<Result> &moveResult, bool force)
{
    UserAccessTracer trace;
    trace.Start("MoveItem");
    if (!IsSystemApp()) {
        HILOG_ERROR("MoveItem check IsSystemAppByFullTokenID failed");
        return GetResult("", "", E_PERMISSION_SYS, "", moveResult);
    }

    Uri sourceFileUri(sourceFile.ToString());
    Uri targetParentUri(targetParent.ToString());
    if (!CheckUri(sourceFile) || !CheckUri(targetParent)) {
        HILOG_ERROR("uri format check error.");
        return GetResult("", "", E_URIS, "", moveResult);
    }

    if (sourceFileUri.GetAuthority() != targetParentUri.GetAuthority()) {
        HILOG_WARN("Operation failed, move not supported");
        return GetResult("", "", EPERM, "", moveResult);
    }

    sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(sourceFile);
    if (fileExtProxy == nullptr) {
        HILOG_ERROR("failed with invalid FileAccessExtBaseProxy");
        return GetResult("", "", E_IPCS, "", moveResult);
    }

    Urie sourceFileConvert(sourceFile.ToString());
    Urie targetParentConvert(targetParent.ToString());
    moveResult.clear();
    int retCode;
    int ret = fileExtProxy->MoveItem(sourceFileConvert, targetParentConvert, moveResult, retCode, force);
    if (ret == ERR_OK) {
        ret = retCode;
    }
    if (moveResult.size() > MAX_COPY_ERROR_COUNT) {
        HILOG_ERROR("Move operation failed, count value greater than max count");
        Result result { "", "", E_COUNT, "Count value greater than max count"};
        moveResult.clear();
        moveResult.push_back(result);
        ret = COPY_EXCEPTION;
    }
    if (ret != ERR_OK) {
        HILOG_ERROR("Move get result error, code:%{public}d", ret);
        return ret;
    }

    return ERR_OK;
}

int FileAccessHelper::MoveFile(Uri &sourceFile, Uri &targetParent, std::string &fileName, Uri &newFile)
{
    UserAccessTracer trace;
    trace.Start("MoveFile");
    if (!IsSystemApp()) {
        HILOG_ERROR("FileAccessHelper::MoveFile check IsSystemAppByFullTokenID failed");
        return E_PERMISSION_SYS;
    }

    Uri sourceFileUri(sourceFile.ToString());
    Uri targetParentUri(targetParent.ToString());
    if (!CheckUri(sourceFile) || !CheckUri(targetParent)) {
        HILOG_ERROR("uri format check error.");
        return E_URIS;
    }

    if (sourceFileUri.GetAuthority() != targetParentUri.GetAuthority()) {
        HILOG_WARN("Operation failed, move not supported");
        return EPERM;
    }

    sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(sourceFile);
    if (fileExtProxy == nullptr) {
        HILOG_ERROR("failed with invalid FileAccessExtBaseProxy");
        return E_IPCS;
    }

    Urie sourceFileConvert(sourceFile.ToString());
    Urie targetParentConvert(targetParent.ToString());
    Urie newFileConvert("");
    int ret = fileExtProxy->MoveFile(sourceFileConvert, targetParentConvert, fileName, newFileConvert);
    if (ret != ERR_OK) {
        HILOG_ERROR("Move get result error, code:%{public}d", ret);
        return ret;
    }
    newFile = Uri(newFileConvert.ToString());

    return ERR_OK;
}
} // namespace FileAccessFwk
} // namespace OHOS