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 "lifecycle_deal.h"
17
18 #include "ability_record.h"
19 #include "ability_util.h"
20 #include "hilog_wrapper.h"
21
22 namespace OHOS {
23 namespace AAFwk {
LifecycleDeal()24 LifecycleDeal::LifecycleDeal()
25 {}
26
~LifecycleDeal()27 LifecycleDeal::~LifecycleDeal()
28 {}
29
SetScheduler(const sptr<IAbilityScheduler> & scheduler)30 void LifecycleDeal::SetScheduler(const sptr<IAbilityScheduler> &scheduler)
31 {
32 std::unique_lock<std::shared_mutex> lock(schedulerMutex_);
33 abilityScheduler_ = scheduler;
34 }
35
GetScheduler()36 sptr<IAbilityScheduler> LifecycleDeal::GetScheduler()
37 {
38 std::shared_lock<std::shared_mutex> lock(schedulerMutex_);
39 return abilityScheduler_;
40 }
41
Activate(const Want & want,LifeCycleStateInfo & stateInfo)42 void LifecycleDeal::Activate(const Want &want, LifeCycleStateInfo &stateInfo)
43 {
44 HILOG_INFO("Activate.");
45 auto abilityScheduler = GetScheduler();
46 CHECK_POINTER(abilityScheduler);
47 HILOG_INFO("caller %{public}s, %{public}s",
48 stateInfo.caller.bundleName.c_str(),
49 stateInfo.caller.abilityName.c_str());
50 stateInfo.state = AbilityLifeCycleState::ABILITY_STATE_ACTIVE;
51 abilityScheduler->ScheduleAbilityTransaction(want, stateInfo);
52 }
53
Inactivate(const Want & want,LifeCycleStateInfo & stateInfo)54 void LifecycleDeal::Inactivate(const Want &want, LifeCycleStateInfo &stateInfo)
55 {
56 HILOG_INFO("Inactivate.");
57 auto abilityScheduler = GetScheduler();
58 CHECK_POINTER(abilityScheduler);
59 stateInfo.state = AbilityLifeCycleState::ABILITY_STATE_INACTIVE;
60 abilityScheduler->ScheduleAbilityTransaction(want, stateInfo);
61 }
62
MoveToBackground(const Want & want,LifeCycleStateInfo & stateInfo)63 void LifecycleDeal::MoveToBackground(const Want &want, LifeCycleStateInfo &stateInfo)
64 {
65 HILOG_INFO("Move to background.");
66 auto abilityScheduler = GetScheduler();
67 CHECK_POINTER(abilityScheduler);
68 stateInfo.state = AbilityLifeCycleState::ABILITY_STATE_BACKGROUND;
69 abilityScheduler->ScheduleAbilityTransaction(want, stateInfo);
70 }
71
ConnectAbility(const Want & want)72 void LifecycleDeal::ConnectAbility(const Want &want)
73 {
74 HILOG_INFO("Connect ability.");
75 auto abilityScheduler = GetScheduler();
76 CHECK_POINTER(abilityScheduler);
77 abilityScheduler->ScheduleConnectAbility(want);
78 }
79
DisconnectAbility(const Want & want)80 void LifecycleDeal::DisconnectAbility(const Want &want)
81 {
82 HILOG_INFO("Disconnect ability.");
83 auto abilityScheduler = GetScheduler();
84 CHECK_POINTER(abilityScheduler);
85 abilityScheduler->ScheduleDisconnectAbility(want);
86 }
87
Terminate(const Want & want,LifeCycleStateInfo & stateInfo)88 void LifecycleDeal::Terminate(const Want &want, LifeCycleStateInfo &stateInfo)
89 {
90 HILOG_INFO("Terminate, send ipc request.");
91 auto abilityScheduler = GetScheduler();
92 CHECK_POINTER(abilityScheduler);
93 stateInfo.state = AbilityLifeCycleState::ABILITY_STATE_INITIAL;
94 abilityScheduler->ScheduleAbilityTransaction(want, stateInfo);
95 }
96
CommandAbility(const Want & want,bool reStart,int startId)97 void LifecycleDeal::CommandAbility(const Want &want, bool reStart, int startId)
98 {
99 HILOG_INFO("Command ability. startId:%{public}d", startId);
100 auto abilityScheduler = GetScheduler();
101 CHECK_POINTER(abilityScheduler);
102 abilityScheduler->ScheduleCommandAbility(want, reStart, startId);
103 }
104
SaveAbilityState()105 void LifecycleDeal::SaveAbilityState()
106 {
107 HILOG_INFO("%{public}s, %{public}d", __func__, __LINE__);
108 auto abilityScheduler = GetScheduler();
109 CHECK_POINTER(abilityScheduler);
110 abilityScheduler->ScheduleSaveAbilityState();
111 }
112
RestoreAbilityState(const PacMap & inState)113 void LifecycleDeal::RestoreAbilityState(const PacMap &inState)
114 {
115 HILOG_INFO("%{public}s, %{public}d", __func__, __LINE__);
116 auto abilityScheduler = GetScheduler();
117 CHECK_POINTER(abilityScheduler);
118 abilityScheduler->ScheduleRestoreAbilityState(inState);
119 }
120
ForegroundNew(const Want & want,LifeCycleStateInfo & stateInfo)121 void LifecycleDeal::ForegroundNew(const Want &want, LifeCycleStateInfo &stateInfo)
122 {
123 HILOG_INFO("ForegroundNew.");
124 auto abilityScheduler = GetScheduler();
125 CHECK_POINTER(abilityScheduler);
126 HILOG_INFO("caller %{public}s, %{public}s",
127 stateInfo.caller.bundleName.c_str(),
128 stateInfo.caller.abilityName.c_str());
129 stateInfo.state = AbilityLifeCycleState::ABILITY_STATE_FOREGROUND_NEW;
130 abilityScheduler->ScheduleAbilityTransaction(want, stateInfo);
131 }
132
BackgroundNew(const Want & want,LifeCycleStateInfo & stateInfo)133 void LifecycleDeal::BackgroundNew(const Want &want, LifeCycleStateInfo &stateInfo)
134 {
135 HILOG_INFO("Start move ability to background.");
136 auto abilityScheduler = GetScheduler();
137 CHECK_POINTER(abilityScheduler);
138 HILOG_INFO("caller %{public}s, %{public}s",
139 stateInfo.caller.bundleName.c_str(),
140 stateInfo.caller.abilityName.c_str());
141 stateInfo.state = AbilityLifeCycleState::ABILITY_STATE_BACKGROUND_NEW;
142 abilityScheduler->ScheduleAbilityTransaction(want, stateInfo);
143 }
144
ContinueAbility(const std::string & deviceId,uint32_t versionCode)145 void LifecycleDeal::ContinueAbility(const std::string& deviceId, uint32_t versionCode)
146 {
147 HILOG_INFO("ContinueAbility.");
148 CHECK_POINTER(abilityScheduler_);
149 abilityScheduler_->ContinueAbility(deviceId, versionCode);
150 }
151
NotifyContinuationResult(int32_t result)152 void LifecycleDeal::NotifyContinuationResult(int32_t result)
153 {
154 HILOG_INFO("NotifyContinuationResult.");
155 auto abilityScheduler = GetScheduler();
156 CHECK_POINTER(abilityScheduler);
157 abilityScheduler->NotifyContinuationResult(result);
158 }
159 } // namespace AAFwk
160 } // namespace OHOS
161