1 /*
2 * Copyright (c) 2022-2024 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_application_context_utils.h"
17
18 #include <cstdint>
19 #include <map>
20
21 #include "ability_business_error.h"
22 #include "ability_manager_client.h"
23 #include "ability_manager_interface.h"
24 #include "ability_runtime_error_util.h"
25 #include "application_context.h"
26 #include "application_info.h"
27 #include "application_context_manager.h"
28 #include "hilog_tag_wrapper.h"
29 #include "ipc_skeleton.h"
30 #include "js_ability_auto_startup_callback.h"
31 #include "js_ability_auto_startup_manager_utils.h"
32 #include "js_app_process_state.h"
33 #include "js_context_utils.h"
34 #include "js_data_struct_converter.h"
35 #include "js_error_utils.h"
36 #include "js_resource_manager_utils.h"
37 #include "js_runtime_utils.h"
38 #include "napi_common_want.h"
39 #include "tokenid_kit.h"
40
41 namespace OHOS {
42 namespace AbilityRuntime {
43 namespace {
44 constexpr char APPLICATION_CONTEXT_NAME[] = "__application_context_ptr__";
45 constexpr size_t ARGC_ZERO = 0;
46 constexpr size_t ARGC_ONE = 1;
47 constexpr size_t ARGC_TWO = 2;
48 constexpr size_t ARGC_THREE = 3;
49 constexpr size_t INDEX_ZERO = 0;
50 constexpr size_t INDEX_ONE = 1;
51 constexpr size_t INDEX_TWO = 2;
52 constexpr int32_t ERROR_CODE_ONE = 1;
53 constexpr double FOUNT_SIZE = 0.0;
54 const char* MD_NAME = "JsApplicationContextUtils";
55 } // namespace
56
CreateBundleContext(napi_env env,napi_callback_info info)57 napi_value JsApplicationContextUtils::CreateBundleContext(napi_env env, napi_callback_info info)
58 {
59 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils,
60 OnCreateBundleContext, APPLICATION_CONTEXT_NAME);
61 }
62
OnCreateBundleContext(napi_env env,NapiCallbackInfo & info)63 napi_value JsApplicationContextUtils::OnCreateBundleContext(napi_env env, NapiCallbackInfo& info)
64 {
65 if (!CheckCallerIsSystemApp()) {
66 TAG_LOGE(AAFwkTag::APPKIT, "not system-app");
67 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_NOT_SYSTEM_APP);
68 return CreateJsUndefined(env);
69 }
70 if (info.argc == 0) {
71 TAG_LOGE(AAFwkTag::APPKIT, "Not enough arguments");
72 ThrowInvalidParamError(env, "Not enough params.");
73 return CreateJsUndefined(env);
74 }
75 auto applicationContext = applicationContext_.lock();
76 if (!applicationContext) {
77 TAG_LOGW(AAFwkTag::APPKIT, "null applicationContext");
78 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
79 return CreateJsUndefined(env);
80 }
81 std::string bundleName;
82 if (!ConvertFromJsValue(env, info.argv[0], bundleName)) {
83 TAG_LOGE(AAFwkTag::APPKIT, "Parse bundleName failed");
84 ThrowInvalidParamError(env, "Parse param bundleName failed, bundleName must be string.");
85 return CreateJsUndefined(env);
86 }
87 auto bundleContext = applicationContext->CreateBundleContext(bundleName);
88 if (!bundleContext) {
89 TAG_LOGE(AAFwkTag::APPKIT, "null bundleContext");
90 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
91 return CreateJsUndefined(env);
92 }
93 napi_value value = CreateJsBaseContext(env, bundleContext, true);
94 auto systemModule = JsRuntime::LoadSystemModuleByEngine(env, "application.Context", &value, 1);
95 if (systemModule == nullptr) {
96 TAG_LOGW(AAFwkTag::APPKIT, "null systemModule");
97 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
98 return CreateJsUndefined(env);
99 }
100 napi_value contextObj = systemModule->GetNapiValue();
101 if (!CheckTypeForNapiValue(env, contextObj, napi_object)) {
102 TAG_LOGE(AAFwkTag::APPKIT, "get object failed");
103 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
104 return CreateJsUndefined(env);
105 }
106 auto workContext = new (std::nothrow) std::weak_ptr<Context>(bundleContext);
107 napi_coerce_to_native_binding_object(env, contextObj, DetachCallbackFunc, AttachBaseContext, workContext, nullptr);
108 auto res = napi_wrap(env, contextObj, workContext,
109 [](napi_env, void *data, void *) {
110 TAG_LOGD(AAFwkTag::APPKIT, "Finalizer for weak_ptr bundle context is called");
111 delete static_cast<std::weak_ptr<Context> *>(data);
112 },
113 nullptr, nullptr);
114 if (res != napi_ok && workContext != nullptr) {
115 TAG_LOGE(AAFwkTag::APPKIT, "napi_wrap failed:%{public}d", res);
116 delete workContext;
117 return CreateJsUndefined(env);
118 }
119 return contextObj;
120 }
121
SwitchArea(napi_env env,napi_callback_info info)122 napi_value JsApplicationContextUtils::SwitchArea(napi_env env, napi_callback_info info)
123 {
124 TAG_LOGD(AAFwkTag::APPKIT, "called");
125 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnSwitchArea, APPLICATION_CONTEXT_NAME);
126 }
127
OnSwitchArea(napi_env env,NapiCallbackInfo & info)128 napi_value JsApplicationContextUtils::OnSwitchArea(napi_env env, NapiCallbackInfo& info)
129 {
130 if (info.argc == 0) {
131 TAG_LOGE(AAFwkTag::APPKIT, "Not enough params");
132 return CreateJsUndefined(env);
133 }
134
135 auto applicationContext = applicationContext_.lock();
136 if (!applicationContext) {
137 TAG_LOGW(AAFwkTag::APPKIT, "null applicationContext");
138 return CreateJsUndefined(env);
139 }
140
141 int mode = 0;
142 if (!ConvertFromJsValue(env, info.argv[0], mode)) {
143 TAG_LOGE(AAFwkTag::APPKIT, "Parse mode failed");
144 return CreateJsUndefined(env);
145 }
146
147 applicationContext->SwitchArea(mode);
148
149 napi_value object = info.thisVar;
150 if (!CheckTypeForNapiValue(env, object, napi_object)) {
151 TAG_LOGE(AAFwkTag::APPKIT, "Check type failed");
152 return CreateJsUndefined(env);
153 }
154 BindNativeProperty(env, object, "cacheDir", GetCacheDir);
155 BindNativeProperty(env, object, "tempDir", GetTempDir);
156 BindNativeProperty(env, object, "resourceDir", GetResourceDir);
157 BindNativeProperty(env, object, "filesDir", GetFilesDir);
158 BindNativeProperty(env, object, "distributedFilesDir", GetDistributedFilesDir);
159 BindNativeProperty(env, object, "databaseDir", GetDatabaseDir);
160 BindNativeProperty(env, object, "preferencesDir", GetPreferencesDir);
161 BindNativeProperty(env, object, "bundleCodeDir", GetBundleCodeDir);
162 BindNativeProperty(env, object, "cloudFileDir", GetCloudFileDir);
163 return CreateJsUndefined(env);
164 }
165
166
CreateModuleContext(napi_env env,napi_callback_info info)167 napi_value JsApplicationContextUtils::CreateModuleContext(napi_env env, napi_callback_info info)
168 {
169 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils,
170 OnCreateModuleContext, APPLICATION_CONTEXT_NAME);
171 }
172
OnCreateModuleContext(napi_env env,NapiCallbackInfo & info)173 napi_value JsApplicationContextUtils::OnCreateModuleContext(napi_env env, NapiCallbackInfo& info)
174 {
175 auto applicationContext = applicationContext_.lock();
176 if (!applicationContext) {
177 TAG_LOGW(AAFwkTag::APPKIT, "null applicationContext");
178 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
179 return CreateJsUndefined(env);
180 }
181
182 std::string moduleName;
183 std::shared_ptr<Context> moduleContext = nullptr;
184 if (!ConvertFromJsValue(env, info.argv[1], moduleName)) {
185 TAG_LOGD(AAFwkTag::APPKIT, "Parse inner module name.");
186 if (!ConvertFromJsValue(env, info.argv[0], moduleName)) {
187 TAG_LOGE(AAFwkTag::APPKIT, "Parse moduleName failed");
188 ThrowInvalidParamError(env, "Parse param moduleName failed, moduleName must be string.");
189 return CreateJsUndefined(env);
190 }
191 moduleContext = applicationContext->CreateModuleContext(moduleName);
192 } else {
193 std::string bundleName;
194 if (!ConvertFromJsValue(env, info.argv[0], bundleName)) {
195 TAG_LOGE(AAFwkTag::APPKIT, "Parse bundleName failed");
196 ThrowInvalidParamError(env, "Parse param bundleName failed, bundleName must be string.");
197 return CreateJsUndefined(env);
198 }
199 if (!CheckCallerIsSystemApp()) {
200 TAG_LOGE(AAFwkTag::APPKIT, "not system-app");
201 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_NOT_SYSTEM_APP);
202 return CreateJsUndefined(env);
203 }
204 TAG_LOGI(AAFwkTag::APPKIT, "parse outer module name");
205 moduleContext = applicationContext->CreateModuleContext(bundleName, moduleName);
206 }
207
208 if (!moduleContext) {
209 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
210 return CreateJsUndefined(env);
211 }
212 return CreateJsModuleContext(env, moduleContext);
213 }
214
CreateJsModuleContext(napi_env env,const std::shared_ptr<Context> & moduleContext)215 napi_value JsApplicationContextUtils::CreateJsModuleContext(napi_env env, const std::shared_ptr<Context>& moduleContext)
216 {
217 napi_value value = CreateJsBaseContext(env, moduleContext, true);
218 auto systemModule = JsRuntime::LoadSystemModuleByEngine(env, "application.Context", &value, 1);
219 if (systemModule == nullptr) {
220 TAG_LOGW(AAFwkTag::APPKIT, "null systemModule");
221 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
222 return CreateJsUndefined(env);
223 }
224 napi_value contextObj = systemModule->GetNapiValue();
225 if (!CheckTypeForNapiValue(env, contextObj, napi_object)) {
226 TAG_LOGE(AAFwkTag::APPKIT, "get object failed");
227 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
228 return CreateJsUndefined(env);
229 }
230 auto workContext = new (std::nothrow) std::weak_ptr<Context>(moduleContext);
231 napi_coerce_to_native_binding_object(env, contextObj, DetachCallbackFunc, AttachBaseContext, workContext, nullptr);
232 auto res = napi_wrap(env, contextObj, workContext,
233 [](napi_env, void *data, void *) {
234 TAG_LOGD(AAFwkTag::APPKIT, "Finalizer for weak_ptr module context is called");
235 delete static_cast<std::weak_ptr<Context> *>(data);
236 },
237 nullptr, nullptr);
238 if (res != napi_ok && workContext != nullptr) {
239 TAG_LOGE(AAFwkTag::APPKIT, "napi_wrap failed:%{public}d", res);
240 delete workContext;
241 return CreateJsUndefined(env);
242 }
243 return contextObj;
244 }
245
CreateSystemHspModuleResourceManager(napi_env env,napi_callback_info info)246 napi_value JsApplicationContextUtils::CreateSystemHspModuleResourceManager(napi_env env, napi_callback_info info)
247 {
248 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils,
249 OnCreateSystemHspModuleResourceManager, APPLICATION_CONTEXT_NAME);
250 }
251
OnCreateSystemHspModuleResourceManager(napi_env env,NapiCallbackInfo & info)252 napi_value JsApplicationContextUtils::OnCreateSystemHspModuleResourceManager(napi_env env, NapiCallbackInfo& info)
253 {
254 auto applicationContext = applicationContext_.lock();
255 if (!applicationContext) {
256 TAG_LOGW(AAFwkTag::APPKIT, "null applicationContext");
257 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
258 return CreateJsUndefined(env);
259 }
260
261 std::string bundleName = "";
262 if (!ConvertFromJsValue(env, info.argv[0], bundleName)) {
263 TAG_LOGE(AAFwkTag::APPKIT, "Parse bundleName failed");
264 ThrowInvalidParamError(env, "Parse param bundleName failed, bundleName must be string.");
265 return CreateJsUndefined(env);
266 }
267 std::string moduleName = "";
268 if (!ConvertFromJsValue(env, info.argv[1], moduleName)) {
269 TAG_LOGD(AAFwkTag::APPKIT, "Parse module name failed.");
270 ThrowInvalidParamError(env, "Parse param moduleName failed, moduleName must be string.");
271 return CreateJsUndefined(env);
272 }
273
274 std::shared_ptr<Global::Resource::ResourceManager> resourceManager = nullptr;
275 int32_t retCode = applicationContext->CreateSystemHspModuleResourceManager(bundleName, moduleName, resourceManager);
276 if (resourceManager == nullptr && retCode == ERR_ABILITY_RUNTIME_EXTERNAL_NOT_SYSTEM_HSP) {
277 TAG_LOGE(AAFwkTag::APPKIT, "null resourceManager");
278 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_NOT_SYSTEM_HSP);
279 return CreateJsUndefined(env);
280 }
281 if (resourceManager == nullptr) {
282 TAG_LOGE(AAFwkTag::APPKIT, "null resourceManager");
283 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
284 return CreateJsUndefined(env);
285 }
286 return CreateJsResourceManager(env, resourceManager, nullptr);
287 }
288
CreateModuleResourceManager(napi_env env,napi_callback_info info)289 napi_value JsApplicationContextUtils::CreateModuleResourceManager(napi_env env, napi_callback_info info)
290 {
291 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils,
292 OnCreateModuleResourceManager, APPLICATION_CONTEXT_NAME);
293 }
294
OnCreateModuleResourceManager(napi_env env,NapiCallbackInfo & info)295 napi_value JsApplicationContextUtils::OnCreateModuleResourceManager(napi_env env, NapiCallbackInfo& info)
296 {
297 auto applicationContext = applicationContext_.lock();
298 if (!applicationContext) {
299 TAG_LOGW(AAFwkTag::APPKIT, "null applicationContext");
300 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
301 return CreateJsUndefined(env);
302 }
303
304 std::string bundleName;
305 if (!ConvertFromJsValue(env, info.argv[0], bundleName)) {
306 TAG_LOGE(AAFwkTag::APPKIT, "Parse bundleName failed");
307 ThrowInvalidParamError(env, "Parse param bundleName failed, bundleName must be string.");
308 return CreateJsUndefined(env);
309 }
310 std::string moduleName;
311 if (!ConvertFromJsValue(env, info.argv[1], moduleName)) {
312 TAG_LOGE(AAFwkTag::APPKIT, "Parse moduleName failed");
313 ThrowInvalidParamError(env, "Parse param moduleName failed, moduleName must be string.");
314 return CreateJsUndefined(env);
315 }
316 if (!CheckCallerIsSystemApp()) {
317 TAG_LOGE(AAFwkTag::APPKIT, "not system-app");
318 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_NOT_SYSTEM_APP);
319 return CreateJsUndefined(env);
320 }
321 auto resourceManager = applicationContext->CreateModuleResourceManager(bundleName, moduleName);
322 if (resourceManager == nullptr) {
323 TAG_LOGE(AAFwkTag::APPKIT, "null resourceManager");
324 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
325 return CreateJsUndefined(env);
326 }
327 auto jsResourceManager = CreateJsResourceManager(env, resourceManager, nullptr);
328 return jsResourceManager;
329 }
330
GetArea(napi_env env,napi_callback_info info)331 napi_value JsApplicationContextUtils::GetArea(napi_env env, napi_callback_info info)
332 {
333 TAG_LOGD(AAFwkTag::APPKIT, "called");
334 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnGetArea, APPLICATION_CONTEXT_NAME);
335 }
336
OnGetArea(napi_env env,NapiCallbackInfo & info)337 napi_value JsApplicationContextUtils::OnGetArea(napi_env env, NapiCallbackInfo& info)
338 {
339 auto applicationContext = applicationContext_.lock();
340 if (!applicationContext) {
341 TAG_LOGW(AAFwkTag::APPKIT, "null applicationContext");
342 return CreateJsUndefined(env);
343 }
344 int area = applicationContext->GetArea();
345 return CreateJsValue(env, area);
346 }
347
GetCacheDir(napi_env env,napi_callback_info info)348 napi_value JsApplicationContextUtils::GetCacheDir(napi_env env, napi_callback_info info)
349 {
350 TAG_LOGD(AAFwkTag::APPKIT, "called");
351 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnGetCacheDir, APPLICATION_CONTEXT_NAME);
352 }
353
OnGetCacheDir(napi_env env,NapiCallbackInfo & info)354 napi_value JsApplicationContextUtils::OnGetCacheDir(napi_env env, NapiCallbackInfo& info)
355 {
356 auto applicationContext = applicationContext_.lock();
357 if (!applicationContext) {
358 TAG_LOGW(AAFwkTag::APPKIT, "null applicationContext");
359 return CreateJsUndefined(env);
360 }
361 std::string path = applicationContext->GetCacheDir();
362 return CreateJsValue(env, path);
363 }
364
GetTempDir(napi_env env,napi_callback_info info)365 napi_value JsApplicationContextUtils::GetTempDir(napi_env env, napi_callback_info info)
366 {
367 TAG_LOGD(AAFwkTag::APPKIT, "called");
368 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnGetTempDir, APPLICATION_CONTEXT_NAME);
369 }
370
OnGetTempDir(napi_env env,NapiCallbackInfo & info)371 napi_value JsApplicationContextUtils::OnGetTempDir(napi_env env, NapiCallbackInfo& info)
372 {
373 auto applicationContext = applicationContext_.lock();
374 if (!applicationContext) {
375 TAG_LOGW(AAFwkTag::APPKIT, "null applicationContext");
376 return CreateJsUndefined(env);
377 }
378 std::string path = applicationContext->GetTempDir();
379 return CreateJsValue(env, path);
380 }
381
GetResourceDir(napi_env env,napi_callback_info info)382 napi_value JsApplicationContextUtils::GetResourceDir(napi_env env, napi_callback_info info)
383 {
384 TAG_LOGD(AAFwkTag::APPKIT, "called");
385 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnGetResourceDir, APPLICATION_CONTEXT_NAME);
386 }
387
OnGetResourceDir(napi_env env,NapiCallbackInfo & info)388 napi_value JsApplicationContextUtils::OnGetResourceDir(napi_env env, NapiCallbackInfo& info)
389 {
390 auto applicationContext = applicationContext_.lock();
391 if (!applicationContext) {
392 TAG_LOGW(AAFwkTag::APPKIT, "null applicationContext");
393 return CreateJsUndefined(env);
394 }
395 std::string path = applicationContext->GetResourceDir();
396 return CreateJsValue(env, path);
397 }
398
GetFilesDir(napi_env env,napi_callback_info info)399 napi_value JsApplicationContextUtils::GetFilesDir(napi_env env, napi_callback_info info)
400 {
401 TAG_LOGD(AAFwkTag::APPKIT, "called");
402 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnGetFilesDir, APPLICATION_CONTEXT_NAME);
403 }
404
OnGetFilesDir(napi_env env,NapiCallbackInfo & info)405 napi_value JsApplicationContextUtils::OnGetFilesDir(napi_env env, NapiCallbackInfo& info)
406 {
407 auto applicationContext = applicationContext_.lock();
408 if (!applicationContext) {
409 TAG_LOGW(AAFwkTag::APPKIT, "null applicationContext");
410 return CreateJsUndefined(env);
411 }
412 std::string path = applicationContext->GetFilesDir();
413 return CreateJsValue(env, path);
414 }
415
GetDistributedFilesDir(napi_env env,napi_callback_info info)416 napi_value JsApplicationContextUtils::GetDistributedFilesDir(napi_env env, napi_callback_info info)
417 {
418 TAG_LOGD(AAFwkTag::APPKIT, "called");
419 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils,
420 OnGetDistributedFilesDir, APPLICATION_CONTEXT_NAME);
421 }
422
OnGetDistributedFilesDir(napi_env env,NapiCallbackInfo & info)423 napi_value JsApplicationContextUtils::OnGetDistributedFilesDir(napi_env env, NapiCallbackInfo& info)
424 {
425 auto applicationContext = applicationContext_.lock();
426 if (!applicationContext) {
427 TAG_LOGW(AAFwkTag::APPKIT, "null applicationContext");
428 return CreateJsUndefined(env);
429 }
430 std::string path = applicationContext->GetDistributedFilesDir();
431 return CreateJsValue(env, path);
432 }
433
GetCloudFileDir(napi_env env,napi_callback_info info)434 napi_value JsApplicationContextUtils::GetCloudFileDir(napi_env env, napi_callback_info info)
435 {
436 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils,
437 OnGetCloudFileDir, APPLICATION_CONTEXT_NAME);
438 }
439
OnGetCloudFileDir(napi_env env,NapiCallbackInfo & info)440 napi_value JsApplicationContextUtils::OnGetCloudFileDir(napi_env env, NapiCallbackInfo& info)
441 {
442 auto applicationContext = applicationContext_.lock();
443 if (!applicationContext) {
444 TAG_LOGW(AAFwkTag::APPKIT, "null applicationContext");
445 return CreateJsUndefined(env);
446 }
447 std::string path = applicationContext->GetCloudFileDir();
448 return CreateJsValue(env, path);
449 }
450
GetProcessName(napi_env env,napi_callback_info info)451 napi_value JsApplicationContextUtils::GetProcessName(napi_env env, napi_callback_info info)
452 {
453 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnGetProcessName, APPLICATION_CONTEXT_NAME);
454 }
455
OnGetProcessName(napi_env env,NapiCallbackInfo & info)456 napi_value JsApplicationContextUtils::OnGetProcessName(napi_env env, NapiCallbackInfo &info)
457 {
458 auto applicationContext = applicationContext_.lock();
459 if (applicationContext == nullptr) {
460 TAG_LOGE(AAFwkTag::APPKIT, "applicationContext is already released");
461 return CreateJsUndefined(env);
462 }
463 std::string name = applicationContext->GetProcessName();
464 return CreateJsValue(env, name);
465 }
466
GetDatabaseDir(napi_env env,napi_callback_info info)467 napi_value JsApplicationContextUtils::GetDatabaseDir(napi_env env, napi_callback_info info)
468 {
469 TAG_LOGD(AAFwkTag::APPKIT, "called");
470 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnGetDatabaseDir, APPLICATION_CONTEXT_NAME);
471 }
472
OnGetDatabaseDir(napi_env env,NapiCallbackInfo & info)473 napi_value JsApplicationContextUtils::OnGetDatabaseDir(napi_env env, NapiCallbackInfo& info)
474 {
475 auto applicationContext = applicationContext_.lock();
476 if (!applicationContext) {
477 TAG_LOGW(AAFwkTag::APPKIT, "null applicationContext");
478 return CreateJsUndefined(env);
479 }
480 std::string path = applicationContext->GetDatabaseDir();
481 return CreateJsValue(env, path);
482 }
483
GetPreferencesDir(napi_env env,napi_callback_info info)484 napi_value JsApplicationContextUtils::GetPreferencesDir(napi_env env, napi_callback_info info)
485 {
486 TAG_LOGD(AAFwkTag::APPKIT, "called");
487 GET_NAPI_INFO_WITH_NAME_AND_CALL(
488 env, info, JsApplicationContextUtils, OnGetPreferencesDir, APPLICATION_CONTEXT_NAME);
489 }
490
GetGroupDir(napi_env env,napi_callback_info info)491 napi_value JsApplicationContextUtils::GetGroupDir(napi_env env, napi_callback_info info)
492 {
493 TAG_LOGD(AAFwkTag::APPKIT, "called");
494 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnGetGroupDir, APPLICATION_CONTEXT_NAME);
495 }
496
OnGetPreferencesDir(napi_env env,NapiCallbackInfo & info)497 napi_value JsApplicationContextUtils::OnGetPreferencesDir(napi_env env, NapiCallbackInfo& info)
498 {
499 auto applicationContext = applicationContext_.lock();
500 if (!applicationContext) {
501 TAG_LOGW(AAFwkTag::APPKIT, "null applicationContext");
502 return CreateJsUndefined(env);
503 }
504 std::string path = applicationContext->GetPreferencesDir();
505 return CreateJsValue(env, path);
506 }
507
OnGetGroupDir(napi_env env,NapiCallbackInfo & info)508 napi_value JsApplicationContextUtils::OnGetGroupDir(napi_env env, NapiCallbackInfo& info)
509 {
510 if (info.argc != ARGC_ONE && info.argc != ARGC_TWO) {
511 TAG_LOGE(AAFwkTag::APPKIT, "Not enough params");
512 ThrowInvalidParamError(env, "Not enough params.");
513 return CreateJsUndefined(env);
514 }
515
516 std::string groupId;
517 if (!ConvertFromJsValue(env, info.argv[0], groupId)) {
518 TAG_LOGE(AAFwkTag::APPKIT, "Parse groupId failed");
519 ThrowInvalidParamError(env, "Parse param groupId failed, groupId must be string.");
520 return CreateJsUndefined(env);
521 }
522
523 TAG_LOGD(AAFwkTag::APPKIT, "Get Group Dir");
524 auto innerErrCode = std::make_shared<ErrCode>(ERR_OK);
525 auto path = std::make_shared<std::string>("");
526 NapiAsyncTask::ExecuteCallback execute =
527 [applicationContext = applicationContext_, groupId, innerErrCode, path]() {
528 auto context = applicationContext.lock();
529 if (!context) {
530 TAG_LOGE(AAFwkTag::APPKIT, "null Context");
531 *innerErrCode = ERR_ABILITY_RUNTIME_EXTERNAL_CONTEXT_NOT_EXIST;
532 return;
533 }
534 *path = context->GetGroupDir(groupId);
535 };
536 auto complete = [innerErrCode, path](napi_env env, NapiAsyncTask& task, int32_t status) {
537 if (*innerErrCode == ERR_OK) {
538 task.ResolveWithNoError(env, CreateJsValue(env, *path));
539 } else {
540 task.Reject(env, CreateJsError(env, *innerErrCode,
541 "applicationContext if already released"));
542 }
543 };
544 napi_value lastParam = (info.argc == ARGC_TWO) ? info.argv[INDEX_ONE] : nullptr;
545 napi_value result = nullptr;
546 NapiAsyncTask::ScheduleHighQos("JsApplicationContextUtils::OnGetGroupDir",
547 env, CreateAsyncTaskWithLastParam(env, lastParam, std::move(execute), std::move(complete), &result));
548 return result;
549 }
550
RestartApp(napi_env env,napi_callback_info info)551 napi_value JsApplicationContextUtils::RestartApp(napi_env env, napi_callback_info info)
552 {
553 TAG_LOGD(AAFwkTag::APPKIT, "called");
554 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnRestartApp, APPLICATION_CONTEXT_NAME);
555 }
556
OnRestartApp(napi_env env,NapiCallbackInfo & info)557 napi_value JsApplicationContextUtils::OnRestartApp(napi_env env, NapiCallbackInfo& info)
558 {
559 // only support one params
560 if (info.argc == ARGC_ZERO) {
561 TAG_LOGE(AAFwkTag::APPKIT, "Not enough params");
562 ThrowInvalidParamError(env, "Not enough params");
563 return CreateJsUndefined(env);
564 }
565 auto applicationContext = applicationContext_.lock();
566 if (!applicationContext) {
567 TAG_LOGW(AAFwkTag::APPKIT, "null applicationContext");
568 return CreateJsUndefined(env);
569 }
570 AAFwk::Want want;
571 if (!AppExecFwk::UnwrapWant(env, info.argv[INDEX_ZERO], want)) {
572 TAG_LOGE(AAFwkTag::APPKIT, "Parse want failed");
573 ThrowInvalidParamError(env, "Parse param want failed, want must be Want.");
574 return CreateJsUndefined(env);
575 }
576
577 auto errCode = applicationContext->RestartApp(want);
578 if (errCode == ERR_OK) {
579 return CreateJsUndefined(env);
580 }
581 if (errCode == ERR_INVALID_VALUE) {
582 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
583 } else if (errCode == AAFwk::ERR_RESTART_APP_INCORRECT_ABILITY) {
584 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_RESTART_APP_INCORRECT_ABILITY);
585 } else if (errCode == AAFwk::ERR_RESTART_APP_FREQUENT) {
586 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_RESTART_APP_FREQUENT);
587 } else if (errCode == AAFwk::NOT_TOP_ABILITY) {
588 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_NOT_TOP_ABILITY);
589 } else {
590 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INTERNAL_ERROR);
591 }
592 TAG_LOGE(AAFwkTag::APPKIT, "errCode:%{public}d.", errCode);
593 return CreateJsUndefined(env);
594 }
595
GetBundleCodeDir(napi_env env,napi_callback_info info)596 napi_value JsApplicationContextUtils::GetBundleCodeDir(napi_env env, napi_callback_info info)
597 {
598 TAG_LOGD(AAFwkTag::APPKIT, "called");
599 GET_NAPI_INFO_WITH_NAME_AND_CALL(
600 env, info, JsApplicationContextUtils, OnGetBundleCodeDir, APPLICATION_CONTEXT_NAME);
601 }
602
OnGetBundleCodeDir(napi_env env,NapiCallbackInfo & info)603 napi_value JsApplicationContextUtils::OnGetBundleCodeDir(napi_env env, NapiCallbackInfo& info)
604 {
605 auto applicationContext = applicationContext_.lock();
606 if (!applicationContext) {
607 TAG_LOGW(AAFwkTag::APPKIT, "null applicationContext");
608 return CreateJsUndefined(env);
609 }
610 std::string path = applicationContext->GetBundleCodeDir();
611 return CreateJsValue(env, path);
612 }
613
KillProcessBySelf(napi_env env,napi_callback_info info)614 napi_value JsApplicationContextUtils::KillProcessBySelf(napi_env env, napi_callback_info info)
615 {
616 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils,
617 OnKillProcessBySelf, APPLICATION_CONTEXT_NAME);
618 }
619
OnKillProcessBySelf(napi_env env,NapiCallbackInfo & info)620 napi_value JsApplicationContextUtils::OnKillProcessBySelf(napi_env env, NapiCallbackInfo& info)
621 {
622 // only support 0 or 1 or 2 params
623 if (info.argc != ARGC_ZERO && info.argc != ARGC_ONE && info.argc != ARGC_TWO) {
624 TAG_LOGE(AAFwkTag::APPKIT, "Not enough params");
625 ThrowInvalidParamError(env, "Not enough params.");
626 return CreateJsUndefined(env);
627 }
628
629 bool clearPageStack = true;
630 bool hasClearPageStack = false;
631 if (info.argc > ARGC_ZERO && ConvertFromJsValue(env, info.argv[0], clearPageStack)) {
632 hasClearPageStack = true;
633 }
634
635 TAG_LOGD(AAFwkTag::APPKIT, "kill self process");
636 auto innerErrCode = std::make_shared<ErrCode>(ERR_OK);
637 NapiAsyncTask::ExecuteCallback execute =
638 [applicationContext = applicationContext_, clearPageStack, innerErrCode]() {
639 auto context = applicationContext.lock();
640 if (!context) {
641 TAG_LOGE(AAFwkTag::APPKIT, "null context");
642 *innerErrCode = ERR_ABILITY_RUNTIME_EXTERNAL_CONTEXT_NOT_EXIST;
643 return;
644 }
645 context->KillProcessBySelf(clearPageStack);
646 };
647 NapiAsyncTask::CompleteCallback complete = [innerErrCode](napi_env env, NapiAsyncTask& task, int32_t status) {
648 if (*innerErrCode != ERR_OK) {
649 task.Reject(env, CreateJsError(env, *innerErrCode, "applicationContext is already released."));
650 return;
651 }
652 task.ResolveWithNoError(env, CreateJsUndefined(env));
653 };
654 napi_value lastParam = (info.argc == ARGC_ONE && !hasClearPageStack) ? info.argv[INDEX_ZERO] : nullptr;
655 napi_value result = nullptr;
656 NapiAsyncTask::ScheduleHighQos("JsApplicationContextUtils::OnkillProcessBySelf",
657 env, CreateAsyncTaskWithLastParam(env, lastParam, std::move(execute), std::move(complete), &result));
658 return result;
659 }
660
SetColorMode(napi_env env,napi_callback_info info)661 napi_value JsApplicationContextUtils::SetColorMode(napi_env env, napi_callback_info info)
662 {
663 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnSetColorMode, APPLICATION_CONTEXT_NAME);
664 }
665
OnSetColorMode(napi_env env,NapiCallbackInfo & info)666 napi_value JsApplicationContextUtils::OnSetColorMode(napi_env env, NapiCallbackInfo& info)
667 {
668 TAG_LOGD(AAFwkTag::APPKIT, "called");
669 // only support one params
670 if (info.argc == ARGC_ZERO) {
671 TAG_LOGE(AAFwkTag::APPKIT, "Not enough params");
672 ThrowInvalidParamError(env, "Not enough params.");
673 return CreateJsUndefined(env);
674 }
675 auto applicationContext = applicationContext_.lock();
676 if (applicationContext == nullptr) {
677 TAG_LOGW(AAFwkTag::APPKIT, "null applicationContext");
678 return CreateJsUndefined(env);
679 }
680
681 int32_t colorMode = 0;
682 if (!ConvertFromJsValue(env, info.argv[INDEX_ZERO], colorMode)) {
683 ThrowInvalidParamError(env, "Parse param colorMode failed, colorMode must be number.");
684 TAG_LOGE(AAFwkTag::APPKIT, "Parse colorMode failed");
685 return CreateJsUndefined(env);
686 }
687 applicationContext->SetColorMode(colorMode);
688 return CreateJsUndefined(env);
689 }
690
SetLanguage(napi_env env,napi_callback_info info)691 napi_value JsApplicationContextUtils::SetLanguage(napi_env env, napi_callback_info info)
692 {
693 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnSetLanguage, APPLICATION_CONTEXT_NAME);
694 }
695
OnSetLanguage(napi_env env,NapiCallbackInfo & info)696 napi_value JsApplicationContextUtils::OnSetLanguage(napi_env env, NapiCallbackInfo& info)
697 {
698 // only support one params
699 if (info.argc == ARGC_ZERO) {
700 TAG_LOGE(AAFwkTag::APPKIT, "Not enough params");
701 ThrowInvalidParamError(env, "Not enough params.");
702 return CreateJsUndefined(env);
703 }
704 auto applicationContext = applicationContext_.lock();
705 if (!applicationContext) {
706 TAG_LOGW(AAFwkTag::APPKIT, "null applicationContext");
707 return CreateJsUndefined(env);
708 }
709 std::string language;
710 if (!ConvertFromJsValue(env, info.argv[INDEX_ZERO], language)) {
711 TAG_LOGE(AAFwkTag::APPKIT, "Parse language failed");
712 ThrowInvalidParamError(env, "Parse param language failed, language must be string.");
713 return CreateJsUndefined(env);
714 }
715 applicationContext->SetLanguage(language);
716 return CreateJsUndefined(env);
717 }
718
SetFontSizeScale(napi_env env,napi_callback_info info)719 napi_value JsApplicationContextUtils::SetFontSizeScale(napi_env env, napi_callback_info info)
720 {
721 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils,
722 OnSetFontSizeScale, APPLICATION_CONTEXT_NAME);
723 }
724
OnSetFontSizeScale(napi_env env,NapiCallbackInfo & info)725 napi_value JsApplicationContextUtils::OnSetFontSizeScale(napi_env env, NapiCallbackInfo& info)
726 {
727 if (info.argc == ARGC_ZERO) {
728 TAG_LOGE(AAFwkTag::APPKIT, "Not enough params");
729 ThrowInvalidParamError(env, "Not enough params.");
730 return CreateJsUndefined(env);
731 }
732
733 auto applicationContext = applicationContext_.lock();
734 if (applicationContext == nullptr) {
735 TAG_LOGE(AAFwkTag::APPKIT, "null applicationContext");
736 ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT);
737 return CreateJsUndefined(env);
738 }
739
740 double fontSizeScale = 1;
741 if (!ConvertFromJsNumber(env, info.argv[INDEX_ZERO], fontSizeScale)) {
742 TAG_LOGE(AAFwkTag::APPKIT, "Parse fontSizeScale failed");
743 ThrowInvalidParamError(env, "Parse fontSizeScale failed, fontSizeScale must be number.");
744 return CreateJsUndefined(env);
745 }
746 TAG_LOGD(AAFwkTag::APPKIT, "fontSizeScale: %{public}f", fontSizeScale);
747 if (fontSizeScale < FOUNT_SIZE) {
748 TAG_LOGE(AAFwkTag::APPKIT, "invalid size");
749 ThrowInvalidParamError(env, "Invalid font size.");
750 return CreateJsUndefined(env);
751 }
752
753 applicationContext->SetFontSizeScale(fontSizeScale);
754 return CreateJsUndefined(env);
755 }
756
SetFont(napi_env env,napi_callback_info info)757 napi_value JsApplicationContextUtils::SetFont(napi_env env, napi_callback_info info)
758 {
759 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnSetFont, APPLICATION_CONTEXT_NAME);
760 }
761
OnSetFont(napi_env env,NapiCallbackInfo & info)762 napi_value JsApplicationContextUtils::OnSetFont(napi_env env, NapiCallbackInfo& info)
763 {
764 // only support one params
765 if (info.argc == ARGC_ZERO) {
766 TAG_LOGE(AAFwkTag::APPKIT, "Not enough params");
767 ThrowInvalidParamError(env, "Not enough params.");
768 return CreateJsUndefined(env);
769 }
770 auto applicationContext = applicationContext_.lock();
771 if (!applicationContext) {
772 TAG_LOGW(AAFwkTag::APPKIT, "null applicationContext");
773 return CreateJsUndefined(env);
774 }
775 std::string font;
776 if (!ConvertFromJsValue(env, info.argv[INDEX_ZERO], font)) {
777 TAG_LOGE(AAFwkTag::APPKIT, "Parse font failed");
778 ThrowInvalidParamError(env, "Parse param font failed, font must be string.");
779 return CreateJsUndefined(env);
780 }
781 applicationContext->SetFont(font);
782 return CreateJsUndefined(env);
783 }
784
PreloadUIExtensionAbility(napi_env env,napi_callback_info info)785 napi_value JsApplicationContextUtils::PreloadUIExtensionAbility(napi_env env, napi_callback_info info)
786 {
787 GET_NAPI_INFO_WITH_NAME_AND_CALL(
788 env, info, JsApplicationContextUtils, OnPreloadUIExtensionAbility, APPLICATION_CONTEXT_NAME);
789 }
790
OnPreloadUIExtensionAbility(napi_env env,NapiCallbackInfo & info)791 napi_value JsApplicationContextUtils::OnPreloadUIExtensionAbility(napi_env env, NapiCallbackInfo& info)
792 {
793 TAG_LOGD(AAFwkTag::APPKIT, "called");
794 if (info.argc < ARGC_ONE) {
795 TAG_LOGW(AAFwkTag::APPKIT, "params error");
796 ThrowTooFewParametersError(env);
797 return CreateJsUndefined(env);
798 }
799
800 AAFwk::Want want;
801 if (!AppExecFwk::UnwrapWant(env, info.argv[INDEX_ZERO], want)) {
802 TAG_LOGW(AAFwkTag::APPKIT, "Parse want failed");
803 ThrowInvalidParamError(env,
804 "Parse param want failed, want must be Want.");
805 return CreateJsUndefined(env);
806 }
807
808 auto innerErrCode = std::make_shared<ErrCode>(ERR_OK);
809 NapiAsyncTask::ExecuteCallback execute = [applicationContext = applicationContext_, want, innerErrCode]() {
810 auto context = applicationContext.lock();
811 if (!context) {
812 TAG_LOGE(AAFwkTag::APPKIT, "null context");
813 *innerErrCode = static_cast<int>(AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT);
814 return;
815 }
816 auto hostBundleName = context->GetBundleName();
817 TAG_LOGD(AAFwkTag::APPKIT, "HostBundleName is %{public}s", hostBundleName.c_str());
818 *innerErrCode = AAFwk::AbilityManagerClient::GetInstance()->PreloadUIExtensionAbility(want, hostBundleName);
819 };
820 NapiAsyncTask::CompleteCallback complete = [innerErrCode](napi_env env, NapiAsyncTask& task, int32_t status) {
821 if (*innerErrCode == ERR_OK) {
822 task.Resolve(env, CreateJsUndefined(env));
823 } else {
824 TAG_LOGE(AAFwkTag::APPKIT, "OnPreloadUIExtensionAbility failed %{public}d", *innerErrCode);
825 task.Reject(env, CreateJsErrorByNativeErr(env, *innerErrCode));
826 }
827 };
828 napi_value result = nullptr;
829 NapiAsyncTask::ScheduleHighQos("JsApplicationContextUtils::OnPreloadUIExtensionAbility",
830 env, CreateAsyncTaskWithLastParam(env, nullptr, std::move(execute), std::move(complete), &result));
831 return result;
832 }
833
ClearUpApplicationData(napi_env env,napi_callback_info info)834 napi_value JsApplicationContextUtils::ClearUpApplicationData(napi_env env, napi_callback_info info)
835 {
836 GET_NAPI_INFO_WITH_NAME_AND_CALL(
837 env, info, JsApplicationContextUtils, OnClearUpApplicationData, APPLICATION_CONTEXT_NAME);
838 }
839
OnClearUpApplicationData(napi_env env,NapiCallbackInfo & info)840 napi_value JsApplicationContextUtils::OnClearUpApplicationData(napi_env env, NapiCallbackInfo &info)
841 {
842 // only support 0 or 1 params
843 if (info.argc != ARGC_ZERO && info.argc != ARGC_ONE) {
844 TAG_LOGE(AAFwkTag::APPKIT, "Not enough params");
845 ThrowInvalidParamError(env, "Not enough params.");
846 return CreateJsUndefined(env);
847 }
848 auto innerErrCode = std::make_shared<ErrCode>(ERR_OK);
849 NapiAsyncTask::ExecuteCallback execute = [applicationContext = applicationContext_, innerErrCode]() {
850 auto context = applicationContext.lock();
851 if (!context) {
852 TAG_LOGE(AAFwkTag::APPKIT, "null context");
853 *innerErrCode = ERR_ABILITY_RUNTIME_EXTERNAL_CONTEXT_NOT_EXIST;
854 return;
855 }
856 context->ClearUpApplicationData();
857 };
858 NapiAsyncTask::CompleteCallback complete =
859 [applicationContext = applicationContext_, innerErrCode](napi_env env, NapiAsyncTask& task, int32_t status) {
860 if (*innerErrCode == ERR_OK) {
861 task.ResolveWithNoError(env, CreateJsUndefined(env));
862 } else {
863 task.Reject(env, CreateJsError(env, *innerErrCode, "applicationContext if already released."));
864 }
865 };
866 napi_value lastParam = (info.argc == ARGC_ONE) ? info.argv[INDEX_ZERO] : nullptr;
867 napi_value result = nullptr;
868 NapiAsyncTask::ScheduleHighQos("JsApplicationContextUtils::OnClearUpApplicationData",
869 env, CreateAsyncTaskWithLastParam(env, lastParam, std::move(execute), std::move(complete), &result));
870 return result;
871 }
872
GetRunningProcessInformation(napi_env env,napi_callback_info info)873 napi_value JsApplicationContextUtils::GetRunningProcessInformation(napi_env env, napi_callback_info info)
874 {
875 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils,
876 OnGetRunningProcessInformation, APPLICATION_CONTEXT_NAME);
877 }
878
OnGetRunningProcessInformation(napi_env env,NapiCallbackInfo & info)879 napi_value JsApplicationContextUtils::OnGetRunningProcessInformation(napi_env env, NapiCallbackInfo& info)
880 {
881 // only support 0 or 1 params
882 if (info.argc != ARGC_ZERO && info.argc != ARGC_ONE) {
883 TAG_LOGE(AAFwkTag::APPKIT, "Not enough params");
884 ThrowInvalidParamError(env, "Not enough params.");
885 return CreateJsUndefined(env);
886 }
887 TAG_LOGD(AAFwkTag::APPKIT, "Get Process Info");
888 auto innerErrCode = std::make_shared<ErrCode>(ERR_OK);
889 auto processInfo = std::make_shared<AppExecFwk::RunningProcessInfo>();
890 NapiAsyncTask::ExecuteCallback execute = [applicationContext = applicationContext_, innerErrCode, processInfo]() {
891 auto context = applicationContext.lock();
892 if (!context) {
893 TAG_LOGE(AAFwkTag::APPKIT, "null context");
894 *innerErrCode = ERR_ABILITY_RUNTIME_EXTERNAL_CONTEXT_NOT_EXIST;
895 return;
896 }
897 *innerErrCode = context->GetProcessRunningInformation(*processInfo);
898 };
899 auto complete = [innerErrCode, processInfo](napi_env env, NapiAsyncTask& task, int32_t status) {
900 if (*innerErrCode == ERR_ABILITY_RUNTIME_EXTERNAL_CONTEXT_NOT_EXIST) {
901 task.Reject(env, CreateJsError(env, *innerErrCode,
902 "applicationContext if already released."));
903 return;
904 }
905 if (*innerErrCode == ERR_OK) {
906 napi_value object = nullptr;
907 napi_create_object(env, &object);
908 napi_set_named_property(env, object, "processName", CreateJsValue(env, processInfo->processName_));
909 napi_set_named_property(env, object, "pid", CreateJsValue(env, processInfo->pid_));
910 napi_set_named_property(env, object, "uid", CreateJsValue(env, processInfo->uid_));
911 napi_set_named_property(env, object, "bundleNames", CreateNativeArray(env, processInfo->bundleNames));
912 napi_set_named_property(env, object,
913 "state", CreateJsValue(env, ConvertToJsAppProcessState(processInfo->state_, processInfo->isFocused)));
914 if (processInfo->appCloneIndex != -1) {
915 napi_set_named_property(env, object, "appCloneIndex", CreateJsValue(env, processInfo->appCloneIndex));
916 }
917 napi_value array = nullptr;
918 napi_create_array_with_length(env, 1, &array);
919 if (array == nullptr) {
920 TAG_LOGE(AAFwkTag::APPKIT, "null array");
921 task.Reject(env, CreateJsError(env, ERR_ABILITY_RUNTIME_EXTERNAL_INTERNAL_ERROR,
922 "Initiate array failed."));
923 } else {
924 napi_set_element(env, array, 0, object);
925 task.ResolveWithNoError(env, array);
926 }
927 } else {
928 task.Reject(env, CreateJsError(env, ERR_ABILITY_RUNTIME_EXTERNAL_INTERNAL_ERROR,
929 "Get process infos failed."));
930 }
931 };
932 napi_value lastParam = (info.argc == ARGC_ONE) ? info.argv[INDEX_ZERO] : nullptr;
933 napi_value result = nullptr;
934 NapiAsyncTask::Schedule("JsApplicationContextUtils::OnGetRunningProcessInformation",
935 env, CreateAsyncTaskWithLastParam(env, lastParam, std::move(execute), std::move(complete), &result));
936 return result;
937 }
938
GetCurrentAppCloneIndex(napi_env env,napi_callback_info info)939 napi_value JsApplicationContextUtils::GetCurrentAppCloneIndex(napi_env env, napi_callback_info info)
940 {
941 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils,
942 OnGetCurrentAppCloneIndex, APPLICATION_CONTEXT_NAME);
943 }
944
OnGetCurrentAppCloneIndex(napi_env env,NapiCallbackInfo & info)945 napi_value JsApplicationContextUtils::OnGetCurrentAppCloneIndex(napi_env env, NapiCallbackInfo& info)
946 {
947 TAG_LOGD(AAFwkTag::APPKIT, "Get App Index");
948 auto context = applicationContext_.lock();
949 if (context == nullptr) {
950 TAG_LOGE(AAFwkTag::APPKIT, "null context");
951 ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT);
952 return CreateJsUndefined(env);
953 }
954 if (context->GetCurrentAppMode() != static_cast<int32_t>(AppExecFwk::MultiAppModeType::APP_CLONE)) {
955 ThrowError(env, AbilityErrorCode::ERROR_NOT_APP_CLONE);
956 return CreateJsUndefined(env);
957 }
958 int32_t appIndex = context->GetCurrentAppCloneIndex();
959 return CreateJsValue(env, appIndex);
960 }
961
GetCurrentInstanceKey(napi_env env,napi_callback_info info)962 napi_value JsApplicationContextUtils::GetCurrentInstanceKey(napi_env env, napi_callback_info info)
963 {
964 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils,
965 OnGetCurrentInstanceKey, APPLICATION_CONTEXT_NAME);
966 }
967
OnGetCurrentInstanceKey(napi_env env,NapiCallbackInfo & info)968 napi_value JsApplicationContextUtils::OnGetCurrentInstanceKey(napi_env env, NapiCallbackInfo& info)
969 {
970 TAG_LOGD(AAFwkTag::APPKIT, "Get current instance key");
971 auto context = applicationContext_.lock();
972 if (context == nullptr) {
973 TAG_LOGE(AAFwkTag::APPKIT, "null context");
974 ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT);
975 return CreateJsUndefined(env);
976 }
977 if (context->GetCurrentAppMode() != static_cast<int32_t>(AppExecFwk::MultiAppModeType::MULTI_INSTANCE)) {
978 ThrowError(env, AbilityErrorCode::ERROR_MULTI_INSTANCE_NOT_SUPPORTED);
979 return CreateJsUndefined(env);
980 }
981 std::string instanceKey = context->GetCurrentInstanceKey();
982 return CreateJsValue(env, instanceKey);
983 }
984
GetAllRunningInstanceKeys(napi_env env,napi_callback_info info)985 napi_value JsApplicationContextUtils::GetAllRunningInstanceKeys(napi_env env, napi_callback_info info)
986 {
987 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils,
988 OnGetAllRunningInstanceKeys, APPLICATION_CONTEXT_NAME);
989 }
990
OnGetAllRunningInstanceKeys(napi_env env,NapiCallbackInfo & info)991 napi_value JsApplicationContextUtils::OnGetAllRunningInstanceKeys(napi_env env, NapiCallbackInfo& info)
992 {
993 TAG_LOGD(AAFwkTag::APPKIT, "Get all running instance keys");
994 auto innerErrCode = std::make_shared<ErrCode>(ERR_OK);
995 std::shared_ptr<std::vector<std::string>> instanceKeys = std::make_shared<std::vector<std::string>>();
996 NapiAsyncTask::ExecuteCallback execute =
997 [applicationContext = applicationContext_, innerErrCode, instanceKeys]() {
998 auto context = applicationContext.lock();
999 if (!context) {
1000 TAG_LOGE(AAFwkTag::APPKIT, "null context");
1001 *innerErrCode = ERR_ABILITY_RUNTIME_EXTERNAL_CONTEXT_NOT_EXIST;
1002 return;
1003 }
1004 if (context->GetCurrentAppMode() != static_cast<int32_t>(AppExecFwk::MultiAppModeType::MULTI_INSTANCE)) {
1005 TAG_LOGE(AAFwkTag::APPKIT, "not supported");
1006 *innerErrCode = static_cast<int>(AbilityErrorCode::ERROR_MULTI_INSTANCE_NOT_SUPPORTED);
1007 return;
1008 }
1009 *innerErrCode = context->GetAllRunningInstanceKeys(*instanceKeys);
1010 };
1011 auto complete = [applicationContext = applicationContext_, innerErrCode, instanceKeys](
1012 napi_env env, NapiAsyncTask& task, int32_t status) {
1013 if (*innerErrCode != ERR_OK) {
1014 TAG_LOGE(AAFwkTag::APPKIT, "innerErrCode=%{public}d", *innerErrCode);
1015 task.Reject(env, CreateJsErrorByNativeErr(env, *innerErrCode));
1016 return;
1017 }
1018 task.ResolveWithNoError(env, CreateNativeArray(env, *instanceKeys));
1019 };
1020
1021 napi_value result = nullptr;
1022 NapiAsyncTask::Schedule("JsApplicationContextUtils::OnGetAllRunningInstanceKeys",
1023 env, CreateAsyncTaskWithLastParam(env, nullptr, std::move(execute), std::move(complete), &result));
1024 return result;
1025 }
1026
CreateAreaModeContext(napi_env env,napi_callback_info info)1027 napi_value JsApplicationContextUtils::CreateAreaModeContext(napi_env env, napi_callback_info info)
1028 {
1029 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils,
1030 OnCreateAreaModeContext, APPLICATION_CONTEXT_NAME);
1031 }
1032
OnCreateAreaModeContext(napi_env env,NapiCallbackInfo & info)1033 napi_value JsApplicationContextUtils::OnCreateAreaModeContext(napi_env env, NapiCallbackInfo &info)
1034 {
1035 if (info.argc == ARGC_ZERO) {
1036 TAG_LOGE(AAFwkTag::APPKIT, "not enough params");
1037 ThrowTooFewParametersError(env);
1038 return CreateJsUndefined(env);
1039 }
1040
1041 auto applicationContext = applicationContext_.lock();
1042 if (applicationContext == nullptr) {
1043 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1044 TAG_LOGE(AAFwkTag::APPKIT, "applicationContext is already released");
1045 return CreateJsUndefined(env);
1046 }
1047
1048 int areaMode = 0;
1049 if (!ConvertFromJsValue(env, info.argv[0], areaMode)) {
1050 TAG_LOGE(AAFwkTag::APPKIT, "parse areaMode failed");
1051 ThrowInvalidParamError(env, "parse param areaMode failed, areaMode must be number.");
1052 return CreateJsUndefined(env);
1053 }
1054
1055 auto areaContext = applicationContext->CreateAreaModeContext(areaMode);
1056 if (areaContext == nullptr) {
1057 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1058 TAG_LOGE(AAFwkTag::APPKIT, "failed to create areaContext");
1059 return CreateJsUndefined(env);
1060 }
1061
1062 return CreateJsContext(env, areaContext);
1063 }
1064
CreateDisplayContext(napi_env env,napi_callback_info info)1065 napi_value JsApplicationContextUtils::CreateDisplayContext(napi_env env, napi_callback_info info)
1066 {
1067 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils,
1068 OnCreateDisplayContext, APPLICATION_CONTEXT_NAME);
1069 }
1070
OnCreateDisplayContext(napi_env env,NapiCallbackInfo & info)1071 napi_value JsApplicationContextUtils::OnCreateDisplayContext(napi_env env, NapiCallbackInfo &info)
1072 {
1073 #ifdef SUPPORT_GRAPHICS
1074 if (info.argc == ARGC_ZERO) {
1075 TAG_LOGE(AAFwkTag::APPKIT, "not enough params");
1076 ThrowTooFewParametersError(env);
1077 return CreateJsUndefined(env);
1078 }
1079
1080 auto applicationContext = applicationContext_.lock();
1081 if (applicationContext == nullptr) {
1082 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1083 TAG_LOGE(AAFwkTag::APPKIT, "applicationContext is already released");
1084 return CreateJsUndefined(env);
1085 }
1086
1087 int64_t displayId = -1;
1088 if (!ConvertFromJsValue(env, info.argv[0], displayId)) {
1089 TAG_LOGE(AAFwkTag::APPKIT, "parse displayId failed");
1090 ThrowInvalidParamError(env, "parse param displayId failed, displayId must be number.");
1091 return CreateJsUndefined(env);
1092 }
1093 if (displayId < 0) {
1094 TAG_LOGE(AAFwkTag::APPKIT, "displayId is invalid, less than 0");
1095 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1096 return CreateJsUndefined(env);
1097 }
1098 uint64_t validDisplayId = static_cast<uint64_t>(displayId);
1099
1100 auto context = applicationContext->CreateDisplayContext(validDisplayId);
1101 if (context == nullptr) {
1102 TAG_LOGE(AAFwkTag::APPKIT, "failed to create context");
1103 return CreateJsUndefined(env);
1104 }
1105 return CreateJsContext(env, context);
1106 #else
1107 return CreateJsUndefined(env);
1108 #endif
1109 }
1110
CreateJsContext(napi_env env,const std::shared_ptr<Context> & context)1111 napi_value JsApplicationContextUtils::CreateJsContext(napi_env env, const std::shared_ptr<Context> &context)
1112 {
1113 napi_value value = CreateJsBaseContext(env, context, true);
1114 auto systemModule = JsRuntime::LoadSystemModuleByEngine(env, "application.Context", &value, 1);
1115 if (systemModule == nullptr) {
1116 TAG_LOGE(AAFwkTag::APPKIT, "invalid systemModule");
1117 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1118 return CreateJsUndefined(env);
1119 }
1120 napi_value contextObj = systemModule->GetNapiValue();
1121 if (!CheckTypeForNapiValue(env, contextObj, napi_object)) {
1122 TAG_LOGE(AAFwkTag::APPKIT, "failed to get context native object");
1123 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1124 return CreateJsUndefined(env);
1125 }
1126 auto workContext = new (std::nothrow) std::weak_ptr<Context>(context);
1127 auto status = napi_coerce_to_native_binding_object(env, contextObj, DetachCallbackFunc, AttachBaseContext,
1128 workContext, nullptr);
1129 if (status != napi_ok) {
1130 TAG_LOGE(AAFwkTag::APPKIT, "coerce context failed: %{public}d", status);
1131 delete workContext;
1132 return CreateJsUndefined(env);
1133 }
1134 auto res = napi_wrap(env, contextObj, workContext,
1135 [](napi_env, void *data, void *) {
1136 TAG_LOGD(AAFwkTag::APPKIT, "Finalizer for weak_ptr module context is called");
1137 delete static_cast<std::weak_ptr<Context> *>(data);
1138 },
1139 nullptr, nullptr);
1140 if (res != napi_ok && workContext != nullptr) {
1141 TAG_LOGE(AAFwkTag::APPKIT, "napi_wrap failed:%{public}d", res);
1142 delete workContext;
1143 return CreateJsUndefined(env);
1144 }
1145 return contextObj;
1146 }
1147
Finalizer(napi_env env,void * data,void * hint)1148 void JsApplicationContextUtils::Finalizer(napi_env env, void *data, void *hint)
1149 {
1150 TAG_LOGD(AAFwkTag::APPKIT, "called");
1151 std::unique_ptr<JsApplicationContextUtils>(static_cast<JsApplicationContextUtils *>(data));
1152 }
1153
RegisterAbilityLifecycleCallback(napi_env env,napi_callback_info info)1154 napi_value JsApplicationContextUtils::RegisterAbilityLifecycleCallback(napi_env env, napi_callback_info info)
1155 {
1156 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils,
1157 OnRegisterAbilityLifecycleCallback, APPLICATION_CONTEXT_NAME);
1158 }
1159
UnregisterAbilityLifecycleCallback(napi_env env,napi_callback_info info)1160 napi_value JsApplicationContextUtils::UnregisterAbilityLifecycleCallback(
1161 napi_env env, napi_callback_info info)
1162 {
1163 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils,
1164 OnUnregisterAbilityLifecycleCallback, APPLICATION_CONTEXT_NAME);
1165 }
1166
OnRegisterAbilityLifecycleCallback(napi_env env,NapiCallbackInfo & info)1167 napi_value JsApplicationContextUtils::OnRegisterAbilityLifecycleCallback(
1168 napi_env env, NapiCallbackInfo& info)
1169 {
1170 TAG_LOGD(AAFwkTag::APPKIT, "called");
1171 // only support one params
1172 if (info.argc != ARGC_ONE) {
1173 TAG_LOGE(AAFwkTag::APPKIT, "Not enough params");
1174 return CreateJsUndefined(env);
1175 }
1176
1177 auto applicationContext = applicationContext_.lock();
1178 if (applicationContext == nullptr) {
1179 TAG_LOGE(AAFwkTag::APPKIT, "null applicationContext");
1180 return CreateJsUndefined(env);
1181 }
1182 if (callback_ != nullptr) {
1183 TAG_LOGD(AAFwkTag::APPKIT, "callback_ is not nullptr");
1184 return CreateJsValue(env, callback_->Register(info.argv[0]));
1185 }
1186 callback_ = std::make_shared<JsAbilityLifecycleCallback>(env);
1187 int32_t callbackId = callback_->Register(info.argv[INDEX_ZERO]);
1188 applicationContext->RegisterAbilityLifecycleCallback(callback_);
1189 return CreateJsValue(env, callbackId);
1190 }
1191
OnUnregisterAbilityLifecycleCallback(napi_env env,NapiCallbackInfo & info)1192 napi_value JsApplicationContextUtils::OnUnregisterAbilityLifecycleCallback(
1193 napi_env env, NapiCallbackInfo& info)
1194 {
1195 TAG_LOGD(AAFwkTag::APPKIT, "called");
1196 int32_t errCode = 0;
1197 auto applicationContext = applicationContext_.lock();
1198 if (applicationContext == nullptr) {
1199 TAG_LOGE(AAFwkTag::APPKIT, "null ApplicationContext");
1200 errCode = ERROR_CODE_ONE;
1201 }
1202 int32_t callbackId = -1;
1203 if (info.argc != ARGC_ONE && info.argc != ARGC_TWO) {
1204 TAG_LOGE(AAFwkTag::APPKIT, "not enough params");
1205 errCode = ERROR_CODE_ONE;
1206 } else {
1207 napi_get_value_int32(env, info.argv[INDEX_ZERO], &callbackId);
1208 TAG_LOGD(AAFwkTag::APPKIT, "callbackId is %{public}d.", callbackId);
1209 }
1210 std::weak_ptr<JsAbilityLifecycleCallback> callbackWeak(callback_);
1211
1212 NapiAsyncTask::CompleteCallback complete = [callbackWeak, callbackId, errCode](
1213 napi_env env, NapiAsyncTask &task, int32_t status) {
1214 if (errCode != 0) {
1215 task.Reject(env, CreateJsError(env, errCode, "Invalidate params."));
1216 return;
1217 }
1218 auto callback = callbackWeak.lock();
1219 if (callback == nullptr) {
1220 TAG_LOGE(AAFwkTag::APPKIT, "null callback");
1221 task.Reject(env, CreateJsError(env, ERROR_CODE_ONE, "callback is nullptr"));
1222 return;
1223 }
1224
1225 TAG_LOGD(AAFwkTag::APPKIT, "OnUnregisterAbilityLifecycleCallback begin");
1226 if (!callback->UnRegister(callbackId)) {
1227 TAG_LOGE(AAFwkTag::APPKIT, "call UnRegister failed");
1228 task.Reject(env, CreateJsError(env, ERROR_CODE_ONE, "call UnRegister failed!"));
1229 return;
1230 }
1231
1232 task.Resolve(env, CreateJsUndefined(env));
1233 };
1234 napi_value lastParam = (info.argc <= ARGC_ONE) ? nullptr : info.argv[INDEX_ONE];
1235 napi_value result = nullptr;
1236 NapiAsyncTask::Schedule("JsApplicationContextUtils::OnUnregisterAbilityLifecycleCallback", env,
1237 CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result));
1238 return result;
1239 }
1240
RegisterEnvironmentCallback(napi_env env,napi_callback_info info)1241 napi_value JsApplicationContextUtils::RegisterEnvironmentCallback(napi_env env, napi_callback_info info)
1242 {
1243 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils,
1244 OnRegisterEnvironmentCallback, APPLICATION_CONTEXT_NAME);
1245 }
1246
UnregisterEnvironmentCallback(napi_env env,napi_callback_info info)1247 napi_value JsApplicationContextUtils::UnregisterEnvironmentCallback(
1248 napi_env env, napi_callback_info info)
1249 {
1250 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils,
1251 OnUnregisterEnvironmentCallback, APPLICATION_CONTEXT_NAME);
1252 }
1253
OnRegisterEnvironmentCallback(napi_env env,NapiCallbackInfo & info)1254 napi_value JsApplicationContextUtils::OnRegisterEnvironmentCallback(
1255 napi_env env, NapiCallbackInfo& info)
1256 {
1257 TAG_LOGD(AAFwkTag::APPKIT, "called");
1258 // only support one params
1259 if (info.argc != ARGC_ONE) {
1260 TAG_LOGE(AAFwkTag::APPKIT, "Not enough params");
1261 return CreateJsUndefined(env);
1262 }
1263
1264 auto applicationContext = applicationContext_.lock();
1265 if (applicationContext == nullptr) {
1266 TAG_LOGE(AAFwkTag::APPKIT, "null applicationContext");
1267 return CreateJsUndefined(env);
1268 }
1269 if (envCallback_ != nullptr) {
1270 TAG_LOGD(AAFwkTag::APPKIT, "envCallback_ is not nullptr");
1271 return CreateJsValue(env, envCallback_->Register(info.argv[0]));
1272 }
1273 envCallback_ = std::make_shared<JsEnvironmentCallback>(env);
1274 int32_t callbackId = envCallback_->Register(info.argv[INDEX_ZERO]);
1275 applicationContext->RegisterEnvironmentCallback(envCallback_);
1276 return CreateJsValue(env, callbackId);
1277 }
1278
OnUnregisterEnvironmentCallback(napi_env env,NapiCallbackInfo & info)1279 napi_value JsApplicationContextUtils::OnUnregisterEnvironmentCallback(
1280 napi_env env, NapiCallbackInfo& info)
1281 {
1282 int32_t errCode = 0;
1283 auto applicationContext = applicationContext_.lock();
1284 if (applicationContext == nullptr) {
1285 TAG_LOGE(AAFwkTag::APPKIT, "null applicationContext");
1286 errCode = ERROR_CODE_ONE;
1287 }
1288 int32_t callbackId = -1;
1289 if (info.argc != ARGC_ONE && info.argc != ARGC_TWO) {
1290 TAG_LOGE(AAFwkTag::APPKIT, "Not enough params");
1291 errCode = ERROR_CODE_ONE;
1292 } else {
1293 napi_get_value_int32(env, info.argv[INDEX_ZERO], &callbackId);
1294 TAG_LOGD(AAFwkTag::APPKIT, "callbackId is %{public}d", callbackId);
1295 }
1296 std::weak_ptr<JsEnvironmentCallback> envCallbackWeak(envCallback_);
1297 NapiAsyncTask::CompleteCallback complete = [envCallbackWeak, callbackId, errCode](
1298 napi_env env, NapiAsyncTask &task, int32_t status) {
1299 if (errCode != 0) {
1300 task.Reject(env, CreateJsError(env, errCode, "Invalidate params."));
1301 return;
1302 }
1303 auto env_callback = envCallbackWeak.lock();
1304 if (env_callback == nullptr) {
1305 TAG_LOGE(AAFwkTag::APPKIT, "null env_callback");
1306 task.Reject(env, CreateJsError(env, ERROR_CODE_ONE, "env_callback is nullptr"));
1307 return;
1308 }
1309
1310 if (!env_callback->UnRegister(callbackId)) {
1311 TAG_LOGE(AAFwkTag::APPKIT, "call UnRegister failed");
1312 task.Reject(env, CreateJsError(env, ERROR_CODE_ONE, "call UnRegister failed!"));
1313 return;
1314 }
1315
1316 task.Resolve(env, CreateJsUndefined(env));
1317 };
1318 napi_value lastParam = (info.argc <= ARGC_ONE) ? nullptr : info.argv[INDEX_ONE];
1319 napi_value result = nullptr;
1320 NapiAsyncTask::Schedule("JsApplicationContextUtils::OnUnregisterEnvironmentCallback", env,
1321 CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result));
1322 return result;
1323 }
1324
On(napi_env env,napi_callback_info info)1325 napi_value JsApplicationContextUtils::On(napi_env env, napi_callback_info info)
1326 {
1327 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnOn, APPLICATION_CONTEXT_NAME);
1328 }
1329
Off(napi_env env,napi_callback_info info)1330 napi_value JsApplicationContextUtils::Off(napi_env env, napi_callback_info info)
1331 {
1332 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnOff, APPLICATION_CONTEXT_NAME);
1333 }
1334
OnOn(napi_env env,NapiCallbackInfo & info)1335 napi_value JsApplicationContextUtils::OnOn(napi_env env, NapiCallbackInfo& info)
1336 {
1337 TAG_LOGD(AAFwkTag::APPKIT, "called");
1338
1339 if (info.argc != ARGC_TWO) {
1340 TAG_LOGE(AAFwkTag::APPKIT, "Not enough params");
1341 ThrowInvalidParamError(env, "Not enough params.");
1342 return CreateJsUndefined(env);
1343 }
1344
1345 if (!CheckTypeForNapiValue(env, info.argv[0], napi_string)) {
1346 TAG_LOGE(AAFwkTag::APPKIT, "param invalid");
1347 ThrowInvalidParamError(env, "Parse param type failed, type must be string.");
1348 return CreateJsUndefined(env);
1349 }
1350 std::string type;
1351 if (!ConvertFromJsValue(env, info.argv[0], type)) {
1352 TAG_LOGE(AAFwkTag::APPKIT, "convert type failed");
1353 ThrowInvalidParamError(env,
1354 "Parse param type failed, type must be string.");
1355 return CreateJsUndefined(env);
1356 }
1357
1358 if (type == "abilityLifecycle") {
1359 return OnOnAbilityLifecycle(env, info, false);
1360 }
1361 if (type == "abilityLifecycleEvent") {
1362 return OnOnAbilityLifecycle(env, info, true);
1363 }
1364 if (type == "environment") {
1365 return OnOnEnvironment(env, info, false);
1366 }
1367 if (type == "environmentEvent") {
1368 return OnOnEnvironment(env, info, true);
1369 }
1370 if (type == "applicationStateChange") {
1371 return OnOnApplicationStateChange(env, info);
1372 }
1373 TAG_LOGE(AAFwkTag::APPKIT, "on function type not match");
1374 ThrowInvalidParamError(env, "Parse param callback failed, callback must be function.");
1375 return CreateJsUndefined(env);
1376 }
1377
OnOff(napi_env env,NapiCallbackInfo & info)1378 napi_value JsApplicationContextUtils::OnOff(napi_env env, NapiCallbackInfo& info)
1379 {
1380 TAG_LOGD(AAFwkTag::APPKIT, "called");
1381 if (info.argc < ARGC_ONE) {
1382 TAG_LOGE(AAFwkTag::APPKIT, "Not enough params");
1383 ThrowInvalidParamError(env, "Not enough params.");
1384 return CreateJsUndefined(env);
1385 }
1386
1387 if (!CheckTypeForNapiValue(env, info.argv[0], napi_string)) {
1388 TAG_LOGE(AAFwkTag::APPKIT, "param invalid");
1389 ThrowInvalidParamError(env, "Parse param type failed, type must be string.");
1390 return CreateJsUndefined(env);
1391 }
1392 std::string type;
1393 if (!ConvertFromJsValue(env, info.argv[0], type)) {
1394 TAG_LOGE(AAFwkTag::APPKIT, "convert type failed");
1395 ThrowInvalidParamError(env,
1396 "Parse param type failed, type must be string.");
1397 return CreateJsUndefined(env);
1398 }
1399
1400 if (type == "applicationStateChange") {
1401 return OnOffApplicationStateChange(env, info);
1402 }
1403
1404 if (info.argc != ARGC_TWO && info.argc != ARGC_THREE) {
1405 TAG_LOGE(AAFwkTag::APPKIT, "Not enough params");
1406 ThrowInvalidParamError(env, "Not enough params.");
1407 return CreateJsUndefined(env);
1408 }
1409
1410 int32_t callbackId = -1;
1411 if (CheckTypeForNapiValue(env, info.argv[1], napi_number)) {
1412 napi_get_value_int32(env, info.argv[1], &callbackId);
1413 TAG_LOGD(AAFwkTag::APPKIT, "callbackId is %{public}d.", callbackId);
1414 }
1415
1416 if (type == "abilityLifecycle") {
1417 return OnOffAbilityLifecycle(env, info, callbackId);
1418 }
1419 if (type == "abilityLifecycleEvent") {
1420 return OnOffAbilityLifecycleEventSync(env, info, callbackId);
1421 }
1422 if (type == "environment") {
1423 return OnOffEnvironment(env, info, callbackId);
1424 }
1425 if (type == "environmentEvent") {
1426 return OnOffEnvironmentEventSync(env, info, callbackId);
1427 }
1428 TAG_LOGE(AAFwkTag::APPKIT, "off function type not match");
1429 ThrowInvalidParamError(env, "Parse param callback failed, callback must be function.");
1430 return CreateJsUndefined(env);
1431 }
1432
OnOnAbilityLifecycle(napi_env env,NapiCallbackInfo & info,bool isSync)1433 napi_value JsApplicationContextUtils::OnOnAbilityLifecycle(
1434 napi_env env, NapiCallbackInfo& info, bool isSync)
1435 {
1436 auto applicationContext = applicationContext_.lock();
1437 if (applicationContext == nullptr) {
1438 TAG_LOGE(AAFwkTag::APPKIT, "null applicationContext");
1439 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1440 return CreateJsUndefined(env);
1441 }
1442
1443 if (callback_ != nullptr) {
1444 TAG_LOGD(AAFwkTag::APPKIT, "callback_ is not nullptr");
1445 return CreateJsValue(env, callback_->Register(info.argv[1], isSync));
1446 }
1447 callback_ = std::make_shared<JsAbilityLifecycleCallback>(env);
1448 int32_t callbackId = callback_->Register(info.argv[1], isSync);
1449 applicationContext->RegisterAbilityLifecycleCallback(callback_);
1450 return CreateJsValue(env, callbackId);
1451 }
1452
OnOffAbilityLifecycle(napi_env env,NapiCallbackInfo & info,int32_t callbackId)1453 napi_value JsApplicationContextUtils::OnOffAbilityLifecycle(
1454 napi_env env, NapiCallbackInfo& info, int32_t callbackId)
1455 {
1456 auto applicationContext = applicationContext_.lock();
1457 if (applicationContext == nullptr) {
1458 TAG_LOGE(AAFwkTag::APPKIT, "null applicationContext");
1459 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1460 return CreateJsUndefined(env);
1461 }
1462
1463 std::weak_ptr<JsAbilityLifecycleCallback> callbackWeak(callback_);
1464 NapiAsyncTask::CompleteCallback complete = [callbackWeak, callbackId](
1465 napi_env env, NapiAsyncTask &task, int32_t status) {
1466 auto callback = callbackWeak.lock();
1467 if (callback == nullptr) {
1468 TAG_LOGE(AAFwkTag::APPKIT, "null callback");
1469 task.Reject(env, CreateJsError(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER,
1470 "callback is nullptr"));
1471 return;
1472 }
1473
1474 if (!callback->UnRegister(callbackId, false)) {
1475 TAG_LOGE(AAFwkTag::APPKIT, "call UnRegister failed");
1476 task.Reject(env, CreateJsError(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER,
1477 "call UnRegister failed!"));
1478 return;
1479 }
1480
1481 task.ResolveWithNoError(env, CreateJsUndefined(env));
1482 };
1483 napi_value lastParam = (info.argc <= ARGC_TWO) ? nullptr : info.argv[INDEX_TWO];
1484 napi_value result = nullptr;
1485 NapiAsyncTask::Schedule("JsApplicationContextUtils::OnOffAbilityLifecycle", env,
1486 CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result));
1487 return result;
1488 }
1489
OnOffAbilityLifecycleEventSync(napi_env env,NapiCallbackInfo & info,int32_t callbackId)1490 napi_value JsApplicationContextUtils::OnOffAbilityLifecycleEventSync(
1491 napi_env env, NapiCallbackInfo& info, int32_t callbackId)
1492 {
1493 TAG_LOGD(AAFwkTag::APPKIT, "called");
1494
1495 auto applicationContext = applicationContext_.lock();
1496 if (applicationContext == nullptr) {
1497 TAG_LOGE(AAFwkTag::APPKIT, "null applicationContext");
1498 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INTERNAL_ERROR);
1499 return CreateJsUndefined(env);
1500 }
1501 if (callback_ == nullptr) {
1502 TAG_LOGE(AAFwkTag::APPKIT, "null callback");
1503 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INTERNAL_ERROR);
1504 return CreateJsUndefined(env);
1505 }
1506 if (!callback_->UnRegister(callbackId, true)) {
1507 TAG_LOGE(AAFwkTag::APPKIT, "call UnRegister failed");
1508 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INTERNAL_ERROR);
1509 return CreateJsUndefined(env);
1510 }
1511 return CreateJsUndefined(env);
1512 }
1513
OnOnEnvironment(napi_env env,NapiCallbackInfo & info,bool isSync)1514 napi_value JsApplicationContextUtils::OnOnEnvironment(
1515 napi_env env, NapiCallbackInfo& info, bool isSync)
1516 {
1517 TAG_LOGD(AAFwkTag::APPKIT, "called");
1518
1519 auto applicationContext = applicationContext_.lock();
1520 if (applicationContext == nullptr) {
1521 TAG_LOGE(AAFwkTag::APPKIT, "null applicationContext");
1522 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INTERNAL_ERROR);
1523 return CreateJsUndefined(env);
1524 }
1525
1526 if (envCallback_ != nullptr) {
1527 TAG_LOGD(AAFwkTag::APPKIT, "envCallback_ is not nullptr.");
1528 return CreateJsValue(env, envCallback_->Register(info.argv[1], isSync));
1529 }
1530 envCallback_ = std::make_shared<JsEnvironmentCallback>(env);
1531 int32_t callbackId = envCallback_->Register(info.argv[1], isSync);
1532 applicationContext->RegisterEnvironmentCallback(envCallback_);
1533 TAG_LOGD(AAFwkTag::APPKIT, "OnOnEnvironment is end");
1534 return CreateJsValue(env, callbackId);
1535 }
1536
OnOffEnvironment(napi_env env,NapiCallbackInfo & info,int32_t callbackId)1537 napi_value JsApplicationContextUtils::OnOffEnvironment(
1538 napi_env env, NapiCallbackInfo& info, int32_t callbackId)
1539 {
1540 TAG_LOGD(AAFwkTag::APPKIT, "called");
1541
1542 auto applicationContext = applicationContext_.lock();
1543 if (applicationContext == nullptr) {
1544 TAG_LOGE(AAFwkTag::APPKIT, "null applicationContext");
1545 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1546 return CreateJsUndefined(env);
1547 }
1548
1549 std::weak_ptr<JsEnvironmentCallback> envCallbackWeak(envCallback_);
1550 NapiAsyncTask::CompleteCallback complete = [envCallbackWeak, callbackId](
1551 napi_env env, NapiAsyncTask &task, int32_t status) {
1552 auto env_callback = envCallbackWeak.lock();
1553 if (env_callback == nullptr) {
1554 TAG_LOGE(AAFwkTag::APPKIT, "null env_callback");
1555 task.Reject(env,
1556 CreateJsError(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER,
1557 "env_callback is nullptr"));
1558 return;
1559 }
1560
1561 TAG_LOGD(AAFwkTag::APPKIT, "OnOffEnvironment begin");
1562 if (!env_callback->UnRegister(callbackId, false)) {
1563 TAG_LOGE(AAFwkTag::APPKIT, "call UnRegister failed");
1564 task.Reject(env, CreateJsError(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER,
1565 "call UnRegister failed!"));
1566 return;
1567 }
1568
1569 task.ResolveWithNoError(env, CreateJsUndefined(env));
1570 };
1571 napi_value lastParam = (info.argc <= ARGC_TWO) ? nullptr : info.argv[INDEX_TWO];
1572 napi_value result = nullptr;
1573 NapiAsyncTask::Schedule("JsApplicationContextUtils::OnOffEnvironment", env,
1574 CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result));
1575 return result;
1576 }
1577
OnOffEnvironmentEventSync(napi_env env,NapiCallbackInfo & info,int32_t callbackId)1578 napi_value JsApplicationContextUtils::OnOffEnvironmentEventSync(
1579 napi_env env, NapiCallbackInfo& info, int32_t callbackId)
1580 {
1581 TAG_LOGD(AAFwkTag::APPKIT, "called");
1582
1583 auto applicationContext = applicationContext_.lock();
1584 if (applicationContext == nullptr) {
1585 TAG_LOGE(AAFwkTag::APPKIT, "null applicationContext");
1586 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INTERNAL_ERROR);
1587 return CreateJsUndefined(env);
1588 }
1589 if (envCallback_ == nullptr) {
1590 TAG_LOGE(AAFwkTag::APPKIT, "null envCallback");
1591 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INTERNAL_ERROR);
1592 return CreateJsUndefined(env);
1593 }
1594 if (!envCallback_->UnRegister(callbackId, true)) {
1595 TAG_LOGE(AAFwkTag::APPKIT, "call UnRegister failed");
1596 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INTERNAL_ERROR);
1597 return CreateJsUndefined(env);
1598 }
1599 return CreateJsUndefined(env);
1600 }
1601
OnOnApplicationStateChange(napi_env env,NapiCallbackInfo & info)1602 napi_value JsApplicationContextUtils::OnOnApplicationStateChange(
1603 napi_env env, NapiCallbackInfo& info)
1604 {
1605 TAG_LOGD(AAFwkTag::APPKIT, "called");
1606 auto applicationContext = applicationContext_.lock();
1607 if (applicationContext == nullptr) {
1608 TAG_LOGE(AAFwkTag::APPKIT, "null applicationContext");
1609 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1610 return CreateJsUndefined(env);
1611 }
1612
1613 std::lock_guard<std::mutex> lock(applicationStateCallbackLock_);
1614 if (applicationStateCallback_ != nullptr) {
1615 applicationStateCallback_->Register(info.argv[INDEX_ONE]);
1616 return CreateJsUndefined(env);
1617 }
1618
1619 applicationStateCallback_ = std::make_shared<JsApplicationStateChangeCallback>(env);
1620 applicationStateCallback_->Register(info.argv[INDEX_ONE]);
1621 applicationContext->RegisterApplicationStateChangeCallback(applicationStateCallback_);
1622 return CreateJsUndefined(env);
1623 }
1624
OnOffApplicationStateChange(napi_env env,NapiCallbackInfo & info)1625 napi_value JsApplicationContextUtils::OnOffApplicationStateChange(
1626 napi_env env, NapiCallbackInfo& info)
1627 {
1628 TAG_LOGD(AAFwkTag::APPKIT, "called");
1629 auto applicationContext = applicationContext_.lock();
1630 if (applicationContext == nullptr) {
1631 TAG_LOGE(AAFwkTag::APPKIT, "null applicationContext");
1632 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1633 return CreateJsUndefined(env);
1634 }
1635
1636 std::lock_guard<std::mutex> lock(applicationStateCallbackLock_);
1637 if (applicationStateCallback_ == nullptr) {
1638 TAG_LOGE(AAFwkTag::APPKIT, "null applicationStateCallback_");
1639 ThrowInvalidParamError(env,
1640 "Parse applicationStateCallback failed, applicationStateCallback must be function.");
1641 return CreateJsUndefined(env);
1642 }
1643
1644 if (info.argc == ARGC_ONE || !CheckTypeForNapiValue(env, info.argv[INDEX_ONE], napi_object)) {
1645 applicationStateCallback_->UnRegister();
1646 } else if (!applicationStateCallback_->UnRegister(info.argv[INDEX_ONE])) {
1647 TAG_LOGE(AAFwkTag::APPKIT, "call UnRegister failed");
1648 ThrowInvalidParamError(env, "Parse param call UnRegister failed, call UnRegister must be function.");
1649 return CreateJsUndefined(env);
1650 }
1651
1652 if (applicationStateCallback_->IsEmpty()) {
1653 applicationStateCallback_.reset();
1654 }
1655 return CreateJsUndefined(env);
1656 }
1657
GetApplicationContext(napi_env env,napi_callback_info info)1658 napi_value JsApplicationContextUtils::GetApplicationContext(napi_env env, napi_callback_info info)
1659 {
1660 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils,
1661 OnGetApplicationContext, APPLICATION_CONTEXT_NAME);
1662 }
1663
OnGetApplicationContext(napi_env env,NapiCallbackInfo & info)1664 napi_value JsApplicationContextUtils::OnGetApplicationContext(napi_env env, NapiCallbackInfo& info)
1665 {
1666 TAG_LOGD(AAFwkTag::APPKIT, "called");
1667 auto applicationContext = applicationContext_.lock();
1668 if (!applicationContext) {
1669 TAG_LOGW(AAFwkTag::APPKIT, "null applicationContext");
1670 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1671 return CreateJsUndefined(env);
1672 }
1673
1674 if (!applicationContext->GetApplicationInfoUpdateFlag()) {
1675 auto appContextObj = ApplicationContextManager::GetApplicationContextManager().GetGlobalObject(env);
1676 if (appContextObj != nullptr) {
1677 return appContextObj->GetNapiValue();
1678 }
1679 }
1680
1681 napi_value value = CreateJsApplicationContext(env);
1682 auto systemModule = JsRuntime::LoadSystemModuleByEngine(env, "application.ApplicationContext", &value, 1);
1683 if (systemModule == nullptr) {
1684 TAG_LOGW(AAFwkTag::APPKIT, "null systemModule");
1685 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1686 return CreateJsUndefined(env);
1687 }
1688 napi_value contextObj = systemModule->GetNapiValue();
1689 if (!CheckTypeForNapiValue(env, contextObj, napi_object)) {
1690 TAG_LOGE(AAFwkTag::APPKIT, "get object failed");
1691 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1692 return CreateJsUndefined(env);
1693 }
1694 auto workContext = new (std::nothrow) std::weak_ptr<ApplicationContext>(applicationContext);
1695 napi_coerce_to_native_binding_object(
1696 env, contextObj, DetachCallbackFunc, AttachApplicationContext, workContext, nullptr);
1697 if (workContext != nullptr) {
1698 auto res = napi_wrap(env, contextObj, workContext,
1699 [](napi_env, void *data, void *) {
1700 TAG_LOGD(AAFwkTag::APPKIT, "Finalizer for weak_ptr application context is called");
1701 delete static_cast<std::weak_ptr<ApplicationContext> *>(data);
1702 data = nullptr;
1703 },
1704 nullptr, nullptr);
1705 if (res != napi_ok && workContext != nullptr) {
1706 TAG_LOGE(AAFwkTag::APPKIT, "napi_wrap failed:%{public}d", res);
1707 delete workContext;
1708 return CreateJsUndefined(env);
1709 }
1710 }
1711 return contextObj;
1712 }
1713
CheckCallerIsSystemApp()1714 bool JsApplicationContextUtils::CheckCallerIsSystemApp()
1715 {
1716 auto selfToken = IPCSkeleton::GetSelfTokenID();
1717 if (!Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(selfToken)) {
1718 return false;
1719 }
1720 return true;
1721 }
1722
CreateJsApplicationContext(napi_env env)1723 napi_value JsApplicationContextUtils::CreateJsApplicationContext(napi_env env)
1724 {
1725 TAG_LOGD(AAFwkTag::APPKIT, "start");
1726 napi_value object = nullptr;
1727 napi_create_object(env, &object);
1728 if (object == nullptr) {
1729 return nullptr;
1730 }
1731
1732 std::shared_ptr<ApplicationContext> applicationContext = ApplicationContext::GetInstance();
1733 if (applicationContext == nullptr) {
1734 return object;
1735 }
1736
1737 auto jsApplicationContextUtils = std::make_unique<JsApplicationContextUtils>(applicationContext);
1738 SetNamedNativePointer(env, object, APPLICATION_CONTEXT_NAME, jsApplicationContextUtils.release(),
1739 JsApplicationContextUtils::Finalizer);
1740
1741 auto appInfo = applicationContext->GetApplicationInfo();
1742 if (appInfo != nullptr) {
1743 napi_set_named_property(env, object, "applicationInfo", CreateJsApplicationInfo(env, *appInfo));
1744 }
1745 auto resourceManager = applicationContext->GetResourceManager();
1746 std::shared_ptr<Context> context = std::dynamic_pointer_cast<Context>(applicationContext);
1747 if (resourceManager != nullptr) {
1748 napi_set_named_property(env, object, "resourceManager", CreateJsResourceManager(env, resourceManager, context));
1749 }
1750 napi_value applicationContextValue = nullptr;
1751 Context *contextPtr = context.get();
1752 int64_t applicationContextAddress = reinterpret_cast<int64_t>(contextPtr);
1753 auto status = napi_create_int64(env, applicationContextAddress, &applicationContextValue);
1754 if (status != napi_ok) {
1755 TAG_LOGE(AAFwkTag::APPKIT, "get context index fial");
1756 return nullptr;
1757 }
1758 napi_set_named_property(env, object, "index", applicationContextValue);
1759
1760 std::string type = "ApplicationContext";
1761 napi_set_named_property(env, object, "contextType", CreateJsValue(env, type));
1762
1763 BindNativeApplicationContextOne(env, object);
1764 BindNativeApplicationContextTwo(env, object);
1765 return object;
1766 }
1767
SetSupportedProcessCacheSelf(napi_env env,napi_callback_info info)1768 napi_value JsApplicationContextUtils::SetSupportedProcessCacheSelf(napi_env env, napi_callback_info info)
1769 {
1770 GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils,
1771 OnSetSupportedProcessCacheSelf, APPLICATION_CONTEXT_NAME);
1772 }
1773
OnSetSupportedProcessCacheSelf(napi_env env,NapiCallbackInfo & info)1774 napi_value JsApplicationContextUtils::OnSetSupportedProcessCacheSelf(napi_env env, NapiCallbackInfo& info)
1775 {
1776 TAG_LOGD(AAFwkTag::APPKIT, "called");
1777
1778 // only support one params
1779 if (info.argc == ARGC_ZERO) {
1780 TAG_LOGE(AAFwkTag::APPKIT, "Not enough params");
1781 ThrowInvalidParamError(env, "Not enough params.");
1782 return CreateJsUndefined(env);
1783 }
1784 auto applicationContext = applicationContext_.lock();
1785 if (applicationContext == nullptr) {
1786 TAG_LOGW(AAFwkTag::APPKIT, "null applicationContext");
1787 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_CONTEXT_NOT_EXIST);
1788 return CreateJsUndefined(env);
1789 }
1790
1791 bool isSupport = false;
1792 if (!ConvertFromJsValue(env, info.argv[INDEX_ZERO], isSupport)) {
1793 TAG_LOGE(AAFwkTag::APPKIT, "Parse isSupport failed");
1794 ThrowInvalidParamError(env,
1795 "Parse param isSupport failed, isSupport must be boolean.");
1796 return CreateJsUndefined(env);
1797 }
1798
1799 int32_t errCode = applicationContext->SetSupportedProcessCacheSelf(isSupport);
1800 if (errCode == AAFwk::ERR_CAPABILITY_NOT_SUPPORT) {
1801 TAG_LOGE(AAFwkTag::APPKIT, "process cache feature disabled");
1802 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_NO_SUCH_SYSCAP);
1803 } else if (errCode != ERR_OK) {
1804 TAG_LOGE(AAFwkTag::APPKIT, "set failed");
1805 AbilityRuntimeErrorUtil::Throw(env, ERR_ABILITY_RUNTIME_EXTERNAL_INTERNAL_ERROR);
1806 }
1807 return CreateJsUndefined(env);
1808 }
1809
BindNativeApplicationContextOne(napi_env env,napi_value object)1810 void JsApplicationContextUtils::BindNativeApplicationContextOne(napi_env env, napi_value object)
1811 {
1812 BindNativeProperty(env, object, "cacheDir", JsApplicationContextUtils::GetCacheDir);
1813 BindNativeProperty(env, object, "tempDir", JsApplicationContextUtils::GetTempDir);
1814 BindNativeProperty(env, object, "resourceDir", JsApplicationContextUtils::GetResourceDir);
1815 BindNativeProperty(env, object, "filesDir", JsApplicationContextUtils::GetFilesDir);
1816 BindNativeProperty(env, object, "distributedFilesDir", JsApplicationContextUtils::GetDistributedFilesDir);
1817 BindNativeProperty(env, object, "databaseDir", JsApplicationContextUtils::GetDatabaseDir);
1818 BindNativeProperty(env, object, "preferencesDir", JsApplicationContextUtils::GetPreferencesDir);
1819 BindNativeProperty(env, object, "bundleCodeDir", JsApplicationContextUtils::GetBundleCodeDir);
1820 BindNativeProperty(env, object, "cloudFileDir", JsApplicationContextUtils::GetCloudFileDir);
1821 BindNativeProperty(env, object, "processName", JsApplicationContextUtils::GetProcessName);
1822 BindNativeFunction(env, object, "registerAbilityLifecycleCallback", MD_NAME,
1823 JsApplicationContextUtils::RegisterAbilityLifecycleCallback);
1824 BindNativeFunction(env, object, "unregisterAbilityLifecycleCallback", MD_NAME,
1825 JsApplicationContextUtils::UnregisterAbilityLifecycleCallback);
1826 BindNativeFunction(env, object, "registerEnvironmentCallback", MD_NAME,
1827 JsApplicationContextUtils::RegisterEnvironmentCallback);
1828 BindNativeFunction(env, object, "unregisterEnvironmentCallback", MD_NAME,
1829 JsApplicationContextUtils::UnregisterEnvironmentCallback);
1830 BindNativeFunction(env, object, "createBundleContext", MD_NAME, JsApplicationContextUtils::CreateBundleContext);
1831 BindNativeFunction(env, object, "switchArea", MD_NAME, JsApplicationContextUtils::SwitchArea);
1832 BindNativeFunction(env, object, "getArea", MD_NAME, JsApplicationContextUtils::GetArea);
1833 BindNativeFunction(env, object, "createModuleContext", MD_NAME, JsApplicationContextUtils::CreateModuleContext);
1834 BindNativeFunction(env, object, "createSystemHspModuleResourceManager", MD_NAME,
1835 JsApplicationContextUtils::CreateSystemHspModuleResourceManager);
1836 BindNativeFunction(env, object, "createModuleResourceManager", MD_NAME,
1837 JsApplicationContextUtils::CreateModuleResourceManager);
1838 BindNativeFunction(env, object, "on", MD_NAME, JsApplicationContextUtils::On);
1839 BindNativeFunction(env, object, "off", MD_NAME, JsApplicationContextUtils::Off);
1840 BindNativeFunction(env, object, "getApplicationContext", MD_NAME,
1841 JsApplicationContextUtils::GetApplicationContext);
1842 BindNativeFunction(env, object, "killAllProcesses", MD_NAME, JsApplicationContextUtils::KillProcessBySelf);
1843 BindNativeFunction(env, object, "setColorMode", MD_NAME, JsApplicationContextUtils::SetColorMode);
1844 BindNativeFunction(env, object, "setLanguage", MD_NAME, JsApplicationContextUtils::SetLanguage);
1845 BindNativeFunction(env, object, "setFont", MD_NAME, JsApplicationContextUtils::SetFont);
1846 BindNativeFunction(env, object, "clearUpApplicationData", MD_NAME,
1847 JsApplicationContextUtils::ClearUpApplicationData);
1848 BindNativeFunction(env, object, "createAreaModeContext", MD_NAME, JsApplicationContextUtils::CreateAreaModeContext);
1849 BindNativeFunction(env, object, "createDisplayContext", MD_NAME,
1850 JsApplicationContextUtils::CreateDisplayContext);
1851 }
1852
BindNativeApplicationContextTwo(napi_env env,napi_value object)1853 void JsApplicationContextUtils::BindNativeApplicationContextTwo(napi_env env, napi_value object)
1854 {
1855 BindNativeFunction(env, object, "preloadUIExtensionAbility", MD_NAME,
1856 JsApplicationContextUtils::PreloadUIExtensionAbility);
1857 BindNativeFunction(env, object, "getProcessRunningInformation", MD_NAME,
1858 JsApplicationContextUtils::GetRunningProcessInformation);
1859 BindNativeFunction(env, object, "getRunningProcessInformation", MD_NAME,
1860 JsApplicationContextUtils::GetRunningProcessInformation);
1861 BindNativeFunction(env, object, "getCurrentAppCloneIndex", MD_NAME,
1862 JsApplicationContextUtils::GetCurrentAppCloneIndex);
1863 BindNativeFunction(env, object, "getCurrentInstanceKey", MD_NAME,
1864 JsApplicationContextUtils::GetCurrentInstanceKey);
1865 BindNativeFunction(env, object, "getAllRunningInstanceKeys", MD_NAME,
1866 JsApplicationContextUtils::GetAllRunningInstanceKeys);
1867 BindNativeFunction(env, object, "getGroupDir", MD_NAME, JsApplicationContextUtils::GetGroupDir);
1868 BindNativeFunction(env, object, "restartApp", MD_NAME, JsApplicationContextUtils::RestartApp);
1869 BindNativeFunction(env, object, "setSupportedProcessCache", MD_NAME,
1870 JsApplicationContextUtils::SetSupportedProcessCacheSelf);
1871 BindNativeFunction(env, object, "setFontSizeScale", MD_NAME,
1872 JsApplicationContextUtils::SetFontSizeScale);
1873 }
1874 } // namespace AbilityRuntime
1875 } // namespace OHOS
1876