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 }
56
~ApplicationStateObserverStub()57 ApplicationStateObserverStub::~ApplicationStateObserverStub()
58 {
59 memberFuncMap_.clear();
60 }
61
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)62 int ApplicationStateObserverStub::OnRemoteRequest(
63 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
64 {
65 HILOG_DEBUG("ApplicationStateObserverStub::OnReceived, code = %{public}u, flags= %{public}d.",
66 code, option.GetFlags());
67 std::u16string descriptor = ApplicationStateObserverStub::GetDescriptor();
68 std::u16string remoteDescriptor = data.ReadInterfaceToken();
69 if (descriptor != remoteDescriptor) {
70 HILOG_ERROR("local descriptor is not equal to remote");
71 return ERR_INVALID_STATE;
72 }
73
74 auto itFunc = memberFuncMap_.find(code);
75 if (itFunc != memberFuncMap_.end()) {
76 auto memberFunc = itFunc->second;
77 if (memberFunc != nullptr) {
78 return (this->*memberFunc)(data, reply);
79 }
80 }
81 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
82 }
83
OnForegroundApplicationChanged(const AppStateData & appStateData)84 void ApplicationStateObserverStub::OnForegroundApplicationChanged(const AppStateData &appStateData)
85 {}
86
OnAbilityStateChanged(const AbilityStateData & abilityStateData)87 void ApplicationStateObserverStub::OnAbilityStateChanged(const AbilityStateData &abilityStateData)
88 {}
89
OnExtensionStateChanged(const AbilityStateData & abilityStateData)90 void ApplicationStateObserverStub::OnExtensionStateChanged(const AbilityStateData &abilityStateData)
91 {}
92
OnProcessCreated(const ProcessData & processData)93 void ApplicationStateObserverStub::OnProcessCreated(const ProcessData &processData)
94 {}
95
OnProcessStateChanged(const ProcessData & processData)96 void ApplicationStateObserverStub::OnProcessStateChanged(const ProcessData &processData)
97 {}
98
OnProcessDied(const ProcessData & processData)99 void ApplicationStateObserverStub::OnProcessDied(const ProcessData &processData)
100 {}
101
OnApplicationStateChanged(const AppStateData & appStateData)102 void ApplicationStateObserverStub::OnApplicationStateChanged(const AppStateData &appStateData)
103 {}
104
OnAppStateChanged(const AppStateData & appStateData)105 void ApplicationStateObserverStub::OnAppStateChanged(const AppStateData &appStateData)
106 {}
107
OnProcessReused(const ProcessData & processData)108 void ApplicationStateObserverStub::OnProcessReused(const ProcessData &processData)
109 {}
110
HandleOnForegroundApplicationChanged(MessageParcel & data,MessageParcel & reply)111 int32_t ApplicationStateObserverStub::HandleOnForegroundApplicationChanged(MessageParcel &data, MessageParcel &reply)
112 {
113 std::unique_ptr<AppStateData> processData(data.ReadParcelable<AppStateData>());
114 if (!processData) {
115 HILOG_ERROR("ReadParcelable<AppStateData> failed");
116 return ERR_APPEXECFWK_PARCEL_ERROR;
117 }
118
119 OnForegroundApplicationChanged(*processData);
120 return NO_ERROR;
121 }
122
HandleOnAbilityStateChanged(MessageParcel & data,MessageParcel & reply)123 int32_t ApplicationStateObserverStub::HandleOnAbilityStateChanged(MessageParcel &data, MessageParcel &reply)
124 {
125 AbilityStateData* abilityStateData = nullptr;
126 {
127 std::unique_lock<std::mutex> lock(callbackMutex_);
128 abilityStateData = data.ReadParcelable<AbilityStateData>();
129 if (!abilityStateData) {
130 HILOG_ERROR("ReadParcelable<AbilityStateData> failed");
131 return ERR_APPEXECFWK_PARCEL_ERROR;
132 }
133 }
134 OnAbilityStateChanged(*abilityStateData);
135 {
136 // Protect Multi Thread Deconstruct IRemoteObject
137 std::unique_lock<std::mutex> lock(callbackMutex_);
138 delete abilityStateData;
139 }
140 return NO_ERROR;
141 }
142
HandleOnExtensionStateChanged(MessageParcel & data,MessageParcel & reply)143 int32_t ApplicationStateObserverStub::HandleOnExtensionStateChanged(MessageParcel &data, MessageParcel &reply)
144 {
145 AbilityStateData* abilityStateData = nullptr;
146 {
147 std::unique_lock<std::mutex> lock(callbackMutex_);
148 abilityStateData = data.ReadParcelable<AbilityStateData>();
149 if (!abilityStateData) {
150 HILOG_ERROR("ReadParcelable<AbilityStateData> failed");
151 return ERR_APPEXECFWK_PARCEL_ERROR;
152 }
153 }
154 OnExtensionStateChanged(*abilityStateData);
155 {
156 // Protect Multi Thread Deconstruct IRemoteObject
157 std::unique_lock<std::mutex> lock(callbackMutex_);
158 delete abilityStateData;
159 }
160 return NO_ERROR;
161 }
162
HandleOnProcessCreated(MessageParcel & data,MessageParcel & reply)163 int32_t ApplicationStateObserverStub::HandleOnProcessCreated(MessageParcel &data, MessageParcel &reply)
164 {
165 std::unique_ptr<ProcessData> processData(data.ReadParcelable<ProcessData>());
166 if (!processData) {
167 HILOG_ERROR("ReadParcelable<ProcessData> failed");
168 return ERR_APPEXECFWK_PARCEL_ERROR;
169 }
170
171 OnProcessCreated(*processData);
172 return NO_ERROR;
173 }
174
HandleOnProcessStateChanged(MessageParcel & data,MessageParcel & reply)175 int32_t ApplicationStateObserverStub::HandleOnProcessStateChanged(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 OnProcessStateChanged(*processData);
184 return NO_ERROR;
185 }
186
HandleOnProcessDied(MessageParcel & data,MessageParcel & reply)187 int32_t ApplicationStateObserverStub::HandleOnProcessDied(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 OnProcessDied(*processData);
196 return NO_ERROR;
197 }
198
HandleOnApplicationStateChanged(MessageParcel & data,MessageParcel & reply)199 int32_t ApplicationStateObserverStub::HandleOnApplicationStateChanged(MessageParcel &data, MessageParcel &reply)
200 {
201 std::unique_ptr<AppStateData> processData(data.ReadParcelable<AppStateData>());
202 if (!processData) {
203 HILOG_ERROR("ReadParcelable<AppStateData> failed");
204 return ERR_APPEXECFWK_PARCEL_ERROR;
205 }
206
207 OnApplicationStateChanged(*processData);
208 return NO_ERROR;
209 }
210
HandleOnAppStateChanged(MessageParcel & data,MessageParcel & reply)211 int32_t ApplicationStateObserverStub::HandleOnAppStateChanged(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 OnAppStateChanged(*processData);
220 return NO_ERROR;
221 }
222
OnRemoteDied(const wptr<IRemoteObject> & remote)223 void ApplicationStateObserverRecipient::OnRemoteDied(const wptr<IRemoteObject> &__attribute__((unused)) remote)
224 {
225 HILOG_ERROR("ApplicationStateObserverRecipient On remote died.");
226 if (handler_) {
227 handler_(remote);
228 }
229 }
230
HandleOnProcessReused(MessageParcel & data,MessageParcel & reply)231 int32_t ApplicationStateObserverStub::HandleOnProcessReused(MessageParcel &data, MessageParcel &reply)
232 {
233 std::unique_ptr<ProcessData> processData(data.ReadParcelable<ProcessData>());
234 if (!processData) {
235 HILOG_ERROR("ReadParcelable<ProcessData> failed");
236 return ERR_APPEXECFWK_PARCEL_ERROR;
237 }
238
239 OnProcessReused(*processData);
240 return NO_ERROR;
241 }
242
ApplicationStateObserverRecipient(RemoteDiedHandler handler)243 ApplicationStateObserverRecipient::ApplicationStateObserverRecipient(RemoteDiedHandler handler) : handler_(handler)
244 {}
245
~ApplicationStateObserverRecipient()246 ApplicationStateObserverRecipient::~ApplicationStateObserverRecipient()
247 {}
248 } // namespace AppExecFwk
249 } // namespace OHOS
250