1 /*
2 * Copyright (c) 2021-2022 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 "application_state_observer_stub.h"
17 #include "appexecfwk_errors.h"
18 #include "hilog_wrapper.h"
19 #include "ipc_types.h"
20 #include "iremote_object.h"
21
22 namespace OHOS {
23 namespace AppExecFwk {
24 std::mutex ApplicationStateObserverStub::callbackMutex_;
25
ApplicationStateObserverStub()26 ApplicationStateObserverStub::ApplicationStateObserverStub()
27 {
28 memberFuncMap_[static_cast<uint32_t>(
29 IApplicationStateObserver::Message::TRANSACT_ON_FOREGROUND_APPLICATION_CHANGED)] =
30 &ApplicationStateObserverStub::HandleOnForegroundApplicationChanged;
31 memberFuncMap_[static_cast<uint32_t>(
32 IApplicationStateObserver::Message::TRANSACT_ON_ABILITY_STATE_CHANGED)] =
33 &ApplicationStateObserverStub::HandleOnAbilityStateChanged;
34 memberFuncMap_[static_cast<uint32_t>(
35 IApplicationStateObserver::Message::TRANSACT_ON_EXTENSION_STATE_CHANGED)] =
36 &ApplicationStateObserverStub::HandleOnExtensionStateChanged;
37 memberFuncMap_[static_cast<uint32_t>(
38 IApplicationStateObserver::Message::TRANSACT_ON_PROCESS_CREATED)] =
39 &ApplicationStateObserverStub::HandleOnProcessCreated;
40 memberFuncMap_[static_cast<uint32_t>(
41 IApplicationStateObserver::Message::TRANSACT_ON_PROCESS_STATE_CHANGED)] =
42 &ApplicationStateObserverStub::HandleOnProcessStateChanged;
43 memberFuncMap_[static_cast<uint32_t>(
44 IApplicationStateObserver::Message::TRANSACT_ON_PROCESS_DIED)] =
45 &ApplicationStateObserverStub::HandleOnProcessDied;
46 memberFuncMap_[static_cast<uint32_t>(
47 IApplicationStateObserver::Message::TRANSACT_ON_APPLICATION_STATE_CHANGED)] =
48 &ApplicationStateObserverStub::HandleOnApplicationStateChanged;
49 memberFuncMap_[static_cast<uint32_t>(
50 IApplicationStateObserver::Message::TRANSACT_ON_APP_STATE_CHANGED)] =
51 &ApplicationStateObserverStub::HandleOnAppStateChanged;
52 memberFuncMap_[static_cast<uint32_t>(
53 IApplicationStateObserver::Message::TRANSACT_ON_PROCESS_REUSED)] =
54 &ApplicationStateObserverStub::HandleOnProcessReused;
55 memberFuncMap_[static_cast<uint32_t>(
56 IApplicationStateObserver::Message::TRANSACT_ON_APP_STARTED)] =
57 &ApplicationStateObserverStub::HandleOnAppStarted;
58 memberFuncMap_[static_cast<uint32_t>(
59 IApplicationStateObserver::Message::TRANSACT_ON_APP_STOPPED)] =
60 &ApplicationStateObserverStub::HandleOnAppStopped;
61 }
62
~ApplicationStateObserverStub()63 ApplicationStateObserverStub::~ApplicationStateObserverStub()
64 {
65 memberFuncMap_.clear();
66 }
67
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)68 int ApplicationStateObserverStub::OnRemoteRequest(
69 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
70 {
71 HILOG_DEBUG("ApplicationStateObserverStub::OnReceived, code = %{public}u, flags= %{public}d.",
72 code, option.GetFlags());
73 std::u16string descriptor = ApplicationStateObserverStub::GetDescriptor();
74 std::u16string remoteDescriptor = data.ReadInterfaceToken();
75 if (descriptor != remoteDescriptor) {
76 HILOG_ERROR("local descriptor is not equal to remote");
77 return ERR_INVALID_STATE;
78 }
79
80 auto itFunc = memberFuncMap_.find(code);
81 if (itFunc != memberFuncMap_.end()) {
82 auto memberFunc = itFunc->second;
83 if (memberFunc != nullptr) {
84 return (this->*memberFunc)(data, reply);
85 }
86 }
87 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
88 }
89
OnForegroundApplicationChanged(const AppStateData & appStateData)90 void ApplicationStateObserverStub::OnForegroundApplicationChanged(const AppStateData &appStateData)
91 {}
92
OnAbilityStateChanged(const AbilityStateData & abilityStateData)93 void ApplicationStateObserverStub::OnAbilityStateChanged(const AbilityStateData &abilityStateData)
94 {}
95
OnExtensionStateChanged(const AbilityStateData & abilityStateData)96 void ApplicationStateObserverStub::OnExtensionStateChanged(const AbilityStateData &abilityStateData)
97 {}
98
OnProcessCreated(const ProcessData & processData)99 void ApplicationStateObserverStub::OnProcessCreated(const ProcessData &processData)
100 {}
101
OnProcessStateChanged(const ProcessData & processData)102 void ApplicationStateObserverStub::OnProcessStateChanged(const ProcessData &processData)
103 {}
104
OnProcessDied(const ProcessData & processData)105 void ApplicationStateObserverStub::OnProcessDied(const ProcessData &processData)
106 {}
107
OnApplicationStateChanged(const AppStateData & appStateData)108 void ApplicationStateObserverStub::OnApplicationStateChanged(const AppStateData &appStateData)
109 {}
110
OnAppStateChanged(const AppStateData & appStateData)111 void ApplicationStateObserverStub::OnAppStateChanged(const AppStateData &appStateData)
112 {}
113
OnProcessReused(const ProcessData & processData)114 void ApplicationStateObserverStub::OnProcessReused(const ProcessData &processData)
115 {}
116
OnAppStarted(const AppStateData & appStateData)117 void ApplicationStateObserverStub::OnAppStarted(const AppStateData &appStateData)
118 {}
119
OnAppStopped(const AppStateData & appStateData)120 void ApplicationStateObserverStub::OnAppStopped(const AppStateData &appStateData)
121 {}
122
HandleOnForegroundApplicationChanged(MessageParcel & data,MessageParcel & reply)123 int32_t ApplicationStateObserverStub::HandleOnForegroundApplicationChanged(MessageParcel &data, MessageParcel &reply)
124 {
125 std::unique_ptr<AppStateData> processData(data.ReadParcelable<AppStateData>());
126 if (!processData) {
127 HILOG_ERROR("ReadParcelable<AppStateData> failed");
128 return ERR_APPEXECFWK_PARCEL_ERROR;
129 }
130
131 OnForegroundApplicationChanged(*processData);
132 return NO_ERROR;
133 }
134
HandleOnAbilityStateChanged(MessageParcel & data,MessageParcel & reply)135 int32_t ApplicationStateObserverStub::HandleOnAbilityStateChanged(MessageParcel &data, MessageParcel &reply)
136 {
137 AbilityStateData* abilityStateData = nullptr;
138 {
139 std::unique_lock<std::mutex> lock(callbackMutex_);
140 abilityStateData = data.ReadParcelable<AbilityStateData>();
141 if (!abilityStateData) {
142 HILOG_ERROR("ReadParcelable<AbilityStateData> failed");
143 return ERR_APPEXECFWK_PARCEL_ERROR;
144 }
145 }
146 OnAbilityStateChanged(*abilityStateData);
147 {
148 // Protect Multi Thread Deconstruct IRemoteObject
149 std::unique_lock<std::mutex> lock(callbackMutex_);
150 delete abilityStateData;
151 }
152 return NO_ERROR;
153 }
154
HandleOnExtensionStateChanged(MessageParcel & data,MessageParcel & reply)155 int32_t ApplicationStateObserverStub::HandleOnExtensionStateChanged(MessageParcel &data, MessageParcel &reply)
156 {
157 AbilityStateData* abilityStateData = nullptr;
158 {
159 std::unique_lock<std::mutex> lock(callbackMutex_);
160 abilityStateData = data.ReadParcelable<AbilityStateData>();
161 if (!abilityStateData) {
162 HILOG_ERROR("ReadParcelable<AbilityStateData> failed");
163 return ERR_APPEXECFWK_PARCEL_ERROR;
164 }
165 }
166 OnExtensionStateChanged(*abilityStateData);
167 {
168 // Protect Multi Thread Deconstruct IRemoteObject
169 std::unique_lock<std::mutex> lock(callbackMutex_);
170 delete abilityStateData;
171 }
172 return NO_ERROR;
173 }
174
HandleOnProcessCreated(MessageParcel & data,MessageParcel & reply)175 int32_t ApplicationStateObserverStub::HandleOnProcessCreated(MessageParcel &data, MessageParcel &reply)
176 {
177 std::unique_ptr<ProcessData> processData(data.ReadParcelable<ProcessData>());
178 if (!processData) {
179 HILOG_ERROR("ReadParcelable<ProcessData> failed");
180 return ERR_APPEXECFWK_PARCEL_ERROR;
181 }
182
183 OnProcessCreated(*processData);
184 return NO_ERROR;
185 }
186
HandleOnProcessStateChanged(MessageParcel & data,MessageParcel & reply)187 int32_t ApplicationStateObserverStub::HandleOnProcessStateChanged(MessageParcel &data, MessageParcel &reply)
188 {
189 std::unique_ptr<ProcessData> processData(data.ReadParcelable<ProcessData>());
190 if (!processData) {
191 HILOG_ERROR("ReadParcelable<ProcessData> failed");
192 return ERR_APPEXECFWK_PARCEL_ERROR;
193 }
194
195 OnProcessStateChanged(*processData);
196 return NO_ERROR;
197 }
198
HandleOnProcessDied(MessageParcel & data,MessageParcel & reply)199 int32_t ApplicationStateObserverStub::HandleOnProcessDied(MessageParcel &data, MessageParcel &reply)
200 {
201 std::unique_ptr<ProcessData> processData(data.ReadParcelable<ProcessData>());
202 if (!processData) {
203 HILOG_ERROR("ReadParcelable<ProcessData> failed");
204 return ERR_APPEXECFWK_PARCEL_ERROR;
205 }
206
207 OnProcessDied(*processData);
208 return NO_ERROR;
209 }
210
HandleOnApplicationStateChanged(MessageParcel & data,MessageParcel & reply)211 int32_t ApplicationStateObserverStub::HandleOnApplicationStateChanged(MessageParcel &data, MessageParcel &reply)
212 {
213 std::unique_ptr<AppStateData> processData(data.ReadParcelable<AppStateData>());
214 if (!processData) {
215 HILOG_ERROR("ReadParcelable<AppStateData> failed");
216 return ERR_APPEXECFWK_PARCEL_ERROR;
217 }
218
219 OnApplicationStateChanged(*processData);
220 return NO_ERROR;
221 }
222
HandleOnAppStateChanged(MessageParcel & data,MessageParcel & reply)223 int32_t ApplicationStateObserverStub::HandleOnAppStateChanged(MessageParcel &data, MessageParcel &reply)
224 {
225 std::unique_ptr<AppStateData> processData(data.ReadParcelable<AppStateData>());
226 if (!processData) {
227 HILOG_ERROR("ReadParcelable<AppStateData> failed");
228 return ERR_APPEXECFWK_PARCEL_ERROR;
229 }
230
231 OnAppStateChanged(*processData);
232 return NO_ERROR;
233 }
234
OnRemoteDied(const wptr<IRemoteObject> & remote)235 void ApplicationStateObserverRecipient::OnRemoteDied(const wptr<IRemoteObject> &__attribute__((unused)) remote)
236 {
237 HILOG_ERROR("ApplicationStateObserverRecipient On remote died.");
238 if (handler_) {
239 handler_(remote);
240 }
241 }
242
HandleOnProcessReused(MessageParcel & data,MessageParcel & reply)243 int32_t ApplicationStateObserverStub::HandleOnProcessReused(MessageParcel &data, MessageParcel &reply)
244 {
245 std::unique_ptr<ProcessData> processData(data.ReadParcelable<ProcessData>());
246 if (!processData) {
247 HILOG_ERROR("ReadParcelable<ProcessData> failed");
248 return ERR_APPEXECFWK_PARCEL_ERROR;
249 }
250
251 OnProcessReused(*processData);
252 return NO_ERROR;
253 }
254
HandleOnAppStarted(MessageParcel & data,MessageParcel & reply)255 int32_t ApplicationStateObserverStub::HandleOnAppStarted(MessageParcel &data, MessageParcel &reply)
256 {
257 std::unique_ptr<AppStateData> processData(data.ReadParcelable<AppStateData>());
258 if (!processData) {
259 HILOG_ERROR("ReadParcelable<AppStateData> failed");
260 return ERR_APPEXECFWK_PARCEL_ERROR;
261 }
262
263 OnAppStarted(*processData);
264 return NO_ERROR;
265 }
266
HandleOnAppStopped(MessageParcel & data,MessageParcel & reply)267 int32_t ApplicationStateObserverStub::HandleOnAppStopped(MessageParcel &data, MessageParcel &reply)
268 {
269 std::unique_ptr<AppStateData> processData(data.ReadParcelable<AppStateData>());
270 if (!processData) {
271 HILOG_ERROR("ReadParcelable<AppStateData> failed");
272 return ERR_APPEXECFWK_PARCEL_ERROR;
273 }
274
275 OnAppStopped(*processData);
276 return NO_ERROR;
277 }
278
ApplicationStateObserverRecipient(RemoteDiedHandler handler)279 ApplicationStateObserverRecipient::ApplicationStateObserverRecipient(RemoteDiedHandler handler) : handler_(handler)
280 {}
281
~ApplicationStateObserverRecipient()282 ApplicationStateObserverRecipient::~ApplicationStateObserverRecipient()
283 {}
284 } // namespace AppExecFwk
285 } // namespace OHOS
286