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_ability.h"
17 #include "app_log_wrapper.h"
18 #include "test_utils.h"
19
20 namespace OHOS {
21 namespace AppExecFwk {
22 using namespace OHOS::EventFwk;
23 namespace {
24 constexpr int SLEEP_SECOND = 2;
25 constexpr int loopCnt = 3;
26 }
27
~AbilityAbility()28 AbilityAbility::~AbilityAbility()
29 {
30 CommonEventManager::UnSubscribeCommonEvent(subscriber_);
31 }
32
Init(const std::shared_ptr<AbilityInfo> & abilityInfo,const std::shared_ptr<OHOSApplication> & application,std::shared_ptr<AbilityHandler> & handler,const sptr<IRemoteObject> & token)33 void AbilityAbility::Init(const std::shared_ptr<AbilityInfo> &abilityInfo,
34 const std::shared_ptr<OHOSApplication> &application, std::shared_ptr<AbilityHandler> &handler,
35 const sptr<IRemoteObject> &token)
36 {
37 APP_LOGI("AbilityAbility::Init called.");
38 BaseAbility::Init(abilityInfo, application, handler, token);
39
40 SubscribeEvent();
41 }
42
DoTestCase()43 void AbilityAbility::DoTestCase()
44 {
45 if (!AbilityAbility::sequenceNumber_.empty()) {
46 switch ((CaseIndex)std::stoi(AbilityAbility::sequenceNumber_)) {
47 case CaseIndex::TWELVE:
48 OHOS::AppExecFwk::PostTask<AbilityConnectCallback>();
49 break;
50 case CaseIndex::THIRTEEN:
51 DoWhile<AbilityConnectCallback>();
52 break;
53 default:
54 break;
55 }
56 }
57 }
58
SubscribeEvent()59 bool AbilityAbility::SubscribeEvent()
60 {
61 MatchingSkills matchingSkills;
62 matchingSkills.AddEvent(APP_ABILITY_REQ_EVENT_NAME);
63 CommonEventSubscribeInfo subscribeInfo(matchingSkills);
64 subscribeInfo.SetPriority(1);
65 subscriber_ = std::make_shared<AbilityAbilityEventSubscriber>(subscribeInfo);
66 subscriber_->mainAbility = *this;
67 return CommonEventManager::SubscribeCommonEvent(subscriber_);
68 }
69
OnStart(const Want & want)70 void AbilityAbility::OnStart(const Want &want)
71 {
72 APP_LOGI("AbilityAbility::OnStart");
73
74 sequenceNumber_ = GetNoFromWantInfo(want);
75 APP_LOGI("AbilityAbility::OnStart sequenceNumber_ = %{public}s", sequenceNumber_.c_str());
76 want_ = want;
77 APP_LOGI("AbilityAbility::OnStart");
78 BaseAbility::OnStart(want);
79 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, AbilityLifecycleExecutor::LifecycleState::INACTIVE, "OnStart");
80
81 DoTestCase();
82 }
83
OnStop()84 void AbilityAbility::OnStop()
85 {
86 APP_LOGI("AbilityAbility::OnStop");
87
88 BaseAbility::OnStop();
89 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, AbilityLifecycleExecutor::LifecycleState::INITIAL, "OnStop");
90
91 DoTestCase();
92 }
93
OnActive()94 void AbilityAbility::OnActive()
95 {
96 APP_LOGI("AbilityAbility::OnActive");
97
98 BaseAbility::OnActive();
99 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, AbilityLifecycleExecutor::LifecycleState::ACTIVE, "OnActive");
100
101 DoTestCase();
102 }
103
OnInactive()104 void AbilityAbility::OnInactive()
105 {
106 APP_LOGI("AbilityAbility::OnInactive");
107
108 BaseAbility::OnInactive();
109 TestUtils::PublishEvent(
110 APP_ABILITY_RESP_EVENT_NAME, AbilityLifecycleExecutor::LifecycleState::INACTIVE, "OnInactive");
111
112 DoTestCase();
113 }
114
OnBackground()115 void AbilityAbility::OnBackground()
116 {
117 APP_LOGI("AbilityAbility::OnBackground");
118
119 BaseAbility::OnBackground();
120 TestUtils::PublishEvent(
121 APP_ABILITY_RESP_EVENT_NAME, AbilityLifecycleExecutor::LifecycleState::BACKGROUND, "OnBackground");
122
123 DoTestCase();
124 }
125
OnForeground(const Want & want)126 void AbilityAbility::OnForeground(const Want &want)
127 {
128 APP_LOGI("AbilityAbility::OnForeground");
129
130 BaseAbility::OnBackground();
131 TestUtils::PublishEvent(
132 APP_ABILITY_RESP_EVENT_NAME, AbilityLifecycleExecutor::LifecycleState::INACTIVE, "OnForeground");
133
134 DoTestCase();
135 }
136
OnCommand(const Want & want,bool restart,int startId)137 void AbilityAbility::OnCommand(const Want &want, bool restart, int startId)
138 {
139 APP_LOGI("AbilityAbility::OnCommand");
140
141 BaseAbility::OnCommand(want, restart, startId);
142 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, AbilityLifecycleExecutor::LifecycleState::ACTIVE, "OnCommand");
143
144 DoTestCase();
145 }
146
OnConnect(const Want & want)147 sptr<IRemoteObject> AbilityAbility::OnConnect(const Want &want)
148 {
149 APP_LOGI("AbilityAbility::OnConnect");
150
151 sptr<IRemoteObject> ret = BaseAbility::OnConnect(want);
152 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, AbilityLifecycleExecutor::LifecycleState::ACTIVE, "OnConnect");
153
154 DoTestCase();
155
156 return ret;
157 }
158
OnDisconnect(const Want & want)159 void AbilityAbility::OnDisconnect(const Want &want)
160 {
161 APP_LOGI("AbilityAbility::OnDisconnect");
162
163 BaseAbility::OnDisconnect(want);
164 TestUtils::PublishEvent(
165 APP_ABILITY_RESP_EVENT_NAME, AbilityLifecycleExecutor::LifecycleState::BACKGROUND, "OnDisconnect");
166
167 DoTestCase();
168 }
169
OnNewWant(const Want & want)170 void AbilityAbility::OnNewWant(const Want &want)
171 {
172 APP_LOGI("AbilityAbility::OnNewWant");
173
174 BaseAbility::OnNewWant(want);
175 TestUtils::PublishEvent(
176 APP_ABILITY_RESP_EVENT_NAME, AbilityLifecycleExecutor::LifecycleState::INACTIVE, "OnNewWant");
177
178 DoTestCase();
179 }
180
CaseIndexOne()181 void AbilityAbility::CaseIndexOne() {
182 stub_ = new (std::nothrow) AbilityConnectCallback();
183 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
184 bool ret = ConnectAbility(want_, connCallback_);
185 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestConnectAbility");
186 sleep(SLEEP_SECOND);
187 DisconnectAbility(connCallback_);
188 }
189
CaseIndexTwo()190 void AbilityAbility::CaseIndexTwo() {
191 stub_ = new (std::nothrow) AbilityConnectCallback();
192 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
193 MAP_STR_STR params;
194 Want want =
195 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKit", params);
196 bool ret = ConnectAbility(want, connCallback_);
197 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestConnectAbility");
198 sleep(SLEEP_SECOND);
199 DisconnectAbility(connCallback_);
200 }
201
TestConnectAbility()202 void AbilityAbility::TestConnectAbility()
203 {
204 APP_LOGI("AbilityAbility::OnStart sequenceNumber_ = %{public}s %{public}d",
205 sequenceNumber_.c_str(),
206 std::stoi(AbilityAbility::sequenceNumber_));
207
208 switch ((CaseIndex)std::stoi(AbilityAbility::sequenceNumber_)) {
209 case CaseIndex::ONE: {
210 CaseIndexOne();
211 } break;
212 case CaseIndex::TWO: {
213 CaseIndexTwo();
214 } break;
215 case CaseIndex::THREE: {
216 stub_ = new (std::nothrow) AbilityConnectCallback();
217 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
218 MAP_STR_STR params;
219 Want want = TestUtils::MakeWant("", "AmsStServiceAbilityA1", "com.ohos.amsst.service.appA", params);
220 bool ret = ConnectAbility(want, connCallback_);
221 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestConnectAbility");
222 sleep(SLEEP_SECOND);
223 DisconnectAbility(connCallback_);
224 } break;
225 case CaseIndex::FOUR: {
226 for (int i = 0; i < (int)CaseIndex::THREE; i++) {
227 stub_ = new (std::nothrow) AbilityConnectCallback();
228 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
229 bool ret = ConnectAbility(want_, connCallback_);
230 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestConnectAbility");
231 sleep(SLEEP_SECOND);
232 DisconnectAbility(connCallback_);
233 }
234 } break;
235 case CaseIndex::FIVE: {
236 sptr<AbilityConnectCallback> stub(new (std::nothrow) AbilityConnectCallback());
237 sptr<AbilityConnectionProxy> connCallback(new (std::nothrow) AbilityConnectionProxy(stub));
238 bool ret = ConnectAbility(want_, connCallback);
239 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestConnectAbility");
240 sleep(SLEEP_SECOND);
241 DisconnectAbility(connCallback);
242 } break;
243 default:
244 break;
245 }
246 }
247
TestStopAbility()248 void AbilityAbility::TestStopAbility()
249 {
250 APP_LOGI("AbilityAbility::OnStart sequenceNumber_ = %{public}s %{public}d",
251 sequenceNumber_.c_str(),
252 std::stoi(AbilityAbility::sequenceNumber_));
253
254 switch ((CaseIndex)std::stoi(AbilityAbility::sequenceNumber_)) {
255 case CaseIndex::ONE: {
256 bool ret = StopAbility(want_);
257 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestStopAbility");
258 } break;
259 case CaseIndex::TWO: {
260 MAP_STR_STR params;
261 Want want =
262 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKit", params);
263 bool ret = StopAbility(want);
264 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestStopAbility");
265 } break;
266 case CaseIndex::THREE: {
267 MAP_STR_STR params;
268 Want want = TestUtils::MakeWant("", "AmsStServiceAbilityA1", "com.ohos.amsst.service.appA", params);
269 bool ret = StopAbility(want);
270 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestStopAbility");
271 } break;
272 case CaseIndex::FOUR: {
273 for (int i = 0; i < loopCnt; i++) {
274 bool ret = StopAbility(want_);
275 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestStopAbility");
276 }
277 } break;
278 case CaseIndex::FIVE: {
279 MAP_STR_STR params;
280 Want want =
281 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKitx", params);
282 bool ret = StopAbility(want);
283 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestStopAbility");
284 } break;
285 default:
286 break;
287 }
288 }
289
DisconnectCaseIndexOne()290 void AbilityAbility::DisconnectCaseIndexOne() {
291 stub_ = new (std::nothrow) AbilityConnectCallback();
292 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
293 bool ret = ConnectAbility(want_, connCallback_);
294 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestDisconnectAbility");
295 DisconnectAbility(connCallback_);
296 }
297
DisconnectCaseIndexTwo()298 void AbilityAbility::DisconnectCaseIndexTwo() {
299 MAP_STR_STR params;
300 Want want =
301 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKit", params);
302 stub_ = new (std::nothrow) AbilityConnectCallback();
303 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
304 bool ret = ConnectAbility(want, connCallback_);
305 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestDisconnectAbility");
306 DisconnectAbility(connCallback_);
307 }
308
TestDisconnectAbility()309 void AbilityAbility::TestDisconnectAbility()
310 {
311 APP_LOGI("AbilityAbility::OnStart sequenceNumber_ = %{public}s %{public}d",
312 sequenceNumber_.c_str(),
313 std::stoi(AbilityAbility::sequenceNumber_));
314
315 switch ((CaseIndex)std::stoi(AbilityAbility::sequenceNumber_)) {
316 case CaseIndex::ONE: {
317 DisconnectCaseIndexOne();
318 } break;
319 case CaseIndex::TWO: {
320 DisconnectCaseIndexTwo();
321 } break;
322 case CaseIndex::THREE: {
323 MAP_STR_STR params;
324 Want want = TestUtils::MakeWant("", "AmsStServiceAbilityA1", "com.ohos.amsst.service.appA", params);
325 stub_ = new (std::nothrow) AbilityConnectCallback();
326 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
327 bool ret = ConnectAbility(want, connCallback_);
328 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestDisconnectAbility");
329 DisconnectAbility(connCallback_);
330 } break;
331 case CaseIndex::FOUR: {
332 for (int i = 0; i < loopCnt; i++) {
333 stub_ = new (std::nothrow) AbilityConnectCallback();
334 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
335 bool ret = ConnectAbility(want_, connCallback_);
336 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestDisconnectAbility");
337 DisconnectAbility(connCallback_);
338 }
339 } break;
340 case CaseIndex::FIVE: {
341 MAP_STR_STR params;
342 Want want =
343 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKitx", params);
344 stub_ = new (std::nothrow) AbilityConnectCallback();
345 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
346 bool ret = ConnectAbility(want, connCallback_);
347 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestDisconnectAbility");
348 DisconnectAbility(connCallback_);
349 } break;
350 default:
351 break;
352 }
353 }
354
TestStartAbility()355 void AbilityAbility::TestStartAbility()
356 {
357 APP_LOGI("AbilityAbility::OnStart sequenceNumber_ = %{public}s %{public}d",
358 sequenceNumber_.c_str(),
359 std::stoi(AbilityAbility::sequenceNumber_));
360
361 switch ((CaseIndex)std::stoi(AbilityAbility::sequenceNumber_)) {
362 case CaseIndex::ONE: {
363 StartAbility(want_, 0);
364 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, 1, "TestStartAbility");
365 } break;
366 case CaseIndex::TWO: {
367 MAP_STR_STR params;
368 Want want =
369 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKit", params);
370 StartAbility(want, INT_MAX);
371 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, 1, "TestStartAbility");
372 } break;
373 case CaseIndex::THREE: {
374 MAP_STR_STR params;
375 Want want = TestUtils::MakeWant("", "AmsStServiceAbilityA1", "com.ohos.amsst.service.appA", params);
376 StartAbility(want, INT_MIN);
377 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, 1, "TestStartAbility");
378 } break;
379 case CaseIndex::FOUR: {
380 for (int i = 0; i < (int)CaseIndex::THREE; i++) {
381 StartAbility(want_, 0);
382 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, 1, "TestStartAbility");
383 }
384 } break;
385 case CaseIndex::FIVE: {
386 MAP_STR_STR params;
387 Want want =
388 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKitx", params);
389 StartAbility(want, 0);
390 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, 1, "TestStartAbility");
391 } break;
392 default:
393 break;
394 }
395 }
396
TestTerminateAbility()397 void AbilityAbility::TestTerminateAbility()
398 {
399 APP_LOGI("AbilityAbility::OnStart sequenceNumber_ = %{public}s %{public}d",
400 sequenceNumber_.c_str(),
401 std::stoi(AbilityAbility::sequenceNumber_));
402
403 switch ((CaseIndex)std::stoi(AbilityAbility::sequenceNumber_)) {
404 case CaseIndex::ONE: {
405 TerminateAbility();
406 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, 1, "TestTerminateAbility");
407 } break;
408 case CaseIndex::TWO: {
409 MAP_STR_STR params;
410 Want want =
411 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKit", params);
412 StartAbility(want, 0);
413 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, 1, "TestTerminateAbility");
414 sleep(SLEEP_SECOND);
415 StopAbility(want);
416 TerminateAbility();
417 } break;
418 case CaseIndex::THREE: {
419 MAP_STR_STR params;
420 Want want = TestUtils::MakeWant("", "AmsStServiceAbilityA1", "com.ohos.amsst.service.appA", params);
421 StartAbility(want, 0);
422 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, 1, "TestTerminateAbility");
423 sleep(SLEEP_SECOND);
424 StopAbility(want);
425 TerminateAbility();
426 } break;
427 case CaseIndex::FOUR: {
428 for (int i = 0; i < (int)CaseIndex::THREE; i++) {
429 TerminateAbility();
430 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, 1, "TestTerminateAbility");
431 }
432 } break;
433 case CaseIndex::FIVE: {
434 MAP_STR_STR params;
435 Want want =
436 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKitx", params);
437 StartAbility(want, 0);
438 sleep(SLEEP_SECOND);
439 TerminateAbility();
440 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, 1, "TestTerminateAbility");
441 } break;
442 default:
443 break;
444 }
445 }
446
TestAbilityStartAbility()447 void AbilityAbility::TestAbilityStartAbility()
448 {
449 APP_LOGI("AbilityAbility::OnStart sequenceNumber_ = %{public}s %{public}d",
450 sequenceNumber_.c_str(),
451 std::stoi(AbilityAbility::sequenceNumber_));
452
453 switch ((CaseIndex)std::stoi(AbilityAbility::sequenceNumber_)) {
454 case CaseIndex::ONE: {
455 StartAbility(want_);
456 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, 1, "TestAbilityStartAbility");
457 } break;
458 case CaseIndex::TWO: {
459 MAP_STR_STR params;
460 Want want =
461 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKit", params);
462 StartAbility(want);
463 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, 1, "TestAbilityStartAbility");
464 sleep(1);
465 StopAbility(want);
466 } break;
467 case CaseIndex::THREE: {
468 MAP_STR_STR params;
469 Want want = TestUtils::MakeWant("", "AmsStServiceAbilityA1", "com.ohos.amsst.service.appA", params);
470 StartAbility(want);
471 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, 1, "TestAbilityStartAbility");
472 sleep(1);
473 StopAbility(want);
474 } break;
475 case CaseIndex::FOUR: {
476 for (int i = 0; i < (int)CaseIndex::THREE; i++) {
477 StartAbility(want_);
478 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, 1, "TestAbilityStartAbility");
479 }
480 } break;
481 case CaseIndex::FIVE: {
482 MAP_STR_STR params;
483 Want want =
484 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKitx", params);
485 StartAbility(want);
486 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, 1, "TestAbilityStartAbility");
487 } break;
488 default:
489 break;
490 }
491 }
492
TestAbilityConnectAbility()493 void AbilityAbility::TestAbilityConnectAbility()
494 {
495 APP_LOGI("AbilityAbility::OnStart sequenceNumber_ = %{public}s %{public}d",
496 sequenceNumber_.c_str(),
497 std::stoi(AbilityAbility::sequenceNumber_));
498
499 switch ((CaseIndex)std::stoi(AbilityAbility::sequenceNumber_)) {
500 case CaseIndex::ONE: {
501 stub_ = new (std::nothrow) AbilityConnectCallback();
502 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
503 bool ret = ConnectAbility(want_, connCallback_);
504 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestAbilityConnectAbility");
505 } break;
506 case CaseIndex::TWO: {
507 stub_ = new (std::nothrow) AbilityConnectCallback();
508 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
509 MAP_STR_STR params;
510 Want want =
511 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKit", params);
512 bool ret = ConnectAbility(want, connCallback_);
513 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestAbilityConnectAbility");
514 sleep(SLEEP_SECOND);
515 DisconnectAbility(connCallback_);
516 } break;
517 case CaseIndex::THREE: {
518 stub_ = new (std::nothrow) AbilityConnectCallback();
519 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
520 MAP_STR_STR params;
521 Want want = TestUtils::MakeWant("", "AmsStServiceAbilityA1", "com.ohos.amsst.service.appA", params);
522 bool ret = ConnectAbility(want, connCallback_);
523 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestAbilityConnectAbility");
524 sleep(SLEEP_SECOND);
525 DisconnectAbility(connCallback_);
526 } break;
527 case CaseIndex::FOUR: {
528 for (int i = 0; i < (int)CaseIndex::THREE; i++) {
529 stub_ = new (std::nothrow) AbilityConnectCallback();
530 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
531 bool ret = ConnectAbility(want_, connCallback_);
532 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestAbilityConnectAbility");
533 }
534 } break;
535 case CaseIndex::FIVE: {
536 sptr<AbilityConnectCallback> stub(new (std::nothrow) AbilityConnectCallback());
537 sptr<AbilityConnectionProxy> connCallback(new (std::nothrow) AbilityConnectionProxy(stub));
538 bool ret = ConnectAbility(want_, connCallback);
539 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestAbilityConnectAbility");
540 } break;
541 default:
542 break;
543 }
544 }
545
TestAbilityStopAbility()546 void AbilityAbility::TestAbilityStopAbility()
547 {
548 APP_LOGI("AbilityAbility::OnStart sequenceNumber_ = %{public}s %{public}d",
549 sequenceNumber_.c_str(),
550 std::stoi(AbilityAbility::sequenceNumber_));
551
552 switch ((CaseIndex)std::stoi(AbilityAbility::sequenceNumber_)) {
553 case CaseIndex::ONE: {
554 bool ret = StopAbility(want_);
555 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestAbilityStopAbility");
556 } break;
557 case CaseIndex::TWO: {
558 MAP_STR_STR params;
559 Want want =
560 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKit", params);
561 StartAbility(want);
562 sleep(1);
563 bool ret = StopAbility(want);
564 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestAbilityStopAbility");
565 } break;
566 case CaseIndex::THREE: {
567 MAP_STR_STR params;
568 Want want = TestUtils::MakeWant("", "AmsStServiceAbilityA1", "com.ohos.amsst.service.appA", params);
569 StartAbility(want);
570 sleep(1);
571 bool ret = StopAbility(want);
572 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestAbilityStopAbility");
573 } break;
574 case CaseIndex::FOUR: {
575 for (int i = 0; i < (int)CaseIndex::THREE; i++) {
576 bool ret = StopAbility(want_);
577 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestAbilityStopAbility");
578 }
579 } break;
580 case CaseIndex::FIVE: {
581 MAP_STR_STR params;
582 Want want =
583 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKitx", params);
584 StartAbility(want);
585 bool ret = StopAbility(want);
586 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestAbilityStopAbility");
587 } break;
588 default:
589 break;
590 }
591 }
592
TestAbilityGetLifecycle()593 void AbilityAbility::TestAbilityGetLifecycle()
594 {
595 APP_LOGI("AbilityAbility::OnStart sequenceNumber_ = %{public}s %{public}d",
596 sequenceNumber_.c_str(),
597 std::stoi(AbilityAbility::sequenceNumber_));
598
599 switch ((CaseIndex)std::stoi(AbilityAbility::sequenceNumber_)) {
600 case CaseIndex::ONE: {
601 auto lifecycle = GetLifecycle();
602 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, 1, "TestAbilityGetLifecycle");
603 } break;
604 case CaseIndex::TWO: {
605 for (int i = 0; i < (int)CaseIndex::HANDRED; i++) {
606 auto lifecycle = GetLifecycle();
607 }
608 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, 1, "TestAbilityGetLifecycle");
609 } break;
610 case CaseIndex::THREE: {
611 auto lifecycle = GetLifecycle();
612 TestUtils::PublishEvent(
613 APP_ABILITY_RESP_EVENT_NAME, lifecycle->GetLifecycleState(), "TestAbilityGetLifecycle");
614 } break;
615 case CaseIndex::FOUR: {
616 auto lifecycle = GetLifecycle();
617 lifecycle->AddObserver(nullptr);
618 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, 1, "TestAbilityGetLifecycle");
619 } break;
620 case CaseIndex::FIVE: {
621 auto lifecycle = GetLifecycle();
622 lifecycle->DispatchLifecycle(LifeCycle::Event::ON_ACTIVE);
623 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, 1, "TestAbilityGetLifecycle");
624 } break;
625 case CaseIndex::SIX: {
626 auto lifecycle = GetLifecycle();
627 lifecycle->RemoveObserver(nullptr);
628 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, 1, "TestAbilityGetLifecycle");
629 } break;
630 default:
631 break;
632 }
633 }
634
AbilityDisconnectCaseIndexOne()635 void AbilityAbility::AbilityDisconnectCaseIndexOne() {
636 stub_ = new (std::nothrow) AbilityConnectCallback();
637 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
638 bool ret = ConnectAbility(want_, connCallback_);
639 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestAbilityDisconnectAbility");
640 sleep(1);
641 DisconnectAbility(connCallback_);
642 }
643
AbilityDisconnectCaseIndexTwo()644 void AbilityAbility::AbilityDisconnectCaseIndexTwo() {
645 MAP_STR_STR params;
646 Want want =
647 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKit", params);
648 stub_ = new (std::nothrow) AbilityConnectCallback();
649 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
650 bool ret = ConnectAbility(want, connCallback_);
651 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestAbilityDisconnectAbility");
652 sleep(1);
653 DisconnectAbility(connCallback_);
654 }
655
TestAbilityDisconnectAbility()656 void AbilityAbility::TestAbilityDisconnectAbility()
657 {
658 APP_LOGI("AbilityAbility::OnStart sequenceNumber_ = %{public}s %{public}d",
659 sequenceNumber_.c_str(),
660 std::stoi(AbilityAbility::sequenceNumber_));
661
662 switch ((CaseIndex)std::stoi(AbilityAbility::sequenceNumber_)) {
663 case CaseIndex::ONE: {
664 AbilityDisconnectCaseIndexOne();
665 } break;
666 case CaseIndex::TWO: {
667 AbilityDisconnectCaseIndexTwo();
668 } break;
669 case CaseIndex::THREE: {
670 MAP_STR_STR params;
671 Want want = TestUtils::MakeWant("", "AmsStServiceAbilityA1", "com.ohos.amsst.service.appA", params);
672 stub_ = new (std::nothrow) AbilityConnectCallback();
673 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
674 bool ret = ConnectAbility(want, connCallback_);
675 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestAbilityDisconnectAbility");
676 sleep(1);
677 DisconnectAbility(connCallback_);
678 } break;
679 case CaseIndex::FOUR: {
680 for (int i = 0; i < (int)CaseIndex::THREE; i++) {
681 stub_ = new (std::nothrow) AbilityConnectCallback();
682 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
683 bool ret = ConnectAbility(want_, connCallback_);
684 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestAbilityDisconnectAbility");
685 sleep(1);
686 DisconnectAbility(connCallback_);
687 }
688 } break;
689 case CaseIndex::FIVE: {
690 MAP_STR_STR params;
691 Want want =
692 TestUtils::MakeWant("", "LifecycleCallbacksAbility", "com.ohos.amsst.service.AppKitx", params);
693 stub_ = new (std::nothrow) AbilityConnectCallback();
694 connCallback_ = new (std::nothrow) AbilityConnectionProxy(stub_);
695 bool ret = ConnectAbility(want, connCallback_);
696 TestUtils::PublishEvent(APP_ABILITY_RESP_EVENT_NAME, ret, "TestAbilityDisconnectAbility");
697 sleep(1);
698 DisconnectAbility(connCallback_);
699 } break;
700 default:
701 break;
702 }
703 }
704
OnReceiveEvent(const CommonEventData & data)705 void AbilityAbilityEventSubscriber::OnReceiveEvent(const CommonEventData &data)
706 {
707 APP_LOGI("AbilityAbilityEventSubscriber::OnReceiveEvent:event=%{public}s", data.GetWant().GetAction().c_str());
708 APP_LOGI("AbilityAbilityEventSubscriber::OnReceiveEvent:data=%{public}s", data.GetData().c_str());
709 APP_LOGI("AbilityAbilityEventSubscriber::OnReceiveEvent:code=%{public}d", data.GetCode());
710
711 auto eventName = data.GetWant().GetAction();
712 if (std::strcmp(eventName.c_str(), APP_ABILITY_REQ_EVENT_NAME.c_str()) == 0) {
713 auto target = data.GetData();
714 auto func = mapTestFunc_.find(target);
715 if (func != mapTestFunc_.end()) {
716 func->second();
717 } else {
718 APP_LOGI(
719 "AbilityAbilityEventSubscriber::OnReceiveEvent: CommonEventData error(%{public}s)", target.c_str());
720 }
721 }
722 }
723 REGISTER_AA(AbilityAbility)
724 } // namespace AppExecFwk
725 } // namespace OHOS
726