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_listener.h"
17 
18 #include <algorithm>
19 #include <cinttypes>
20 #include <dlfcn.h>
21 
22 #include "if_system_ability_manager.h"
23 #include "iservice_registry.h"
24 #include "nlohmann/json.hpp"
25 #include "string_ex.h"
26 
27 #include "ipublisher_listener.h"
28 
29 #include "constants_dinput.h"
30 #include "dinput_errcode.h"
31 #include "dinput_log.h"
32 #include "dinput_utils_tool.h"
33 #include "dinput_softbus_define.h"
34 #include "distributed_input_inject.h"
35 
36 namespace OHOS {
37 namespace DistributedHardware {
38 namespace DistributedInput {
DInputSourceListener(DistributedInputSourceManager * manager)39 DInputSourceListener::DInputSourceListener(DistributedInputSourceManager *manager)
40 {
41     sourceManagerObj_ = manager;
42     DHLOGI("DInputSourceListener init.");
43 }
44 
~DInputSourceListener()45 DInputSourceListener::~DInputSourceListener()
46 {
47     sourceManagerObj_ = nullptr;
48     DHLOGI("DInputSourceListener destory.");
49 }
50 
OnResponseRegisterDistributedHardware(const std::string deviceId,const std::string dhId,bool result)51 void DInputSourceListener::OnResponseRegisterDistributedHardware(
52     const std::string deviceId, const std::string dhId, bool result)
53 {
54     DHLOGI("OnResponseRegisterDistributedHardware called, deviceId: %{public}s, "
55         "result: %{public}s.", GetAnonyString(deviceId).c_str(), result ? "success" : "failed");
56     if (sourceManagerObj_ == nullptr) {
57         DHLOGE("OnResponseRegisterDistributedHardware sourceManagerObj is null.");
58         return;
59     }
60     if (sourceManagerObj_->GetCallbackEventHandler() == nullptr) {
61         sourceManagerObj_->RunRegisterCallback(deviceId, dhId,
62             ERR_DH_INPUT_SERVER_SOURCE_MANAGERGET_CALLBACK_HANDLER_FAIL);
63         DHLOGE("OnResponseRegisterDistributedHardware GetCallbackEventHandler is null.");
64         return;
65     }
66 
67     auto jsonArrayMsg = std::make_shared<nlohmann::json>();
68     nlohmann::json tmpJson;
69     tmpJson[INPUT_SOURCEMANAGER_KEY_DEVID] = deviceId;
70     tmpJson[INPUT_SOURCEMANAGER_KEY_HWID] = dhId;
71     tmpJson[INPUT_SOURCEMANAGER_KEY_RESULT] = result;
72     jsonArrayMsg->push_back(tmpJson);
73     AppExecFwk::InnerEvent::Pointer msgEvent = AppExecFwk::InnerEvent::Get(
74         DINPUT_SOURCE_MANAGER_RIGISTER_MSG, jsonArrayMsg, 0);
75     sourceManagerObj_->GetCallbackEventHandler()->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE);
76 }
77 
OnResponsePrepareRemoteInput(const std::string deviceId,bool result,const std::string & object)78 void DInputSourceListener::OnResponsePrepareRemoteInput(const std::string deviceId,
79     bool result, const std::string &object)
80 {
81     DHLOGI("OnResponsePrepareRemoteInput called, deviceId: %{public}s, result: %{public}s.",
82         GetAnonyString(deviceId).c_str(), result ? "success" : "failed");
83 
84     if (sourceManagerObj_ == nullptr) {
85         DHLOGE("OnResponsePrepareRemoteInput sourceManagerObj is null.");
86         return;
87     }
88     if (sourceManagerObj_->GetCallbackEventHandler() == nullptr) {
89         sourceManagerObj_->RunPrepareCallback(deviceId,
90             ERR_DH_INPUT_SERVER_SOURCE_MANAGERGET_CALLBACK_HANDLER_FAIL, object);
91         DHLOGE("OnResponsePrepareRemoteInput GetCallbackEventHandler is null.");
92         return;
93     }
94     auto jsonArrayMsg = std::make_shared<nlohmann::json>();
95     nlohmann::json tmpJson;
96     tmpJson[INPUT_SOURCEMANAGER_KEY_DEVID] = deviceId;
97     tmpJson[INPUT_SOURCEMANAGER_KEY_RESULT] = result;
98     tmpJson[INPUT_SOURCEMANAGER_KEY_WHITELIST] = object;
99     jsonArrayMsg->push_back(tmpJson);
100     AppExecFwk::InnerEvent::Pointer msgEvent = AppExecFwk::InnerEvent::Get(
101         DINPUT_SOURCE_MANAGER_PREPARE_MSG, jsonArrayMsg, 0);
102     sourceManagerObj_->GetCallbackEventHandler()->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE);
103 }
104 
OnResponseUnprepareRemoteInput(const std::string deviceId,bool result)105 void DInputSourceListener::OnResponseUnprepareRemoteInput(const std::string deviceId, bool result)
106 {
107     DHLOGI("OnResponseUnprepareRemoteInput called, deviceId: %{public}s, "
108         "result: %{public}s.", GetAnonyString(deviceId).c_str(), result ? "success" : "failed");
109 
110     if (sourceManagerObj_ == nullptr) {
111         DHLOGE("OnResponseUnprepareRemoteInput sourceManagerObj is null.");
112         return;
113     }
114     if (sourceManagerObj_->GetCallbackEventHandler() == nullptr) {
115         sourceManagerObj_->RunUnprepareCallback(deviceId,
116             ERR_DH_INPUT_SERVER_SOURCE_MANAGERGET_CALLBACK_HANDLER_FAIL);
117         DHLOGE("OnResponseUnprepareRemoteInput GetCallbackEventHandler is null.");
118         return;
119     }
120 
121     auto jsonArrayMsg = std::make_shared<nlohmann::json>();
122     nlohmann::json tmpJson;
123     tmpJson[INPUT_SOURCEMANAGER_KEY_DEVID] = deviceId;
124     tmpJson[INPUT_SOURCEMANAGER_KEY_RESULT] = result;
125     jsonArrayMsg->push_back(tmpJson);
126     AppExecFwk::InnerEvent::Pointer msgEvent = AppExecFwk::InnerEvent::Get(
127         DINPUT_SOURCE_MANAGER_UNPREPARE_MSG, jsonArrayMsg, 0);
128     sourceManagerObj_->GetCallbackEventHandler()->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE);
129 }
130 
OnResponseRelayPrepareRemoteInput(int32_t toSrcSessionId,const std::string & deviceId,bool result,const std::string & object)131 void DInputSourceListener::OnResponseRelayPrepareRemoteInput(int32_t toSrcSessionId,
132     const std::string &deviceId, bool result, const std::string &object)
133 {
134     DHLOGI("OnResponseRelayPrepareRemoteInput deviceId: %{public}s, result: %{public}d.",
135         GetAnonyString(deviceId).c_str(), result);
136     if (sourceManagerObj_ == nullptr) {
137         DHLOGE("sourceManagerObj is null.");
138         return;
139     }
140     if (sourceManagerObj_->GetCallbackEventHandler() == nullptr) {
141         DHLOGE("GetCallbackEventHandler is null.");
142         return;
143     }
144 
145     auto jsonArrayMsg = std::make_shared<nlohmann::json>();
146     nlohmann::json tmpJson;
147     tmpJson[INPUT_SOURCEMANAGER_KEY_DEVID] = deviceId;
148     tmpJson[INPUT_SOURCEMANAGER_KEY_RESULT] = result;
149     tmpJson[INPUT_SOURCEMANAGER_KEY_WHITELIST] = object;
150     tmpJson[INPUT_SOURCEMANAGER_KEY_SESSIONID] = toSrcSessionId;
151     jsonArrayMsg->push_back(tmpJson);
152     AppExecFwk::InnerEvent::Pointer msgEvent = AppExecFwk::InnerEvent::Get(
153         DINPUT_SOURCE_MANAGER_RELAY_PREPARE_RESULT_TO_ORIGIN, jsonArrayMsg, 0);
154     sourceManagerObj_->GetCallbackEventHandler()->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE);
155 }
156 
OnResponseRelayUnprepareRemoteInput(int32_t toSrcSessionId,const std::string & deviceId,bool result)157 void DInputSourceListener::OnResponseRelayUnprepareRemoteInput(int32_t toSrcSessionId,
158     const std::string &deviceId, bool result)
159 {
160     DHLOGI("OnResponseRelayUnprepareRemoteInput deviceId: %{public}s, result: %{public}d.",
161         GetAnonyString(deviceId).c_str(), result);
162     if (sourceManagerObj_ == nullptr) {
163         DHLOGE("sourceManagerObj is null.");
164         return;
165     }
166     if (sourceManagerObj_->GetCallbackEventHandler() == nullptr) {
167         DHLOGE("GetCallbackEventHandler is null.");
168         return;
169     }
170 
171     auto jsonArrayMsg = std::make_shared<nlohmann::json>();
172     nlohmann::json tmpJson;
173     tmpJson[INPUT_SOURCEMANAGER_KEY_DEVID] = deviceId;
174     tmpJson[INPUT_SOURCEMANAGER_KEY_RESULT] = result;
175     tmpJson[INPUT_SOURCEMANAGER_KEY_SESSIONID] = toSrcSessionId;
176     jsonArrayMsg->push_back(tmpJson);
177     AppExecFwk::InnerEvent::Pointer msgEvent = AppExecFwk::InnerEvent::Get(
178         DINPUT_SOURCE_MANAGER_RELAY_UNPREPARE_RESULT_TO_ORIGIN, jsonArrayMsg, 0);
179     sourceManagerObj_->GetCallbackEventHandler()->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE);
180 }
181 
OnResponseStartRemoteInput(const std::string deviceId,const uint32_t inputTypes,bool result)182 void DInputSourceListener::OnResponseStartRemoteInput(
183     const std::string deviceId, const uint32_t inputTypes, bool result)
184 {
185     DHLOGI("OnResponseStartRemoteInput called, deviceId: %{public}s, inputTypes: %{public}d, result: %{public}s.",
186         GetAnonyString(deviceId).c_str(), inputTypes, result ? "success" : "failed");
187 
188     if (sourceManagerObj_ == nullptr) {
189         DHLOGE("sourceManagerObj is null.");
190         return;
191     }
192     if (sourceManagerObj_->GetCallbackEventHandler() == nullptr) {
193         sourceManagerObj_->RunStartCallback(deviceId, inputTypes,
194             ERR_DH_INPUT_SERVER_SOURCE_MANAGERGET_CALLBACK_HANDLER_FAIL);
195         DHLOGE("GetCallbackEventHandler is null.");
196         return;
197     }
198     if (result) {
199         sourceManagerObj_->SetDeviceMapValue(deviceId, DINPUT_SOURCE_SWITCH_ON);
200     }
201 
202     auto jsonArrayMsg = std::make_shared<nlohmann::json>();
203     nlohmann::json tmpJson;
204     tmpJson[INPUT_SOURCEMANAGER_KEY_DEVID] = deviceId;
205     tmpJson[INPUT_SOURCEMANAGER_KEY_ITP] = inputTypes;
206     tmpJson[INPUT_SOURCEMANAGER_KEY_RESULT] = result;
207     jsonArrayMsg->push_back(tmpJson);
208     AppExecFwk::InnerEvent::Pointer msgEvent = AppExecFwk::InnerEvent::Get(
209         DINPUT_SOURCE_MANAGER_START_MSG, jsonArrayMsg, 0);
210     sourceManagerObj_->GetCallbackEventHandler()->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE);
211 }
212 
OnResponseStopRemoteInput(const std::string deviceId,const uint32_t inputTypes,bool result)213 void DInputSourceListener::OnResponseStopRemoteInput(const std::string deviceId, const uint32_t inputTypes, bool result)
214 {
215     DHLOGI("OnResponseStopRemoteInput called, deviceId: %{public}s, inputTypes: %{public}d, result: %{public}s.",
216         GetAnonyString(deviceId).c_str(), inputTypes, result ? "true" : "failed");
217 
218     if (sourceManagerObj_ == nullptr) {
219         DHLOGE("OnResponseStopRemoteInput sourceManagerObj_ is null.");
220         return;
221     }
222     if (sourceManagerObj_->GetCallbackEventHandler() == nullptr) {
223         DHLOGE("OnResponseStopRemoteInput GetCallbackEventHandler is null.");
224         sourceManagerObj_->RunStopCallback(deviceId, inputTypes,
225             ERR_DH_INPUT_SERVER_SOURCE_MANAGERGET_CALLBACK_HANDLER_FAIL);
226         return;
227     }
228 
229     auto jsonArrayMsg = std::make_shared<nlohmann::json>();
230     nlohmann::json tmpJson;
231     tmpJson[INPUT_SOURCEMANAGER_KEY_DEVID] = deviceId;
232     tmpJson[INPUT_SOURCEMANAGER_KEY_ITP] = inputTypes;
233     tmpJson[INPUT_SOURCEMANAGER_KEY_RESULT] = result;
234     jsonArrayMsg->push_back(tmpJson);
235     AppExecFwk::InnerEvent::Pointer msgEvent = AppExecFwk::InnerEvent::Get(
236         DINPUT_SOURCE_MANAGER_STOP_MSG, jsonArrayMsg, 0);
237     sourceManagerObj_->GetCallbackEventHandler()->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE);
238 }
239 
OnResponseStartRemoteInputDhid(const std::string deviceId,const std::string & dhids,bool result)240 void DInputSourceListener::OnResponseStartRemoteInputDhid(
241     const std::string deviceId, const std::string &dhids, bool result)
242 {
243     DHLOGI("OnResponseStartRemoteInputDhid called, deviceId: %{public}s, result: %{public}s.",
244         GetAnonyString(deviceId).c_str(), result ? "success" : "failed");
245 
246     if (sourceManagerObj_ == nullptr) {
247         DHLOGE("OnResponseStartRemoteInputDhid sourceManagerObj_ is null.");
248         return;
249     }
250     if (sourceManagerObj_->GetCallbackEventHandler() == nullptr) {
251         DHLOGE("OnResponseStartRemoteInputDhid GetCallbackEventHandler is null.");
252         sourceManagerObj_->RunStartDhidCallback(deviceId, dhids,
253                                                 ERR_DH_INPUT_SERVER_SOURCE_MANAGERGET_CALLBACK_HANDLER_FAIL);
254         return;
255     }
256     if (result) {
257         sourceManagerObj_->SetDeviceMapValue(deviceId, DINPUT_SOURCE_SWITCH_ON);
258     }
259 
260     std::vector<std::string> devDhIds;
261     SplitStringToVector(dhids, INPUT_STRING_SPLIT_POINT, devDhIds);
262 
263     auto jsonArrayMsg = std::make_shared<nlohmann::json>();
264     nlohmann::json tmpJson;
265     tmpJson[INPUT_SOURCEMANAGER_KEY_DEVID] = deviceId;
266     tmpJson[INPUT_SOURCEMANAGER_KEY_DHID] = dhids;
267     tmpJson[INPUT_SOURCEMANAGER_KEY_RESULT] = result;
268     jsonArrayMsg->push_back(tmpJson);
269     AppExecFwk::InnerEvent::Pointer msgEvent =
270         AppExecFwk::InnerEvent::Get(DINPUT_SOURCE_MANAGER_START_DHID_MSG, jsonArrayMsg, 0);
271     sourceManagerObj_->GetCallbackEventHandler()->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE);
272 }
273 
OnResponseStopRemoteInputDhid(const std::string deviceId,const std::string & dhids,bool result)274 void DInputSourceListener::OnResponseStopRemoteInputDhid(
275     const std::string deviceId, const std::string &dhids, bool result)
276 {
277     DHLOGI("OnResponseStopRemoteInputDhid called, deviceId: %{public}s, result: %{public}s.",
278         GetAnonyString(deviceId).c_str(), result ? "success" : "failed");
279 
280     if (sourceManagerObj_ == nullptr) {
281         DHLOGE("OnResponseStopRemoteInputDhid sourceManagerObj_ is null.");
282         return;
283     }
284     if (sourceManagerObj_->GetCallbackEventHandler() == nullptr) {
285         DHLOGE("OnResponseStopRemoteInputDhid GetCallbackEventHandler is null.");
286         sourceManagerObj_->RunStopDhidCallback(deviceId, dhids,
287                                                ERR_DH_INPUT_SERVER_SOURCE_MANAGERGET_CALLBACK_HANDLER_FAIL);
288         return;
289     }
290 
291     auto jsonArrayMsg = std::make_shared<nlohmann::json>();
292     nlohmann::json tmpJson;
293     tmpJson[INPUT_SOURCEMANAGER_KEY_DEVID] = deviceId;
294     tmpJson[INPUT_SOURCEMANAGER_KEY_DHID] = dhids;
295     tmpJson[INPUT_SOURCEMANAGER_KEY_RESULT] = result;
296     jsonArrayMsg->push_back(tmpJson);
297     AppExecFwk::InnerEvent::Pointer msgEvent =
298         AppExecFwk::InnerEvent::Get(DINPUT_SOURCE_MANAGER_STOP_DHID_MSG, jsonArrayMsg, 0);
299     sourceManagerObj_->GetCallbackEventHandler()->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE);
300 }
301 
OnResponseKeyState(const std::string deviceId,const std::string & dhid,const uint32_t type,const uint32_t code,const uint32_t value)302 void DInputSourceListener::OnResponseKeyState(const std::string deviceId,
303     const std::string &dhid, const uint32_t type, const uint32_t code, const uint32_t value)
304 {
305     DHLOGI("OnResponseKeyState called, deviceId: %{public}s, dhid: %{public}s.", GetAnonyString(deviceId).c_str(),
306         GetAnonyString(dhid).c_str());
307     if (sourceManagerObj_ == nullptr) {
308         DHLOGE("sourceManagerObj is null.");
309         return;
310     }
311     if (sourceManagerObj_->GetCallbackEventHandler() == nullptr) {
312         DHLOGE("GetCallbackEventHandler is null.");
313         sourceManagerObj_->RunKeyStateCallback(deviceId, dhid, type, code, value);
314         return;
315     }
316 
317     auto jsonArrayMsg = std::make_shared<nlohmann::json>();
318     nlohmann::json tmpJson;
319     tmpJson[INPUT_SOURCEMANAGER_KEY_DEVID] = deviceId;
320     tmpJson[INPUT_SOURCEMANAGER_KEY_DHID] = dhid;
321     tmpJson[INPUT_SOURCEMANAGER_KEY_TYPE] = type;
322     tmpJson[INPUT_SOURCEMANAGER_KEY_CODE] = code;
323     tmpJson[INPUT_SOURCEMANAGER_KEY_VALUE] = value;
324     jsonArrayMsg->push_back(tmpJson);
325     AppExecFwk::InnerEvent::Pointer msgEvent =
326         AppExecFwk::InnerEvent::Get(DINPUT_SOURCE_MANAGER_KEY_STATE_MSG, jsonArrayMsg, 0);
327     sourceManagerObj_->GetCallbackEventHandler()->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE);
328 }
329 
330 
OnResponseKeyStateBatch(const std::string deviceId,const std::string & event)331 void DInputSourceListener::OnResponseKeyStateBatch(const std::string deviceId, const std::string &event)
332 {
333     DHLOGI("OnResponseKeyStateBatch events, deviceId: %{public}s.", GetAnonyString(deviceId).c_str());
334     OnReceivedEventRemoteInput(deviceId, event);
335 }
336 
OnReceivedEventRemoteInput(const std::string deviceId,const std::string & event)337 void DInputSourceListener::OnReceivedEventRemoteInput(const std::string deviceId, const std::string &event)
338 {
339     nlohmann::json inputData = nlohmann::json::parse(event, nullptr, false);
340     if (inputData.is_discarded()) {
341         DHLOGE("inputData parse failed!");
342         return;
343     }
344 
345     if (!inputData.is_array()) {
346         DHLOGE("inputData not vector!");
347         return;
348     }
349 
350     size_t jsonSize = inputData.size();
351     DHLOGD("OnReceivedEventRemoteInput called, deviceId: %{public}s, json size:%{public}zu.",
352         GetAnonyString(deviceId).c_str(), jsonSize);
353 
354     std::vector<RawEvent> mEventBuffer(jsonSize);
355     int idx = 0;
356     for (auto it = inputData.begin(); it != inputData.end(); ++it) {
357         nlohmann::json oneData = (*it);
358         if (!IsInt64(oneData, INPUT_KEY_WHEN) || !IsUInt32(oneData, INPUT_KEY_TYPE) ||
359             !IsUInt32(oneData, INPUT_KEY_CODE) || !IsInt32(oneData, INPUT_KEY_VALUE) ||
360             !IsString(oneData, INPUT_KEY_DESCRIPTOR) || !IsString(oneData, INPUT_KEY_PATH)) {
361             DHLOGE("The key is invaild.");
362             continue;
363         }
364         mEventBuffer[idx].when = oneData[INPUT_KEY_WHEN];
365         mEventBuffer[idx].type = oneData[INPUT_KEY_TYPE];
366         mEventBuffer[idx].code = oneData[INPUT_KEY_CODE];
367         mEventBuffer[idx].value = oneData[INPUT_KEY_VALUE];
368         mEventBuffer[idx].descriptor = oneData[INPUT_KEY_DESCRIPTOR];
369         mEventBuffer[idx].path = oneData[INPUT_KEY_PATH];
370         RecordEventLog(oneData[INPUT_KEY_WHEN], oneData[INPUT_KEY_TYPE], oneData[INPUT_KEY_CODE],
371             oneData[INPUT_KEY_VALUE], oneData[INPUT_KEY_PATH]);
372         ++idx;
373     }
374 
375     DistributedInputInject::GetInstance().RegisterDistributedEvent(deviceId, mEventBuffer);
376 }
377 
OnReceiveRelayPrepareResult(int32_t status,const std::string & srcId,const std::string & sinkId)378 void DInputSourceListener::OnReceiveRelayPrepareResult(int32_t status,
379     const std::string &srcId, const std::string &sinkId)
380 {
381     DHLOGI("status:%{public}d, srcId: %{public}s, sinkId: %{public}s.", status, GetAnonyString(srcId).c_str(),
382         GetAnonyString(sinkId).c_str());
383     if (sourceManagerObj_ == nullptr) {
384         DHLOGE("sourceManagerObj is null.");
385         return;
386     }
387     if (sourceManagerObj_->GetCallbackEventHandler() == nullptr) {
388         DHLOGE("GetCallbackEventHandler is null.");
389         return;
390     }
391 
392     auto jsonArrayMsg = std::make_shared<nlohmann::json>();
393     nlohmann::json tmpJson;
394     tmpJson[INPUT_SOURCEMANAGER_KEY_SRC_DEVID] = srcId;
395     tmpJson[INPUT_SOURCEMANAGER_KEY_SINK_DEVID] = sinkId;
396     tmpJson[INPUT_SOURCEMANAGER_KEY_VALUE] = status;
397     jsonArrayMsg->push_back(tmpJson);
398     AppExecFwk::InnerEvent::Pointer msgEvent =
399         AppExecFwk::InnerEvent::Get(DINPUT_SOURCE_MANAGER_RELAY_PREPARE_RESULT_MMI, jsonArrayMsg, 0);
400     sourceManagerObj_->GetCallbackEventHandler()->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE);
401 }
402 
OnReceiveRelayUnprepareResult(int32_t status,const std::string & srcId,const std::string & sinkId)403 void DInputSourceListener::OnReceiveRelayUnprepareResult(int32_t status,
404     const std::string &srcId, const std::string &sinkId)
405 {
406     DHLOGI("status:%{public}d, srcId: %{public}s, sinkId: %{public}s.", status, GetAnonyString(srcId).c_str(),
407         GetAnonyString(sinkId).c_str());
408     if (sourceManagerObj_ == nullptr) {
409         DHLOGE("sourceManagerObj is null.");
410         return;
411     }
412     if (sourceManagerObj_->GetCallbackEventHandler() == nullptr) {
413         DHLOGE("GetCallbackEventHandler is null.");
414         return;
415     }
416 
417     auto jsonArrayMsg = std::make_shared<nlohmann::json>();
418     nlohmann::json tmpJson;
419     tmpJson[INPUT_SOURCEMANAGER_KEY_SRC_DEVID] = srcId;
420     tmpJson[INPUT_SOURCEMANAGER_KEY_SINK_DEVID] = sinkId;
421     tmpJson[INPUT_SOURCEMANAGER_KEY_VALUE] = status;
422     jsonArrayMsg->push_back(tmpJson);
423     AppExecFwk::InnerEvent::Pointer msgEvent =
424         AppExecFwk::InnerEvent::Get(DINPUT_SOURCE_MANAGER_RELAY_UNPREPARE_RESULT_MMI, jsonArrayMsg, 0);
425     sourceManagerObj_->GetCallbackEventHandler()->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE);
426 }
427 
OnReceiveRelayStartDhidResult(int32_t status,const std::string & srcId,const std::string & sinkId,const std::string & dhids)428 void DInputSourceListener::OnReceiveRelayStartDhidResult(int32_t status,
429     const std::string &srcId, const std::string &sinkId, const std::string &dhids)
430 {
431     DHLOGI("status:%{public}d, srcId: %{public}s, sinkId: %{public}s.", status, GetAnonyString(srcId).c_str(),
432         GetAnonyString(sinkId).c_str());
433     if (sourceManagerObj_ == nullptr) {
434         DHLOGE("sourceManagerObj is null.");
435         return;
436     }
437     if (sourceManagerObj_->GetCallbackEventHandler() == nullptr) {
438         DHLOGE("GetCallbackEventHandler is null.");
439         return;
440     }
441 
442     auto jsonArrayMsg = std::make_shared<nlohmann::json>();
443     nlohmann::json tmpJson;
444     tmpJson[INPUT_SOURCEMANAGER_KEY_SRC_DEVID] = srcId;
445     tmpJson[INPUT_SOURCEMANAGER_KEY_SINK_DEVID] = sinkId;
446     tmpJson[INPUT_SOURCEMANAGER_KEY_VALUE] = status;
447     tmpJson[INPUT_SOURCEMANAGER_KEY_DHID] = dhids;
448     jsonArrayMsg->push_back(tmpJson);
449     AppExecFwk::InnerEvent::Pointer msgEvent =
450         AppExecFwk::InnerEvent::Get(DINPUT_SOURCE_MANAGER_RELAY_STARTDHID_RESULT_MMI, jsonArrayMsg, 0);
451     sourceManagerObj_->GetCallbackEventHandler()->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE);
452 }
453 
OnReceiveRelayStopDhidResult(int32_t status,const std::string & srcId,const std::string & sinkId,const std::string & dhids)454 void DInputSourceListener::OnReceiveRelayStopDhidResult(int32_t status,
455     const std::string &srcId, const std::string &sinkId, const std::string &dhids)
456 {
457     DHLOGI("status:%{public}d, srcId: %{public}s, sinkId: %{public}s.", status, GetAnonyString(srcId).c_str(),
458         GetAnonyString(sinkId).c_str());
459     if (sourceManagerObj_ == nullptr) {
460         DHLOGE("sourceManagerObj is null.");
461         return;
462     }
463     if (sourceManagerObj_->GetCallbackEventHandler() == nullptr) {
464         DHLOGE("GetCallbackEventHandler is null.");
465         return;
466     }
467 
468     auto jsonArrayMsg = std::make_shared<nlohmann::json>();
469     nlohmann::json tmpJson;
470     tmpJson[INPUT_SOURCEMANAGER_KEY_SRC_DEVID] = srcId;
471     tmpJson[INPUT_SOURCEMANAGER_KEY_SINK_DEVID] = sinkId;
472     tmpJson[INPUT_SOURCEMANAGER_KEY_VALUE] = status;
473     tmpJson[INPUT_SOURCEMANAGER_KEY_DHID] = dhids;
474     jsonArrayMsg->push_back(tmpJson);
475     AppExecFwk::InnerEvent::Pointer msgEvent =
476         AppExecFwk::InnerEvent::Get(DINPUT_SOURCE_MANAGER_RELAY_STOPDHID_RESULT_MMI, jsonArrayMsg, 0);
477     sourceManagerObj_->GetCallbackEventHandler()->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE);
478 }
479 
OnReceiveRelayStartTypeResult(int32_t status,const std::string & srcId,const std::string & sinkId,uint32_t inputTypes)480 void DInputSourceListener::OnReceiveRelayStartTypeResult(int32_t status,
481     const std::string &srcId, const std::string &sinkId, uint32_t inputTypes)
482 {
483     DHLOGI("status:%{public}d, srcId: %{public}s, sinkId: %{public}s.", status, GetAnonyString(srcId).c_str(),
484         GetAnonyString(sinkId).c_str());
485     if (sourceManagerObj_ == nullptr) {
486         DHLOGE("sourceManagerObj is null.");
487         return;
488     }
489     if (sourceManagerObj_->GetCallbackEventHandler() == nullptr) {
490         DHLOGE("GetCallbackEventHandler is null.");
491         return;
492     }
493 
494     auto jsonArrayMsg = std::make_shared<nlohmann::json>();
495     nlohmann::json tmpJson;
496     tmpJson[INPUT_SOURCEMANAGER_KEY_SRC_DEVID] = srcId;
497     tmpJson[INPUT_SOURCEMANAGER_KEY_SINK_DEVID] = sinkId;
498     tmpJson[INPUT_SOURCEMANAGER_KEY_VALUE] = status;
499     tmpJson[INPUT_SOURCEMANAGER_KEY_TYPE] = inputTypes;
500     jsonArrayMsg->push_back(tmpJson);
501     AppExecFwk::InnerEvent::Pointer msgEvent =
502         AppExecFwk::InnerEvent::Get(DINPUT_SOURCE_MANAGER_RELAY_STARTTYPE_RESULT_MMI, jsonArrayMsg, 0);
503     sourceManagerObj_->GetCallbackEventHandler()->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE);
504 }
505 
OnReceiveRelayStopTypeResult(int32_t status,const std::string & srcId,const std::string & sinkId,uint32_t inputTypes)506 void DInputSourceListener::OnReceiveRelayStopTypeResult(int32_t status,
507     const std::string &srcId, const std::string &sinkId, uint32_t inputTypes)
508 {
509     DHLOGI("status:%{public}d, srcId: %{public}s, sinkId: %{public}s.", status, GetAnonyString(srcId).c_str(),
510         GetAnonyString(sinkId).c_str());
511     if (sourceManagerObj_ == nullptr) {
512         DHLOGE("sourceManagerObj is null.");
513         return;
514     }
515     if (sourceManagerObj_->GetCallbackEventHandler() == nullptr) {
516         DHLOGE("GetCallbackEventHandler is null.");
517         return;
518     }
519 
520     auto jsonArrayMsg = std::make_shared<nlohmann::json>();
521     nlohmann::json tmpJson;
522     tmpJson[INPUT_SOURCEMANAGER_KEY_SRC_DEVID] = srcId;
523     tmpJson[INPUT_SOURCEMANAGER_KEY_SINK_DEVID] = sinkId;
524     tmpJson[INPUT_SOURCEMANAGER_KEY_VALUE] = status;
525     tmpJson[INPUT_SOURCEMANAGER_KEY_TYPE] = inputTypes;
526     jsonArrayMsg->push_back(tmpJson);
527     AppExecFwk::InnerEvent::Pointer msgEvent =
528         AppExecFwk::InnerEvent::Get(DINPUT_SOURCE_MANAGER_RELAY_STOPTYPE_RESULT_MMI, jsonArrayMsg, 0);
529     sourceManagerObj_->GetCallbackEventHandler()->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE);
530 }
531 
RecordEventLog(int64_t when,int32_t type,int32_t code,int32_t value,const std::string & path)532 void DInputSourceListener::RecordEventLog(int64_t when, int32_t type, int32_t code,
533     int32_t value, const std::string &path)
534 {
535     std::string eventType = "";
536     switch (type) {
537         case EV_KEY:
538             eventType = "EV_KEY";
539             break;
540         case EV_REL:
541             eventType = "EV_REL";
542             break;
543         case EV_ABS:
544             eventType = "EV_ABS";
545             break;
546         default:
547             eventType = "other type";
548             break;
549     }
550     DHLOGD("3.E2E-Test Source softBus receive event, EventType: %{public}s, Code: %{public}d, Value: %{public}d, "
551         "Path: %{public}s, When: %{public}" PRId64 "", eventType.c_str(), code, value, path.c_str(), when);
552 }
553 } // namespace DistributedInput
554 } // namespace DistributedHardware
555 } // namespace OHOS