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
21namespace OHOS {
22namespace AAFwk {
23LifecycleDeal::LifecycleDeal()
24{}
25
26LifecycleDeal::~LifecycleDeal()
27{}
28
29void LifecycleDeal::SetScheduler(const sptr<IAbilityScheduler> &scheduler)
30{
31    std::unique_lock<std::shared_mutex> lock(schedulerMutex_);
32    abilityScheduler_ = scheduler;
33}
34
35sptr<IAbilityScheduler> LifecycleDeal::GetScheduler()
36{
37    std::shared_lock<std::shared_mutex> lock(schedulerMutex_);
38    return abilityScheduler_;
39}
40
41void 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
53void 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
63void 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
72void 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
80void 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
88void 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
97void 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
105void 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
113void LifecycleDeal::SaveAbilityState()
114{
115    TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
116    auto abilityScheduler = GetScheduler();
117    CHECK_POINTER(abilityScheduler);
118    abilityScheduler->ScheduleSaveAbilityState();
119}
120
121void 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
129bool 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
142void 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
155void 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
162void 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
170void 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
178bool LifecycleDeal::PrepareTerminateAbility()
179{
180    TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
181    auto abilityScheduler = GetScheduler();
182    if (abilityScheduler == nullptr) {
183        TAG_LOGE(AAFwkTag::ABILITYMGR, "null abilityScheduler");
184        return false;
185    }
186    return abilityScheduler->SchedulePrepareTerminateAbility();
187}
188
189void 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