1 /*
2  * Copyright (c) 2023-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 "dinput_source_manager_event_handler.h"
17 
18 #include "if_system_ability_manager.h"
19 #include "iservice_registry.h"
20 #include "nlohmann/json.hpp"
21 #include "string_ex.h"
22 
23 #include "distributed_hardware_fwk_kit.h"
24 #include "ipublisher_listener.h"
25 
26 #include "constants_dinput.h"
27 #include "dinput_errcode.h"
28 #include "dinput_log.h"
29 #include "dinput_utils_tool.h"
30 #include "dinput_softbus_define.h"
31 #include "distributed_input_source_transport.h"
32 
33 namespace OHOS {
34 namespace DistributedHardware {
35 namespace DistributedInput {
DInputSourceManagerEventHandler(const std::shared_ptr<AppExecFwk::EventRunner> & runner,DistributedInputSourceManager * manager)36 DInputSourceManagerEventHandler::DInputSourceManagerEventHandler(
37     const std::shared_ptr<AppExecFwk::EventRunner> &runner, DistributedInputSourceManager *manager)
38     : AppExecFwk::EventHandler(runner)
39 {
40     sourceManagerObj_ = manager;
41 }
42 
~DInputSourceManagerEventHandler()43 DInputSourceManagerEventHandler::~DInputSourceManagerEventHandler()
44 {
45     sourceManagerObj_ = nullptr;
46 }
47 
NotifyRegisterCallback(const AppExecFwk::InnerEvent::Pointer & event)48 void DInputSourceManagerEventHandler::NotifyRegisterCallback(const AppExecFwk::InnerEvent::Pointer &event)
49 {
50     if (event == nullptr) {
51         DHLOGE("event is null.");
52         return;
53     }
54     std::shared_ptr<nlohmann::json> dataMsg = event->GetSharedObject<nlohmann::json>();
55     if (dataMsg == nullptr) {
56         DHLOGE("dataMsg is null.");
57         return;
58     }
59     auto it = dataMsg->begin();
60     nlohmann::json innerMsg = *it;
61     if (!IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_DEVID) ||
62         !IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_HWID) ||
63         !IsBoolean(innerMsg, INPUT_SOURCEMANAGER_KEY_RESULT)) {
64         DHLOGE("The key is invaild.");
65         return ;
66     }
67     std::string deviceId = innerMsg[INPUT_SOURCEMANAGER_KEY_DEVID];
68     std::string dhId = innerMsg[INPUT_SOURCEMANAGER_KEY_HWID];
69     bool result = innerMsg[INPUT_SOURCEMANAGER_KEY_RESULT];
70 
71     DistributedInputSourceManager::InputDeviceId inputDeviceId {deviceId, dhId};
72     std::vector<DistributedInputSourceManager::InputDeviceId> tmpInputDevId = sourceManagerObj_->GetInputDeviceId();
73     // Find out if the dh exists
74     auto devIt  = std::find(tmpInputDevId.begin(), tmpInputDevId.end(), inputDeviceId);
75     if (devIt != tmpInputDevId.end()) {
76         if (result == false) {
77             sourceManagerObj_->RemoveInputDeviceId(deviceId, dhId);
78         }
79     } else {
80         DHLOGW("ProcessEvent DINPUT_SOURCE_MANAGER_RIGISTER_MSG the, devId: %{public}s, dhId: %{public}s is bad data.",
81             GetAnonyString(deviceId).c_str(), GetAnonyString(dhId).c_str());
82     }
83 
84     sourceManagerObj_->RunRegisterCallback(deviceId, dhId,
85         result ? DH_SUCCESS : ERR_DH_INPUT_SERVER_SOURCE_MANAGER_REGISTER_MSG_IS_BAD);
86 }
87 
NotifyUnregisterCallback(const AppExecFwk::InnerEvent::Pointer & event)88 void DInputSourceManagerEventHandler::NotifyUnregisterCallback(const AppExecFwk::InnerEvent::Pointer &event)
89 {
90     if (event == nullptr) {
91         DHLOGE("event is null.");
92         return;
93     }
94     std::shared_ptr<nlohmann::json> dataMsg = event->GetSharedObject<nlohmann::json>();
95     if (dataMsg == nullptr) {
96         DHLOGE("dataMsg is null.");
97         return;
98     }
99     auto it = dataMsg->begin();
100     nlohmann::json innerMsg = *it;
101     if (!IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_DEVID) ||
102         !IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_HWID) ||
103         !IsBoolean(innerMsg, INPUT_SOURCEMANAGER_KEY_RESULT)) {
104         DHLOGE("The key is invaild.");
105         return ;
106     }
107     std::string deviceId = innerMsg[INPUT_SOURCEMANAGER_KEY_DEVID];
108     std::string dhId = innerMsg[INPUT_SOURCEMANAGER_KEY_HWID];
109     bool result = innerMsg[INPUT_SOURCEMANAGER_KEY_RESULT];
110     if (result) {
111         sourceManagerObj_->SetDeviceMapValue(deviceId, DINPUT_SOURCE_SWITCH_OFF);
112     }
113     sourceManagerObj_->RunUnregisterCallback(deviceId, dhId,
114         result ? DH_SUCCESS : ERR_DH_INPUT_SERVER_SOURCE_MANAGER_UNREGISTER_MSG_IS_BAD);
115 }
116 
NotifyPrepareCallback(const AppExecFwk::InnerEvent::Pointer & event)117 void DInputSourceManagerEventHandler::NotifyPrepareCallback(const AppExecFwk::InnerEvent::Pointer &event)
118 {
119     if (event == nullptr) {
120         DHLOGE("event is null.");
121         return;
122     }
123     std::shared_ptr<nlohmann::json> dataMsg = event->GetSharedObject<nlohmann::json>();
124     if (dataMsg == nullptr) {
125         DHLOGE("dataMsg is null.");
126         return;
127     }
128     auto it = dataMsg->begin();
129     nlohmann::json innerMsg = *it;
130     if (!IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_DEVID) ||
131         !IsBoolean(innerMsg, INPUT_SOURCEMANAGER_KEY_RESULT) ||
132         !IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_WHITELIST)) {
133         DHLOGE("The key is invaild.");
134         return ;
135     }
136     std::string deviceId = innerMsg[INPUT_SOURCEMANAGER_KEY_DEVID];
137     bool result = innerMsg[INPUT_SOURCEMANAGER_KEY_RESULT];
138     std::string object = innerMsg[INPUT_SOURCEMANAGER_KEY_WHITELIST];
139 
140     sourceManagerObj_->RunPrepareCallback(deviceId,
141         result ? DH_SUCCESS : ERR_DH_INPUT_SERVER_SOURCE_MANAGER_PREPARE_MSG_IS_BAD, object);
142 }
143 
NotifyUnprepareCallback(const AppExecFwk::InnerEvent::Pointer & event)144 void DInputSourceManagerEventHandler::NotifyUnprepareCallback(const AppExecFwk::InnerEvent::Pointer &event)
145 {
146     if (event == nullptr) {
147         DHLOGE("event is null.");
148         return;
149     }
150     std::shared_ptr<nlohmann::json> dataMsg = event->GetSharedObject<nlohmann::json>();
151     if (dataMsg == nullptr) {
152         DHLOGE("dataMsg is null.");
153         return;
154     }
155     auto it = dataMsg->begin();
156     nlohmann::json innerMsg = *it;
157     if (!IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_DEVID) ||
158         !IsBoolean(innerMsg, INPUT_SOURCEMANAGER_KEY_RESULT)) {
159         DHLOGE("The key is invaild.");
160         return ;
161     }
162     std::string deviceId = innerMsg[INPUT_SOURCEMANAGER_KEY_DEVID];
163     bool result = innerMsg[INPUT_SOURCEMANAGER_KEY_RESULT];
164     if (result) {
165         sourceManagerObj_->SetDeviceMapValue(deviceId, DINPUT_SOURCE_SWITCH_OFF);
166     }
167     sourceManagerObj_->RunUnprepareCallback(deviceId,
168         result ? DH_SUCCESS : ERR_DH_INPUT_SERVER_SOURCE_MANAGER_UNPREPARE_MSG_IS_BAD);
169 }
170 
NotifyStartCallback(const AppExecFwk::InnerEvent::Pointer & event)171 void DInputSourceManagerEventHandler::NotifyStartCallback(const AppExecFwk::InnerEvent::Pointer &event)
172 {
173     if (event == nullptr) {
174         DHLOGE("event is null.");
175         return;
176     }
177     std::shared_ptr<nlohmann::json> dataMsg = event->GetSharedObject<nlohmann::json>();
178     if (dataMsg == nullptr) {
179         DHLOGE("dataMsg is null.");
180         return;
181     }
182     auto it = dataMsg->begin();
183     nlohmann::json innerMsg = *it;
184     if (!IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_DEVID) ||
185         !IsUInt32(innerMsg, INPUT_SOURCEMANAGER_KEY_ITP) ||
186         !IsBoolean(innerMsg, INPUT_SOURCEMANAGER_KEY_RESULT)) {
187         DHLOGE("The key is invaild.");
188         return ;
189     }
190     std::string deviceId = innerMsg[INPUT_SOURCEMANAGER_KEY_DEVID];
191     uint32_t inputTypes = innerMsg[INPUT_SOURCEMANAGER_KEY_ITP];
192     bool result = innerMsg[INPUT_SOURCEMANAGER_KEY_RESULT];
193     DHLOGI("Start DInput Recv Callback ret: %{public}s, devId: %{public}s, inputTypes: %{public}d",
194         result ? "true" : "false", GetAnonyString(deviceId).c_str(), inputTypes);
195     if (result) {
196         sourceManagerObj_->SetInputTypesMap(
197             deviceId, sourceManagerObj_->GetInputTypesMap(deviceId) | inputTypes);
198     }
199     sourceManagerObj_->SetStartTransFlag((result && (sourceManagerObj_->GetInputTypesMap(deviceId) > 0)) ?
200         DInputServerType::SOURCE_SERVER_TYPE : DInputServerType::NULL_SERVER_TYPE);
201     sourceManagerObj_->RunStartCallback(deviceId, inputTypes,
202         result ? DH_SUCCESS : ERR_DH_INPUT_SERVER_SOURCE_MANAGER_START_MSG_IS_BAD);
203 }
204 
NotifyStopCallback(const AppExecFwk::InnerEvent::Pointer & event)205 void DInputSourceManagerEventHandler::NotifyStopCallback(const AppExecFwk::InnerEvent::Pointer &event)
206 {
207     if (event == nullptr) {
208         DHLOGE("event is null.");
209         return;
210     }
211     std::shared_ptr<nlohmann::json> dataMsg = event->GetSharedObject<nlohmann::json>();
212     if (dataMsg == nullptr) {
213         DHLOGE("dataMsg is null.");
214         return;
215     }
216     auto it = dataMsg->begin();
217     nlohmann::json innerMsg = *it;
218     if (!IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_DEVID) ||
219         !IsUInt32(innerMsg, INPUT_SOURCEMANAGER_KEY_ITP) ||
220         !IsBoolean(innerMsg, INPUT_SOURCEMANAGER_KEY_RESULT)) {
221         DHLOGE("The key is invaild.");
222         return ;
223     }
224     std::string deviceId = innerMsg[INPUT_SOURCEMANAGER_KEY_DEVID];
225     uint32_t inputTypes = innerMsg[INPUT_SOURCEMANAGER_KEY_ITP];
226     bool result = innerMsg[INPUT_SOURCEMANAGER_KEY_RESULT];
227 
228     DHLOGI("Stop DInput Recv Callback ret: %{public}d, devId: %{public}s, inputTypes: %{public}d",
229         result, GetAnonyString(deviceId).c_str(), inputTypes);
230     if (result && (sourceManagerObj_->GetInputTypesMap(deviceId) & inputTypes)) {
231         sourceManagerObj_->SetInputTypesMap(
232             deviceId, sourceManagerObj_->GetInputTypesMap(deviceId) -
233             (sourceManagerObj_->GetInputTypesMap(deviceId) & inputTypes));
234     }
235 
236     if (sourceManagerObj_->GetInputTypesMap(deviceId) == 0) {
237         sourceManagerObj_->SetDeviceMapValue(deviceId, DINPUT_SOURCE_SWITCH_OFF);
238     }
239 
240     // DeviceMap_ all sink device switch is off,call isstart's callback
241     bool isAllDevSwitchOff = sourceManagerObj_->GetDeviceMapAllDevSwitchOff();
242     if (isAllDevSwitchOff) {
243         DHLOGI("All Dev Switch Off");
244         sourceManagerObj_->SetStartTransFlag(DInputServerType::NULL_SERVER_TYPE);
245     }
246     sourceManagerObj_->RunStopCallback(deviceId, inputTypes,
247         result ? DH_SUCCESS : ERR_DH_INPUT_SERVER_SOURCE_MANAGER_STOP_MSG_IS_BAD);
248 }
249 
NotifyStartDhidCallback(const AppExecFwk::InnerEvent::Pointer & event)250 void DInputSourceManagerEventHandler::NotifyStartDhidCallback(const AppExecFwk::InnerEvent::Pointer &event)
251 {
252     if (event == nullptr) {
253         DHLOGE("event is null.");
254         return;
255     }
256     std::shared_ptr<nlohmann::json> dataMsg = event->GetSharedObject<nlohmann::json>();
257     if (dataMsg == nullptr) {
258         DHLOGE("dataMsg is null.");
259         return;
260     }
261     auto it = dataMsg->begin();
262     nlohmann::json innerMsg = *it;
263     if (!IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_DEVID) ||
264         !IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_DHID) ||
265         !IsBoolean(innerMsg, INPUT_SOURCEMANAGER_KEY_RESULT)) {
266         DHLOGE("The key is invaild.");
267         return ;
268     }
269     std::string deviceId = innerMsg[INPUT_SOURCEMANAGER_KEY_DEVID];
270     std::string dhidStr = innerMsg[INPUT_SOURCEMANAGER_KEY_DHID];
271     bool result = innerMsg[INPUT_SOURCEMANAGER_KEY_RESULT];
272 
273     sourceManagerObj_->RunStartDhidCallback(deviceId, dhidStr,
274         result ? DH_SUCCESS : ERR_DH_INPUT_SERVER_SOURCE_MANAGER_START_MSG_IS_BAD);
275 }
276 
NotifyStopDhidCallback(const AppExecFwk::InnerEvent::Pointer & event)277 void DInputSourceManagerEventHandler::NotifyStopDhidCallback(const AppExecFwk::InnerEvent::Pointer &event)
278 {
279     if (event == nullptr) {
280         DHLOGE("event is null.");
281         return;
282     }
283     std::shared_ptr<nlohmann::json> dataMsg = event->GetSharedObject<nlohmann::json>();
284     if (dataMsg == nullptr) {
285         DHLOGE("dataMsg is null.");
286         return;
287     }
288     auto it = dataMsg->begin();
289     nlohmann::json innerMsg = *it;
290     if (!IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_DEVID) ||
291         !IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_DHID) ||
292         !IsBoolean(innerMsg, INPUT_SOURCEMANAGER_KEY_RESULT)) {
293         DHLOGE("The key is invaild.");
294         return ;
295     }
296     std::string deviceId = innerMsg[INPUT_SOURCEMANAGER_KEY_DEVID];
297     std::string dhidStr = innerMsg[INPUT_SOURCEMANAGER_KEY_DHID];
298     bool result = innerMsg[INPUT_SOURCEMANAGER_KEY_RESULT];
299 
300     sourceManagerObj_->RunStopDhidCallback(deviceId, dhidStr,
301         result ? DH_SUCCESS : ERR_DH_INPUT_SERVER_SOURCE_MANAGER_STOP_MSG_IS_BAD);
302 }
303 
NotifyKeyStateCallback(const AppExecFwk::InnerEvent::Pointer & event)304 void DInputSourceManagerEventHandler::NotifyKeyStateCallback(const AppExecFwk::InnerEvent::Pointer &event)
305 {
306     if (event == nullptr) {
307         DHLOGE("event is null.");
308         return;
309     }
310     std::shared_ptr<nlohmann::json> dataMsg = event->GetSharedObject<nlohmann::json>();
311     if (dataMsg == nullptr) {
312         DHLOGE("dataMsg is null.");
313         return;
314     }
315     auto it = dataMsg->begin();
316     nlohmann::json innerMsg = *it;
317     if (!IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_DEVID) ||
318         !IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_DHID) ||
319         !IsUInt32(innerMsg, INPUT_SOURCEMANAGER_KEY_TYPE) ||
320         !IsUInt32(innerMsg, INPUT_SOURCEMANAGER_KEY_CODE) ||
321         !IsUInt32(innerMsg, INPUT_SOURCEMANAGER_KEY_VALUE)) {
322         DHLOGE("The key is invaild.");
323         return ;
324     }
325     std::string deviceId = innerMsg[INPUT_SOURCEMANAGER_KEY_DEVID];
326     std::string dhid = innerMsg[INPUT_SOURCEMANAGER_KEY_DHID];
327     uint32_t keyType = innerMsg[INPUT_SOURCEMANAGER_KEY_TYPE];
328     uint32_t keyCode = innerMsg[INPUT_SOURCEMANAGER_KEY_CODE];
329     uint32_t keyValue = innerMsg[INPUT_SOURCEMANAGER_KEY_VALUE];
330 
331     sourceManagerObj_->RunKeyStateCallback(deviceId, dhid, keyType, keyCode, keyValue);
332 }
333 
NotifyStartServerCallback(const AppExecFwk::InnerEvent::Pointer & event)334 void DInputSourceManagerEventHandler::NotifyStartServerCallback(const AppExecFwk::InnerEvent::Pointer &event)
335 {
336     if (event == nullptr) {
337         DHLOGE("event is null.");
338         return;
339     }
340     std::shared_ptr<nlohmann::json> dataMsg = event->GetSharedObject<nlohmann::json>();
341     if (dataMsg == nullptr) {
342         DHLOGE("dataMsg is null.");
343         return;
344     }
345     auto it = dataMsg->begin();
346     nlohmann::json innerMsg = *it;
347     if (!IsInt32(innerMsg, INPUT_SOURCEMANAGER_KEY_RESULT)) {
348         DHLOGE("The key is invaild.");
349         return ;
350     }
351     int32_t serType = innerMsg[INPUT_SOURCEMANAGER_KEY_RESULT];
352     DInputServerType startTransFlag = DInputServerType(serType);
353     sourceManagerObj_->SetStartTransFlag(startTransFlag);
354 }
355 
356 
NotifyRelayPrepareCallback(const AppExecFwk::InnerEvent::Pointer & event)357 void DInputSourceManagerEventHandler::NotifyRelayPrepareCallback(const AppExecFwk::InnerEvent::Pointer &event)
358 {
359     if (event == nullptr) {
360         DHLOGE("event is null.");
361         return;
362     }
363     std::shared_ptr<nlohmann::json> dataMsg = event->GetSharedObject<nlohmann::json>();
364     if (dataMsg == nullptr) {
365         DHLOGE("dataMsg is null.");
366         return;
367     }
368     nlohmann::json::iterator it = dataMsg->begin();
369     nlohmann::json innerMsg = *it;
370     if (!IsInt32(innerMsg, INPUT_SOURCEMANAGER_KEY_VALUE) ||
371         !IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_SRC_DEVID) ||
372         !IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_SINK_DEVID)) {
373         DHLOGE("The key is invaild.");
374         return ;
375     }
376     int32_t status = innerMsg[INPUT_SOURCEMANAGER_KEY_VALUE];
377     std::string srcId = innerMsg[INPUT_SOURCEMANAGER_KEY_SRC_DEVID];
378     std::string sinkId = innerMsg[INPUT_SOURCEMANAGER_KEY_SINK_DEVID];
379 
380     sourceManagerObj_->RunRelayPrepareCallback(srcId, sinkId, status);
381 }
382 
NotifyRelayUnprepareCallback(const AppExecFwk::InnerEvent::Pointer & event)383 void DInputSourceManagerEventHandler::NotifyRelayUnprepareCallback(const AppExecFwk::InnerEvent::Pointer &event)
384 {
385     if (event == nullptr) {
386         DHLOGE("event is null.");
387         return;
388     }
389     std::shared_ptr<nlohmann::json> dataMsg = event->GetSharedObject<nlohmann::json>();
390     if (dataMsg == nullptr) {
391         DHLOGE("dataMsg is null.");
392         return;
393     }
394     nlohmann::json::iterator it = dataMsg->begin();
395     nlohmann::json innerMsg = *it;
396     if (!IsInt32(innerMsg, INPUT_SOURCEMANAGER_KEY_VALUE) ||
397         !IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_SRC_DEVID) ||
398         !IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_SINK_DEVID)) {
399         DHLOGE("The key is invaild.");
400         return ;
401     }
402     int32_t status = innerMsg[INPUT_SOURCEMANAGER_KEY_VALUE];
403     std::string srcId = innerMsg[INPUT_SOURCEMANAGER_KEY_SRC_DEVID];
404     std::string sinkId = innerMsg[INPUT_SOURCEMANAGER_KEY_SINK_DEVID];
405 
406     sourceManagerObj_->RunRelayUnprepareCallback(srcId, sinkId, status);
407 }
408 
NotifyRelayPrepareRemoteInput(const AppExecFwk::InnerEvent::Pointer & event)409 void DInputSourceManagerEventHandler::NotifyRelayPrepareRemoteInput(const AppExecFwk::InnerEvent::Pointer &event)
410 {
411     if (event == nullptr) {
412         DHLOGE("event is null.");
413         return;
414     }
415     std::shared_ptr<nlohmann::json> dataMsg = event->GetSharedObject<nlohmann::json>();
416     if (dataMsg == nullptr) {
417         DHLOGE("dataMsg is null.");
418         return;
419     }
420     nlohmann::json::iterator it = dataMsg->begin();
421     nlohmann::json innerMsg = *it;
422     if (!IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_DEVID) ||
423         !IsBoolean(innerMsg, INPUT_SOURCEMANAGER_KEY_RESULT) ||
424         !IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_WHITELIST) ||
425         !IsInt32(innerMsg, INPUT_SOURCEMANAGER_KEY_SESSIONID)) {
426         DHLOGE("The key is invaild.");
427         return ;
428     }
429     std::string deviceId = innerMsg[INPUT_SOURCEMANAGER_KEY_DEVID];
430     bool result = innerMsg[INPUT_SOURCEMANAGER_KEY_RESULT];
431     std::string object = innerMsg[INPUT_SOURCEMANAGER_KEY_WHITELIST];
432     int32_t toSrcSessionId = innerMsg[INPUT_SOURCEMANAGER_KEY_SESSIONID];
433     DHLOGI("Device whitelist object: %{public}s", object.c_str());
434     std::string localNetworkId = GetLocalNetworkId();
435     if (localNetworkId.empty()) {
436         return;
437     }
438 
439     // notify to origin sourcesa result.
440     int32_t ret = DistributedInputSourceTransport::GetInstance().NotifyOriginPrepareResult(toSrcSessionId,
441         localNetworkId, deviceId, result ? DH_SUCCESS : ERR_DH_INPUT_SERVER_SOURCE_MANAGER_PREPARE_MSG_IS_BAD);
442     if (ret != DH_SUCCESS) {
443         DHLOGE("ProcessEvent DINPUT_SOURCE_MANAGER_RELAY_PREPARE_RESULT_TO_ORIGIN notify is fail.");
444         return;
445     }
446     sourceManagerObj_->RunWhiteListCallback(deviceId, object);
447 }
448 
NotifyRelayUnprepareRemoteInput(const AppExecFwk::InnerEvent::Pointer & event)449 void DInputSourceManagerEventHandler::NotifyRelayUnprepareRemoteInput(const AppExecFwk::InnerEvent::Pointer &event)
450 {
451     if (event == nullptr) {
452         DHLOGE("event is null.");
453         return;
454     }
455     std::shared_ptr<nlohmann::json> dataMsg = event->GetSharedObject<nlohmann::json>();
456     if (dataMsg == nullptr) {
457         DHLOGE("dataMsg is null.");
458         return;
459     }
460     nlohmann::json::iterator it = dataMsg->begin();
461     nlohmann::json innerMsg = *it;
462     if (!IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_DEVID) ||
463         !IsBoolean(innerMsg, INPUT_SOURCEMANAGER_KEY_RESULT) ||
464         !IsInt32(innerMsg, INPUT_SOURCEMANAGER_KEY_SESSIONID)) {
465         DHLOGE("The key is invaild.");
466         return ;
467     }
468     std::string deviceId = innerMsg[INPUT_SOURCEMANAGER_KEY_DEVID];
469     bool result = innerMsg[INPUT_SOURCEMANAGER_KEY_RESULT];
470     int32_t toSrcSessionId = innerMsg[INPUT_SOURCEMANAGER_KEY_SESSIONID];
471     std::string localNetworkId = GetLocalNetworkId();
472     if (localNetworkId.empty()) {
473         return;
474     }
475 
476     // notify to origin sourcesa result.
477     int32_t ret = DistributedInputSourceTransport::GetInstance().NotifyOriginUnprepareResult(toSrcSessionId,
478         localNetworkId, deviceId, result ? DH_SUCCESS : ERR_DH_INPUT_SERVER_SOURCE_MANAGER_UNPREPARE_MSG_IS_BAD);
479     if (ret != DH_SUCCESS) {
480         DHLOGE("ProcessEvent DINPUT_SOURCE_MANAGER_RELAY_UNPREPARE_RESULT_TO_ORIGIN notify is fail.");
481         return;
482     }
483 }
484 
NotifyRelayStartDhidCallback(const AppExecFwk::InnerEvent::Pointer & event)485 void DInputSourceManagerEventHandler::NotifyRelayStartDhidCallback(const AppExecFwk::InnerEvent::Pointer &event)
486 {
487     if (event == nullptr) {
488         DHLOGE("event is null.");
489         return;
490     }
491     std::shared_ptr<nlohmann::json> dataMsg = event->GetSharedObject<nlohmann::json>();
492     if (dataMsg == nullptr) {
493         DHLOGE("dataMsg is null.");
494         return;
495     }
496     nlohmann::json::iterator it = dataMsg->begin();
497     nlohmann::json innerMsg = *it;
498     if (!IsInt32(innerMsg, INPUT_SOURCEMANAGER_KEY_VALUE) ||
499         !IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_SRC_DEVID) ||
500         !IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_SINK_DEVID) ||
501         !IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_DHID)) {
502         DHLOGE("The key is invaild.");
503         return ;
504     }
505     int32_t status = innerMsg[INPUT_SOURCEMANAGER_KEY_VALUE];
506     std::string srcId = innerMsg[INPUT_SOURCEMANAGER_KEY_SRC_DEVID];
507     std::string sinkId = innerMsg[INPUT_SOURCEMANAGER_KEY_SINK_DEVID];
508     std::string dhids = innerMsg[INPUT_SOURCEMANAGER_KEY_DHID];
509 
510     sourceManagerObj_->RunRelayStartDhidCallback(srcId, sinkId, status, dhids);
511 }
512 
NotifyRelayStopDhidCallback(const AppExecFwk::InnerEvent::Pointer & event)513 void DInputSourceManagerEventHandler::NotifyRelayStopDhidCallback(const AppExecFwk::InnerEvent::Pointer &event)
514 {
515     if (event == nullptr) {
516         DHLOGE("event is null.");
517         return;
518     }
519     std::shared_ptr<nlohmann::json> dataMsg = event->GetSharedObject<nlohmann::json>();
520     if (dataMsg == nullptr) {
521         DHLOGE("dataMsg is null.");
522         return;
523     }
524     nlohmann::json::iterator it = dataMsg->begin();
525     nlohmann::json innerMsg = *it;
526     if (!IsInt32(innerMsg, INPUT_SOURCEMANAGER_KEY_VALUE) ||
527         !IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_SRC_DEVID) ||
528         !IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_SINK_DEVID) ||
529         !IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_DHID)) {
530         DHLOGE("The key is invaild.");
531         return ;
532     }
533     int32_t status = innerMsg[INPUT_SOURCEMANAGER_KEY_VALUE];
534     std::string srcId = innerMsg[INPUT_SOURCEMANAGER_KEY_SRC_DEVID];
535     std::string sinkId = innerMsg[INPUT_SOURCEMANAGER_KEY_SINK_DEVID];
536     std::string dhids = innerMsg[INPUT_SOURCEMANAGER_KEY_DHID];
537 
538     sourceManagerObj_->RunRelayStopDhidCallback(srcId, sinkId, status, dhids);
539 }
540 
NotifyRelayStartTypeCallback(const AppExecFwk::InnerEvent::Pointer & event)541 void DInputSourceManagerEventHandler::NotifyRelayStartTypeCallback(const AppExecFwk::InnerEvent::Pointer &event)
542 {
543     if (event == nullptr) {
544         DHLOGE("event is null.");
545         return;
546     }
547     std::shared_ptr<nlohmann::json> dataMsg = event->GetSharedObject<nlohmann::json>();
548     if (dataMsg == nullptr) {
549         DHLOGE("dataMsg is null.");
550         return;
551     }
552     nlohmann::json::iterator it = dataMsg->begin();
553     nlohmann::json innerMsg = *it;
554     if (!IsInt32(innerMsg, INPUT_SOURCEMANAGER_KEY_VALUE) ||
555         !IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_SRC_DEVID) ||
556         !IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_SINK_DEVID) ||
557         !IsUInt32(innerMsg, INPUT_SOURCEMANAGER_KEY_TYPE)) {
558         DHLOGE("The key is invaild.");
559         return ;
560     }
561     int32_t status = innerMsg[INPUT_SOURCEMANAGER_KEY_VALUE];
562     std::string srcId = innerMsg[INPUT_SOURCEMANAGER_KEY_SRC_DEVID];
563     std::string sinkId = innerMsg[INPUT_SOURCEMANAGER_KEY_SINK_DEVID];
564     uint32_t inputTypes = innerMsg[INPUT_SOURCEMANAGER_KEY_TYPE];
565 
566     sourceManagerObj_->RunRelayStartTypeCallback(srcId, sinkId, status, inputTypes);
567 }
568 
NotifyRelayStopTypeCallback(const AppExecFwk::InnerEvent::Pointer & event)569 void DInputSourceManagerEventHandler::NotifyRelayStopTypeCallback(const AppExecFwk::InnerEvent::Pointer &event)
570 {
571     if (event == nullptr) {
572         DHLOGE("event is null.");
573         return;
574     }
575     std::shared_ptr<nlohmann::json> dataMsg = event->GetSharedObject<nlohmann::json>();
576     if (dataMsg == nullptr) {
577         DHLOGE("dataMsg is null.");
578         return;
579     }
580     nlohmann::json::iterator it = dataMsg->begin();
581     nlohmann::json innerMsg = *it;
582     if (!IsInt32(innerMsg, INPUT_SOURCEMANAGER_KEY_VALUE) ||
583         !IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_SRC_DEVID) ||
584         !IsString(innerMsg, INPUT_SOURCEMANAGER_KEY_SINK_DEVID) ||
585         !IsUInt32(innerMsg, INPUT_SOURCEMANAGER_KEY_TYPE)) {
586         DHLOGE("The key is invaild.");
587         return ;
588     }
589     int32_t status = innerMsg[INPUT_SOURCEMANAGER_KEY_VALUE];
590     std::string srcId = innerMsg[INPUT_SOURCEMANAGER_KEY_SRC_DEVID];
591     std::string sinkId = innerMsg[INPUT_SOURCEMANAGER_KEY_SINK_DEVID];
592     uint32_t inputTypes = innerMsg[INPUT_SOURCEMANAGER_KEY_TYPE];
593 
594     sourceManagerObj_->RunRelayStopTypeCallback(srcId, sinkId, status, inputTypes);
595 }
596 
ProcessEventInner(const AppExecFwk::InnerEvent::Pointer & event)597 void DInputSourceManagerEventHandler::ProcessEventInner(const AppExecFwk::InnerEvent::Pointer &event)
598 {
599     switch (event->GetInnerEventId()) {
600         case DINPUT_SOURCE_MANAGER_RELAY_UNPREPARE_RESULT_TO_ORIGIN:
601             NotifyRelayUnprepareRemoteInput(event);
602             break;
603         case DINPUT_SOURCE_MANAGER_RELAY_PREPARE_RESULT_MMI:
604             NotifyRelayPrepareCallback(event);
605             break;
606         case DINPUT_SOURCE_MANAGER_RELAY_UNPREPARE_RESULT_MMI:
607             NotifyRelayUnprepareCallback(event);
608             break;
609         case DINPUT_SOURCE_MANAGER_RELAY_STARTDHID_RESULT_MMI:
610             NotifyRelayStartDhidCallback(event);
611             break;
612         case DINPUT_SOURCE_MANAGER_RELAY_STOPDHID_RESULT_MMI:
613             NotifyRelayStopDhidCallback(event);
614             break;
615         case DINPUT_SOURCE_MANAGER_RELAY_STARTTYPE_RESULT_MMI:
616             NotifyRelayStartTypeCallback(event);
617             break;
618         case DINPUT_SOURCE_MANAGER_RELAY_STOPTYPE_RESULT_MMI:
619             NotifyRelayStopTypeCallback(event);
620             break;
621         default:
622             DHLOGE("Event Id %{public}d is undefined.", event->GetInnerEventId());
623     }
624 }
625 
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)626 void DInputSourceManagerEventHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event)
627 {
628     switch (event->GetInnerEventId()) {
629         case DINPUT_SOURCE_MANAGER_RIGISTER_MSG:
630             NotifyRegisterCallback(event);
631             break;
632         case DINPUT_SOURCE_MANAGER_UNRIGISTER_MSG:
633             NotifyUnregisterCallback(event);
634             break;
635         case DINPUT_SOURCE_MANAGER_PREPARE_MSG:
636             NotifyPrepareCallback(event);
637             break;
638         case DINPUT_SOURCE_MANAGER_UNPREPARE_MSG:
639             NotifyUnprepareCallback(event);
640             break;
641         case DINPUT_SOURCE_MANAGER_START_MSG:
642             NotifyStartCallback(event);
643             break;
644         case DINPUT_SOURCE_MANAGER_STOP_MSG:
645             NotifyStopCallback(event);
646             break;
647         case DINPUT_SOURCE_MANAGER_START_DHID_MSG:
648             NotifyStartDhidCallback(event);
649             break;
650         case DINPUT_SOURCE_MANAGER_STOP_DHID_MSG:
651             NotifyStopDhidCallback(event);
652             break;
653         case DINPUT_SOURCE_MANAGER_KEY_STATE_MSG:
654             NotifyKeyStateCallback(event);
655             break;
656         case DINPUT_SOURCE_MANAGER_STARTSERVER_MSG:
657             NotifyStartServerCallback(event);
658             break;
659         case DINPUT_SOURCE_MANAGER_RELAY_PREPARE_RESULT_TO_ORIGIN:
660             NotifyRelayPrepareRemoteInput(event);
661             break;
662         default:
663             ProcessEventInner(event);
664     }
665 }
666 } // namespace DistributedInput
667 } // namespace DistributedHardware
668 } // namespace OHOS