1 /*
2 * Copyright (c) 2021 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_connection_ability.h"
17 #include "app_log_wrapper.h"
18 #include "base_ability.h"
19
20 namespace OHOS {
21 namespace AppExecFwk {
22 using namespace OHOS::EventFwk;
23
~AbilityConnectionAbility()24 AbilityConnectionAbility::~AbilityConnectionAbility()
25 {
26 CommonEventManager::UnSubscribeCommonEvent(subscriber_);
27 }
28
Init(const std::shared_ptr<AbilityInfo> & abilityInfo,const std::shared_ptr<OHOSApplication> & application,std::shared_ptr<AbilityHandler> & handler,const sptr<IRemoteObject> & token)29 void AbilityConnectionAbility::Init(const std::shared_ptr<AbilityInfo> &abilityInfo,
30 const std::shared_ptr<OHOSApplication> &application, std::shared_ptr<AbilityHandler> &handler,
31 const sptr<IRemoteObject> &token)
32 {
33 APP_LOGI("AbilityConnectionAbility::Init called.");
34 BaseAbility::Init(abilityInfo, application, handler, token);
35
36 SubscribeEvent();
37 }
38
SubscribeEvent()39 bool AbilityConnectionAbility::SubscribeEvent()
40 {
41 MatchingSkills matchingSkills;
42 matchingSkills.AddEvent(APP_ABILITY_CONNECTION_REQ_EVENT_NAME);
43 CommonEventSubscribeInfo subscribeInfo(matchingSkills);
44 subscribeInfo.SetPriority(1);
45 subscriber_ = std::make_shared<AbilityConnectionAbilityEventSubscriber>(subscribeInfo);
46 subscriber_->mainAbility = *this;
47 return CommonEventManager::SubscribeCommonEvent(subscriber_);
48 }
49
OnStart(const Want & want)50 void AbilityConnectionAbility::OnStart(const Want &want)
51 {
52 want_ = want;
53 sequenceNumber_ = GetNoFromWantInfo(want);
54 APP_LOGI("AbilityConnectionAbility::OnStart");
55
56 BaseAbility::OnStart(want);
57 TestUtils::PublishEvent(
58 APP_ABILITY_CONNECTION_RESP_EVENT_NAME, AbilityLifecycleExecutor::LifecycleState::INACTIVE, "OnStart");
59 }
60
OnStop()61 void AbilityConnectionAbility::OnStop()
62 {
63 APP_LOGI("AbilityConnectionAbility::OnStop");
64 BaseAbility::OnStop();
65 TestUtils::PublishEvent(
66 APP_ABILITY_CONNECTION_RESP_EVENT_NAME, AbilityLifecycleExecutor::LifecycleState::INITIAL, "OnStop");
67 }
68
OnActive()69 void AbilityConnectionAbility::OnActive()
70 {
71 APP_LOGI("AbilityConnectionAbility::OnActive");
72 BaseAbility::OnActive();
73 TestUtils::PublishEvent(
74 APP_ABILITY_CONNECTION_RESP_EVENT_NAME, AbilityLifecycleExecutor::LifecycleState::ACTIVE, "OnActive");
75 }
76
OnInactive()77 void AbilityConnectionAbility::OnInactive()
78 {
79 APP_LOGI("AbilityConnectionAbility::OnInactive");
80 BaseAbility::OnInactive();
81 TestUtils::PublishEvent(
82 APP_ABILITY_CONNECTION_RESP_EVENT_NAME, AbilityLifecycleExecutor::LifecycleState::INACTIVE, "OnInactive");
83 }
84
OnBackground()85 void AbilityConnectionAbility::OnBackground()
86 {
87 APP_LOGI("AbilityConnectionAbility::OnBackground");
88 BaseAbility::OnBackground();
89 TestUtils::PublishEvent(
90 APP_ABILITY_CONNECTION_RESP_EVENT_NAME, AbilityLifecycleExecutor::LifecycleState::BACKGROUND, "OnBackground");
91 }
92
OnForeground(const Want & want)93 void AbilityConnectionAbility::OnForeground(const Want &want)
94 {
95 APP_LOGI("AbilityConnectionAbility::OnForeground");
96 BaseAbility::OnBackground();
97 TestUtils::PublishEvent(
98 APP_ABILITY_CONNECTION_RESP_EVENT_NAME, AbilityLifecycleExecutor::LifecycleState::INACTIVE, "OnForeground");
99 }
100
OnCommand(const Want & want,bool restart,int startId)101 void AbilityConnectionAbility::OnCommand(const Want &want, bool restart, int startId)
102 {
103 APP_LOGI("AbilityConnectionAbility::OnCommand");
104
105 BaseAbility::OnCommand(want, restart, startId);
106 TestUtils::PublishEvent(
107 APP_ABILITY_CONNECTION_RESP_EVENT_NAME, AbilityLifecycleExecutor::LifecycleState::ACTIVE, "OnCommand");
108 }
109
OnConnect(const Want & want)110 sptr<IRemoteObject> AbilityConnectionAbility::OnConnect(const Want &want)
111 {
112 APP_LOGI("AbilityConnectionAbility::OnConnect");
113
114 sptr<IRemoteObject> ret = BaseAbility::OnConnect(want);
115 TestUtils::PublishEvent(
116 APP_ABILITY_CONNECTION_RESP_EVENT_NAME, AbilityLifecycleExecutor::LifecycleState::ACTIVE, "OnConnect");
117 return ret;
118 }
119
OnDisconnect(const Want & want)120 void AbilityConnectionAbility::OnDisconnect(const Want &want)
121 {
122 APP_LOGI("AbilityConnectionAbility::OnDisconnect");
123
124 BaseAbility::OnDisconnect(want);
125 TestUtils::PublishEvent(
126 APP_ABILITY_CONNECTION_RESP_EVENT_NAME, AbilityLifecycleExecutor::LifecycleState::BACKGROUND, "OnDisconnect");
127 }
128
ConnectCaseIndexOne()129 void AbilityConnectionAbility::ConnectCaseIndexOne() {
130 stub_ = new (std::nothrow) AbilityConnectionConnectCallback();
131 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
132 bool ret = BaseAbility::GetContext()->ConnectAbility(want_, connCallback_);
133 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, ret, "TestConnectAbility");
134 sleep(1);
135 BaseAbility::GetContext()->DisconnectAbility(connCallback_);
136 }
137
ConnectCaseIndexTwo()138 void AbilityConnectionAbility::ConnectCaseIndexTwo() {
139 stub_ = new (std::nothrow) AbilityConnectionConnectCallback();
140 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
141 MAP_STR_STR params;
142 Want want =
143 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKit", params);
144 bool ret = BaseAbility::GetContext()->ConnectAbility(want, connCallback_);
145 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, ret, "TestConnectAbility");
146 sleep(1);
147 BaseAbility::GetContext()->DisconnectAbility(connCallback_);
148 }
149
TestConnectAbility()150 void AbilityConnectionAbility::TestConnectAbility()
151 {
152 switch ((CaseIndex)std::stoi(AbilityConnectionAbility::sequenceNumber_)) {
153 case CaseIndex::ONE: {
154 ConnectCaseIndexOne();
155 } break;
156 case CaseIndex::TWO: {
157 ConnectCaseIndexTwo();
158 } break;
159 case CaseIndex::THREE: {
160 stub_ = new (std::nothrow) AbilityConnectionConnectCallback();
161 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
162 MAP_STR_STR params;
163 Want want = TestUtils::MakeWant("", "AmsStServiceAbilityA1", "com.ohos.amsst.service.appA", params);
164 bool ret = BaseAbility::GetContext()->ConnectAbility(want, connCallback_);
165 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, ret, "TestConnectAbility");
166 sleep(1);
167 BaseAbility::GetContext()->DisconnectAbility(connCallback_);
168 } break;
169 case CaseIndex::FOUR: {
170 for (int i = 0; i < (int)CaseIndex::THREE; i++) {
171 stub_ = new (std::nothrow) AbilityConnectionConnectCallback();
172 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
173 bool ret = BaseAbility::GetContext()->ConnectAbility(want_, connCallback_);
174 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, ret, "TestConnectAbility");
175 sleep(1);
176 BaseAbility::GetContext()->DisconnectAbility(connCallback_);
177 }
178 } break;
179 case CaseIndex::FIVE: {
180 sptr<AbilityConnectionConnectCallback> stub(new (std::nothrow) AbilityConnectionConnectCallback());
181 sptr<AbilityConnectionProxy> connCallback(new (std::nothrow) AbilityConnectionProxy(stub));
182 bool ret = BaseAbility::GetContext()->ConnectAbility(want_, connCallback);
183 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, ret, "TestConnectAbility");
184 sleep(1);
185 BaseAbility::GetContext()->DisconnectAbility(connCallback_);
186 } break;
187 default:
188 break;
189 }
190 }
191
TestStopAbility()192 void AbilityConnectionAbility::TestStopAbility()
193 {
194 switch ((CaseIndex)std::stoi(AbilityConnectionAbility::sequenceNumber_)) {
195 case CaseIndex::ONE: {
196 bool ret = BaseAbility::GetContext()->StopAbility(want_);
197 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, ret, "TestStopAbility");
198 } break;
199 case CaseIndex::TWO: {
200 MAP_STR_STR params;
201 Want want =
202 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKit", params);
203 bool ret = BaseAbility::GetContext()->StopAbility(want);
204 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, ret, "TestStopAbility");
205 } break;
206 case CaseIndex::THREE: {
207 MAP_STR_STR params;
208 Want want = TestUtils::MakeWant("", "AmsStServiceAbilityA1", "com.ohos.amsst.service.appA", params);
209 bool ret = BaseAbility::GetContext()->StopAbility(want);
210 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, ret, "TestStopAbility");
211 } break;
212 case CaseIndex::FOUR: {
213 for (int i = 0; i < (int)CaseIndex::THREE; i++) {
214 bool ret = BaseAbility::GetContext()->StopAbility(want_);
215 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, ret, "TestStopAbility");
216 }
217 } break;
218 case CaseIndex::FIVE: {
219 MAP_STR_STR params;
220 Want want =
221 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKitx", params);
222 bool ret = BaseAbility::GetContext()->StopAbility(want);
223 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, ret, "TestStopAbility");
224 } break;
225 default:
226 break;
227 }
228 }
229
DisconnectCaseIndexOne()230 void AbilityConnectionAbility::DisconnectCaseIndexOne() {
231 stub_ = new (std::nothrow) AbilityConnectionConnectCallback();
232 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
233 bool ret = BaseAbility::GetContext()->ConnectAbility(want_, connCallback_);
234 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, ret, "TestDisconnectAbility");
235 sleep(1);
236 BaseAbility::GetContext()->DisconnectAbility(connCallback_);
237 }
238
DisconnectCaseIndexTwo()239 void AbilityConnectionAbility::DisconnectCaseIndexTwo() {
240 MAP_STR_STR params;
241 Want want =
242 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKit", params);
243 stub_ = new (std::nothrow) AbilityConnectionConnectCallback();
244 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
245 bool ret = BaseAbility::GetContext()->ConnectAbility(want, connCallback_);
246 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, ret, "TestDisconnectAbility");
247 sleep(1);
248 BaseAbility::GetContext()->DisconnectAbility(connCallback_);
249 }
250
TestDisconnectAbility()251 void AbilityConnectionAbility::TestDisconnectAbility()
252 {
253 switch ((CaseIndex)std::stoi(AbilityConnectionAbility::sequenceNumber_)) {
254 case CaseIndex::ONE: {
255 DisconnectCaseIndexOne();
256 } break;
257 case CaseIndex::TWO: {
258 DisconnectCaseIndexTwo();
259 } break;
260 case CaseIndex::THREE: {
261 MAP_STR_STR params;
262 Want want = TestUtils::MakeWant("", "AmsStServiceAbilityA1", "com.ohos.amsst.service.appA", params);
263 stub_ = new (std::nothrow) AbilityConnectionConnectCallback();
264 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
265 bool ret = BaseAbility::GetContext()->ConnectAbility(want, connCallback_);
266 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, ret, "TestDisconnectAbility");
267 sleep(1);
268 BaseAbility::GetContext()->DisconnectAbility(connCallback_);
269 } break;
270 case CaseIndex::FOUR: {
271 for (int i = 0; i < (int)CaseIndex::THREE; i++) {
272 stub_ = new (std::nothrow) AbilityConnectionConnectCallback();
273 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
274 bool ret = BaseAbility::GetContext()->ConnectAbility(want_, connCallback_);
275 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, ret, "TestDisconnectAbility");
276 sleep(1);
277 BaseAbility::GetContext()->DisconnectAbility(connCallback_);
278 }
279 } break;
280 case CaseIndex::FIVE: {
281 MAP_STR_STR params;
282 Want want =
283 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKitx", params);
284 stub_ = new (std::nothrow) AbilityConnectionConnectCallback();
285 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
286 bool ret = BaseAbility::GetContext()->ConnectAbility(want, connCallback_);
287 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, ret, "TestDisconnectAbility");
288 sleep(1);
289 BaseAbility::GetContext()->DisconnectAbility(connCallback_);
290 } break;
291 default:
292 break;
293 }
294 }
295
TestStartAbility()296 void AbilityConnectionAbility::TestStartAbility()
297 {
298 switch ((CaseIndex)std::stoi(AbilityConnectionAbility::sequenceNumber_)) {
299 case CaseIndex::ONE: {
300 BaseAbility::GetContext()->StartAbility(want_, 0);
301 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, 1, "TestStartAbility");
302 } break;
303 case CaseIndex::TWO: {
304 MAP_STR_STR params;
305 Want want =
306 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKit", params);
307 BaseAbility::GetContext()->StartAbility(want, 0);
308 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, 1, "TestStartAbility");
309 } break;
310 case CaseIndex::THREE: {
311 MAP_STR_STR params;
312 Want want = TestUtils::MakeWant("", "AmsStServiceAbilityA1", "com.ohos.amsst.service.appA", params);
313 BaseAbility::GetContext()->StartAbility(want, 0);
314 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, 1, "TestStartAbility");
315 } break;
316 case CaseIndex::FOUR: {
317 for (int i = 0; i < (int)CaseIndex::THREE; i++) {
318 BaseAbility::GetContext()->StartAbility(want_, 0);
319 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, 1, "TestStartAbility");
320 }
321 } break;
322 case CaseIndex::FIVE: {
323 MAP_STR_STR params;
324 Want want =
325 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKitx", params);
326 BaseAbility::GetContext()->StartAbility(want, 0);
327 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, 1, "TestStartAbility");
328 } break;
329 default:
330 break;
331 }
332 }
333
TestTerminateAbility()334 void AbilityConnectionAbility::TestTerminateAbility()
335 {
336 switch ((CaseIndex)std::stoi(AbilityConnectionAbility::sequenceNumber_)) {
337 case CaseIndex::ONE: {
338 BaseAbility::GetContext()->TerminateAbility();
339 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, 1, "TestTerminateAbility");
340 } break;
341 case CaseIndex::TWO: {
342 MAP_STR_STR params;
343 Want want =
344 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKit", params);
345 BaseAbility::GetContext()->StartAbility(want, 0);
346 BaseAbility::GetContext()->TerminateAbility();
347 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, 1, "TestTerminateAbility");
348 } break;
349 case CaseIndex::THREE: {
350 MAP_STR_STR params;
351 Want want = TestUtils::MakeWant("", "AmsStServiceAbilityA1", "com.ohos.amsst.service.appA", params);
352 BaseAbility::GetContext()->StartAbility(want, 0);
353 BaseAbility::GetContext()->TerminateAbility();
354 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, 1, "TestTerminateAbility");
355 } break;
356 case CaseIndex::FOUR: {
357 for (int i = 0; i < (int)CaseIndex::THREE; i++) {
358 BaseAbility::GetContext()->TerminateAbility();
359 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, 1, "TestTerminateAbility");
360 }
361 } break;
362 case CaseIndex::FIVE: {
363 MAP_STR_STR params;
364 Want want =
365 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKitx", params);
366 BaseAbility::GetContext()->StartAbility(want, 0);
367 BaseAbility::GetContext()->TerminateAbility();
368 TestUtils::PublishEvent(APP_ABILITY_CONNECTION_RESP_EVENT_NAME, 1, "TestTerminateAbility");
369 } break;
370 default:
371 break;
372 }
373 }
374
OnReceiveEvent(const CommonEventData & data)375 void AbilityConnectionAbilityEventSubscriber::OnReceiveEvent(const CommonEventData &data)
376 {
377 APP_LOGI(
378 "AbilityConnectionAbilityEventSubscriber::OnReceiveEvent:event=%{public}s", data.GetWant().GetAction().c_str());
379 APP_LOGI("AbilityConnectionAbilityEventSubscriber::OnReceiveEvent:data=%{public}s", data.GetData().c_str());
380 APP_LOGI("AbilityConnectionAbilityEventSubscriber::OnReceiveEvent:code=%{public}d", data.GetCode());
381
382 auto eventName = data.GetWant().GetAction();
383 if (std::strcmp(eventName.c_str(), APP_ABILITY_CONNECTION_REQ_EVENT_NAME.c_str()) == 0) {
384 auto target = data.GetData();
385 auto func = mapTestFunc_.find(target);
386 if (func != mapTestFunc_.end()) {
387 func->second();
388 } else {
389 APP_LOGI("AbilityConnectionAbilityEventSubscriber::OnReceiveEvent: CommonEventData error(%{public}s)",
390 target.c_str());
391 }
392 }
393 }
394 REGISTER_AA(AbilityConnectionAbility)
395 } // namespace AppExecFwk
396 } // namespace OHOS