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 #ifndef BUNDLE_MGR_H
17 #define BUNDLE_MGR_H
18 #include <vector>
19 
20 #include "napi/native_api.h"
21 #include "napi/native_common.h"
22 #include "napi/native_node_api.h"
23 
24 #include "application_info.h"
25 #include "bundle_death_recipient.h"
26 #include "bundle_mgr_interface.h"
27 #include "cleancache_callback.h"
28 #include "js_runtime_utils.h"
29 #ifdef BUNDLE_FRAMEWORK_GRAPHICS
30 #include "pixel_map.h"
31 #endif
32 #include "want.h"
33 
34 namespace OHOS {
35 namespace AppExecFwk {
36 struct AsyncWorkData {
37     explicit AsyncWorkData(napi_env napiEnv);
38     virtual ~AsyncWorkData();
39     napi_env env;
40     napi_async_work asyncWork = nullptr;
41     napi_deferred deferred = nullptr;
42     napi_ref callback = nullptr;
43 };
44 
45 struct BaseCallbackInfo: public AsyncWorkData {
BaseCallbackInfoBaseCallbackInfo46     explicit BaseCallbackInfo(napi_env napiEnv) : AsyncWorkData(napiEnv) {}
47     int32_t err = 0;
48     std::string message;
49 };
50 
51 struct QueryParameter {
52     int flags;
53     std::string userId;
54 };
55 
56 struct BundleOptions {
57     int32_t userId = Constants::UNSPECIFIED_USERID;
58 };
59 
60 struct AbilityEnableCallbackInfo : public BaseCallbackInfo {
AbilityEnableCallbackInfoAbilityEnableCallbackInfo61     explicit AbilityEnableCallbackInfo(napi_env napiEnv) : BaseCallbackInfo(napiEnv) {}
62     AbilityInfo abilityInfo;
63     bool isEnable = false;
64 };
65 
66 struct ApplicationEnableCallbackInfo : public BaseCallbackInfo {
ApplicationEnableCallbackInfoApplicationEnableCallbackInfo67     explicit ApplicationEnableCallbackInfo(napi_env napiEnv) : BaseCallbackInfo(napiEnv) {}
68     std::string bundleName;
69     bool isEnable = false;
70 };
71 
72 struct LaunchWantCallbackInfo : public BaseCallbackInfo {
LaunchWantCallbackInfoLaunchWantCallbackInfo73     explicit LaunchWantCallbackInfo(napi_env napiEnv) : BaseCallbackInfo(napiEnv) {}
74     std::string bundleName;
75     int32_t userId = Constants::UNSPECIFIED_USERID;
76     OHOS::AAFwk::Want want;
77     ErrCode ret = ERR_OK;
78 };
79 
80 struct GetBundleArchiveInfoCallbackInfo : public BaseCallbackInfo {
GetBundleArchiveInfoCallbackInfoGetBundleArchiveInfoCallbackInfo81     explicit GetBundleArchiveInfoCallbackInfo(napi_env napiEnv) : BaseCallbackInfo(napiEnv) {}
82     std::string hapFilePath;
83     int32_t flags = 0;
84     BundleInfo bundleInfo;
85     bool ret = false;
86 };
87 
88 struct AbilityIconCallbackInfo : public BaseCallbackInfo {
AbilityIconCallbackInfoAbilityIconCallbackInfo89     explicit AbilityIconCallbackInfo(napi_env napiEnv) : BaseCallbackInfo(napiEnv) {}
90     std::string bundleName;
91     std::string moduleName;
92     std::string abilityName;
93     bool hasModuleName = false;
94     ErrCode ret = ERR_OK;
95 #ifdef BUNDLE_FRAMEWORK_GRAPHICS
96     std::shared_ptr<Media::PixelMap> pixelMap = nullptr;
97 #endif
98 };
99 
100 struct AsyncAbilityInfoCallbackInfo : public AsyncWorkData {
AsyncAbilityInfoCallbackInfoAsyncAbilityInfoCallbackInfo101     explicit AsyncAbilityInfoCallbackInfo(napi_env env) : AsyncWorkData(env) {}
102     OHOS::AAFwk::Want want;
103     int32_t flags = 0;
104     int32_t userId = Constants::UNSPECIFIED_USERID;
105     std::vector<OHOS::AppExecFwk::AbilityInfo> abilityInfos;
106     bool ret = false;
107     int32_t err = 0;
108 };
109 
110 struct AsyncAbilityInfosCallbackInfo : public AsyncWorkData {
AsyncAbilityInfosCallbackInfoAsyncAbilityInfosCallbackInfo111     explicit AsyncAbilityInfosCallbackInfo(napi_env env) : AsyncWorkData(env) {}
112     int32_t flags = 0;
113     std::string bundleName;
114     std::string abilityName;
115     std::string moduleName = "";
116     bool hasModuleName = false;
117     OHOS::AppExecFwk::AbilityInfo abilityInfo;
118     bool ret = false;
119     int32_t err = 0;
120     std::string message;
121 };
122 
123 struct AsyncBundleInfoCallbackInfo : public AsyncWorkData {
AsyncBundleInfoCallbackInfoAsyncBundleInfoCallbackInfo124     explicit AsyncBundleInfoCallbackInfo(napi_env env) : AsyncWorkData(env) {}
125     std::string param;
126     int32_t flags = 0;
127     OHOS::AppExecFwk::BundleInfo bundleInfo;
128     bool ret = false;
129     int32_t err = 0;
130     std::string message;
131     BundleOptions bundleOptions;
132 };
133 
134 struct AsyncApplicationInfoCallbackInfo : public AsyncWorkData {
AsyncApplicationInfoCallbackInfoAsyncApplicationInfoCallbackInfo135     explicit AsyncApplicationInfoCallbackInfo(napi_env env) : AsyncWorkData(env) {}
136     std::string bundleName;
137     int32_t flags = 0;
138     int32_t userId = Constants::UNSPECIFIED_USERID;
139     OHOS::AppExecFwk::ApplicationInfo appInfo;
140     bool ret = false;
141     int32_t err = 0;
142     std::string message;
143 };
144 
145 struct AsyncPermissionDefCallbackInfo : public AsyncWorkData {
AsyncPermissionDefCallbackInfoAsyncPermissionDefCallbackInfo146     explicit AsyncPermissionDefCallbackInfo(napi_env env) : AsyncWorkData(env) {}
147     std::string permissionName;
148     OHOS::AppExecFwk::PermissionDef permissionDef;
149     bool ret = false;
150     int32_t err = 0;
151     std::string message;
152 };
153 
154 struct AsyncBundleInfosCallbackInfo : public AsyncWorkData {
AsyncBundleInfosCallbackInfoAsyncBundleInfosCallbackInfo155     explicit AsyncBundleInfosCallbackInfo(napi_env env) : AsyncWorkData(env) {}
156     int32_t flags = 0;
157     std::vector<OHOS::AppExecFwk::BundleInfo> bundleInfos;
158     bool ret = false;
159     int32_t err = 0;
160     std::string message;
161     int32_t userId = Constants::UNSPECIFIED_USERID;
162 };
163 
164 struct AsyncApplicationInfosCallbackInfo : public AsyncWorkData {
AsyncApplicationInfosCallbackInfoAsyncApplicationInfosCallbackInfo165     explicit AsyncApplicationInfosCallbackInfo(napi_env env) : AsyncWorkData(env) {}
166     int32_t flags = 0;
167     int32_t userId = Constants::UNSPECIFIED_USERID;
168     std::vector<OHOS::AppExecFwk::ApplicationInfo> appInfos;
169     bool ret = false;
170     int32_t err = 0;
171     std::string message;
172 };
173 
174 struct AsyncAbilityLabelCallbackInfo : public AsyncWorkData {
AsyncAbilityLabelCallbackInfoAsyncAbilityLabelCallbackInfo175     explicit AsyncAbilityLabelCallbackInfo(napi_env env) : AsyncWorkData(env) {}
176     std::string bundleName;
177     std::string className;
178     std::string moduleName = "";
179     bool hasModuleName = false;
180     std::string abilityLabel;
181     int32_t err = 0;
182     std::string message;
183 };
184 
185 struct InstallResult {
186     std::string resultMsg;
187     int32_t resultCode = 0;
188 };
189 
190 struct AsyncInstallCallbackInfo : public AsyncWorkData {
AsyncInstallCallbackInfoAsyncInstallCallbackInfo191     explicit AsyncInstallCallbackInfo(napi_env env) : AsyncWorkData(env) {}
192     std::vector<std::string> hapFiles;
193     std::string bundleName;
194     std::string param;
195     OHOS::AppExecFwk::InstallParam installParam;
196     InstallResult installResult;
197     int32_t errCode = 0;
198 };
199 
200 struct AsyncGetBundleInstallerCallbackInfo : public AsyncWorkData {
AsyncGetBundleInstallerCallbackInfoAsyncGetBundleInstallerCallbackInfo201     explicit AsyncGetBundleInstallerCallbackInfo(napi_env env) : AsyncWorkData(env) {}
202 };
203 
204 struct AsyncFormInfosCallbackInfo : public AsyncWorkData {
AsyncFormInfosCallbackInfoAsyncFormInfosCallbackInfo205     explicit AsyncFormInfosCallbackInfo(napi_env env) : AsyncWorkData(env) {}
206     std::vector<OHOS::AppExecFwk::FormInfo> formInfos;
207     bool ret = false;
208 };
209 
210 struct AsyncFormInfosByModuleCallbackInfo : public AsyncWorkData {
AsyncFormInfosByModuleCallbackInfoAsyncFormInfosByModuleCallbackInfo211     explicit AsyncFormInfosByModuleCallbackInfo(napi_env env) : AsyncWorkData(env) {}
212     std::string bundleName;
213     std::string moduleName;
214     std::vector<OHOS::AppExecFwk::FormInfo> formInfos;
215     bool ret = false;
216 };
217 
218 struct AsyncFormInfosByAppCallbackInfo : public AsyncWorkData {
AsyncFormInfosByAppCallbackInfoAsyncFormInfosByAppCallbackInfo219     explicit AsyncFormInfosByAppCallbackInfo(napi_env env) : AsyncWorkData(env) {}
220     std::string bundleName;
221     std::vector<OHOS::AppExecFwk::FormInfo> formInfos;
222     bool ret = false;
223 };
224 
225 struct AsyncLaunchWantForBundleCallbackInfo : public AsyncWorkData {
AsyncLaunchWantForBundleCallbackInfoAsyncLaunchWantForBundleCallbackInfo226     explicit AsyncLaunchWantForBundleCallbackInfo(napi_env env) : AsyncWorkData(env) {}
227     std::string bundleName;
228     OHOS::AAFwk::Want want;
229     bool ret = false;
230     int32_t err = 0;
231 };
232 
233 struct AsyncGetBundleGidsCallbackInfo : public AsyncWorkData {
AsyncGetBundleGidsCallbackInfoAsyncGetBundleGidsCallbackInfo234     explicit AsyncGetBundleGidsCallbackInfo(napi_env env) : AsyncWorkData(env) {}
235     std::string bundleName;
236     std::vector<int32_t> gids;
237     int32_t err = 0;
238     bool ret = false;
239     std::string message;
240 };
241 
242 struct AsyncGetNameByUidInfo : public AsyncWorkData {
AsyncGetNameByUidInfoAsyncGetNameByUidInfo243     explicit AsyncGetNameByUidInfo(napi_env env) : AsyncWorkData(env) {}
244     int32_t uid = 0;
245     std::string bundleName;
246     int32_t err = 0;
247     bool ret = false;
248 };
249 
250 struct AsyncHandleBundleContext : public AsyncWorkData {
AsyncHandleBundleContextAsyncHandleBundleContext251     explicit AsyncHandleBundleContext(napi_env env) : AsyncWorkData(env) {}
252     OHOS::sptr<CleanCacheCallback> cleanCacheCallback;
253     std::string bundleName;
254     std::string className;
255     uint32_t labelId = 0;
256     uint32_t iconId = 0;
257     bool ret = false;
258     int32_t err = 0;
259 };
260 
261 struct EnabledInfo : public AsyncWorkData {
EnabledInfoEnabledInfo262     explicit EnabledInfo(napi_env env) : AsyncWorkData(env) {}
263     std::string bundleName;
264     OHOS::AppExecFwk::AbilityInfo abilityInfo;
265     bool isEnable = false;
266     bool result = false;
267     int32_t errCode = 0;
268     std::string errMssage;
269 };
270 
271 struct AsyncAbilityInfo : public AsyncWorkData {
AsyncAbilityInfoAsyncAbilityInfo272     explicit AsyncAbilityInfo(napi_env env) : AsyncWorkData(env) {}
273     std::string bundleName;
274     std::string abilityName;
275     std::string moduleName = "";
276     bool hasModuleName = false;
277 #ifdef BUNDLE_FRAMEWORK_GRAPHICS
278     std::shared_ptr<Media::PixelMap> pixelMap;
279 #endif
280     int32_t errCode = 0;
281     bool result = false;
282     std::string errMssage;
283 };
284 
285 struct Query {
286     std::string bundleName_;
287     std::string interfaceType_;
288     int32_t flags_ = 0;
289     int32_t userId_ = Constants::UNSPECIFIED_USERID;
290     napi_env env_;
QueryQuery291     Query(const std::string &bundleName, const std::string &interfaceType, int32_t flags, int32_t userId, napi_env env)
292         : bundleName_(bundleName), interfaceType_(interfaceType), flags_(flags), userId_(userId), env_(env) {}
293 
294     bool operator==(const Query &query) const
295     {
296         return bundleName_ == query.bundleName_ && interfaceType_ == query.interfaceType_ &&
297             flags_ == query.flags_ && userId_ == query.userId_ && env_ == query.env_;
298     }
299 };
300 
301 struct QueryHash  {
operatorQueryHash302     size_t operator()(const Query &query) const
303     {
304         return std::hash<std::string>()(query.bundleName_) ^ std::hash<std::string>()(query.interfaceType_) ^
305             std::hash<int32_t>()(query.flags_) ^ std::hash<int32_t>()(query.userId_);
306     }
307 };
308 
309 class BundleMgrDeathRecipient : public IRemoteObject::DeathRecipient {
310     virtual void OnRemoteDied([[maybe_unused]] const wptr<IRemoteObject>& remote) override;
311 };
312 
313 extern thread_local napi_ref g_classBundleInstaller;
314 
315 napi_value WrapVoidToJS(napi_env env);
316 napi_value GetApplicationInfos(napi_env env, napi_callback_info info);
317 napi_value QueryAbilityInfos(napi_env env, napi_callback_info info);
318 napi_value GetBundleInfos(napi_env env, napi_callback_info info);
319 napi_value GetPermissionDef(napi_env env, napi_callback_info info);
320 napi_value GetBundleInfo(napi_env env, napi_callback_info info);
321 napi_value GetNameForUid(napi_env env, napi_callback_info info);
322 napi_value GetPermissionDef(napi_env env, napi_callback_info info);
323 napi_value GetAllFormsInfo(napi_env env, napi_callback_info info);
324 napi_value GetFormsInfoByApp(napi_env env, napi_callback_info info);
325 napi_value GetFormsInfoByModule(napi_env env, napi_callback_info info);
326 napi_value GetShortcutInfos(napi_env env, napi_callback_info info);
327 napi_value UnregisterPermissionsChanged(napi_env env, napi_callback_info info);
328 napi_value ClearBundleCache(napi_env env, napi_callback_info info);
329 napi_value GetBundleArchiveInfo(napi_env env, napi_callback_info info);
330 napi_value GetAbilityIcon(napi_env env, napi_callback_info info);
331 napi_value GetLaunchWantForBundle(napi_env env, napi_callback_info info);
332 napi_value IsApplicationEnabled(napi_env env, napi_callback_info info);
333 napi_value IsAbilityEnabled(napi_env env, napi_callback_info info);
334 napi_value SetAbilityEnabled(napi_env env, napi_callback_info info);
335 napi_value SetApplicationEnabled(napi_env env, napi_callback_info info);
336 napi_value GetBundleGids(napi_env env, napi_callback_info info);
337 napi_value GetAbilityInfo(napi_env env, napi_callback_info info);
338 napi_value GetAbilityLabel(napi_env env, napi_callback_info info);
339 napi_value GetBundleInstaller(napi_env env, napi_callback_info info);
340 napi_value Install(napi_env env, napi_callback_info info);
341 napi_value Recover(napi_env env, napi_callback_info info);
342 napi_value Uninstall(napi_env env, napi_callback_info info);
343 napi_value BundleInstallerConstructor(napi_env env, napi_callback_info info);
344 bool UnwrapAbilityInfo(napi_env env, napi_value param, OHOS::AppExecFwk::AbilityInfo& abilityInfo);
345 void CreateInstallErrorCodeObject(napi_env env, napi_value value);
346 
347 napi_value CreateAbilityTypeObject(napi_env env);
348 napi_value CreateAbilitySubTypeObject(napi_env env);
349 napi_value CreateDisplayOrientationObject(napi_env env);
350 napi_value CreateLaunchModeObject(napi_env env);
351 napi_value CreateColorModeObject(napi_env env);
352 napi_value CreateGrantStatusObject(napi_env env);
353 napi_value CreateModuleRemoveFlagObject(napi_env env);
354 napi_value CreateSignatureCompareResultObject(napi_env env);
355 napi_value CreateShortcutExistenceObject(napi_env env);
356 napi_value CreateQueryShortCutFlagObject(napi_env env);
357 napi_value CreateBundleFlagObject(napi_env env);
358 napi_value GetAllApplicationInfo(napi_env env, napi_callback_info info);
359 napi_value GetApplicationInfo(napi_env env, napi_callback_info info);
360 class JsBundleMgr {
361 public:
362     JsBundleMgr() = default;
363     ~JsBundleMgr() = default;
364 
365     struct JsAbilityInfo {
366         std::string bundleName;
367         std::string abilityName;
368         std::string moduleName = "";
369         bool hasModuleName = false;
370         OHOS::AppExecFwk::AbilityInfo abilityInfo;
371         bool ret = false;
372     };
373 
374     struct JsNameForUid {
375         std::string bundleName;
376         int32_t uid;
377         bool ret = false;
378     };
379 
380     struct JsAbilityLabel {
381         std::string bundleName;
382         std::string className;
383         std::string moduleName = "";
384         bool hasModuleName = false;
385         std::string abilityLabel;
386     };
387 
388     struct JsAbilityIcon {
389         std::string bundleName;
390         std::string abilityName;
391         std::string moduleName = "";
392         bool hasModuleName = false;
393     };
394 
395     struct JsGetPermissionDef {
396         std::string permissionName;
397         OHOS::AppExecFwk::PermissionDef permissionDef;
398         bool ret = false;
399     };
400 
401     struct JsQueryAbilityInfo {
402         std::vector<AbilityInfo> abilityInfos;
403         bool ret = false;
404         bool getCache = false;
405     };
406     std::string errMessage_;
407 
408 private:
409 };
410 
411 class JsBundleInstall {
412 public:
413     JsBundleInstall() = default;
414     ~JsBundleInstall() = default;
415     struct BundleInstallResult {
416         int32_t resCode = 0;
417         std::string resMessage;
418     };
419 private:
420     static void ConvertInstallResult(std::shared_ptr<BundleInstallResult> installResult);
421 };
422 
423 }  // namespace AppExecFwk
424 }  // namespace OHOS
425 #endif /* BUNDLE_MGR_H */
426