1 /*
2  * Copyright (c) 2023 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 "ability_mgr_service_slite.h"
17 
18 #include "ability_errors.h"
19 #include "ability_record_observer.h"
20 #include "ability_record_observer_manager.h"
21 #include "ability_service_interface.h"
22 #include "ability_thread_loader.h"
23 #include "abilityms_slite_client.h"
24 #include "abilityms_log.h"
25 #include "iunknown.h"
26 #include "js_ability_thread.h"
27 #include "native_ability_thread.h"
28 #include "ohos_init.h"
29 #include "samgr_lite.h"
30 #include "slite_ability_loader.h"
31 #include "slite_ace_ability.h"
32 #include "utils.h"
33 #include "want.h"
34 
35 namespace OHOS {
36 namespace AbilitySlite {
37 typedef struct {
38     INHERIT_IUNKNOWNENTRY(AmsSliteInterface);
39     AbilityMgrServiceSlite *ams;
40 } AbilityMgrServiceSliteImpl;
41 
42 AbilityMgrServiceSliteImpl g_amsSliteImpl = {
43     DEFAULT_IUNKNOWN_ENTRY_BEGIN,
44     .StartAbility = AbilityMgrServiceSlite::StartAbility,
45     .TerminateAbility = AbilityMgrServiceSlite::TerminateAbility,
46     .SchedulerLifecycleDone = AbilityMgrServiceSlite::SchedulerLifecycleDone,
47     .ForceStopBundle = AbilityMgrServiceSlite::ForceStopBundle,
48     .GetTopAbility = AbilityMgrServiceSlite::GetTopAbility,
49     .GetMissionInfos = AbilityMgrServiceSlite::GetMissionInfos,
50     DEFAULT_IUNKNOWN_ENTRY_END
51 };
52 
InitService()53 static void InitService()
54 {
55     SamgrLite *sm = SAMGR_GetInstance();
56     CHECK_NULLPTR_RETURN(sm, "AbilityManagerService", "get samgr error");
57     BOOL result = sm->RegisterService(AbilityMgrServiceSlite::GetInstance());
58     HILOG_INFO(HILOG_MODULE_AAFWK, "ams starts %{public}s", result ? "successfully" : "unsuccessfully");
59 }
60 
61 SYSEX_SERVICE_INIT(InitService);
62 
InitFeature()63 static void InitFeature()
64 {
65     SamgrLite *samgrLite = SAMGR_GetInstance();
66     CHECK_NULLPTR_RETURN(samgrLite, "AbilityMgrServiceSlite", "get samgr error");
67     BOOL result = samgrLite->RegisterFeature(AMS_SERVICE, AbilityMgrServiceSlite::GetInstance());
68     if (result == FALSE) {
69         HILOG_ERROR(HILOG_MODULE_AAFWK, "ams register feature failure");
70         return;
71     }
72     g_amsSliteImpl.ams = AbilityMgrServiceSlite::GetInstance();
73     auto publicApi = GET_IUNKNOWN(g_amsSliteImpl);
74     CHECK_NULLPTR_RETURN(publicApi, "AbilityMgrServiceSlite", "publicApi is nullptr");
75     BOOL apiResult = samgrLite->RegisterFeatureApi(AMS_SERVICE, AMS_SLITE_FEATURE, publicApi);
76     HILOG_INFO(HILOG_MODULE_AAFWK, "ams feature init %{public}s", apiResult ? "success" : "failure");
77 }
78 
79 SYSEX_FEATURE_INIT(InitFeature);
80 
AbilityMgrServiceSlite()81 AbilityMgrServiceSlite::AbilityMgrServiceSlite() : Service(), Feature()
82 {
83     this->Feature::GetName = AbilityMgrServiceSlite::GetFeatureName;
84     this->Feature::OnInitialize = AbilityMgrServiceSlite::OnFeatureInitialize;
85     this->Feature::OnStop = AbilityMgrServiceSlite::OnFeatureStop;
86     this->Feature::OnMessage = AbilityMgrServiceSlite::OnFeatureMessage;
87     this->Service::GetName = AbilityMgrServiceSlite::GetServiceName;
88     this->Service::Initialize = AbilityMgrServiceSlite::ServiceInitialize;
89     this->Service::MessageHandle = AbilityMgrServiceSlite::ServiceMessageHandle;
90     this->Service::GetTaskConfig = AbilityMgrServiceSlite::GetServiceTaskConfig;
91 }
92 
93 AbilityMgrServiceSlite::~AbilityMgrServiceSlite() = default;
94 
GetInstance()95 AbilityMgrServiceSlite *AbilityMgrServiceSlite::GetInstance()
96 {
97     static AbilityMgrServiceSlite instance;
98     return &instance;
99 }
100 
GetIdentity()101 const Identity *AbilityMgrServiceSlite::GetIdentity()
102 {
103     return &serviceIdentity_;
104 }
105 
106 const char *AbilityMgrServiceSlite::GetFeatureName([[maybe_unused]] Feature *feature)
107 {
108     return AMS_SLITE_FEATURE;
109 }
110 
111 void AbilityMgrServiceSlite::OnFeatureInitialize(Feature *feature, [[maybe_unused]] Service *parent, Identity identity)
112 {
113     CHECK_NULLPTR_RETURN(feature, "AbilityMgrServiceSlite", "feature initialize fail");
114     auto *abilityMgrService = static_cast<AbilityMgrServiceSlite *>(feature);
115     abilityMgrService->featureIdentity_ = identity;
116     AbilityRecordManager::GetInstance().StartLauncher();
117 }
118 
119 void AbilityMgrServiceSlite::OnFeatureStop([[maybe_unused]] Feature *feature, [[maybe_unused]] Identity identity)
120 {
121 }
122 
OnFeatureMessage(Feature * feature,Request * request)123 BOOL AbilityMgrServiceSlite::OnFeatureMessage(Feature *feature, Request *request)
124 {
125     if (feature == nullptr || request == nullptr) {
126         return FALSE;
127     }
128     return TRUE;
129 }
130 
131 const char *AbilityMgrServiceSlite::GetServiceName([[maybe_unused]] Service *service)
132 {
133     return AMS_SERVICE;
134 }
135 
ServiceInitialize(Service * service,Identity identity)136 BOOL AbilityMgrServiceSlite::ServiceInitialize(Service *service, Identity identity)
137 {
138     if (service == nullptr) {
139         return FALSE;
140     }
141     auto *abilityMgrService = static_cast<AbilityMgrServiceSlite *>(service);
142     abilityMgrService->serviceIdentity_ = identity;
143     InitAbilityThreadLoad();
144     InitAbilityLoad();
145     AbilityRecordObserverManager::GetInstance();
146     AbilityMsClient::GetInstance().SetServiceIdentity(&abilityMgrService->serviceIdentity_);
147     return TRUE;
148 }
149 
ServiceMessageHandle(Service * service,Request * request)150 BOOL AbilityMgrServiceSlite::ServiceMessageHandle(Service *service, Request *request)
151 {
152     if (request == nullptr) {
153         return FALSE;
154     }
155     int32_t ret = ERR_OK;
156     if (request->msgId == START_ABILITY) {
157         auto *data = static_cast<StartAbilityData *>(request->data);
158         if (data == nullptr) {
159             return FALSE;
160         }
161         AbilityRecordManager::GetInstance().curTask_ = data->curTask;
162         ret = AbilityRecordManager::GetInstance().StartAbility(data->want);
163         ClearWant(data->want);
164         AdapterFree(data->want);
165         AdapterFree(request->data);
166         request->data = nullptr;
167         request->len = 0;
168     } else if (request->msgId == TERMINATE_ABILITY) {
169         ret = AbilityRecordManager::GetInstance().TerminateAbility(request->msgValue);
170     } else if (request->msgId == TERMINATE_MISSION) {
171         ret = AbilityRecordManager::GetInstance().TerminateMission(request->msgValue);
172     } else if (request->msgId == TERMINATE_APP) {
173         ret = AbilityRecordManager::GetInstance().ForceStopBundle(request->msgValue);
174     } else if (request->msgId == TERMINATE_APP_BY_BUNDLENAME) {
175         auto *data = static_cast<Want *>(request->data);
176         if (data == nullptr) {
177             return FALSE;
178         }
179         ret = AbilityRecordManager::GetInstance().ForceStop(data);
180         ClearWant(data);
181         AdapterFree(request->data);
182         request->data = nullptr;
183         request->len = 0;
184     } else if (request->msgId == TERMINATE_ALL) {
185         char *excludedBundleName = reinterpret_cast<char *>(request->data);
186         ret = AbilityRecordManager::GetInstance().TerminateAll(excludedBundleName);
187         AdapterFree(request->data);
188         request->data = nullptr;
189         request->len = 0;
190     } else if (request->msgId == ABILITY_TRANSACTION_DONE) {
191         uint32_t token = request->msgValue & TRANSACTION_MSG_TOKEN_MASK;
192         uint32_t state = (request->msgValue >> TRANSACTION_MSG_STATE_OFFSET) & TRANSACTION_MSG_STATE_MASK;
193         return AbilityRecordManager::GetInstance().SchedulerLifecycleDone(token, state) == ERR_OK;
194     } else if (request->msgId == ADD_ABILITY_RECORD_OBSERVER) {
195         AbilityRecordObserver *observer = reinterpret_cast<AbilityRecordObserver *>(request->msgValue);
196         return AbilityRecordManager::GetInstance().AddAbilityRecordObserver(observer) == ERR_OK;
197     } else if (request->msgId == REMOVE_ABILITY_RECORD_OBSERVER) {
198         AbilityRecordObserver *observer = reinterpret_cast<AbilityRecordObserver *>(request->msgValue);
199         return AbilityRecordManager::GetInstance().RemoveAbilityRecordObserver(observer) == ERR_OK;
200     }
201     if ((ret != ERR_OK) || (!AbilityRecordManager::GetInstance().GetIsAppScheduling())) {
202         AbilityRecordManager::GetInstance().SetIsAppScheduling(false);
203         return AbilityRecordManager::GetInstance().RunOperation() == ERR_OK;
204     }
205     return ret == ERR_OK;
206 }
207 
GetServiceTaskConfig(Service * service)208 TaskConfig AbilityMgrServiceSlite::GetServiceTaskConfig(Service *service)
209 {
210     constexpr uint16 QUEUE_SIZE = 20;
211     TaskConfig config = { LEVEL_HIGH, PRI_NORMAL, AMS_TASK_STACK_SIZE, QUEUE_SIZE, SINGLE_TASK };
212     return config;
213 }
214 
StartAbility(const Want * want)215 int32_t AbilityMgrServiceSlite::StartAbility(const Want *want)
216 {
217     int32 ret = AbilityRecordManager::GetInstance().StartAbility(want);
218     ClearWant(const_cast<Want *>(want));
219     return ret;
220 }
221 
TerminateAbility(uint64_t token)222 int32_t AbilityMgrServiceSlite::TerminateAbility(uint64_t token)
223 {
224     uint32_t slitToken = token & TRANSACTION_MSG_TOKEN_MASK;
225     return AbilityRecordManager::GetInstance().TerminateAbility(slitToken);
226 }
227 
SchedulerLifecycleDone(uint64_t token,int state)228 int32_t AbilityMgrServiceSlite::SchedulerLifecycleDone(uint64_t token, int state)
229 {
230     return AbilityRecordManager::GetInstance().SchedulerLifecycleDone(token, state);
231 }
232 
ForceStopBundle(uint64_t token)233 int32_t AbilityMgrServiceSlite::ForceStopBundle(uint64_t token)
234 {
235     uint16_t slitToken = token & TRANSACTION_MSG_TOKEN_MASK;
236     return AbilityRecordManager::GetInstance().ForceStopBundle(slitToken);
237 }
238 
GetTopAbility()239 ElementName *AbilityMgrServiceSlite::GetTopAbility()
240 {
241     return AbilityRecordManager::GetInstance().GetTopAbility();
242 }
243 
GetMissionInfos(uint32_t maxNum)244 void *AbilityMgrServiceSlite::GetMissionInfos(uint32_t maxNum)
245 {
246     return static_cast<void *>(AbilityRecordManager::GetInstance().GetMissionInfos(maxNum));
247 }
248 
CreateJsAbilityThread()249 static AbilityThread *CreateJsAbilityThread()
250 {
251     auto *jsThread = new JsAbilityThread();
252     return jsThread;
253 }
254 
CreateNativeAbilityThread()255 static AbilityThread *CreateNativeAbilityThread()
256 {
257     auto *nativeThread = new NativeAbilityThread();
258     return nativeThread;
259 }
260 
InitAbilityThreadLoad()261 void AbilityMgrServiceSlite::InitAbilityThreadLoad()
262 {
263     AbilityThreadLoader::GetInstance().SetCreatorFunc(AbilityThreadCreatorType::JS_CREATOR, CreateJsAbilityThread);
264     AbilityThreadLoader::GetInstance().SetCreatorFunc(AbilityThreadCreatorType::NATIVE_CREATOR,
265         CreateNativeAbilityThread);
266 }
267 
CreateJsAbility(const char * bundleName)268 static SliteAbility *CreateJsAbility(const char *bundleName)
269 {
270     SliteAbility *jsAbility = new ACELite::SliteAceAbility(bundleName);
271     return jsAbility;
272 }
273 
InitAbilityLoad()274 void AbilityMgrServiceSlite::InitAbilityLoad()
275 {
276     SliteAbilityLoader::GetInstance().SetAbilityCreatorFunc(SliteAbilityType::JS_ABILITY, CreateJsAbility);
277 }
278 } // namespace AbilitySlite
279 } // namespace OHOS
280