• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <pthread.h>
17 #include <stdio.h>
18 #include <string.h>
19 #include <unistd.h>
20 
21 #include "app_log_wrapper.h"
22 #include "bundle_status_callback.h"
23 #include "common_func.h"
24 #include "js_launcher_mgr.h"
25 #include "js_launcher.h"
26 #include "launcher_service.h"
27 #include "napi/native_api.h"
28 #include "napi/native_node_api.h"
29 #include "napi_arg.h"
30 #include "napi_constants.h"
31 
32 using namespace OHOS::AppExecFwk;
33 namespace {
34 const std::string REGISTERCALLBACK = "BundleStatusChange";
35 const std::string UNREGISTERCALLBACK = "BundleStatusChange";
36 const std::string TYPE_MISMATCH = "type mismatch";
37 constexpr int32_t NAPI_RETURN_ZERO = 0;
38 constexpr int32_t OPERATION_SUCESS = 0;
39 constexpr int32_t OPERATION_FAILED = 1;
40 constexpr int32_t OPERATION_TYPE_MIAMATCH = 2;
41 constexpr int32_t INDEX_ONE = 1;
42 constexpr int32_t INDEX_TWO = 2;
43 constexpr int32_t INDEX_THREE = 3;
44 }
45 
46 struct AsyncHandleBundleContext {
47     napi_env env = nullptr;
48     napi_async_work asyncWork = nullptr;
49     napi_deferred deferred = nullptr;
50     napi_ref callbackRef = 0;
51     OHOS::sptr<BundleStatusCallback> bundleStatusCallback = nullptr;
52     std::vector<OHOS::AppExecFwk::LauncherAbilityInfo> launcherAbilityInfos;
53     std::vector<OHOS::AppExecFwk::ShortcutInfo> shortcutInfos;
54     std::string bundleName;
55     int32_t userId = 0;
56     bool ret = false;
57     uint32_t err = 0;
58     std::string message;
59 };
60 
GetLauncherService()61 static OHOS::sptr<OHOS::AppExecFwk::LauncherService> GetLauncherService()
62 {
63     return OHOS::AppExecFwk::JSLauncherMgr::GetLauncherService();
64 }
65 
ParseString(napi_env env,napi_value value,std::string & result)66 static void ParseString(napi_env env, napi_value value, std::string& result)
67 {
68     size_t size = 0;
69 
70     if (napi_get_value_string_utf8(env, value, nullptr, NAPI_RETURN_ZERO, &size) != napi_ok) {
71         APP_LOGE("can not get string size");
72         return;
73     }
74 
75     result.reserve(size + NAPI_RETURN_ONE);
76     result.resize(size);
77     if (napi_get_value_string_utf8(env, value, result.data(), (size + NAPI_RETURN_ONE), &size) != napi_ok) {
78         APP_LOGE("can not get string value");
79         return;
80     }
81 }
82 
ParseBundleStatusCallback(napi_env env,OHOS::sptr<BundleStatusCallback> & bundleStatusCallback,napi_value args)83 static bool ParseBundleStatusCallback(napi_env env,
84     OHOS::sptr<BundleStatusCallback>& bundleStatusCallback, napi_value args)
85 {
86     APP_LOGD("parse bundleStatusCallback begin");
87     napi_status status;
88     napi_valuetype valueType;
89     NAPI_CALL_BASE(env, napi_typeof(env, args, &valueType), false);
90     if (valueType != napi_object) {
91         APP_LOGE("param type mismatch!");
92         return false;
93     }
94 
95     // parse added callback
96     napi_ref addCallback = nullptr;
97     napi_value addValue = nullptr;
98     status = napi_get_named_property(env, args, "add", &addValue);
99     NAPI_ASSERT_BASE(env, status == napi_ok, "property name incorrect!", false);
100     napi_typeof(env, addValue, &valueType);
101     if (valueType != napi_function) {
102         APP_LOGE("add param type mismatch!");
103         return false;
104     }
105     napi_create_reference(env, addValue, NAPI_RETURN_ONE, &addCallback);
106 
107     // parse updated callback
108     napi_ref updateCallback = nullptr;
109     napi_value updateValue = nullptr;
110     status = napi_get_named_property(env, args, "update", &updateValue);
111     NAPI_ASSERT_BASE(env, status == napi_ok, "property name incorrect!", false);
112     napi_typeof(env, updateValue, &valueType);
113     if (valueType != napi_function) {
114         APP_LOGE("update param type mismatch!");
115         return false;
116     }
117     napi_create_reference(env, updateValue, NAPI_RETURN_ONE, &updateCallback);
118 
119     // parse remove callback
120     napi_ref removeCallback = nullptr;
121     napi_value removeValue = nullptr;
122     status = napi_get_named_property(env, args, "remove", &removeValue);
123     NAPI_ASSERT_BASE(env, status == napi_ok, "property name incorrect!", false);
124     napi_typeof(env, removeValue, &valueType);
125     if (valueType != napi_function) {
126         APP_LOGE("remove param type mismatch!");
127         return false;
128     }
129     napi_create_reference(env, removeValue, NAPI_RETURN_ONE, &removeCallback);
130 
131     bundleStatusCallback = new BundleStatusCallback(env, addCallback, updateCallback, removeCallback);
132     APP_LOGD("parse bundleStatusCallback end");
133     return true;
134 }
135 
ConvertApplicationInfo(napi_env env,napi_value objAppInfo,const OHOS::AppExecFwk::ApplicationInfo & appInfo)136 static void ConvertApplicationInfo(napi_env env, napi_value objAppInfo,
137     const OHOS::AppExecFwk::ApplicationInfo &appInfo)
138 {
139     napi_value nName;
140     NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
141     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "name", nName));
142 
143     napi_value nCodePath;
144     NAPI_CALL_RETURN_VOID(
145         env, napi_create_string_utf8(env, appInfo.codePath.c_str(), NAPI_AUTO_LENGTH, &nCodePath));
146     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "codePath", nCodePath));
147 
148     napi_value nDescription;
149     NAPI_CALL_RETURN_VOID(
150         env, napi_create_string_utf8(env, appInfo.description.c_str(), NAPI_AUTO_LENGTH, &nDescription));
151     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "description", nDescription));
152 
153     napi_value nDescriptionId;
154     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, appInfo.descriptionId, &nDescriptionId));
155     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "descriptionId", nDescriptionId));
156 
157     napi_value nIsSystemApp;
158     NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, appInfo.isSystemApp, &nIsSystemApp));
159     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "systemApp", nIsSystemApp));
160 
161     napi_value nEnabled;
162     NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, appInfo.enabled, &nEnabled));
163     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "enabled", nEnabled));
164 
165     napi_value nRemovable;
166     NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, appInfo.removable, &nRemovable));
167     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "removable", nRemovable));
168 
169     napi_value nLabel;
170     NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.label.c_str(), NAPI_AUTO_LENGTH, &nLabel));
171     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "label", nLabel));
172 
173     napi_value nLabelId;
174     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, appInfo.labelId, &nLabelId));
175     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "labelId", nLabelId));
176 
177     napi_value nIconPath;
178     NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.iconPath.c_str(), NAPI_AUTO_LENGTH, &nIconPath));
179     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "icon", nIconPath));
180 
181     napi_value nIconId;
182     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, appInfo.iconId, &nIconId));
183     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "iconId", nIconId));
184 
185     napi_value nSupportedModes;
186     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, appInfo.supportedModes, &nSupportedModes));
187     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "supportedModes", nSupportedModes));
188 
189     napi_value nProcess;
190     NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.process.c_str(), NAPI_AUTO_LENGTH, &nProcess));
191     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "process", nProcess));
192 
193     napi_value nModuleSourceDirs;
194     NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nModuleSourceDirs));
195     for (size_t idx = 0; idx < appInfo.moduleSourceDirs.size(); idx++) {
196         napi_value nModuleSourceDir;
197         NAPI_CALL_RETURN_VOID(env,
198             napi_create_string_utf8(env, appInfo.moduleSourceDirs[idx].c_str(),
199                                     NAPI_AUTO_LENGTH, &nModuleSourceDir));
200         NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nModuleSourceDirs, idx, nModuleSourceDir));
201     }
202     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "moduleSourceDirs", nModuleSourceDirs));
203 
204     napi_value nPermissions;
205     NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nPermissions));
206     for (size_t idx = 0; idx < appInfo.permissions.size(); idx++) {
207         napi_value nPermission;
208         NAPI_CALL_RETURN_VOID(
209             env, napi_create_string_utf8(env, appInfo.permissions[idx].c_str(), NAPI_AUTO_LENGTH, &nPermission));
210         NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nPermissions, idx, nPermission));
211     }
212     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "permissions", nPermissions));
213 
214     napi_value nModuleInfos;
215     NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nModuleInfos));
216     for (size_t idx = 0; idx < appInfo.moduleInfos.size(); idx++) {
217         napi_value objModuleInfos;
218         NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &objModuleInfos));
219 
220         napi_value nModuleName;
221         NAPI_CALL_RETURN_VOID(
222             env, napi_create_string_utf8(env,
223                                          appInfo.moduleInfos[idx].moduleName.c_str(),
224                                          NAPI_AUTO_LENGTH, &nModuleName));
225         NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objModuleInfos, "moduleName", nModuleName));
226 
227         napi_value nModuleSourceDir;
228         NAPI_CALL_RETURN_VOID(
229             env, napi_create_string_utf8(env,
230                                          appInfo.moduleInfos[idx].moduleSourceDir.c_str(),
231                                          NAPI_AUTO_LENGTH, &nModuleSourceDir));
232         NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objModuleInfos, "moduleSourceDir", nModuleSourceDir));
233 
234         NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nModuleInfos, idx, objModuleInfos));
235     }
236     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "moduleInfos", nModuleInfos));
237 
238     napi_value nEntryDir;
239     NAPI_CALL_RETURN_VOID(
240         env, napi_create_string_utf8(env, appInfo.entryDir.c_str(), NAPI_AUTO_LENGTH, &nEntryDir));
241     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "entryDir", nEntryDir));
242 
243     napi_value nFlags;
244     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, appInfo.flags, &nFlags));
245     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "flags", nFlags));
246 }
247 
ConvertElementName(napi_env env,napi_value elementInfo,const OHOS::AppExecFwk::ElementName & elementName)248 static void ConvertElementName(napi_env env, napi_value elementInfo, const OHOS::AppExecFwk::ElementName &elementName)
249 {
250     // wrap deviceId
251     napi_value deviceId;
252     NAPI_CALL_RETURN_VOID(
253         env, napi_create_string_utf8(env, elementName.GetDeviceID().c_str(), NAPI_AUTO_LENGTH, &deviceId));
254     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, elementInfo, "deviceId", deviceId));
255 
256     // wrap bundleName
257     napi_value bundleName;
258     NAPI_CALL_RETURN_VOID(
259         env, napi_create_string_utf8(env, elementName.GetBundleName().c_str(), NAPI_AUTO_LENGTH, &bundleName));
260     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, elementInfo, "bundleName", bundleName));
261 
262     // wrap moduleName
263     napi_value moduleName;
264     NAPI_CALL_RETURN_VOID(
265         env, napi_create_string_utf8(env, elementName.GetModuleName().c_str(), NAPI_AUTO_LENGTH, &moduleName));
266     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, elementInfo, "moduleName", moduleName));
267 
268     // wrap abilityName
269     napi_value abilityName;
270     NAPI_CALL_RETURN_VOID(
271         env, napi_create_string_utf8(env, elementName.GetAbilityName().c_str(), NAPI_AUTO_LENGTH, &abilityName));
272     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, elementInfo, "abilityName", abilityName));
273 }
274 
ConvertLauncherAbilityInfo(napi_env env,napi_value objAbilityInfo,const OHOS::AppExecFwk::LauncherAbilityInfo & launcherAbilityInfo)275 static void ConvertLauncherAbilityInfo(napi_env env, napi_value objAbilityInfo,
276     const OHOS::AppExecFwk::LauncherAbilityInfo &launcherAbilityInfo)
277 {
278     // wrap labelId
279     napi_value labelId;
280     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, launcherAbilityInfo.labelId, &labelId));
281     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "labelId", labelId));
282 
283     // wrap iconId
284     napi_value iconId;
285     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, launcherAbilityInfo.iconId, &iconId));
286     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "iconId", iconId));
287 
288     // wrap userId
289     napi_value userId;
290     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, launcherAbilityInfo.userId, &userId));
291     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "userId", userId));
292 
293     // wrap installTime
294     napi_value installTime;
295     NAPI_CALL_RETURN_VOID(env, napi_create_int64(env, launcherAbilityInfo.installTime, &installTime));
296     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "installTime", installTime));
297 
298     // wrap elementName
299     napi_value elementName;
300     NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &elementName));
301     ConvertElementName(env, elementName, launcherAbilityInfo.elementName);
302     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "elementName", elementName));
303 
304     // wrap application
305     napi_value appInfo;
306     NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &appInfo));
307     ConvertApplicationInfo(env, appInfo, launcherAbilityInfo.applicationInfo);
308     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "applicationInfo", appInfo));
309 }
310 
ParseLauncherAbilityInfo(napi_env env,napi_value result,const std::vector<OHOS::AppExecFwk::LauncherAbilityInfo> & launcherAbilityInfos)311 static bool ParseLauncherAbilityInfo(
312     napi_env env, napi_value result,
313     const std::vector<OHOS::AppExecFwk::LauncherAbilityInfo> &launcherAbilityInfos)
314 {
315     if (launcherAbilityInfos.empty()) {
316         return false;
317     }
318     size_t index = 0;
319     for (const auto& abilityInfo : launcherAbilityInfos) {
320         napi_value objAbilityInfo = nullptr;
321         napi_create_object(env, &objAbilityInfo);
322         ConvertLauncherAbilityInfo(env, objAbilityInfo, abilityInfo);
323         napi_set_element(env, result, index, objAbilityInfo);
324         index++;
325     }
326     return true;
327 }
328 
ConvertShortcutIntent(napi_env env,napi_value objShortcutInfo,const OHOS::AppExecFwk::ShortcutIntent & shortcutIntent)329 static void ConvertShortcutIntent(napi_env env, napi_value objShortcutInfo,
330                                   const OHOS::AppExecFwk::ShortcutIntent &shortcutIntent)
331 {
332     napi_value nTargetBundle;
333     NAPI_CALL_RETURN_VOID(
334         env, napi_create_string_utf8(env, shortcutIntent.targetBundle.c_str(), NAPI_AUTO_LENGTH, &nTargetBundle));
335     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objShortcutInfo, "targetBundle", nTargetBundle));
336 
337     napi_value nTargetModule;
338     NAPI_CALL_RETURN_VOID(
339         env, napi_create_string_utf8(env, shortcutIntent.targetModule.c_str(), NAPI_AUTO_LENGTH, &nTargetModule));
340     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objShortcutInfo, "targetModule", nTargetModule));
341 
342     napi_value nTargetClass;
343     NAPI_CALL_RETURN_VOID(
344         env, napi_create_string_utf8(env, shortcutIntent.targetClass.c_str(), NAPI_AUTO_LENGTH, &nTargetClass));
345     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objShortcutInfo, "targetClass", nTargetClass));
346 }
347 
ConvertShortcutInfo(napi_env env,napi_value objShortcutInfo,const OHOS::AppExecFwk::ShortcutInfo & shortcutInfo)348 static void ConvertShortcutInfo(
349     napi_env env, napi_value objShortcutInfo,
350     const OHOS::AppExecFwk::ShortcutInfo &shortcutInfo)
351 {
352     // wrap id
353     napi_value shortId;
354     NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env,
355                                                        shortcutInfo.id.c_str(), NAPI_AUTO_LENGTH, &shortId));
356     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objShortcutInfo, "id", shortId));
357 
358     // wrap bundleName
359     napi_value bundleName;
360     NAPI_CALL_RETURN_VOID(
361         env, napi_create_string_utf8(env, shortcutInfo.bundleName.c_str(), NAPI_AUTO_LENGTH, &bundleName));
362     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objShortcutInfo, "bundleName", bundleName));
363 
364     // wrap moduleName
365     napi_value moduleName;
366     NAPI_CALL_RETURN_VOID(
367         env, napi_create_string_utf8(env, shortcutInfo.moduleName.c_str(), NAPI_AUTO_LENGTH, &moduleName));
368     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objShortcutInfo, "moduleName", moduleName));
369 
370     // wrap hostAbility
371     napi_value hostAbility;
372     NAPI_CALL_RETURN_VOID(
373         env, napi_create_string_utf8(env, shortcutInfo.hostAbility.c_str(), NAPI_AUTO_LENGTH, &hostAbility));
374     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objShortcutInfo, "hostAbility", hostAbility));
375 
376     // wrap icon
377     napi_value icon;
378     NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, shortcutInfo.icon.c_str(), NAPI_AUTO_LENGTH, &icon));
379     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objShortcutInfo, "icon", icon));
380 
381     // wrap iconId
382     napi_value iconId;
383     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, shortcutInfo.iconId, &iconId));
384     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objShortcutInfo, "iconId", iconId));
385 
386     // wrap label
387     napi_value label;
388     NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, shortcutInfo.label.c_str(), NAPI_AUTO_LENGTH, &label));
389     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objShortcutInfo, "label", label));
390 
391     // wrap labelId
392     napi_value labelId;
393     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, shortcutInfo.labelId, &labelId));
394     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objShortcutInfo, "labelId", labelId));
395 
396     // wrap disableMessage
397     napi_value disableMessage;
398     NAPI_CALL_RETURN_VOID(
399         env, napi_create_string_utf8(env, shortcutInfo.disableMessage.c_str(), NAPI_AUTO_LENGTH, &disableMessage));
400     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objShortcutInfo, "disableMessage", disableMessage));
401 
402     // wrap wants
403     napi_value intents;
404     NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &intents));
405     for (size_t index = 0; index < shortcutInfo.intents.size(); ++index) {
406         napi_value intent;
407         NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &intent));
408         ConvertShortcutIntent(env, intent, shortcutInfo.intents[index]);
409         NAPI_CALL_RETURN_VOID(env, napi_set_element(env, intents, index, intent));
410     }
411     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objShortcutInfo, "wants", intents));
412 
413     // wrap isStatic
414     napi_value isStatic;
415     NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, shortcutInfo.isStatic, &isStatic));
416     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objShortcutInfo, "isStatic", isStatic));
417 
418     // wrap isHomeShortcut
419     napi_value isHomeShortcut;
420     NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, shortcutInfo.isHomeShortcut, &isHomeShortcut));
421     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objShortcutInfo, "isHomeShortcut", isHomeShortcut));
422 
423     // wrap isEnabled
424     napi_value isEnabled;
425     NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, shortcutInfo.isEnables, &isEnabled));
426     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objShortcutInfo, "isEnabled", isEnabled));
427 }
428 
ParseShortcutInfo(napi_env env,napi_value result,const std::vector<OHOS::AppExecFwk::ShortcutInfo> & shortcutInfos)429 static void ParseShortcutInfo(napi_env env, napi_value result,
430                               const std::vector<OHOS::AppExecFwk::ShortcutInfo> &shortcutInfos)
431 {
432     if (shortcutInfos.empty()) {
433         APP_LOGE("launcher shortcut info is empty");
434         return;
435     }
436     size_t index = 0;
437     for (const auto& item : shortcutInfos) {
438         napi_value objShortcutInfo;
439         NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &objShortcutInfo));
440         ConvertShortcutInfo(env, objShortcutInfo, item);
441         NAPI_CALL_RETURN_VOID(env, napi_set_element(env, result, index, objShortcutInfo));
442         index++;
443     }
444     return;
445 }
446 
447 
InnerJSLauncherServiceOn(napi_env env,OHOS::sptr<BundleStatusCallback> callbackRef)448 static bool InnerJSLauncherServiceOn(napi_env env, OHOS::sptr<BundleStatusCallback> callbackRef)
449 {
450     if (callbackRef == nullptr) {
451         APP_LOGE("Input null BundleStatusCallback");
452     }
453     auto launcher = GetLauncherService();
454     if (launcher == nullptr) {
455         APP_LOGE("can not get launcher");
456         return false;
457     }
458 
459     auto result = launcher->RegisterCallback(callbackRef);
460     if (!result) {
461         APP_LOGE("RegisterBundleStatusCallback call error");
462         return false;
463     }
464     return true;
465 }
466 
JSLauncherServiceOn(napi_env env,napi_callback_info info)467 static napi_value JSLauncherServiceOn(napi_env env, napi_callback_info info)
468 {
469     size_t requireArgc = 2;
470     size_t argc = 3;
471     napi_value argv[3] = { 0 };
472     napi_value thisArg = nullptr;
473     void *data = nullptr;
474 
475     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
476     NAPI_ASSERT(env, argc >= requireArgc, "requires 2 parameter");
477     std::string command;
478 
479     AsyncHandleBundleContext *asyncCallbackInfo = new AsyncHandleBundleContext();
480     if (asyncCallbackInfo == nullptr) {
481         return nullptr;
482     }
483     asyncCallbackInfo->env = env;
484     for (size_t i = 0; i < argc; ++i) {
485         napi_valuetype valueType = napi_undefined;
486         napi_typeof(env, argv[i], &valueType);
487         if ((i == 0) && (valueType == napi_string)) {
488             ParseString(env, argv[i], command);
489         } else if ((i == INDEX_ONE) && (valueType == napi_object)) {
490             bool res = ParseBundleStatusCallback(env, asyncCallbackInfo->bundleStatusCallback, argv[i]);
491             if (!res) {
492                 asyncCallbackInfo->err = OPERATION_TYPE_MIAMATCH;
493                 asyncCallbackInfo->message = "type mismatch";
494             }
495         } else if ((i == INDEX_TWO) && (valueType == napi_function))  {
496             napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callbackRef);
497             break;
498         } else {
499             asyncCallbackInfo->err = OPERATION_TYPE_MIAMATCH;
500             asyncCallbackInfo->message = "type mismatch";
501         }
502     }
503 
504     napi_value promise = nullptr;
505     if (command != REGISTERCALLBACK) {
506         APP_LOGE("Input wrong command");
507         delete asyncCallbackInfo;
508         asyncCallbackInfo = nullptr;
509         return promise;
510     }
511 
512     if (asyncCallbackInfo->callbackRef == nullptr) {
513         napi_create_promise(env, &asyncCallbackInfo->deferred, &promise);
514     } else {
515         napi_get_undefined(env,  &promise);
516     }
517 
518     napi_value resource = nullptr;
519     napi_create_string_utf8(env, "JSLauncherServiceOn", NAPI_AUTO_LENGTH, &resource);
520 
521     napi_create_async_work(
522         env, nullptr, resource,
523         [](napi_env env, void* data) {
524         },
525         [](napi_env env, napi_status status, void* data) {
526             AsyncHandleBundleContext *asyncCallbackInfo = reinterpret_cast<AsyncHandleBundleContext *>(data);
527             if (!asyncCallbackInfo->err) {
528                 asyncCallbackInfo->ret = InnerJSLauncherServiceOn(env, asyncCallbackInfo->bundleStatusCallback);
529             }
530             napi_value result[2] = { 0 };
531             // wrap result
532             if (asyncCallbackInfo->err) {
533                 napi_create_uint32(env, asyncCallbackInfo->err, &result[0]);
534                 napi_create_string_utf8(env, asyncCallbackInfo->message.c_str(), NAPI_AUTO_LENGTH, &result[1]);
535             } else {
536                 if (asyncCallbackInfo->ret) {
537                     napi_create_uint32(env, OPERATION_SUCESS, &result[0]);
538                     napi_create_string_utf8(env, "register success", NAPI_AUTO_LENGTH, &result[1]);
539                 } else {
540                     napi_create_uint32(env, OPERATION_FAILED, &result[0]);
541                     napi_create_string_utf8(env, "register failed", NAPI_AUTO_LENGTH, &result[1]);
542                 }
543             }
544             // callback or promise return
545             if (asyncCallbackInfo->deferred) {
546                 if (asyncCallbackInfo->ret) {
547                     napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[1]);
548                 } else {
549                     napi_reject_deferred(env, asyncCallbackInfo->deferred, result[0]);
550                 }
551             } else {
552                 napi_value callback = nullptr;
553                 napi_value placeHolder = nullptr;
554                 napi_get_reference_value(env, asyncCallbackInfo->callbackRef, &callback);
555                 napi_call_function(env, nullptr, callback, sizeof(result) / sizeof(result[0]), result, &placeHolder);
556                 napi_delete_reference(env, asyncCallbackInfo->callbackRef);
557             }
558             napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
559             delete asyncCallbackInfo;
560             asyncCallbackInfo = nullptr;
561         },
562         reinterpret_cast<void*>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork);
563     napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
564 
565     return promise;
566 }
567 
InnerJSLauncherServiceOff()568 static bool InnerJSLauncherServiceOff()
569 {
570     auto launcher = GetLauncherService();
571     if (launcher == nullptr) {
572         APP_LOGE("can not get launcher");
573         return false;
574     }
575 
576     auto result = launcher->UnRegisterCallback();
577     if (!result) {
578         APP_LOGE("RegisterBundleStatusCallback call error");
579         return false;
580     }
581     return true;
582 }
583 
LauncherServiceOffComplete(napi_env env,napi_status status,void * data)584 static void LauncherServiceOffComplete(napi_env env, napi_status status, void* data)
585 {
586     AsyncHandleBundleContext *asyncCallbackInfo = reinterpret_cast<AsyncHandleBundleContext*>(data);
587     if (!asyncCallbackInfo->err) {
588         asyncCallbackInfo->ret = InnerJSLauncherServiceOff();
589     }
590     napi_value result[INDEX_TWO] = { 0 };
591     if (asyncCallbackInfo->ret) {
592         napi_create_uint32(env, 0, &result[0]);
593         napi_create_string_utf8(env, "unregister success", NAPI_AUTO_LENGTH, &result[INDEX_ONE]);
594     } else {
595         napi_create_uint32(env, INDEX_ONE, &result[0]);
596         napi_create_string_utf8(env, "unregister failed", NAPI_AUTO_LENGTH, &result[INDEX_ONE]);
597     }
598     if (asyncCallbackInfo->deferred) {
599         if (asyncCallbackInfo->ret) {
600             napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[INDEX_ONE]);
601         } else {
602             napi_reject_deferred(env, asyncCallbackInfo->deferred, result[0]);
603         }
604     } else {
605         napi_value callback = nullptr;
606         napi_value placeHolder = nullptr;
607         napi_get_reference_value(env, asyncCallbackInfo->callbackRef, &callback);
608         napi_call_function(env, nullptr, callback, sizeof(result) / sizeof(result[0]), result, &placeHolder);
609         napi_delete_reference(env, asyncCallbackInfo->callbackRef);
610     }
611     napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
612     delete asyncCallbackInfo;
613     asyncCallbackInfo = nullptr;
614 }
615 
JSLauncherServiceOff(napi_env env,napi_callback_info info)616 static napi_value JSLauncherServiceOff(napi_env env, napi_callback_info info)
617 {
618     size_t requireArgc = INDEX_ONE;
619     size_t argc = INDEX_TWO;
620     napi_value argv[INDEX_TWO] = { 0 };
621     napi_value thisArg = nullptr;
622     void *data = nullptr;
623 
624     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
625     NAPI_ASSERT(env, argc >= requireArgc, "requires 1 parameter");
626     std::string command;
627     AsyncHandleBundleContext *asyncCallbackInfo = new AsyncHandleBundleContext();
628     if (asyncCallbackInfo == nullptr) {
629         return nullptr;
630     }
631     asyncCallbackInfo->env = env;
632     for (size_t i = 0; i < argc; ++i) {
633         napi_valuetype valueType = napi_undefined;
634         napi_typeof(env, argv[i], &valueType);
635         if ((i == 0) && (valueType == napi_string)) {
636             ParseString(env, argv[i], command);
637         } else if ((i == INDEX_ONE) && (valueType == napi_function))  {
638             napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callbackRef);
639         } else {
640             asyncCallbackInfo->err = OPERATION_TYPE_MIAMATCH;
641             asyncCallbackInfo->message = "type mismatch";
642         }
643     }
644     napi_value promise = nullptr;
645     if (command != UNREGISTERCALLBACK) {
646         APP_LOGE("Input wrong command");
647         delete asyncCallbackInfo;
648         asyncCallbackInfo = nullptr;
649         return promise;
650     }
651     if (asyncCallbackInfo->callbackRef == nullptr) {
652         napi_create_promise(env, &asyncCallbackInfo->deferred, &promise);
653     } else {
654         napi_get_undefined(env,  &promise);
655     }
656     napi_value resource = nullptr;
657     napi_create_string_utf8(env, "JSLauncherServiceOn", NAPI_AUTO_LENGTH, &resource);
658     napi_create_async_work(
659         env, nullptr, resource, [](napi_env env, void* data) {}, LauncherServiceOffComplete,
660         reinterpret_cast<void*>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork);
661     napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
662     return promise;
663 }
664 
InnerJSGetAllLauncherAbilityInfos(uint32_t userId,std::vector<OHOS::AppExecFwk::LauncherAbilityInfo> & launcherAbilityInfos)665 static bool InnerJSGetAllLauncherAbilityInfos(uint32_t userId,
666     std::vector<OHOS::AppExecFwk::LauncherAbilityInfo> &launcherAbilityInfos)
667 {
668     auto launcher = GetLauncherService();
669     if (launcher == nullptr) {
670         APP_LOGE("can not get launcher");
671         return false;
672     }
673 
674     auto result = launcher->GetAllLauncherAbilityInfos(userId, launcherAbilityInfos);
675     if (!result) {
676         APP_LOGE("GetAllLauncherAbilityInfos call error");
677         return false;
678     }
679     return true;
680 }
681 
JsGetAllLauncherAbilityInfoExec(napi_env env,void * data)682 void JsGetAllLauncherAbilityInfoExec(napi_env env, void *data)
683 {
684     JsGetAllLauncherAbilityCallbackInfo *asyncCallbackInfo =
685         reinterpret_cast<JsGetAllLauncherAbilityCallbackInfo *>(data);
686     if (asyncCallbackInfo == nullptr) {
687         APP_LOGE("asyncCallbackInfo is null");
688         return;
689     }
690     if (asyncCallbackInfo->err == OPERATION_TYPE_MIAMATCH) {
691         return;
692     }
693     if (InnerJSGetAllLauncherAbilityInfos(asyncCallbackInfo->userId,
694         asyncCallbackInfo->launcherAbilityInfos)) {
695         asyncCallbackInfo->err = OPERATION_SUCESS;
696     } else {
697         asyncCallbackInfo->err = OPERATION_FAILED;
698     }
699 }
700 
JsGetAllLauncherAbilityInfoComplete(napi_env env,napi_status status,void * data)701 void JsGetAllLauncherAbilityInfoComplete(napi_env env, napi_status status, void *data)
702 {
703     JsGetAllLauncherAbilityCallbackInfo *asyncCallbackInfo =
704         reinterpret_cast<JsGetAllLauncherAbilityCallbackInfo *>(data);
705     if (asyncCallbackInfo == nullptr) {
706         APP_LOGE("asyncCallbackInfo is null in %{public}s", __func__);
707         return;
708     }
709     std::unique_ptr<JsGetAllLauncherAbilityCallbackInfo> callbackPtr {asyncCallbackInfo};
710     napi_value result[ARGS_SIZE_TWO] = {0};
711     if (asyncCallbackInfo->err == OPERATION_SUCESS) {
712         NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &result[ARGS_POS_ZERO]));
713         NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &result[ARGS_POS_ONE]));
714         ParseLauncherAbilityInfo(env, result[ARGS_POS_ONE], asyncCallbackInfo->launcherAbilityInfos);
715     } else {
716         napi_create_int32(env, asyncCallbackInfo->err, &result[0]);
717         napi_get_undefined(env, &result[ARGS_POS_ONE]);
718     }
719     if (asyncCallbackInfo->deferred) {
720         if (asyncCallbackInfo->err == OPERATION_SUCESS) {
721             NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[1]));
722         } else {
723             NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[0]));
724         }
725     } else {
726         napi_value callback = nullptr;
727         napi_value placeHolder = nullptr;
728         NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
729         NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback,
730             sizeof(result) / sizeof(result[0]), result, &placeHolder));
731     }
732 }
733 
JSGetAllLauncherAbilityInfos(napi_env env,napi_callback_info info)734 napi_value JSGetAllLauncherAbilityInfos(napi_env env, napi_callback_info info)
735 {
736     APP_LOGD("napi begin to JSGetAllLauncherAbilityInfos");
737     NapiArg args(env, info);
738     JsGetAllLauncherAbilityCallbackInfo *asyncCallbackInfo =
739         new (std::nothrow) JsGetAllLauncherAbilityCallbackInfo(env);
740     if (asyncCallbackInfo == nullptr) {
741         APP_LOGE("asyncCallbackInfo is null");
742         return nullptr;
743     }
744     std::unique_ptr<JsGetAllLauncherAbilityCallbackInfo> callbackPtr{asyncCallbackInfo};
745     if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_TWO)) {
746         asyncCallbackInfo->err = OPERATION_TYPE_MIAMATCH;
747         asyncCallbackInfo->message = TYPE_MISMATCH;
748     }
749 
750     if (args.GetMaxArgc() >= ARGS_SIZE_ONE) {
751         if (!CommonFunc::ParseInt(env, args[ARGS_POS_ZERO], callbackPtr->userId)) {
752             asyncCallbackInfo->err = OPERATION_TYPE_MIAMATCH;
753             asyncCallbackInfo->message = TYPE_MISMATCH;
754         }
755         if (args.GetMaxArgc() == ARGS_SIZE_TWO) {
756             napi_valuetype valueType = napi_undefined;
757             napi_typeof(env, args[ARGS_POS_ONE], &valueType);
758             if (valueType == napi_function) {
759                 NAPI_CALL(env, napi_create_reference(env, args[ARGS_POS_ONE],
760                     NAPI_RETURN_ONE, &callbackPtr->callback));
761             }
762         }
763     } else {
764         asyncCallbackInfo->err = OPERATION_TYPE_MIAMATCH;
765         asyncCallbackInfo->message = TYPE_MISMATCH;
766     }
767     auto promise = CommonFunc::AsyncCallNativeMethod<JsGetAllLauncherAbilityCallbackInfo>(
768         env, asyncCallbackInfo, "GetLauncherAbilityInfo",
769         JsGetAllLauncherAbilityInfoExec, JsGetAllLauncherAbilityInfoComplete);
770     callbackPtr.release();
771     APP_LOGD("call GetAllLauncherAbilityInfo done");
772     return promise;
773 }
774 
InnerJSGetLauncherAbilityInfos(napi_env env,std::string & bundleName,uint32_t userId,std::vector<OHOS::AppExecFwk::LauncherAbilityInfo> & launcherAbilityInfos)775 static bool InnerJSGetLauncherAbilityInfos(napi_env env, std::string& bundleName,
776     uint32_t userId, std::vector<OHOS::AppExecFwk::LauncherAbilityInfo>& launcherAbilityInfos)
777 {
778     auto launcher = GetLauncherService();
779     if (launcher == nullptr) {
780         APP_LOGE("can not get launcher");
781         return false;
782     }
783 
784     auto result = launcher->GetAbilityList(bundleName, userId, launcherAbilityInfos);
785     if (!result) {
786         APP_LOGE("GetAbilityList call error, bundlename is %{public}s, userId is %{public}d",
787             bundleName.c_str(), userId);
788         return false;
789     }
790     return true;
791 }
792 
JSGetLauncherAbilityInfos(napi_env env,napi_callback_info info)793 static napi_value JSGetLauncherAbilityInfos(napi_env env, napi_callback_info info)
794 {
795     size_t argc = INDEX_THREE;
796     napi_value argv[INDEX_THREE] = { 0 };
797     size_t requireArgc = INDEX_TWO;
798     napi_value thisArg = nullptr;
799     void *data = nullptr;
800     std::string bundleName;
801 
802     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
803     NAPI_ASSERT(env, argc >= requireArgc, "requires 2 parameter");
804     AsyncHandleBundleContext *asyncCallbackInfo = new AsyncHandleBundleContext();
805     asyncCallbackInfo->env = env;
806 
807     for (size_t i = 0; i < argc; ++i) {
808         napi_valuetype valueType = napi_undefined;
809         napi_typeof(env, argv[i], &valueType);
810         if ((i == 0) && (valueType == napi_string)) {
811             ParseString(env, argv[i], asyncCallbackInfo->bundleName);
812         } else if ((i == INDEX_ONE) && (valueType == napi_number)) {
813             napi_get_value_int32(env, argv[i], &asyncCallbackInfo->userId);
814         } else if ((i == INDEX_TWO) && (valueType == napi_function)) {
815             napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callbackRef);
816             break;
817         } else {
818             asyncCallbackInfo->err = OPERATION_TYPE_MIAMATCH;
819             asyncCallbackInfo->message = "type mismatch";
820         }
821     }
822 
823     napi_value promise = nullptr;
824     if (asyncCallbackInfo->callbackRef == nullptr) {
825         napi_create_promise(env, &asyncCallbackInfo->deferred, &promise);
826     } else {
827         napi_get_undefined(env,  &promise);
828     }
829 
830     napi_value resource = nullptr;
831     napi_create_string_utf8(env, "JSGetLauncherAbilityInfos", NAPI_AUTO_LENGTH, &resource);
832     napi_create_async_work(
833         env, nullptr, resource,
834         [](napi_env env, void* data) {
835             AsyncHandleBundleContext* asyncCallbackInfo = reinterpret_cast<AsyncHandleBundleContext*>(data);
836             if (!asyncCallbackInfo->err) {
837               asyncCallbackInfo->ret = InnerJSGetLauncherAbilityInfos(asyncCallbackInfo->env,
838                                                                       asyncCallbackInfo->bundleName,
839                                                                       asyncCallbackInfo->userId,
840                                                                       asyncCallbackInfo->launcherAbilityInfos);
841             }
842         },
843         [](napi_env env, napi_status status, void* data) {
844             AsyncHandleBundleContext* asyncCallbackInfo = reinterpret_cast<AsyncHandleBundleContext*>(data);
845             napi_value result[INDEX_TWO] = { 0 };
846             // wrap result
847             if (asyncCallbackInfo->err) {
848                 napi_create_int32(env, asyncCallbackInfo->err, &result[0]);
849                 napi_get_undefined(env, &result[INDEX_ONE]);
850             } else {
851                 if (asyncCallbackInfo->ret) {
852                   napi_create_uint32(env, OPERATION_SUCESS, &result[0]);
853                   napi_create_array(env, &result[INDEX_ONE]);
854                   ParseLauncherAbilityInfo(env, result[INDEX_ONE], asyncCallbackInfo->launcherAbilityInfos);
855                 } else {
856                   napi_create_uint32(env, OPERATION_FAILED, &result[0]);
857                   napi_get_undefined(env, &result[INDEX_ONE]);
858                 }
859             }
860             // return callback or promise
861             if (asyncCallbackInfo->deferred) {
862               if (asyncCallbackInfo->ret) {
863                   napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[INDEX_ONE]);
864               } else {
865                   napi_reject_deferred(env, asyncCallbackInfo->deferred, result[0]);
866               }
867             } else {
868                 napi_value callback = nullptr;
869                 napi_value callResult = 0;
870                 napi_value undefined = 0;
871                 napi_get_reference_value(env, asyncCallbackInfo->callbackRef, &callback);
872                 napi_call_function(env, undefined, callback, sizeof(result) / sizeof(result[0]), result, &callResult);
873                 napi_delete_reference(env, asyncCallbackInfo->callbackRef);
874             }
875             napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
876             delete asyncCallbackInfo;
877             asyncCallbackInfo = nullptr;
878         },
879         reinterpret_cast<void*>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork);
880     napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated);
881     return promise;
882 }
883 
InnerJSGetShortcutInfos(napi_env env,const std::string & bundleName,std::vector<OHOS::AppExecFwk::ShortcutInfo> & shortcutInfos)884 static bool InnerJSGetShortcutInfos(napi_env env, const std::string& bundleName,
885     std::vector<OHOS::AppExecFwk::ShortcutInfo>& shortcutInfos)
886 {
887     auto launcher = GetLauncherService();
888     if (launcher == nullptr) {
889         APP_LOGE("can not get launcher");
890         return false;
891     }
892     auto result = launcher->GetShortcutInfos(bundleName, shortcutInfos);
893     if (!result) {
894         APP_LOGE("GetShortcutInfos call error");
895         return false;
896     }
897     return true;
898 }
899 
JSGetShortcutInfos(napi_env env,napi_callback_info info)900 static napi_value JSGetShortcutInfos(napi_env env, napi_callback_info info)
901 {
902     size_t argc = INDEX_TWO;
903     napi_value argv[INDEX_TWO] = { 0 };
904     size_t requireArgc = INDEX_ONE;
905     napi_value thisArg = nullptr;
906     void *data = nullptr;
907 
908     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
909     NAPI_ASSERT(env, argc >= requireArgc, "requires 1 parameter");
910     AsyncHandleBundleContext *asyncCallbackInfo = new AsyncHandleBundleContext();
911     asyncCallbackInfo->env = env;
912 
913     for (size_t i = 0; i < argc; ++i) {
914         napi_valuetype valueType = napi_undefined;
915         napi_typeof(env, argv[i], &valueType);
916         if ((i == 0) && (valueType == napi_string)) {
917             ParseString(env, argv[i], asyncCallbackInfo->bundleName);
918         } else if ((i == INDEX_ONE) && (valueType == napi_function)) {
919             napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callbackRef);
920             break;
921         } else {
922             asyncCallbackInfo->err = OPERATION_TYPE_MIAMATCH;
923             asyncCallbackInfo->message = "type mismatch";
924         }
925     }
926     napi_value promise = nullptr;
927     if (asyncCallbackInfo->callbackRef == nullptr) {
928         napi_create_promise(env, &asyncCallbackInfo->deferred, &promise);
929     } else {
930         napi_get_undefined(env,  &promise);
931     }
932     napi_value resource = nullptr;
933     napi_create_string_utf8(env, "JSGetShortcutInfos", NAPI_AUTO_LENGTH, &resource);
934 
935     napi_create_async_work(
936         env, nullptr, resource,
937         [](napi_env env, void* data) {
938             AsyncHandleBundleContext *asyncCallbackInfo = reinterpret_cast<AsyncHandleBundleContext*>(data);
939             if (!asyncCallbackInfo->err) {
940                 asyncCallbackInfo->ret = InnerJSGetShortcutInfos(asyncCallbackInfo->env,
941                                                                  asyncCallbackInfo->bundleName,
942                                                                  asyncCallbackInfo->shortcutInfos);
943             }
944         },
945         [](napi_env env, napi_status status, void* data) {
946             AsyncHandleBundleContext *asyncCallbackInfo = reinterpret_cast<AsyncHandleBundleContext*>(data);
947             napi_value result[INDEX_TWO] = { 0 };
948             // wrap result
949             if (asyncCallbackInfo->err) {
950                 napi_create_int32(env, asyncCallbackInfo->err, &result[0]);
951                 napi_get_undefined(env, &result[INDEX_ONE]);
952             } else {
953                 if (asyncCallbackInfo->ret) {
954                     napi_create_uint32(env, OPERATION_SUCESS, &result[0]);
955                     napi_create_array(env, &result[INDEX_ONE]);
956                     ParseShortcutInfo(env, result[INDEX_ONE], asyncCallbackInfo->shortcutInfos);
957                 } else {
958                     napi_create_uint32(env, OPERATION_FAILED, &result[0]);
959                     napi_get_undefined(env, &result[INDEX_ONE]);
960                 }
961             }
962             // return callback or promise
963             if (asyncCallbackInfo->deferred) {
964                 if (asyncCallbackInfo->ret) {
965                     napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[1]);
966                 } else {
967                     napi_reject_deferred(env, asyncCallbackInfo->deferred, result[0]);
968                 }
969             } else {
970                 napi_value callback = nullptr;
971                 napi_value callResult = 0;
972                 napi_value undefined = 0;
973                 napi_get_reference_value(env, asyncCallbackInfo->callbackRef, &callback);
974                 napi_call_function(env, undefined, callback, sizeof(result) / sizeof(result[0]), result, &callResult);
975                 napi_delete_reference(env, asyncCallbackInfo->callbackRef);
976             }
977             napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
978             delete asyncCallbackInfo;
979             asyncCallbackInfo = nullptr;
980         },
981         reinterpret_cast<void*>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork);
982     napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated);
983 
984     return promise;
985 }
986 
LauncherServiceExport(napi_env env,napi_value exports)987 static napi_value LauncherServiceExport(napi_env env, napi_value exports)
988 {
989     static napi_property_descriptor launcherDesc[] = {
990         DECLARE_NAPI_FUNCTION("on", JSLauncherServiceOn),
991         DECLARE_NAPI_FUNCTION("off", JSLauncherServiceOff),
992         DECLARE_NAPI_FUNCTION("getAllLauncherAbilityInfos", JSGetAllLauncherAbilityInfos),
993         DECLARE_NAPI_FUNCTION("getLauncherAbilityInfos", JSGetLauncherAbilityInfos),
994         DECLARE_NAPI_FUNCTION("getShortcutInfos", JSGetShortcutInfos),
995     };
996 
997     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(launcherDesc) / sizeof(launcherDesc[0]), launcherDesc));
998     return exports;
999 }
1000 
1001 static napi_module launcherServiceModule = {
1002     .nm_version = 1,
1003     .nm_flags = 0,
1004     .nm_filename = nullptr,
1005     .nm_register_func = LauncherServiceExport,
1006     .nm_modname = "bundle.innerBundleManager",
1007     .nm_priv = ((void*)0),
1008     .reserved = { 0 },
1009 };
1010 
LauncherServiceRegister()1011 extern "C" __attribute__((constructor)) void LauncherServiceRegister()
1012 {
1013     napi_module_register(&launcherServiceModule);
1014 }
1015 
1016