1 /*
2 * Copyright (c) 2020 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.h"
17
18 #include <ability_kit_command.h>
19 #include <ability_state.h>
20 #include <log.h>
21 #include <unistd.h>
22
23 #include "ability_info.h"
24 #include "ability_loader.h"
25 #ifdef ABILITY_WINDOW_SUPPORT
26 #include "ability_slice_manager.h"
27 #include "ability_window.h"
28 #endif
29 #include "adapter.h"
30 #include "ipc_skeleton.h"
31 #include "rpc_errno.h"
32
33 namespace OHOS {
OnStart(const Want & want)34 void Ability::OnStart(const Want &want)
35 {
36 HILOG_INFO(HILOG_MODULE_APP, "Ability OnStart");
37 if (abilityState_ != STATE_INITIAL) {
38 HILOG_ERROR(HILOG_MODULE_APP, "Start ability error, state: %{public}d", abilityState_);
39 exit(-1);
40 }
41
42 #ifdef ABILITY_WINDOW_SUPPORT
43 DeliverAbilityLifecycle(START, &want);
44 if (abilityWindow_ != nullptr) {
45 abilityWindow_->OnPostAbilityStart();
46 }
47 #endif
48 abilityState_ = STATE_INACTIVE;
49 }
50
OnInactive()51 void Ability::OnInactive()
52 {
53 HILOG_INFO(HILOG_MODULE_APP, "Ability OnInactive");
54 if (abilityState_ != STATE_ACTIVE) {
55 HILOG_ERROR(HILOG_MODULE_APP, "Inactive ability error, state: %{public}d", abilityState_);
56 exit(-1);
57 }
58
59 #ifdef ABILITY_WINDOW_SUPPORT
60 DeliverAbilityLifecycle(INACTIVE);
61 #endif
62 abilityState_ = STATE_INACTIVE;
63 }
64
OnActive(const Want & want)65 void Ability::OnActive(const Want &want)
66 {
67 HILOG_INFO(HILOG_MODULE_APP, "Ability OnActive");
68 if ((abilityState_ != STATE_INACTIVE) && (abilityState_ != STATE_BACKGROUND)) {
69 HILOG_ERROR(HILOG_MODULE_APP, "Active ability error, state: %{public}d", abilityState_);
70 exit(-1);
71 }
72
73 #ifdef ABILITY_WINDOW_SUPPORT
74 DeliverAbilityLifecycle(ACTIVE, &want);
75 if ((abilityWindow_ != nullptr) && (abilityState_ == STATE_BACKGROUND)) {
76 abilityWindow_->OnPostAbilityActive();
77 }
78 #endif
79 abilityState_ = STATE_ACTIVE;
80 }
81
OnBackground()82 void Ability::OnBackground()
83 {
84 HILOG_INFO(HILOG_MODULE_APP, "Ability OnBackground");
85 if (abilityState_ != STATE_INACTIVE) {
86 HILOG_ERROR(HILOG_MODULE_APP, "Background ability error, state: %{public}d", abilityState_);
87 exit(-1);
88 }
89
90 #ifdef ABILITY_WINDOW_SUPPORT
91 DeliverAbilityLifecycle(BACKGROUND);
92 if (abilityWindow_ != nullptr) {
93 abilityWindow_->OnPostAbilityBackground();
94 }
95 #endif
96 abilityState_ = STATE_BACKGROUND;
97 }
98
OnStop()99 void Ability::OnStop()
100 {
101 HILOG_INFO(HILOG_MODULE_APP, "Ability OnStop");
102 if (abilityState_ != STATE_BACKGROUND) {
103 HILOG_ERROR(HILOG_MODULE_APP, "Stop ability error, state: %{public}d", abilityState_);
104 exit(-1);
105 }
106
107 #ifdef ABILITY_WINDOW_SUPPORT
108 DeliverAbilityLifecycle(STOP);
109 if (abilityWindow_ != nullptr) {
110 abilityWindow_->OnPostAbilityStop();
111 delete abilityWindow_;
112 }
113 delete abilitySliceManager_;
114 abilitySliceManager_ = nullptr;
115 abilityWindow_ = nullptr;
116 #endif
117 abilityState_ = STATE_INITIAL;
118 }
119
OnConnect(const Want & want)120 const SvcIdentity *Ability::OnConnect(const Want &want)
121 {
122 HILOG_INFO(HILOG_MODULE_APP, "Ability Connect");
123 sid_ = static_cast<SvcIdentity *>(AdapterMalloc(sizeof(SvcIdentity)));
124 if (sid_ == nullptr) {
125 HILOG_ERROR(HILOG_MODULE_APP, "malloc memory error, sid_ is null");
126 return nullptr;
127 }
128 objectStub_.func = Ability::MsgHandleInner;
129 objectStub_.args = (void*)this;
130 objectStub_.isRemote = false;
131 sid_->handle = IPC_INVALID_HANDLE;
132 sid_->token = SERVICE_TYPE_ANONYMOUS;
133 sid_->cookie = reinterpret_cast<uintptr_t>(&objectStub_);
134 return sid_;
135 }
136
OnDisconnect(const Want & want)137 void Ability::OnDisconnect(const Want &want)
138 {
139 HILOG_INFO(HILOG_MODULE_APP, "Ability OnDisconnect");
140
141 // clear
142 AdapterFree(sid_);
143 sid_ = nullptr;
144 }
145
146 #ifdef ABILITY_WINDOW_SUPPORT
SetMainRoute(const std::string & entry)147 void Ability::SetMainRoute(const std::string &entry)
148 {
149 if (abilitySliceManager_ == nullptr) {
150 HILOG_ERROR(HILOG_MODULE_APP, "AbilitySliceManager is null, fail to set main route");
151 exit(-1);
152 }
153
154 abilitySliceManager_->SetMainRoute(entry);
155 }
156
SetUIContent(RootView * rootView)157 void Ability::SetUIContent(RootView *rootView)
158 {
159 if (abilityWindow_ == nullptr) {
160 HILOG_ERROR(HILOG_MODULE_APP, "AbilityWindow is null, fail to SetUIContent");
161 exit(-1);
162 }
163
164 abilityWindow_->SetRootView(rootView);
165 }
166 #endif
167
MsgHandle(uint32_t funcId,IpcIo * request,IpcIo * reply)168 void Ability::MsgHandle(uint32_t funcId, IpcIo *request, IpcIo *reply)
169 {
170 }
171
Dump(const std::string & extra)172 void Ability::Dump(const std::string &extra)
173 {
174 }
175
Init(uint64_t token,int abilityType,bool isNativeApp)176 void Ability::Init(uint64_t token, int abilityType, bool isNativeApp)
177 {
178 HILOG_INFO(HILOG_MODULE_APP, "Ability Init");
179 #ifdef ABILITY_WINDOW_SUPPORT
180 if (abilityType == PAGE) {
181 if (isNativeApp) {
182 abilitySliceManager_ = new AbilitySliceManager(*this);
183 }
184 abilityWindow_ = new AbilityWindow();
185 }
186 #endif
187
188 abilityType_ = abilityType;
189 token_ = token;
190 AbilityContext::token_ = token;
191 abilityState_ = STATE_INITIAL;
192 }
193
GetState() const194 int Ability::GetState() const
195 {
196 return abilityState_;
197 }
198
GetDumpInfo() const199 std::string Ability::GetDumpInfo() const
200 {
201 std::string dumpInfo;
202 dumpInfo += "Ability Type: [" + std::to_string(abilityType_) + "]\n";
203 dumpInfo += "Ability State: [" + std::to_string(abilityState_) + "]\n";
204 #ifdef ABILITY_WINDOW_SUPPORT
205 dumpInfo += "AbilitySlice stack:\n";
206 if ((abilityType_ == PAGE) && (abilitySliceManager_ != nullptr)) {
207 // Add slice stack information
208 dumpInfo += abilitySliceManager_->GetSliceStackInfo();
209 } else {
210 dumpInfo += " none";
211 }
212 #endif
213
214 return dumpInfo;
215 }
216
217 #ifdef ABILITY_WINDOW_SUPPORT
DeliverAbilityLifecycle(Action action,const Want * want)218 void Ability::DeliverAbilityLifecycle(Action action, const Want *want)
219 {
220 if (abilitySliceManager_ == nullptr) {
221 HILOG_WARN(HILOG_MODULE_APP, "AbilitySliceManager is null, no need to dispatch lifecycle state change");
222 return;
223 }
224
225 if ((action == START || action == ACTIVE) && want == nullptr) {
226 HILOG_ERROR(HILOG_MODULE_APP, "want is null");
227 return;
228 }
229
230 switch (action) {
231 case START:
232 abilitySliceManager_->OnAbilityStart(*want);
233 break;
234 case INACTIVE:
235 abilitySliceManager_->OnAbilityInactive();
236 break;
237 case ACTIVE:
238 abilitySliceManager_->OnAbilityActive(*want);
239 break;
240 case BACKGROUND:
241 abilitySliceManager_->OnAbilityBackground();
242 break;
243 case STOP:
244 abilitySliceManager_->OnAbilityStop();
245 break;
246 default:
247 HILOG_ERROR(HILOG_MODULE_APP, "action is error");
248 break;
249 }
250 }
251 #endif
252
MsgHandleInner(uint32_t code,IpcIo * data,IpcIo * reply,MessageOption option)253 int32_t Ability::MsgHandleInner(uint32_t code, IpcIo *data, IpcIo *reply, MessageOption option)
254 {
255 auto ability = static_cast<Ability *>(option.args);
256 if (ability == nullptr) {
257 HILOG_INFO(HILOG_MODULE_APP, "handle message error, ability is null");
258 return ERR_INVALID_PARAM;
259 }
260 // call user method
261 ability->MsgHandle(code, data, reply);
262 return ERR_NONE;
263 }
264 } // namespace OHOS
265