1 /*
2 * Copyright (c) 2021-2024 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
21 namespace OHOS {
22 namespace AAFwk {
LifecycleDeal()23 LifecycleDeal::LifecycleDeal()
24 {}
25
~LifecycleDeal()26 LifecycleDeal::~LifecycleDeal()
27 {}
28
SetScheduler(const sptr<IAbilityScheduler> & scheduler)29 void LifecycleDeal::SetScheduler(const sptr<IAbilityScheduler> &scheduler)
30 {
31 std::unique_lock<std::shared_mutex> lock(schedulerMutex_);
32 abilityScheduler_ = scheduler;
33 }
34
GetScheduler()35 sptr<IAbilityScheduler> LifecycleDeal::GetScheduler()
36 {
37 std::shared_lock<std::shared_mutex> lock(schedulerMutex_);
38 return abilityScheduler_;
39 }
40
Activate(const Want & want,LifeCycleStateInfo & stateInfo)41 void LifecycleDeal::Activate(const Want &want, LifeCycleStateInfo &stateInfo)
42 {
43 TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
44 auto abilityScheduler = GetScheduler();
45 CHECK_POINTER(abilityScheduler);
46 TAG_LOGD(AAFwkTag::ABILITYMGR, "caller %{public}s, %{public}s",
47 stateInfo.caller.bundleName.c_str(),
48 stateInfo.caller.abilityName.c_str());
49 stateInfo.state = AbilityLifeCycleState::ABILITY_STATE_ACTIVE;
50 abilityScheduler->ScheduleAbilityTransaction(want, stateInfo);
51 }
52
Inactivate(const Want & want,LifeCycleStateInfo & stateInfo,sptr<SessionInfo> sessionInfo)53 void LifecycleDeal::Inactivate(const Want &want, LifeCycleStateInfo &stateInfo,
54 sptr<SessionInfo> sessionInfo)
55 {
56 TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
57 auto abilityScheduler = GetScheduler();
58 CHECK_POINTER(abilityScheduler);
59 stateInfo.state = AbilityLifeCycleState::ABILITY_STATE_INACTIVE;
60 abilityScheduler->ScheduleAbilityTransaction(want, stateInfo, sessionInfo);
61 }
62
MoveToBackground(const Want & want,LifeCycleStateInfo & stateInfo)63 void LifecycleDeal::MoveToBackground(const Want &want, LifeCycleStateInfo &stateInfo)
64 {
65 TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
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 TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
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 TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
83 auto abilityScheduler = GetScheduler();
84 CHECK_POINTER(abilityScheduler);
85 abilityScheduler->ScheduleDisconnectAbility(want);
86 }
87
Terminate(const Want & want,LifeCycleStateInfo & stateInfo,sptr<SessionInfo> sessionInfo)88 void LifecycleDeal::Terminate(const Want &want, LifeCycleStateInfo &stateInfo, sptr<SessionInfo> sessionInfo)
89 {
90 TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
91 auto abilityScheduler = GetScheduler();
92 CHECK_POINTER(abilityScheduler);
93 stateInfo.state = AbilityLifeCycleState::ABILITY_STATE_INITIAL;
94 abilityScheduler->ScheduleAbilityTransaction(want, stateInfo, sessionInfo);
95 }
96
CommandAbility(const Want & want,bool reStart,int startId)97 void LifecycleDeal::CommandAbility(const Want &want, bool reStart, int startId)
98 {
99 TAG_LOGD(AAFwkTag::ABILITYMGR, "startId:%{public}d", startId);
100 auto abilityScheduler = GetScheduler();
101 CHECK_POINTER(abilityScheduler);
102 abilityScheduler->ScheduleCommandAbility(want, reStart, startId);
103 }
104
CommandAbilityWindow(const Want & want,const sptr<SessionInfo> & sessionInfo,WindowCommand winCmd)105 void LifecycleDeal::CommandAbilityWindow(const Want &want, const sptr<SessionInfo> &sessionInfo, WindowCommand winCmd)
106 {
107 TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
108 auto abilityScheduler = GetScheduler();
109 CHECK_POINTER(abilityScheduler);
110 abilityScheduler->ScheduleCommandAbilityWindow(want, sessionInfo, winCmd);
111 }
112
SaveAbilityState()113 void LifecycleDeal::SaveAbilityState()
114 {
115 TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
116 auto abilityScheduler = GetScheduler();
117 CHECK_POINTER(abilityScheduler);
118 abilityScheduler->ScheduleSaveAbilityState();
119 }
120
RestoreAbilityState(const PacMap & inState)121 void LifecycleDeal::RestoreAbilityState(const PacMap &inState)
122 {
123 TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
124 auto abilityScheduler = GetScheduler();
125 CHECK_POINTER(abilityScheduler);
126 abilityScheduler->ScheduleRestoreAbilityState(inState);
127 }
128
ForegroundNew(const Want & want,LifeCycleStateInfo & stateInfo,sptr<SessionInfo> sessionInfo)129 bool LifecycleDeal::ForegroundNew(const Want &want, LifeCycleStateInfo &stateInfo,
130 sptr<SessionInfo> sessionInfo)
131 {
132 TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
133 auto abilityScheduler = GetScheduler();
134 CHECK_POINTER_AND_RETURN(abilityScheduler, false);
135 TAG_LOGD(AAFwkTag::ABILITYMGR, "caller %{public}s, %{public}s",
136 stateInfo.caller.bundleName.c_str(),
137 stateInfo.caller.abilityName.c_str());
138 stateInfo.state = AbilityLifeCycleState::ABILITY_STATE_FOREGROUND_NEW;
139 return abilityScheduler->ScheduleAbilityTransaction(want, stateInfo, sessionInfo);
140 }
141
BackgroundNew(const Want & want,LifeCycleStateInfo & stateInfo,sptr<SessionInfo> sessionInfo)142 void LifecycleDeal::BackgroundNew(const Want &want, LifeCycleStateInfo &stateInfo,
143 sptr<SessionInfo> sessionInfo)
144 {
145 TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
146 auto abilityScheduler = GetScheduler();
147 CHECK_POINTER(abilityScheduler);
148 TAG_LOGD(AAFwkTag::ABILITYMGR, "caller %{public}s, %{public}s",
149 stateInfo.caller.bundleName.c_str(),
150 stateInfo.caller.abilityName.c_str());
151 stateInfo.state = AbilityLifeCycleState::ABILITY_STATE_BACKGROUND_NEW;
152 abilityScheduler->ScheduleAbilityTransaction(want, stateInfo, sessionInfo);
153 }
154
ContinueAbility(const std::string & deviceId,uint32_t versionCode)155 void LifecycleDeal::ContinueAbility(const std::string& deviceId, uint32_t versionCode)
156 {
157 TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
158 CHECK_POINTER(abilityScheduler_);
159 abilityScheduler_->ContinueAbility(deviceId, versionCode);
160 }
161
NotifyContinuationResult(int32_t result)162 void LifecycleDeal::NotifyContinuationResult(int32_t result)
163 {
164 TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
165 auto abilityScheduler = GetScheduler();
166 CHECK_POINTER(abilityScheduler);
167 abilityScheduler->NotifyContinuationResult(result);
168 }
169
ShareData(const int32_t & uniqueId)170 void LifecycleDeal::ShareData(const int32_t &uniqueId)
171 {
172 TAG_LOGD(AAFwkTag::ABILITYMGR, "uniqueId is %{public}d.", uniqueId);
173 auto abilityScheduler = GetScheduler();
174 CHECK_POINTER(abilityScheduler);
175 abilityScheduler->ScheduleShareData(uniqueId);
176 }
177
PrepareTerminateAbility()178 bool LifecycleDeal::PrepareTerminateAbility()
179 {
180 TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
181 auto abilityScheduler = GetScheduler();
182 if (abilityScheduler == nullptr) {
183 TAG_LOGE(AAFwkTag::ABILITYMGR, "abilityScheduler is nullptr.");
184 return false;
185 }
186 return abilityScheduler->SchedulePrepareTerminateAbility();
187 }
188
UpdateSessionToken(sptr<IRemoteObject> sessionToken)189 void LifecycleDeal::UpdateSessionToken(sptr<IRemoteObject> sessionToken)
190 {
191 auto abilityScheduler = GetScheduler();
192 CHECK_POINTER(abilityScheduler);
193 abilityScheduler->UpdateSessionToken(sessionToken);
194 }
195 } // namespace AAFwk
196 } // namespace OHOS
197