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