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 "mission_manager.h"
17 
18 #include "ability_manager_client.h"
19 #include "event_handler.h"
20 #include "event_runner.h"
21 #include "hilog_tag_wrapper.h"
22 #include "js_error_utils.h"
23 #include "js_mission_info_utils.h"
24 #include "js_mission_listener.h"
25 #include "js_runtime_utils.h"
26 #include "mission_snapshot.h"
27 #include "napi_common_start_options.h"
28 #include "napi_common_util.h"
29 #include "permission_constants.h"
30 #ifdef SUPPORT_GRAPHICS
31 #include "pixel_map_napi.h"
32 #endif
33 #include "start_options.h"
34 
35 #include <mutex>
36 
37 namespace OHOS {
38 namespace AbilityRuntime {
39 using namespace OHOS::AppExecFwk;
40 using AbilityManagerClient = AAFwk::AbilityManagerClient;
41 namespace {
42 constexpr size_t ARGC_ONE = 1;
43 constexpr int32_t ARG_COUNT_TWO = 2;
44 }
45 class JsMissionManager {
46 public:
47     JsMissionManager() = default;
48     ~JsMissionManager() = default;
49 
Finalizer(napi_env env,void * data,void * hint)50     static void Finalizer(napi_env env, void* data, void* hint)
51     {
52         TAG_LOGI(AAFwkTag::MISSION, "called");
53         std::unique_ptr<JsMissionManager>(static_cast<JsMissionManager*>(data));
54     }
55 
RegisterMissionListener(napi_env env,napi_callback_info info)56     static napi_value RegisterMissionListener(napi_env env, napi_callback_info info)
57     {
58         GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnRegisterMissionListener);
59     }
60 
UnregisterMissionListener(napi_env env,napi_callback_info info)61     static napi_value UnregisterMissionListener(napi_env env, napi_callback_info info)
62     {
63         GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnUnregisterMissionListener);
64     }
65 
GetMissionInfos(napi_env env,napi_callback_info info)66     static napi_value GetMissionInfos(napi_env env, napi_callback_info info)
67     {
68         GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnGetMissionInfos);
69     }
70 
GetMissionInfo(napi_env env,napi_callback_info info)71     static napi_value GetMissionInfo(napi_env env, napi_callback_info info)
72     {
73         GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnGetMissionInfo);
74     }
75 
GetMissionSnapShot(napi_env env,napi_callback_info info)76     static napi_value GetMissionSnapShot(napi_env env, napi_callback_info info)
77     {
78         GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnGetMissionSnapShot);
79     }
80 
GetLowResolutionMissionSnapShot(napi_env env,napi_callback_info info)81     static napi_value GetLowResolutionMissionSnapShot(napi_env env, napi_callback_info info)
82     {
83         GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnGetLowResolutionMissionSnapShot);
84     }
85 
LockMission(napi_env env,napi_callback_info info)86     static napi_value LockMission(napi_env env, napi_callback_info info)
87     {
88         GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnLockMission);
89     }
90 
UnlockMission(napi_env env,napi_callback_info info)91     static napi_value UnlockMission(napi_env env, napi_callback_info info)
92     {
93         GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnUnlockMission);
94     }
95 
ClearMission(napi_env env,napi_callback_info info)96     static napi_value ClearMission(napi_env env, napi_callback_info info)
97     {
98         GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnClearMission);
99     }
100 
ClearAllMissions(napi_env env,napi_callback_info info)101     static napi_value ClearAllMissions(napi_env env, napi_callback_info info)
102     {
103         GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnClearAllMissions);
104     }
105 
MoveMissionToFront(napi_env env,napi_callback_info info)106     static napi_value MoveMissionToFront(napi_env env, napi_callback_info info)
107     {
108         GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnMoveMissionToFront);
109     }
110 
111 private:
OnRegisterMissionListener(napi_env env,size_t argc,napi_value * argv)112     napi_value OnRegisterMissionListener(napi_env env, size_t argc, napi_value* argv)
113     {
114         TAG_LOGI(AAFwkTag::MISSION, "called");
115         if (argc < 1) {
116             TAG_LOGE(AAFwkTag::MISSION, "Params not match");
117             ThrowTooFewParametersError(env);
118             return CreateJsUndefined(env);
119         }
120 
121         missionListenerId_++;
122         if (missionListener_ != nullptr) {
123             missionListener_->AddJsListenerObject(missionListenerId_, argv[0]);
124             return CreateJsValue(env, missionListenerId_);
125         }
126 
127         missionListener_ = new JsMissionListener(env);
128         auto ret = AbilityManagerClient::GetInstance()->RegisterMissionListener(missionListener_);
129         if (ret == 0) {
130             missionListener_->AddJsListenerObject(missionListenerId_, argv[0]);
131             return CreateJsValue(env, missionListenerId_);
132         } else {
133             TAG_LOGE(AAFwkTag::MISSION, "error, ret: %{public}d", ret);
134             missionListener_ = nullptr;
135             if (ret == CHECK_PERMISSION_FAILED) {
136                 ThrowNoPermissionError(env, PermissionConstants::PERMISSION_MANAGE_MISSION);
137             } else {
138                 ThrowError(env, AbilityErrorCode::ERROR_CODE_INNER);
139             }
140             return CreateJsUndefined(env);
141         }
142     }
143 
OnUnregisterMissionListener(napi_env env,size_t argc,napi_value * argv)144     napi_value OnUnregisterMissionListener(napi_env env, size_t argc, napi_value* argv)
145     {
146         TAG_LOGI(AAFwkTag::MISSION, "called");
147         if (argc < 1) {
148             TAG_LOGE(AAFwkTag::MISSION, "invalid argc");
149             ThrowTooFewParametersError(env);
150             return CreateJsUndefined(env);
151         }
152 
153         int32_t missionListenerId = -1;
154         if (!ConvertFromJsValue(env, argv[0], missionListenerId)) {
155             TAG_LOGE(AAFwkTag::MISSION, "Parse missionListenerId failed");
156             ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM);
157             return CreateJsUndefined(env);
158         }
159 
160         NapiAsyncTask::CompleteCallback complete =
161             [&missionListener = missionListener_, missionListenerId]
162             (napi_env env, NapiAsyncTask &task, int32_t status) {
163                 if (!missionListener || !missionListener->RemoveJsListenerObject(missionListenerId)) {
164                     task.Reject(env, CreateJsError(env, AbilityErrorCode::ERROR_CODE_NO_MISSION_LISTENER));
165                     return;
166                 }
167 
168                 if (!missionListener->IsEmpty()) {
169                     task.Resolve(env, CreateJsUndefined(env));
170                     return;
171                 }
172                 auto ret = AbilityManagerClient::GetInstance()->UnRegisterMissionListener(missionListener);
173                 if (ret == 0) {
174                     task.Resolve(env, CreateJsUndefined(env));
175                     missionListener = nullptr;
176                 } else {
177                     task.Reject(env,
178                         CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION));
179                 }
180             };
181 
182         napi_value lastParam = (argc <= 1) ? nullptr : argv[1];
183         napi_value result = nullptr;
184         NapiAsyncTask::Schedule("MissionManager::OnUnregisterMissionListener",
185             env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result));
186         return result;
187     }
188 
OnGetMissionInfos(napi_env env,size_t argc,napi_value * argv)189     napi_value OnGetMissionInfos(napi_env env, size_t argc, napi_value* argv)
190     {
191         TAG_LOGI(AAFwkTag::MISSION, "called");
192         if (argc < ARG_COUNT_TWO) { // at least 2 parameters.
193             TAG_LOGE(AAFwkTag::MISSION, "invalid argc");
194             ThrowTooFewParametersError(env);
195             return CreateJsUndefined(env);
196         }
197         std::string deviceId;
198         if (!ConvertFromJsValue(env, argv[0], deviceId)) {
199             TAG_LOGE(AAFwkTag::MISSION, "Parse deviceId failed");
200             ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM);
201             return CreateJsUndefined(env);
202         }
203         int numMax = -1;
204         if (!ConvertFromJsValue(env, argv[1], numMax)) {
205             TAG_LOGE(AAFwkTag::MISSION, "Parse numMax failed");
206             ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM);
207             return CreateJsUndefined(env);
208         }
209 
210         NapiAsyncTask::CompleteCallback complete =
211             [deviceId, numMax](napi_env env, NapiAsyncTask &task, int32_t status) {
212                 std::vector<AAFwk::MissionInfo> missionInfos;
213                 auto ret = AbilityManagerClient::GetInstance()->GetMissionInfos(deviceId, numMax, missionInfos);
214                 if (ret == 0) {
215                     task.Resolve(env, CreateJsMissionInfoArray(env, missionInfos));
216                 } else {
217                     task.Reject(env,
218                         CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION));
219                 }
220             };
221 
222         napi_value lastParam = (argc <= 2) ? nullptr : argv[2];
223         napi_value result = nullptr;
224         NapiAsyncTask::Schedule("MissionManager::OnGetMissionInfos",
225             env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result));
226         return result;
227     }
228 
OnGetMissionInfo(napi_env env,size_t argc,napi_value * argv)229     napi_value OnGetMissionInfo(napi_env env, size_t argc, napi_value* argv)
230     {
231         TAG_LOGI(AAFwkTag::MISSION, "called");
232         if (argc < ARG_COUNT_TWO) {
233             TAG_LOGE(AAFwkTag::MISSION, "invalid argc");
234             ThrowTooFewParametersError(env);
235             return CreateJsUndefined(env);
236         }
237         std::string deviceId;
238         if (!ConvertFromJsValue(env, argv[0], deviceId)) {
239             TAG_LOGE(AAFwkTag::MISSION, "Parse deviceId failed");
240             ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM);
241             return CreateJsUndefined(env);
242         }
243         int32_t missionId = -1;
244         if (!ConvertFromJsValue(env, argv[1], missionId)) {
245             TAG_LOGE(AAFwkTag::MISSION, "Parse missionId failed");
246             ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM);
247             return CreateJsUndefined(env);
248         }
249 
250         NapiAsyncTask::CompleteCallback complete =
251             [deviceId, missionId](napi_env env, NapiAsyncTask &task, int32_t status) {
252                 AAFwk::MissionInfo missionInfo;
253                 auto ret = AbilityManagerClient::GetInstance()->GetMissionInfo(deviceId, missionId, missionInfo);
254                 if (ret == 0) {
255                     task.Resolve(env, CreateJsMissionInfo(env, missionInfo));
256                 } else {
257                     task.Reject(env,
258                         CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION));
259                 }
260             };
261 
262         napi_value lastParam = (argc <= 2) ? nullptr : argv[2];
263         napi_value result = nullptr;
264         NapiAsyncTask::Schedule("MissionManager::OnGetMissionInfo",
265             env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result));
266         return result;
267     }
268 
OnGetMissionSnapShot(napi_env env,size_t argc,napi_value * argv)269     napi_value OnGetMissionSnapShot(napi_env env, size_t argc, napi_value* argv)
270     {
271         TAG_LOGI(AAFwkTag::MISSION, "called");
272         return GetMissionSnapShot(env, argc, argv, false);
273     }
274 
OnGetLowResolutionMissionSnapShot(napi_env env,size_t argc,napi_value * argv)275     napi_value OnGetLowResolutionMissionSnapShot(napi_env env, size_t argc, napi_value* argv)
276     {
277         TAG_LOGI(AAFwkTag::MISSION, "called");
278         return GetMissionSnapShot(env, argc, argv, true);
279     }
280 
GetMissionSnapShot(napi_env env,size_t argc,napi_value * argv,bool isLowResolution)281     napi_value GetMissionSnapShot(napi_env env, size_t argc, napi_value* argv, bool isLowResolution)
282     {
283         std::string deviceId;
284         int32_t missionId = -1;
285         if (!CheckMissionSnapShotParams(env, argc, argv, deviceId, missionId)) {
286             return CreateJsUndefined(env);
287         }
288 
289         class MissionSnapshotWrap {
290         public:
291             int result = -1;
292             AAFwk::MissionSnapshot missionSnapshot;
293         };
294 
295         std::shared_ptr<MissionSnapshotWrap> snapshotWrap = std::make_shared<MissionSnapshotWrap>();
296         auto excute = [deviceId, missionId, isLowResolution, snapshotWrap]() {
297             snapshotWrap->result = AbilityManagerClient::GetInstance()->GetMissionSnapshot(
298                 deviceId, missionId, snapshotWrap->missionSnapshot, isLowResolution);
299         };
300 
301         auto complete = [snapshotWrap](napi_env env, NapiAsyncTask &task, int32_t status) {
302             if (snapshotWrap->result == 0) {
303                 napi_value object = nullptr;
304                 napi_create_object(env, &object);
305                 napi_value abilityObj = nullptr;
306                 napi_create_object(env, &abilityObj);
307                 napi_set_named_property(env, abilityObj, "bundleName",
308                     CreateJsValue(env, snapshotWrap->missionSnapshot.topAbility.GetBundleName()));
309                 napi_set_named_property(env, abilityObj, "abilityName",
310                     CreateJsValue(env, snapshotWrap->missionSnapshot.topAbility.GetAbilityName()));
311                 napi_set_named_property(env, object, "ability", abilityObj);
312 #ifdef SUPPORT_GRAPHICS
313                 auto snapshotValue = Media::PixelMapNapi::CreatePixelMap(
314                     env, snapshotWrap->missionSnapshot.snapshot);
315                 napi_set_named_property(env, object, "snapshot", snapshotValue);
316 #endif
317                 task.Resolve(env, object);
318             } else {
319                 task.Reject(env, CreateJsErrorByNativeErr(env, snapshotWrap->result,
320                     PermissionConstants::PERMISSION_MANAGE_MISSION));
321             }
322         };
323         napi_value lastParam = (argc > ARG_COUNT_TWO) ? argv[ARG_COUNT_TWO] : nullptr;
324         napi_value result = nullptr;
325         NapiAsyncTask::Schedule("MissionManager::GetMissionSnapShot",
326             env, CreateAsyncTaskWithLastParam(env, lastParam, std::move(excute), std::move(complete), &result));
327         return result;
328     }
329 
CheckMissionSnapShotParams(napi_env env,size_t argc,napi_value * argv,std::string & deviceId,int32_t & missionId)330     bool CheckMissionSnapShotParams(napi_env env, size_t argc, napi_value* argv,
331         std::string &deviceId, int32_t &missionId)
332     {
333         if (argc < ARG_COUNT_TWO) {
334             ThrowTooFewParametersError(env);
335             return false;
336         }
337 
338         if (!ConvertFromJsValue(env, argv[0], deviceId)) {
339             TAG_LOGE(AAFwkTag::MISSION, "missionSnapshot: Parse deviceId failed");
340             ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM);
341             return false;
342         }
343 
344         if (!ConvertFromJsValue(env, argv[1], missionId)) {
345             TAG_LOGE(AAFwkTag::MISSION, "missionSnapshot: Parse missionId failed");
346             ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM);
347             return false;
348         }
349 
350         return true;
351     }
352 
OnLockMission(napi_env env,size_t argc,napi_value * argv)353     napi_value OnLockMission(napi_env env, size_t argc, napi_value* argv)
354     {
355         TAG_LOGI(AAFwkTag::MISSION, "called");
356         if (argc == 0) {
357             TAG_LOGE(AAFwkTag::MISSION, "invalid argc");
358             ThrowTooFewParametersError(env);
359             return CreateJsUndefined(env);
360         }
361         int32_t missionId = -1;
362         if (!ConvertFromJsValue(env, argv[0], missionId)) {
363             TAG_LOGE(AAFwkTag::MISSION, "Parse missionId failed");
364             ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM);
365             return CreateJsUndefined(env);
366         }
367 
368         NapiAsyncTask::CompleteCallback complete =
369             [missionId](napi_env env, NapiAsyncTask &task, int32_t status) {
370                 auto ret = AbilityManagerClient::GetInstance()->LockMissionForCleanup(missionId);
371                 if (ret == 0) {
372                     task.Resolve(env, CreateJsUndefined(env));
373                 } else {
374                     task.Reject(env,
375                         CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION));
376                 }
377             };
378 
379         napi_value lastParam = (argc > 1) ?  argv[1] : nullptr;
380         napi_value result = nullptr;
381         NapiAsyncTask::ScheduleHighQos("MissionManager::OnLockMission",
382             env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result));
383         return result;
384     }
385 
OnUnlockMission(napi_env env,size_t argc,napi_value * argv)386     napi_value OnUnlockMission(napi_env env, size_t argc, napi_value* argv)
387     {
388         TAG_LOGI(AAFwkTag::MISSION, "called");
389         if (argc == 0) {
390             TAG_LOGE(AAFwkTag::MISSION, "invalid argc");
391             ThrowTooFewParametersError(env);
392             return CreateJsUndefined(env);
393         }
394         int32_t missionId = -1;
395         if (!ConvertFromJsValue(env, argv[0], missionId)) {
396             TAG_LOGE(AAFwkTag::MISSION, "Parse missionId failed");
397             ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM);
398             return CreateJsUndefined(env);
399         }
400 
401         NapiAsyncTask::CompleteCallback complete =
402             [missionId](napi_env env, NapiAsyncTask &task, int32_t status) {
403                 auto ret = AbilityManagerClient::GetInstance()->UnlockMissionForCleanup(missionId);
404                 if (ret == 0) {
405                     task.Resolve(env, CreateJsUndefined(env));
406                 } else {
407                     task.Reject(env,
408                         CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION));
409                 }
410             };
411 
412         napi_value lastParam = (argc > 1) ? argv[1] : nullptr;
413         napi_value result = nullptr;
414         NapiAsyncTask::ScheduleHighQos("MissionManager::OnUnlockMission",
415             env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result));
416         return result;
417     }
418 
OnClearMission(napi_env env,size_t argc,napi_value * argv)419     napi_value OnClearMission(napi_env env, size_t argc, napi_value* argv)
420     {
421         TAG_LOGI(AAFwkTag::MISSION, "called");
422         if (argc == 0) {
423             TAG_LOGE(AAFwkTag::MISSION, "invalid argc");
424             ThrowTooFewParametersError(env);
425             return CreateJsUndefined(env);
426         }
427         int32_t missionId = -1;
428         if (!ConvertFromJsValue(env, argv[0], missionId)) {
429             TAG_LOGE(AAFwkTag::MISSION, "Parse missionId failed");
430             ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM);
431             return CreateJsUndefined(env);
432         }
433 
434         NapiAsyncTask::CompleteCallback complete =
435             [missionId](napi_env env, NapiAsyncTask &task, int32_t status) {
436                 auto ret = AbilityManagerClient::GetInstance()->CleanMission(missionId);
437                 if (ret == 0) {
438                     task.Resolve(env, CreateJsUndefined(env));
439                 } else {
440                     task.Reject(env,
441                         CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION));
442                 }
443             };
444 
445         napi_value lastParam = (argc > 1) ? argv[1] : nullptr;
446         napi_value result = nullptr;
447         NapiAsyncTask::ScheduleHighQos("MissionManager::OnClearMission",
448             env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result));
449         return result;
450     }
451 
OnClearAllMissions(napi_env env,size_t argc,napi_value * argv)452     napi_value OnClearAllMissions(napi_env env, size_t argc, napi_value* argv)
453     {
454         TAG_LOGI(AAFwkTag::MISSION, "called");
455         NapiAsyncTask::CompleteCallback complete =
456             [](napi_env env, NapiAsyncTask &task, int32_t status) {
457                 auto ret = AbilityManagerClient::GetInstance()->CleanAllMissions();
458                 if (ret == 0) {
459                     task.Resolve(env, CreateJsUndefined(env));
460                 } else {
461                     task.Reject(env,
462                         CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION));
463                 }
464             };
465 
466         napi_value lastParam = (argc > 0) ? argv[0] : nullptr;
467         napi_value result = nullptr;
468         NapiAsyncTask::ScheduleHighQos("MissionManager::OnMoveMissionToFront",
469             env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result));
470         return result;
471     }
472 
OnMoveMissionToFront(napi_env env,size_t argc,napi_value * argv)473     napi_value OnMoveMissionToFront(napi_env env, size_t argc, napi_value* argv)
474     {
475         TAG_LOGI(AAFwkTag::MISSION, "called");
476         if (argc == 0) {
477             TAG_LOGE(AAFwkTag::MISSION, "invalid argc");
478             ThrowTooFewParametersError(env);
479             return CreateJsUndefined(env);
480         }
481         int32_t missionId = -1;
482         if (!ConvertFromJsValue(env, argv[0], missionId)) {
483             TAG_LOGE(AAFwkTag::MISSION, "Parse missionId failed");
484             ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM);
485             return CreateJsUndefined(env);
486         }
487         decltype(argc) unwrapArgc = 1;
488 
489         AAFwk::StartOptions startOptions;
490         if (argc > ARGC_ONE && AppExecFwk::IsTypeForNapiValue(env, argv[1], napi_object)) {
491             TAG_LOGI(AAFwkTag::MISSION, "start options used");
492             AppExecFwk::UnwrapStartOptions(env, argv[1], startOptions);
493             unwrapArgc++;
494         }
495         NapiAsyncTask::CompleteCallback complete =
496             [missionId, startOptions, unwrapArgc](napi_env env, NapiAsyncTask &task, int32_t status) {
497                 auto ret = (unwrapArgc == 1) ? AbilityManagerClient::GetInstance()->MoveMissionToFront(missionId) :
498                     AbilityManagerClient::GetInstance()->MoveMissionToFront(missionId, startOptions);
499                 if (ret == 0) {
500                     task.Resolve(env, CreateJsUndefined(env));
501                 } else {
502                     task.Reject(env,
503                         CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION));
504                 }
505             };
506 
507         napi_value lastParam = (argc > unwrapArgc) ? argv[unwrapArgc] : nullptr;
508         napi_value result = nullptr;
509         NapiAsyncTask::ScheduleHighQos("MissionManager::OnMoveMissionToFront",
510             env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result));
511         return result;
512     }
513 
514     sptr<JsMissionListener> missionListener_ = nullptr;
515     uint32_t missionListenerId_ = 0;
516 };
517 
JsMissionManagerInit(napi_env env,napi_value exportObj)518 napi_value JsMissionManagerInit(napi_env env, napi_value exportObj)
519 {
520     TAG_LOGI(AAFwkTag::MISSION, "called");
521     if (env == nullptr || exportObj == nullptr) {
522         TAG_LOGI(AAFwkTag::MISSION, "Invalid input param");
523         return nullptr;
524     }
525 
526     std::unique_ptr<JsMissionManager> jsMissionManager = std::make_unique<JsMissionManager>();
527     napi_wrap(env, exportObj, jsMissionManager.release(), JsMissionManager::Finalizer, nullptr, nullptr);
528 
529     const char *moduleName = "JsMissionManager";
530     BindNativeFunction(env, exportObj, "registerMissionListener",
531         moduleName, JsMissionManager::RegisterMissionListener);
532     BindNativeFunction(env, exportObj, "unregisterMissionListener",
533         moduleName, JsMissionManager::UnregisterMissionListener);
534     BindNativeFunction(env, exportObj, "getMissionInfos", moduleName, JsMissionManager::GetMissionInfos);
535     BindNativeFunction(env, exportObj, "getMissionInfo", moduleName, JsMissionManager::GetMissionInfo);
536     BindNativeFunction(env, exportObj, "getMissionSnapShot", moduleName, JsMissionManager::GetMissionSnapShot);
537     BindNativeFunction(env, exportObj, "getLowResolutionMissionSnapShot", moduleName,
538         JsMissionManager::GetLowResolutionMissionSnapShot);
539     BindNativeFunction(env, exportObj, "lockMission", moduleName, JsMissionManager::LockMission);
540     BindNativeFunction(env, exportObj, "unlockMission", moduleName, JsMissionManager::UnlockMission);
541     BindNativeFunction(env, exportObj, "clearMission", moduleName, JsMissionManager::ClearMission);
542     BindNativeFunction(env, exportObj, "clearAllMissions", moduleName, JsMissionManager::ClearAllMissions);
543     BindNativeFunction(env, exportObj, "moveMissionToFront", moduleName, JsMissionManager::MoveMissionToFront);
544     return CreateJsUndefined(env);
545 }
546 }  // namespace AbilityRuntime
547 }  // namespace OHOS
548