ohos/entrance/ace_data_ability.cpp

/*
 * Copyright (c) 2021-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 "adapter/ohos/entrance/ace_data_ability.h"

#include "res_config.h"
#include "resource_manager.h"
#include "session_info.h"

#include "adapter/ohos/entrance/pa_container.h"
#include "adapter/ohos/entrance/pa_engine/pa_backend.h"
#include "adapter/ohos/entrance/platform_event_callback.h"
#include "adapter/ohos/entrance/utils.h"
#include "base/log/log.h"
#include "base/utils/utils.h"
#include "core/common/ace_engine.h"
#include "core/common/backend.h"

namespace OHOS {
namespace Ace {

using namespace OHOS::AAFwk;
using namespace OHOS::AppExecFwk;

using DataPlatformFinish = std::function<void()>;
class DataPlatformEventCallback final : public Platform::PlatformEventCallback {
public:
    explicit DataPlatformEventCallback(DataPlatformFinish onFinish) : onFinish_(onFinish) {}

    ~DataPlatformEventCallback() override = default;

    void OnFinish() const override
    {
        LOGI("DataPlatformEventCallback OnFinish");
        CHECK_NULL_VOID_NOLOG(onFinish_);
        onFinish_();
    }

    void OnStatusBarBgColorChanged(uint32_t color) override
    {
        LOGI("DataPlatformEventCallback OnStatusBarBgColorChanged");
    }

private:
    DataPlatformFinish onFinish_;
};

int32_t AceDataAbility::instanceId_ = 200000;
const std::string AceDataAbility::START_PARAMS_KEY = "__startParams";
const std::string AceDataAbility::URI = "url";

REGISTER_AA(AceDataAbility)
void AceDataAbility::OnStart(const OHOS::AAFwk::Want& want, sptr<AAFwk::SessionInfo> sessionInfo)
{
    Ability::OnStart(want, sessionInfo);
    LOGI("AceDataAbility::OnStart called");

    // get url
    std::string parsedUrl;
    if (want.HasParameter(URI)) {
        parsedUrl = want.GetStringParam(URI);
    } else {
        parsedUrl = "data.js";
    }

    // get asset
    auto packagePathStr = GetBundleCodePath();
    auto moduleInfo = GetHapModuleInfo();
    CHECK_NULL_VOID_NOLOG(moduleInfo);
    packagePathStr += "/" + moduleInfo->package + "/";
    std::shared_ptr<AbilityInfo> abilityInfo = GetAbilityInfo();

    // init data ability
    BackendType backendType = BackendType::DATA;
    SrcLanguage srcLanguage = SrcLanguage::ETS;
    if (abilityInfo != nullptr && !abilityInfo->srcLanguage.empty()) {
        if (abilityInfo->srcLanguage == "js") {
            srcLanguage = SrcLanguage::JS;
        }
    }

    std::shared_ptr<Platform::WorkerPath> workerPath = std::make_shared<Platform::WorkerPath>();
    workerPath->packagePathStr = packagePathStr;
    std::vector<std::string> assetBasePathStr;

    AceEngine::InitJsDumpHeadSignal();
    if (abilityInfo != nullptr && !abilityInfo->srcPath.empty()) {
        LOGI("AceDataAbility::OnStart assetBasePathStr: %{public}s, parsedUrl: %{public}s",
            abilityInfo->srcPath.c_str(), parsedUrl.c_str());
        assetBasePathStr = { "assets/js/" + abilityInfo->srcPath + "/", std::string("assets/js/") };
    } else {
        LOGI("AceDataAbility::OnStart parsedUrl: %{public}s", parsedUrl.c_str());
        assetBasePathStr = { std::string("assets/js/default/"), std::string("assets/js/share/") };
    }
    workerPath->assetBasePathStr = assetBasePathStr;

    Platform::PaContainerOptions options;
    options.type = backendType;
    options.language = srcLanguage;
    options.hapPath = moduleInfo->hapPath;
    options.workerPath = workerPath;

    Platform::PaContainer::CreateContainer(abilityId_, this, options,
        std::make_unique<DataPlatformEventCallback>([this]() { TerminateAbility(); }));
    Platform::PaContainer::AddAssetPath(abilityId_, packagePathStr, moduleInfo->hapPath, assetBasePathStr);

    // run data ability
    Platform::PaContainer::RunPa(abilityId_, parsedUrl, want);

    LOGI("AceDataAbility::OnStart called End");
}

void AceDataAbility::OnStop()
{
    LOGI("AceDataAbility::OnStop called");
    Ability::OnStop();
    Platform::PaContainer::DestroyContainer(abilityId_);
    LOGI("AceDataAbility::OnStop called End");
}

int32_t AceDataAbility::Insert(const Uri& uri, const NativeRdb::ValuesBucket& value)
{
    LOGI("AceDataAbility::Insert called");
    int32_t ret = Platform::PaContainer::Insert(abilityId_, uri, value);
    LOGI("AceDataAbility::Insert called End");
    return ret;
}

std::shared_ptr<NativeRdb::AbsSharedResultSet> AceDataAbility::Query(
    const Uri& uri, const std::vector<std::string>& columns,
    const NativeRdb::DataAbilityPredicates& predicates)
{
    LOGI("AceDataAbility::Query called");
    auto resultSet = Platform::PaContainer::Query(abilityId_, uri, columns, predicates);
    LOGI("AceDataAbility::Query called End");
    return resultSet;
}

int32_t AceDataAbility::Update(const Uri& uri, const NativeRdb::ValuesBucket& value,
    const NativeRdb::DataAbilityPredicates& predicates)
{
    LOGI("AceDataAbility::Update called");
    int32_t ret = Platform::PaContainer::Update(abilityId_, uri, value, predicates);
    LOGI("AceDataAbility::Update called End");
    return ret;
}

int32_t AceDataAbility::Delete(const Uri& uri, const NativeRdb::DataAbilityPredicates& predicates)
{
    LOGI("AceDataAbility::Delete called");
    int32_t ret = Platform::PaContainer::Delete(abilityId_, uri, predicates);
    LOGI("AceDataAbility::Delete called End");
    return ret;
}

int32_t AceDataAbility::BatchInsert(const Uri& uri, const std::vector<NativeRdb::ValuesBucket>& values)
{
    LOGI("AceDataAbility::BatchInsert called");
    int32_t ret = Platform::PaContainer::BatchInsert(abilityId_, uri, values);
    LOGI("AceDataAbility::BatchInsert called End");
    return ret;
}

std::string AceDataAbility::GetType(const Uri& uri)
{
    LOGI("AceDataAbility::GetType called");
    std::string ret = Platform::PaContainer::GetType(abilityId_, uri);
    LOGI("AceDataAbility::GetType called End");
    return ret;
}

std::vector<std::string> AceDataAbility::GetFileTypes(const Uri& uri, const std::string& mimeTypeFilter)
{
    LOGI("AceDataAbility::GetFileTypes called");
    std::vector<std::string> ret = Platform::PaContainer::GetFileTypes(abilityId_, uri, mimeTypeFilter);
    LOGI("AceDataAbility::GetFileTypes called End");
    return ret;
}

int32_t AceDataAbility::OpenFile(const Uri& uri, const std::string& mode)
{
    LOGI("AceDataAbility::OpenFile called");
    int32_t ret = Platform::PaContainer::OpenFile(abilityId_, uri, mode);
    LOGI("AceDataAbility::OpenFile called End");
    return ret;
}

int32_t AceDataAbility::OpenRawFile(const Uri& uri, const std::string& mode)
{
    LOGI("AceDataAbility::OpenRawFile called");
    int32_t ret = Platform::PaContainer::OpenRawFile(abilityId_, uri, mode);
    LOGI("AceDataAbility::OpenRawFile called End");
    return ret;
}

Uri AceDataAbility::NormalizeUri(const Uri& uri)
{
    LOGI("AceDataAbility::NormalizeUri called");
    Uri ret = Platform::PaContainer::NormalizeUri(abilityId_, uri);
    LOGI("AceDataAbility::NormalizeUri called End");
    return ret;
}

Uri AceDataAbility::DenormalizeUri(const Uri& uri)
{
    LOGI("AceDataAbility::DenormalizeUri called");
    Uri ret = Platform::PaContainer::DenormalizeUri(abilityId_, uri);
    LOGI("AceDataAbility::DenormalizeUri called End");
    return ret;
}

std::shared_ptr<AppExecFwk::PacMap> AceDataAbility::Call(const Uri& uri,
    const std::string& method, const std::string& arg, const AppExecFwk::PacMap& pacMap)
{
    LOGD("AceDataAbility::Call called");
    std::shared_ptr<AppExecFwk::PacMap> ret = Platform::PaContainer::Call(abilityId_, uri, method, arg, pacMap);
    return ret;
}
} // namespace Ace
} // namespace OHOS