1/*
2 * Copyright (c) 2021-2023 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 "adapter/ohos/entrance/ace_data_ability.h"
17
18#include "adapter/ohos/entrance/pa_engine/pa_backend.h"
19#include "core/common/ace_engine.h"
20
21namespace OHOS {
22namespace Ace {
23
24using namespace OHOS::AAFwk;
25using namespace OHOS::AppExecFwk;
26
27using DataPlatformFinish = std::function<void()>;
28class DataPlatformEventCallback final : public Platform::PlatformEventCallback {
29public:
30    explicit DataPlatformEventCallback(DataPlatformFinish onFinish) : onFinish_(onFinish) {}
31
32    ~DataPlatformEventCallback() override = default;
33
34    void OnFinish() const override
35    {
36        LOGI("DataPlatformEventCallback OnFinish");
37        CHECK_NULL_VOID(onFinish_);
38        onFinish_();
39    }
40
41    void OnStatusBarBgColorChanged(uint32_t color) override
42    {
43        LOGI("DataPlatformEventCallback OnStatusBarBgColorChanged");
44    }
45
46private:
47    DataPlatformFinish onFinish_;
48};
49
50const std::string AceDataAbility::START_PARAMS_KEY = "__startParams";
51const std::string AceDataAbility::URI = "url";
52
53REGISTER_AA(AceDataAbility)
54
55AceDataAbility::AceDataAbility()
56{
57    abilityId_ = Container::GenerateId<PA_DATA_CONTAINER>();
58}
59
60void AceDataAbility::OnStart(const OHOS::AAFwk::Want& want, sptr<AAFwk::SessionInfo> sessionInfo)
61{
62    Ability::OnStart(want, sessionInfo);
63    LOGI("AceDataAbility OnStart called");
64
65    // get url
66    std::string parsedUrl;
67    if (want.HasParameter(URI)) {
68        parsedUrl = want.GetStringParam(URI);
69    } else {
70        parsedUrl = "data.js";
71    }
72
73    // get asset
74    auto packagePathStr = GetBundleCodePath();
75    auto moduleInfo = GetHapModuleInfo();
76    CHECK_NULL_VOID(moduleInfo);
77    packagePathStr += "/" + moduleInfo->package + "/";
78    std::shared_ptr<AbilityInfo> abilityInfo = GetAbilityInfo();
79
80    // init data ability
81    BackendType backendType = BackendType::DATA;
82    SrcLanguage srcLanguage = SrcLanguage::ETS;
83    if (abilityInfo != nullptr && !abilityInfo->srcLanguage.empty()) {
84        if (abilityInfo->srcLanguage == "js") {
85            srcLanguage = SrcLanguage::JS;
86        }
87    }
88
89    std::shared_ptr<Platform::WorkerPath> workerPath = std::make_shared<Platform::WorkerPath>();
90    workerPath->packagePathStr = packagePathStr;
91    std::vector<std::string> assetBasePathStr;
92
93    AceEngine::InitJsDumpHeadSignal();
94    if (abilityInfo != nullptr && !abilityInfo->srcPath.empty()) {
95        assetBasePathStr = { "assets/js/" + abilityInfo->srcPath + "/", std::string("assets/js/") };
96    } else {
97        assetBasePathStr = { std::string("assets/js/default/"), std::string("assets/js/share/") };
98    }
99    workerPath->assetBasePathStr = assetBasePathStr;
100
101    Platform::PaContainerOptions options;
102    options.type = backendType;
103    options.language = srcLanguage;
104    options.hapPath = moduleInfo->hapPath;
105    options.workerPath = workerPath;
106
107    Platform::PaContainer::CreateContainer(abilityId_, this, options,
108        std::make_unique<DataPlatformEventCallback>([this]() { TerminateAbility(); }));
109    Platform::PaContainer::AddAssetPath(abilityId_, packagePathStr, moduleInfo->hapPath, assetBasePathStr);
110
111    // run data ability
112    Platform::PaContainer::RunPa(abilityId_, parsedUrl, want);
113}
114
115void AceDataAbility::OnStop()
116{
117    LOGI("AceDataAbility OnStop called");
118    Ability::OnStop();
119    Platform::PaContainer::DestroyContainer(abilityId_);
120}
121
122int32_t AceDataAbility::Insert(const Uri& uri, const NativeRdb::ValuesBucket& value)
123{
124    LOGI("AceDataAbility Insert called");
125    int32_t ret = Platform::PaContainer::Insert(abilityId_, uri, value);
126    return ret;
127}
128
129std::shared_ptr<NativeRdb::AbsSharedResultSet> AceDataAbility::Query(
130    const Uri& uri, const std::vector<std::string>& columns,
131    const NativeRdb::DataAbilityPredicates& predicates)
132{
133    LOGI("AceDataAbility Query called");
134    auto resultSet = Platform::PaContainer::Query(abilityId_, uri, columns, predicates);
135    return resultSet;
136}
137
138int32_t AceDataAbility::Update(const Uri& uri, const NativeRdb::ValuesBucket& value,
139    const NativeRdb::DataAbilityPredicates& predicates)
140{
141    LOGI("AceDataAbility Update called");
142    int32_t ret = Platform::PaContainer::Update(abilityId_, uri, value, predicates);
143    return ret;
144}
145
146int32_t AceDataAbility::Delete(const Uri& uri, const NativeRdb::DataAbilityPredicates& predicates)
147{
148    LOGI("AceDataAbility Delete called");
149    int32_t ret = Platform::PaContainer::Delete(abilityId_, uri, predicates);
150    return ret;
151}
152
153int32_t AceDataAbility::BatchInsert(const Uri& uri, const std::vector<NativeRdb::ValuesBucket>& values)
154{
155    LOGI("AceDataAbility BatchInsert called");
156    int32_t ret = Platform::PaContainer::BatchInsert(abilityId_, uri, values);
157    return ret;
158}
159
160std::string AceDataAbility::GetType(const Uri& uri)
161{
162    LOGI("AceDataAbility GetType called");
163    std::string ret = Platform::PaContainer::GetType(abilityId_, uri);
164    return ret;
165}
166
167std::vector<std::string> AceDataAbility::GetFileTypes(const Uri& uri, const std::string& mimeTypeFilter)
168{
169    LOGI("AceDataAbility GetFileTypes called");
170    std::vector<std::string> ret = Platform::PaContainer::GetFileTypes(abilityId_, uri, mimeTypeFilter);
171    return ret;
172}
173
174int32_t AceDataAbility::OpenFile(const Uri& uri, const std::string& mode)
175{
176    LOGI("AceDataAbility OpenFile called");
177    int32_t ret = Platform::PaContainer::OpenFile(abilityId_, uri, mode);
178    return ret;
179}
180
181int32_t AceDataAbility::OpenRawFile(const Uri& uri, const std::string& mode)
182{
183    LOGI("AceDataAbility OpenRawFile called");
184    int32_t ret = Platform::PaContainer::OpenRawFile(abilityId_, uri, mode);
185    return ret;
186}
187
188Uri AceDataAbility::NormalizeUri(const Uri& uri)
189{
190    LOGI("AceDataAbility NormalizeUri called");
191    Uri ret = Platform::PaContainer::NormalizeUri(abilityId_, uri);
192    return ret;
193}
194
195Uri AceDataAbility::DenormalizeUri(const Uri& uri)
196{
197    LOGI("AceDataAbility DenormalizeUri called");
198    Uri ret = Platform::PaContainer::DenormalizeUri(abilityId_, uri);
199    return ret;
200}
201
202std::shared_ptr<AppExecFwk::PacMap> AceDataAbility::Call(const Uri& uri,
203    const std::string& method, const std::string& arg, const AppExecFwk::PacMap& pacMap)
204{
205    std::shared_ptr<AppExecFwk::PacMap> ret = Platform::PaContainer::Call(abilityId_, uri, method, arg, pacMap);
206    return ret;
207}
208} // namespace Ace
209} // namespace OHOS
210