1 /*
2 * Copyright (c) 2020 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_worker.h"
17
18 #define __STDC_FORMAT_MACROS
19 #include <cinttypes>
20
21 #include "ability_activate_task.h"
22 #include "ability_attach_task.h"
23 #include "ability_background_task.h"
24 #include "ability_connect_done_task.h"
25 #include "ability_connect_task.h"
26 #include "ability_disconnect_done_task.h"
27 #include "ability_disconnect_task.h"
28 #include "ability_dump_task.h"
29 #include "ability_inactivate_task.h"
30 #include "ability_start_task.h"
31 #include "ability_stop_task.h"
32 #include "ability_terminate_service_task.h"
33 #include "ability_terminate_task.h"
34 #include "app_restart_task.h"
35 #include "app_terminate_task.h"
36 #include "util/abilityms_helper.h"
37
38 namespace OHOS {
AbilityWorker()39 AbilityWorker::AbilityWorker()
40 {
41 abilityMgrContext_ = new AbilityMgrContext();
42 }
43
~AbilityWorker()44 AbilityWorker::~AbilityWorker()
45 {
46 delete abilityMgrContext_;
47 abilityMgrContext_ = nullptr;
48 }
49
StartAbility(const Want & want,const AbilityInfo & target,const BundleInfo & bundleInfo,pid_t callingUid)50 AbilityMsStatus AbilityWorker::StartAbility(const Want &want, const AbilityInfo &target,
51 const BundleInfo &bundleInfo, pid_t callingUid)
52 {
53 if (!AbilityMsHelper::CheckVisiblePermission(callingUid, bundleInfo.uid, target.isVisible)) {
54 return AbilityMsStatus::PermissionStatus("start ability visible is false");
55 }
56 AbilityStartTask startTask(abilityMgrContext_, &want, &target, &bundleInfo);
57 return startTask.Execute();
58 }
59
AttachBundle(const AbilityThreadClient & client)60 AbilityMsStatus AbilityWorker::AttachBundle(const AbilityThreadClient &client)
61 {
62 PRINTD("AbilityWorker", "app token(%{private}" PRIu64 ")", client.GetToken());
63 AbilityAttachTask attachTask(&client);
64 return attachTask.Execute();
65 }
66
TerminateAbility(uint64_t token)67 AbilityMsStatus AbilityWorker::TerminateAbility(uint64_t token)
68 {
69 PRINTD("AbilityWorker", "ability token(%{private}" PRIu64 ")", token);
70 AbilityTerminateTask terminateTask(abilityMgrContext_, token);
71 return terminateTask.Execute();
72 }
73
TerminateService(const AbilityInfo & target,const BundleInfo & bundleInfo,pid_t callingUid)74 AbilityMsStatus AbilityWorker::TerminateService(const AbilityInfo &target, const BundleInfo &bundleInfo,
75 pid_t callingUid)
76 {
77 if (!AbilityMsHelper::CheckVisiblePermission(callingUid, bundleInfo.uid, target.isVisible)) {
78 return AbilityMsStatus::PermissionStatus("terminate service visible is false");
79 }
80 AbilityTerminateServiceTask terminateServiceTask(abilityMgrContext_, &target);
81 return terminateServiceTask.Execute();
82 }
83
AbilityTransaction(const TransactionState & state)84 AbilityMsStatus AbilityWorker::AbilityTransaction(const TransactionState &state)
85 {
86 PRINTD("AbilityWorker", "ability token(%{private}" PRIu64 "), state(%{public}d)", state.token, state.state);
87 AbilityTask *task = nullptr;
88 switch (state.state) {
89 case STATE_BACKGROUND:
90 task = new AbilityBackgroundTask(abilityMgrContext_, state.token);
91 break;
92 case STATE_INACTIVE:
93 task = new AbilityInactivateTask(abilityMgrContext_, state.token);
94 break;
95 case STATE_ACTIVE:
96 task = new AbilityActivateTask(abilityMgrContext_, state.token);
97 break;
98 case STATE_INITIAL:
99 task = new AbilityStopTask(abilityMgrContext_, state.token);
100 break;
101 default:
102 break;
103 }
104 AbilityMsStatus status = (task != nullptr) ? task->Execute() : AbilityMsStatus();
105 delete task;
106 return status;
107 }
108
TerminateApp(const char * bundleName)109 AbilityMsStatus AbilityWorker::TerminateApp(const char *bundleName)
110 {
111 AppTerminateTask appTerminateTask(abilityMgrContext_, bundleName);
112 return appTerminateTask.Execute();
113 }
114
RestartApp(const BundleInfo & bundleInfo)115 AbilityMsStatus AbilityWorker::RestartApp(const BundleInfo &bundleInfo)
116 {
117 AppRestartTask restartTask(abilityMgrContext_, &bundleInfo);
118 return restartTask.Execute();
119 }
120
ConnectAbility(const AbilityConnectTransParam & connectParam,const AbilityInfo & target,const BundleInfo & bundleInfo)121 AbilityMsStatus AbilityWorker::ConnectAbility(const AbilityConnectTransParam &connectParam,
122 const AbilityInfo &target, const BundleInfo &bundleInfo)
123 {
124 if (!AbilityMsHelper::CheckVisiblePermission(connectParam.GetCallingUid(), bundleInfo.uid, target.isVisible)) {
125 return AbilityMsStatus::PermissionStatus("connect ability visible is false");
126 }
127 if (abilityMgrContext_ == nullptr) {
128 return AbilityMsStatus::TaskStatus("connect", "invalid argument");
129 }
130 auto serviceConnects = abilityMgrContext_->GetServiceConnects();
131 if (serviceConnects == nullptr) {
132 return AbilityMsStatus::TaskStatus("connect", "invalid argument");
133 }
134 if (connectParam.GetWant() == nullptr || connectParam.GetWant()->element == nullptr) {
135 return AbilityMsStatus::TaskStatus("connect", "invalid argument");
136 }
137 char *bundleName = connectParam.GetWant()->element->bundleName;
138 char *abilityName = connectParam.GetWant()->element->abilityName;
139 auto abilityRecord = serviceConnects->FindServiceRecord(bundleName, abilityName);
140 if (abilityRecord == nullptr) {
141 PRINTD("AbilityWorker", "ability start first");
142 AbilityStartTask startTask(abilityMgrContext_, connectParam.GetWant(), &target, &bundleInfo);
143 startTask.SetWaitConnect(true);
144 AbilityMsStatus status = startTask.Execute();
145 if (!status.IsOk()) {
146 return status;
147 }
148 } else {
149 PRINTD("AbilityWorker", "ability has started");
150 }
151 abilityRecord = serviceConnects->FindServiceRecord(bundleName, abilityName);
152 if (abilityRecord == nullptr) {
153 return AbilityMsStatus::TaskStatus("connect", "generate ability record failure");
154 }
155 AbilityConnectTask connectTask(abilityMgrContext_, *connectParam.GetWant(),
156 connectParam.GetSvcIdentity(), connectParam.GetToken());
157 AbilityMsStatus status = connectTask.Execute();
158 return status;
159 }
160
DisconnectAbility(const SvcIdentity & identity,uint64_t token)161 AbilityMsStatus AbilityWorker::DisconnectAbility(const SvcIdentity &identity, uint64_t token)
162 {
163 AbilityDisconnectTask disconnectTask(abilityMgrContext_, identity, token);
164 return disconnectTask.Execute();
165 }
166
ConnectAbilityDone(const SvcIdentity & identity,uint64_t token)167 AbilityMsStatus AbilityWorker::ConnectAbilityDone(const SvcIdentity &identity, uint64_t token)
168 {
169 AbilityConnectDoneTask connectDoneTask(abilityMgrContext_, identity, token);
170 return connectDoneTask.Execute();
171 }
172
DisconnectAbilityDone(uint64_t token)173 AbilityMsStatus AbilityWorker::DisconnectAbilityDone(uint64_t token)
174 {
175 AbilityDisconnectDoneTask connectDoneTask(abilityMgrContext_, token);
176 return connectDoneTask.Execute();
177 }
178
DumpAbility(const AbilityDumpClient & client)179 AbilityMsStatus AbilityWorker::DumpAbility(const AbilityDumpClient &client)
180 {
181 AbilityDumpTask dumpTask(abilityMgrContext_, &client);
182 return dumpTask.Execute();
183 }
184 } // namespace OHOS
185