1 /*
2 * Copyright (c) 2022 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 "js_ability_manager.h"
17
18 #include <cstdint>
19
20 #include "ability_business_error.h"
21 #include "ability_manager_client.h"
22 #include "app_mgr_interface.h"
23 #include "errors.h"
24 #include "hilog_wrapper.h"
25 #include "js_error_utils.h"
26 #include "js_runtime.h"
27 #include "js_runtime_utils.h"
28 #include "napi/native_api.h"
29 #include "if_system_ability_manager.h"
30 #include "iservice_registry.h"
31 #include "system_ability_definition.h"
32 #include "js_ability_manager_utils.h"
33 #include "event_runner.h"
34 #include "napi_common_configuration.h"
35
36 namespace OHOS {
37 namespace AbilityRuntime {
38 using AbilityManagerClient = AAFwk::AbilityManagerClient;
39 namespace {
GetAppManagerInstance()40 OHOS::sptr<OHOS::AppExecFwk::IAppMgr> GetAppManagerInstance()
41 {
42 OHOS::sptr<OHOS::ISystemAbilityManager> systemAbilityManager =
43 OHOS::SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
44 OHOS::sptr<OHOS::IRemoteObject> appObject = systemAbilityManager->GetSystemAbility(OHOS::APP_MGR_SERVICE_ID);
45 return OHOS::iface_cast<OHOS::AppExecFwk::IAppMgr>(appObject);
46 }
47
48 class JsAbilityManager final {
49 public:
50 JsAbilityManager() = default;
51 ~JsAbilityManager() = default;
52
Finalizer(NativeEngine * engine,void * data,void * hint)53 static void Finalizer(NativeEngine* engine, void* data, void* hint)
54 {
55 HILOG_INFO("JsAbilityManager::Finalizer is called");
56 std::unique_ptr<JsAbilityManager>(static_cast<JsAbilityManager*>(data));
57 }
58
GetAbilityRunningInfos(NativeEngine * engine,NativeCallbackInfo * info)59 static NativeValue* GetAbilityRunningInfos(NativeEngine* engine, NativeCallbackInfo* info)
60 {
61 JsAbilityManager* me = CheckParamsAndGetThis<JsAbilityManager>(engine, info);
62 return (me != nullptr) ? me->OnGetAbilityRunningInfos(*engine, *info) : nullptr;
63 }
64
GetExtensionRunningInfos(NativeEngine * engine,NativeCallbackInfo * info)65 static NativeValue* GetExtensionRunningInfos(NativeEngine* engine, NativeCallbackInfo* info)
66 {
67 JsAbilityManager* me = CheckParamsAndGetThis<JsAbilityManager>(engine, info);
68 return (me != nullptr) ? me->OnGetExtensionRunningInfos(*engine, *info) : nullptr;
69 }
70
UpdateConfiguration(NativeEngine * engine,NativeCallbackInfo * info)71 static NativeValue* UpdateConfiguration(NativeEngine* engine, NativeCallbackInfo* info)
72 {
73 JsAbilityManager* me = CheckParamsAndGetThis<JsAbilityManager>(engine, info);
74 return (me != nullptr) ? me->OnUpdateConfiguration(*engine, *info) : nullptr;
75 }
76
GetTopAbility(NativeEngine * engine,NativeCallbackInfo * info)77 static NativeValue* GetTopAbility(NativeEngine* engine, NativeCallbackInfo* info)
78 {
79 JsAbilityManager* me = CheckParamsAndGetThis<JsAbilityManager>(engine, info);
80 return (me != nullptr) ? me->OnGetTopAbility(*engine, *info) : nullptr;
81 }
82
83 private:
OnGetAbilityRunningInfos(NativeEngine & engine,const NativeCallbackInfo & info)84 NativeValue* OnGetAbilityRunningInfos(NativeEngine &engine, const NativeCallbackInfo &info)
85 {
86 HILOG_INFO("%{public}s is called", __FUNCTION__);
87 AsyncTask::CompleteCallback complete =
88 [](NativeEngine &engine, AsyncTask &task, int32_t status) {
89 std::vector<AAFwk::AbilityRunningInfo> infos;
90 auto errcode = AbilityManagerClient::GetInstance()->GetAbilityRunningInfos(infos);
91 if (errcode == 0) {
92 #ifdef ENABLE_ERRCODE
93 task.ResolveWithNoError(engine, CreateJsAbilityRunningInfoArray(engine, infos));
94 } else {
95 task.Reject(engine, CreateJsError(engine, GetJsErrorCodeByNativeError(errcode)));
96 #else
97 task.Resolve(engine, CreateJsAbilityRunningInfoArray(engine, infos));
98 } else {
99 task.Reject(engine, CreateJsError(engine, errcode, "Get mission infos failed."));
100 #endif
101 }
102 };
103
104 NativeValue* lastParam = (info.argc == 0) ? nullptr : info.argv[0];
105 NativeValue* result = nullptr;
106 AsyncTask::Schedule("JsAbilityManager::OnGetAbilityRunningInfos",
107 engine, CreateAsyncTaskWithLastParam(engine,
108 lastParam, nullptr, std::move(complete), &result));
109 return result;
110 }
111
OnGetExtensionRunningInfos(NativeEngine & engine,NativeCallbackInfo & info)112 NativeValue* OnGetExtensionRunningInfos(NativeEngine &engine, NativeCallbackInfo &info)
113 {
114 HILOG_INFO("%{public}s is called", __FUNCTION__);
115 if (info.argc == 0) {
116 HILOG_ERROR("Not enough params");
117 #ifdef ENABLE_ERRCODE
118 ThrowTooFewParametersError(engine);
119 #endif
120 return engine.CreateUndefined();
121 }
122 int upperLimit = -1;
123 if (!ConvertFromJsValue(engine, info.argv[0], upperLimit)) {
124 HILOG_ERROR("Parse missionId failed");
125 #ifdef ENABLE_ERRCODE
126 ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM);
127 #endif
128 return engine.CreateUndefined();
129 }
130
131 AsyncTask::CompleteCallback complete =
132 [upperLimit](NativeEngine &engine, AsyncTask &task, int32_t status) {
133 std::vector<AAFwk::ExtensionRunningInfo> infos;
134 auto errcode = AbilityManagerClient::GetInstance()->GetExtensionRunningInfos(upperLimit, infos);
135 if (errcode == 0) {
136 #ifdef ENABLE_ERRCODE
137 task.ResolveWithNoError(engine, CreateJsExtensionRunningInfoArray(engine, infos));
138 } else {
139 task.Reject(engine, CreateJsError(engine, GetJsErrorCodeByNativeError(errcode)));
140 #else
141 task.Resolve(engine, CreateJsExtensionRunningInfoArray(engine, infos));
142 } else {
143 task.Reject(engine, CreateJsError(engine, errcode, "Get mission infos failed."));
144 #endif
145 }
146 };
147
148 NativeValue* lastParam = (info.argc == 1) ? nullptr : info.argv[1];
149 NativeValue* result = nullptr;
150 AsyncTask::Schedule("JsAbilityManager::OnGetExtensionRunningInfos",
151 engine, CreateAsyncTaskWithLastParam(engine,
152 lastParam, nullptr, std::move(complete), &result));
153 return result;
154 }
155
OnUpdateConfiguration(NativeEngine & engine,NativeCallbackInfo & info)156 NativeValue* OnUpdateConfiguration(NativeEngine &engine, NativeCallbackInfo &info)
157 {
158 HILOG_INFO("%{public}s is called", __FUNCTION__);
159 AsyncTask::CompleteCallback complete;
160
161 do {
162 if (info.argc == 0) {
163 HILOG_ERROR("Not enough params");
164 #ifdef ENABLE_ERRCODE
165 ThrowTooFewParametersError(engine);
166 #else
167 complete = [](NativeEngine& engine, AsyncTask& task, int32_t status) {
168 task.Reject(engine, CreateJsError(engine, ERR_INVALID_VALUE, "no enough params."));
169 };
170 #endif
171 break;
172 }
173
174 AppExecFwk::Configuration changeConfig;
175 if (!UnwrapConfiguration(reinterpret_cast<napi_env>(&engine),
176 reinterpret_cast<napi_value>(info.argv[0]), changeConfig)) {
177 #ifdef ENABLE_ERRCODE
178 ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM);
179 #else
180 complete = [](NativeEngine& engine, AsyncTask& task, int32_t status) {
181 task.Reject(engine, CreateJsError(engine, ERR_INVALID_VALUE, "config is invalid."));
182 };
183 #endif
184 break;
185 }
186
187 complete = [changeConfig](NativeEngine& engine, AsyncTask& task, int32_t status) {
188 auto errcode = GetAppManagerInstance()->UpdateConfiguration(changeConfig);
189 if (errcode == 0) {
190 #ifdef ENABLE_ERRCODE
191 task.ResolveWithNoError(engine, engine.CreateUndefined());
192 } else {
193 task.Reject(engine, CreateJsError(engine, GetJsErrorCodeByNativeError(errcode)));
194 #else
195 task.Resolve(engine, engine.CreateUndefined());
196 } else {
197 task.Reject(engine, CreateJsError(engine, errcode, "update config failed."));
198 #endif
199 }
200 };
201 } while (0);
202
203 NativeValue* lastParam = (info.argc == 1) ? nullptr : info.argv[1];
204 NativeValue* result = nullptr;
205 AsyncTask::Schedule("JsAbilityManager::OnGetExtensionRunningInfos",
206 engine, CreateAsyncTaskWithLastParam(engine,
207 lastParam, nullptr, std::move(complete), &result));
208 return result;
209 }
210
OnGetTopAbility(NativeEngine & engine,const NativeCallbackInfo & info)211 NativeValue* OnGetTopAbility(NativeEngine &engine, const NativeCallbackInfo &info)
212 {
213 HILOG_INFO("%{public}s is called", __FUNCTION__);
214 AsyncTask::CompleteCallback complete =
215 [](NativeEngine &engine, AsyncTask &task, int32_t status) {
216 AppExecFwk::ElementName elementName = AbilityManagerClient::GetInstance()->GetTopAbility();
217 #ifdef ENABLE_ERRCOE
218 task.ResolveWithNoError(engine, CreateJsElementName(engine, elementName));
219 #else
220 task.Resolve(engine, CreateJsElementName(engine, elementName));
221 #endif
222 };
223
224 NativeValue* lastParam = (info.argc == 0) ? nullptr : info.argv[0];
225 NativeValue* result = nullptr;
226 AsyncTask::Schedule("JsAbilityManager::OnGetTopAbility",
227 engine, CreateAsyncTaskWithLastParam(engine,
228 lastParam, nullptr, std::move(complete), &result));
229 return result;
230 }
231 };
232 } // namespace
233
JsAbilityManagerInit(NativeEngine * engine,NativeValue * exportObj)234 NativeValue* JsAbilityManagerInit(NativeEngine* engine, NativeValue* exportObj)
235 {
236 HILOG_INFO("JsAbilityManagerInit is called");
237
238 if (engine == nullptr || exportObj == nullptr) {
239 HILOG_INFO("engine or exportObj null");
240 return nullptr;
241 }
242
243 NativeObject* object = ConvertNativeValueTo<NativeObject>(exportObj);
244 if (object == nullptr) {
245 HILOG_INFO("object null");
246 return nullptr;
247 }
248
249 std::unique_ptr<JsAbilityManager> jsAbilityManager = std::make_unique<JsAbilityManager>();
250 object->SetNativePointer(jsAbilityManager.release(), JsAbilityManager::Finalizer, nullptr);
251
252 object->SetProperty("AbilityState", AbilityStateInit(engine));
253
254 HILOG_INFO("JsAbilityManagerInit BindNativeFunction called");
255 const char *moduleName = "JsAbilityManager";
256 BindNativeFunction(*engine, *object, "getAbilityRunningInfos", moduleName,
257 JsAbilityManager::GetAbilityRunningInfos);
258 BindNativeFunction(*engine, *object, "getExtensionRunningInfos", moduleName,
259 JsAbilityManager::GetExtensionRunningInfos);
260 BindNativeFunction(*engine, *object, "updateConfiguration", moduleName, JsAbilityManager::UpdateConfiguration);
261 BindNativeFunction(*engine, *object, "getTopAbility", moduleName, JsAbilityManager::GetTopAbility);
262 HILOG_INFO("JsAbilityManagerInit end");
263 return engine->CreateUndefined();
264 }
265 } // namespace AbilityRuntime
266 } // namespace OHOS
267