1 /*
2  * Copyright (c) 2021-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 "distributed_input_source_transport.h"
17 
18 #include <cstring>
19 #include <pthread.h>
20 
21 #include "distributed_hardware_fwk_kit.h"
22 #include "ipc_skeleton.h"
23 #include "iservice_registry.h"
24 #include "system_ability_definition.h"
25 
26 #include "constants_dinput.h"
27 #include "dinput_context.h"
28 #include "dinput_errcode.h"
29 #include "dinput_hitrace.h"
30 #include "dinput_log.h"
31 #include "dinput_softbus_define.h"
32 #include "dinput_utils_tool.h"
33 #include "distributed_input_inject.h"
34 #include "hidumper.h"
35 
36 #include "distributed_input_transport_base.h"
37 
38 namespace OHOS {
39 namespace DistributedHardware {
40 namespace DistributedInput {
41 namespace {
42     const uint64_t MSG_LATENCY_ALARM_US = 20 * 1000;
43 }
~DistributedInputSourceTransport()44 DistributedInputSourceTransport::~DistributedInputSourceTransport()
45 {
46     DHLOGI("Dtor DistributedInputSourceTransport");
47     Release();
48 }
49 
GetInstance()50 DistributedInputSourceTransport &DistributedInputSourceTransport::GetInstance()
51 {
52     static DistributedInputSourceTransport instance;
53     return instance;
54 }
55 
Init()56 int32_t DistributedInputSourceTransport::Init()
57 {
58     DHLOGI("Init");
59 
60     int32_t ret = DistributedInputTransportBase::GetInstance().Init();
61     if (ret != DH_SUCCESS) {
62         DHLOGE("Init Source Transport failed.");
63         return ret;
64     }
65 
66     statuslistener_ = std::make_shared<DInputTransbaseSourceListener>(this);
67     DistributedInputTransportBase::GetInstance().RegisterSrcHandleSessionCallback(statuslistener_);
68     return DH_SUCCESS;
69 }
70 
Release()71 void DistributedInputSourceTransport::Release()
72 {
73     DHLOGI("Release Source Transport");
74     if (injectThreadNum > 0) {
75         DHLOGI("InjectThread stopped.");
76         DistributedInputInject::GetInstance().StopInjectThread();
77         injectThreadNum = 0;
78     }
79     if (latencyThreadNum > 0) {
80         DHLOGI("LatencyThread stopped.");
81         StopLatencyThread();
82         latencyThreadNum = 0;
83     }
84     return;
85 }
86 
OpenInputSoftbus(const std::string & remoteDevId,bool isToSrc)87 int32_t DistributedInputSourceTransport::OpenInputSoftbus(const std::string &remoteDevId, bool isToSrc)
88 {
89     int32_t ret = DistributedInputTransportBase::GetInstance().StartSession(remoteDevId);
90     if (ret != DH_SUCCESS) {
91         DHLOGE("StartSession fail! remoteDevId:%{public}s.", GetAnonyString(remoteDevId).c_str());
92         return ret;
93     }
94 
95     if (isToSrc) {
96         return DH_SUCCESS;
97     }
98 
99     if (latencyThreadNum == 0) {
100         StartLatencyThread(remoteDevId);
101         DHLOGI("LatencyThread started, remoteDevId: %{public}s.", GetAnonyString(remoteDevId).c_str());
102     } else {
103         DHLOGI("LatencyThread already started.");
104     }
105     latencyThreadNum++;
106 
107     if (injectThreadNum == 0) {
108         DistributedInputInject::GetInstance().StartInjectThread();
109         DHLOGI("InjectThread started.");
110     } else {
111         DHLOGI("InjectThread already started.");
112     }
113     injectThreadNum++;
114 
115     return DH_SUCCESS;
116 }
117 
CloseInputSoftbus(const std::string & remoteDevId,bool isToSrc)118 void DistributedInputSourceTransport::CloseInputSoftbus(const std::string &remoteDevId, bool isToSrc)
119 {
120     DistributedInputTransportBase::GetInstance().StopSession(remoteDevId);
121 
122     if (isToSrc) {
123         return;
124     }
125 
126     SessionClosed();
127     return;
128 }
129 
RegisterSourceRespCallback(std::shared_ptr<DInputSourceTransCallback> callback)130 void DistributedInputSourceTransport::RegisterSourceRespCallback(std::shared_ptr<DInputSourceTransCallback> callback)
131 {
132     DHLOGI("RegisterSourceRespCallback");
133     callback_ = callback;
134 }
135 
136 /*
137  * PrepareRemoteInput.
138  * @param  deviceId is remote device
139  * @return Returns 0 is success, other is fail.
140  */
PrepareRemoteInput(const std::string & deviceId)141 int32_t DistributedInputSourceTransport::PrepareRemoteInput(const std::string &deviceId)
142 {
143     int32_t sessionId = DistributedInputTransportBase::GetInstance().GetSessionIdByDevId(deviceId);
144     if (sessionId < 0) {
145         DHLOGE("PrepareRemoteInput error, not find this device:%{public}s.", GetAnonyString(deviceId).c_str());
146         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_PREPARE_FAIL;
147     }
148     DHLOGI("PrepareRemoteInput sessionId:%{public}d.", sessionId);
149 
150     nlohmann::json jsonStr;
151     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_MSG_PREPARE;
152     jsonStr[DINPUT_SOFTBUS_KEY_DEVICE_ID] = deviceId;
153     jsonStr[DINPUT_SOFTBUS_KEY_SESSION_ID] = sessionId;
154     std::string smsg = jsonStr.dump();
155     int32_t ret = SendMessage(sessionId, smsg);
156     if (ret != DH_SUCCESS) {
157         DHLOGE("PrepareRemoteInput deviceId:%{public}s, sessionId:%{public}d, smsg:%{public}s, SendMsg error, "
158             "ret:%{public}d.", GetAnonyString(deviceId).c_str(), sessionId, SetAnonyId(smsg).c_str(), ret);
159         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_PREPARE_FAIL;
160     }
161     DHLOGI("PrepareRemoteInput devId:%{public}s, sessionId:%{public}d, msg:%{public}s.",
162         GetAnonyString(deviceId).c_str(), sessionId, SetAnonyId(smsg).c_str());
163     return DH_SUCCESS;
164 }
165 
UnprepareRemoteInput(const std::string & deviceId)166 int32_t DistributedInputSourceTransport::UnprepareRemoteInput(const std::string &deviceId)
167 {
168     int32_t sessionId = DistributedInputTransportBase::GetInstance().GetSessionIdByDevId(deviceId);
169     if (sessionId < 0) {
170         DHLOGE("UnprepareRemoteInput error, not find this device:%{public}s.", GetAnonyString(deviceId).c_str());
171         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_UNPREPARE_FAIL;
172     }
173     DHLOGI("UnprepareRemoteInput sessionId:%{public}d.", sessionId);
174 
175     nlohmann::json jsonStr;
176     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_MSG_UNPREPARE;
177     jsonStr[DINPUT_SOFTBUS_KEY_DEVICE_ID] = deviceId;
178     jsonStr[DINPUT_SOFTBUS_KEY_SESSION_ID] = sessionId;
179     std::string smsg = jsonStr.dump();
180     int32_t ret = SendMessage(sessionId, smsg);
181     if (ret != DH_SUCCESS) {
182         DHLOGE("UnprepareRemoteInput deviceId:%{public}s, sessionId:%{public}d, smsg:%{public}s, SendMsg error, "
183             "ret:%{public}d.", GetAnonyString(deviceId).c_str(), sessionId, SetAnonyId(smsg).c_str(), ret);
184         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_UNPREPARE_FAIL;
185     }
186     DHLOGI("UnprepareRemoteInput deviceId:%{public}s, sessionId:%{public}d, smsg:%{public}s.",
187         GetAnonyString(deviceId).c_str(), sessionId, SetAnonyId(smsg).c_str());
188     return DH_SUCCESS;
189 }
190 
PrepareRemoteInput(int32_t srcTsrcSeId,const std::string & deviceId)191 int32_t DistributedInputSourceTransport::PrepareRemoteInput(int32_t srcTsrcSeId, const std::string &deviceId)
192 {
193     int32_t sinkSessionId = DistributedInputTransportBase::GetInstance().GetSessionIdByDevId(deviceId);
194     if (sinkSessionId < 0) {
195         DHLOGE("PrepareRemoteInput error, not find this device:%{public}s.", GetAnonyString(deviceId).c_str());
196         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_PREPARE_FAIL;
197     }
198 
199     DHLOGI("PrepareRemoteInput srcTsrcSeId:%{public}d, sinkSessionId:%{public}d.", srcTsrcSeId, sinkSessionId);
200 
201     nlohmann::json jsonStr;
202     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_MSG_PREPARE_FOR_REL;
203     jsonStr[DINPUT_SOFTBUS_KEY_DEVICE_ID] = deviceId;
204     jsonStr[DINPUT_SOFTBUS_KEY_SESSION_ID] = srcTsrcSeId;
205     std::string smsg = jsonStr.dump();
206     int32_t ret = SendMessage(sinkSessionId, smsg);
207     if (ret != DH_SUCCESS) {
208         DHLOGE("PrepareRemoteInput deviceId:%{public}s, smsg:%{public}s, SendMsg error, ret:%{public}d.",
209             GetAnonyString(deviceId).c_str(), SetAnonyId(smsg).c_str(), ret);
210         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_PREPARE_FAIL;
211     }
212     DHLOGI("PrepareRemoteInput send success, devId:%{public}s, msg:%{public}s.",
213         GetAnonyString(deviceId).c_str(), SetAnonyId(smsg).c_str());
214     return DH_SUCCESS;
215 }
UnprepareRemoteInput(int32_t srcTsrcSeId,const std::string & deviceId)216 int32_t DistributedInputSourceTransport::UnprepareRemoteInput(int32_t srcTsrcSeId, const std::string &deviceId)
217 {
218     int32_t sinkSessionId = DistributedInputTransportBase::GetInstance().GetSessionIdByDevId(deviceId);
219     if (sinkSessionId < 0) {
220         DHLOGE("UnprepareRemoteInput error, not find this device:%{public}s.", GetAnonyString(deviceId).c_str());
221         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_UNPREPARE_FAIL;
222     }
223     DHLOGI("UnprepareRemoteInput srcTsrcSeId:%{public}d, sinkSessionId:%{public}d.", srcTsrcSeId, sinkSessionId);
224 
225     nlohmann::json jsonStr;
226     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_MSG_UNPREPARE_FOR_REL;
227     jsonStr[DINPUT_SOFTBUS_KEY_DEVICE_ID] = deviceId;
228     jsonStr[DINPUT_SOFTBUS_KEY_SESSION_ID] = srcTsrcSeId;
229     std::string smsg = jsonStr.dump();
230     int32_t ret = SendMessage(sinkSessionId, smsg);
231     if (ret != DH_SUCCESS) {
232         DHLOGE("UnprepareRemoteInput deviceId:%{public}s, smsg:%{public}s, SendMsg error, ret:%{public}d.",
233             GetAnonyString(deviceId).c_str(), SetAnonyId(smsg).c_str(), ret);
234         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_UNPREPARE_FAIL;
235     }
236     DHLOGI("UnprepareRemoteInput send success, devId:%{public}s, msg:%{public}s.",
237         GetAnonyString(deviceId).c_str(), SetAnonyId(smsg).c_str());
238     return DH_SUCCESS;
239 }
240 
StartRemoteInputDhids(int32_t srcTsrcSeId,const std::string & deviceId,const std::string & dhids)241 int32_t DistributedInputSourceTransport::StartRemoteInputDhids(int32_t srcTsrcSeId, const std::string &deviceId,
242     const std::string &dhids)
243 {
244     int32_t sinkSessionId = DistributedInputTransportBase::GetInstance().GetSessionIdByDevId(deviceId);
245     if (sinkSessionId < 0) {
246         DHLOGE("StartRemoteInputDhids error, not find this device:%{public}s.", GetAnonyString(deviceId).c_str());
247         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_START_FAIL;
248     }
249     DHLOGI("StartRemoteInputDhids srcTsrcSeId:%{public}d, sinkSessionId:%{public}d.", srcTsrcSeId, sinkSessionId);
250 
251     nlohmann::json jsonStr;
252     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_MSG_START_DHID_FOR_REL;
253     jsonStr[DINPUT_SOFTBUS_KEY_DEVICE_ID] = deviceId;
254     jsonStr[DINPUT_SOFTBUS_KEY_SESSION_ID] = srcTsrcSeId;
255     jsonStr[DINPUT_SOFTBUS_KEY_VECTOR_DHID] = dhids;
256     std::string smsg = jsonStr.dump();
257     int32_t ret = SendMessage(sinkSessionId, smsg);
258     if (ret != DH_SUCCESS) {
259         DHLOGE("StartRemoteInputDhids deviceId:%{public}s, smsg:%{public}s, SendMsg error, ret:%{public}d.",
260             GetAnonyString(deviceId).c_str(), SetAnonyId(smsg).c_str(), ret);
261         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_START_FAIL;
262     }
263     DHLOGI("StartRemoteInputDhids send success, devId:%{public}s, msg:%{public}s.", GetAnonyString(deviceId).c_str(),
264         SetAnonyId(smsg).c_str());
265     return DH_SUCCESS;
266 }
267 
StopRemoteInputDhids(int32_t srcTsrcSeId,const std::string & deviceId,const std::string & dhids)268 int32_t DistributedInputSourceTransport::StopRemoteInputDhids(int32_t srcTsrcSeId, const std::string &deviceId,
269     const std::string &dhids)
270 {
271     int32_t sinkSessionId = DistributedInputTransportBase::GetInstance().GetSessionIdByDevId(deviceId);
272     if (sinkSessionId < 0) {
273         DHLOGE("StopRemoteInputDhids error, not find this device:%{public}s.", GetAnonyString(deviceId).c_str());
274         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_STOP_FAIL;
275     }
276     DHLOGI("StopRemoteInputDhids srcTsrcSeId:%{public}d, sinkSessionId:%{public}d.", srcTsrcSeId, sinkSessionId);
277     std::vector<std::string> dhIdsVec = SplitDhIdString(dhids);
278     ResetKeyboardKeyState(deviceId, dhIdsVec);
279 
280     nlohmann::json jsonStr;
281     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_MSG_STOP_DHID_FOR_REL;
282     jsonStr[DINPUT_SOFTBUS_KEY_DEVICE_ID] = deviceId;
283     jsonStr[DINPUT_SOFTBUS_KEY_SESSION_ID] = srcTsrcSeId;
284     jsonStr[DINPUT_SOFTBUS_KEY_VECTOR_DHID] = dhids;
285     std::string smsg = jsonStr.dump();
286     int32_t ret = SendMessage(sinkSessionId, smsg);
287     if (ret != DH_SUCCESS) {
288         DHLOGE("StopRemoteInputDhids deviceId:%{public}s, smsg:%{public}s, SendMsg error, ret:%{public}d.",
289             GetAnonyString(deviceId).c_str(), SetAnonyId(smsg).c_str(), ret);
290         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_STOP_FAIL;
291     }
292     DHLOGI("StopRemoteInputDhids send success, devId:%{public}s, msg:%{public}s.", GetAnonyString(deviceId).c_str(),
293         SetAnonyId(smsg).c_str());
294     return DH_SUCCESS;
295 }
296 
StartRemoteInputType(int32_t srcTsrcSeId,const std::string & deviceId,const uint32_t & inputTypes)297 int32_t DistributedInputSourceTransport::StartRemoteInputType(int32_t srcTsrcSeId, const std::string &deviceId,
298     const uint32_t &inputTypes)
299 {
300     int32_t sinkSessionId = DistributedInputTransportBase::GetInstance().GetSessionIdByDevId(deviceId);
301     if (sinkSessionId < 0) {
302         DHLOGE("StartRemoteInputType error, not find this device:%{public}s.", GetAnonyString(deviceId).c_str());
303         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_START_FAIL;
304     }
305     DHLOGI("StartRemoteInputType srcTsrcSeId:%{public}d, sinkSessionId:%{public}d.", srcTsrcSeId, sinkSessionId);
306 
307     nlohmann::json jsonStr;
308     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_MSG_START_TYPE_FOR_REL;
309     jsonStr[DINPUT_SOFTBUS_KEY_DEVICE_ID] = deviceId;
310     jsonStr[DINPUT_SOFTBUS_KEY_SESSION_ID] = srcTsrcSeId;
311     jsonStr[DINPUT_SOFTBUS_KEY_INPUT_TYPE] = inputTypes;
312     std::string smsg = jsonStr.dump();
313     int32_t ret = SendMessage(sinkSessionId, smsg);
314     if (ret != DH_SUCCESS) {
315         DHLOGE("StartRemoteInputType deviceId:%{public}s, smsg:%{public}s, SendMsg error, ret:%{public}d.",
316             GetAnonyString(deviceId).c_str(), SetAnonyId(smsg).c_str(), ret);
317         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_START_FAIL;
318     }
319     DHLOGI("StartRemoteInputType send success, devId:%{public}s, msg:%{public}s.", GetAnonyString(deviceId).c_str(),
320         SetAnonyId(smsg).c_str());
321     return DH_SUCCESS;
322 }
323 
StopRemoteInputType(int32_t srcTsrcSeId,const std::string & deviceId,const uint32_t & inputTypes)324 int32_t DistributedInputSourceTransport::StopRemoteInputType(int32_t srcTsrcSeId, const std::string &deviceId,
325     const uint32_t &inputTypes)
326 {
327     int32_t sinkSessionId = DistributedInputTransportBase::GetInstance().GetSessionIdByDevId(deviceId);
328     if (sinkSessionId < 0) {
329         DHLOGE("StopRemoteInputType error, not find this device:%{public}s.", GetAnonyString(deviceId).c_str());
330         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_STOP_FAIL;
331     }
332     DHLOGI("StopRemoteInputType srcTsrcSeId:%{public}d, sinkSessionId:%{public}d.", srcTsrcSeId, sinkSessionId);
333 
334     nlohmann::json jsonStr;
335     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_MSG_STOP_TYPE_FOR_REL;
336     jsonStr[DINPUT_SOFTBUS_KEY_DEVICE_ID] = deviceId;
337     jsonStr[DINPUT_SOFTBUS_KEY_SESSION_ID] = srcTsrcSeId;
338     jsonStr[DINPUT_SOFTBUS_KEY_INPUT_TYPE] = inputTypes;
339     std::string smsg = jsonStr.dump();
340     int32_t ret = SendMessage(sinkSessionId, smsg);
341     if (ret != DH_SUCCESS) {
342         DHLOGE("StopRemoteInputType deviceId:%{public}s, smsg:%{public}s, SendMsg error, ret:%{public}d.",
343             GetAnonyString(deviceId).c_str(), SetAnonyId(smsg).c_str(), ret);
344         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_STOP_FAIL;
345     }
346     DHLOGI("StopRemoteInputType send success, devId:%{public}s, msg:%{public}s.", GetAnonyString(deviceId).c_str(),
347         SetAnonyId(smsg).c_str());
348     return DH_SUCCESS;
349 }
350 
SendRelayPrepareRequest(const std::string & srcId,const std::string & sinkId)351 int32_t DistributedInputSourceTransport::SendRelayPrepareRequest(const std::string &srcId, const std::string &sinkId)
352 {
353     int32_t sessionId = DistributedInputTransportBase::GetInstance().GetSessionIdByDevId(srcId);
354     if (sessionId < 0) {
355         DHLOGE("SendRelayPrepareRequest error, not find this device:%{public}s.", GetAnonyString(srcId).c_str());
356         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_PREPARE_FAIL;
357     }
358     DHLOGI("SendRelayPrepareRequest sessionId:%{public}d.", sessionId);
359 
360     nlohmann::json jsonStr;
361     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_TO_SOURCE_MSG_PREPARE;
362     jsonStr[DINPUT_SOFTBUS_KEY_DEVICE_ID] = sinkId;
363     std::string smsg = jsonStr.dump();
364     int32_t ret = SendMessage(sessionId, smsg);
365     if (ret != DH_SUCCESS) {
366         DHLOGE("SendRelayPrepareRequest srcId:%{public}s, sessionId:%{public}d, smsg:%{public}s, SendMsg error, "
367             "ret:%{public}d.", GetAnonyString(srcId).c_str(), sessionId, SetAnonyId(smsg).c_str(), ret);
368         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_PREPARE_FAIL;
369     }
370     DHLOGI("SendRelayPrepareRequest srcId:%{public}s, sessionId:%{public}d, smsg:%{public}s.",
371         GetAnonyString(srcId).c_str(), sessionId, SetAnonyId(smsg).c_str());
372     return DH_SUCCESS;
373 }
374 
SendRelayUnprepareRequest(const std::string & srcId,const std::string & sinkId)375 int32_t DistributedInputSourceTransport::SendRelayUnprepareRequest(const std::string &srcId, const std::string &sinkId)
376 {
377     int32_t sessionId = DistributedInputTransportBase::GetInstance().GetSessionIdByDevId(srcId);
378     if (sessionId < 0) {
379         DHLOGE("SendRelayUnprepareRequest error, not find this device:%{public}s.", GetAnonyString(srcId).c_str());
380         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_PREPARE_FAIL;
381     }
382     DHLOGI("SendRelayUnprepareRequest sessionId:%{public}d.", sessionId);
383 
384     nlohmann::json jsonStr;
385     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_TO_SOURCE_MSG_UNPREPARE;
386     jsonStr[DINPUT_SOFTBUS_KEY_DEVICE_ID] = sinkId;
387     std::string smsg = jsonStr.dump();
388     int32_t ret = SendMessage(sessionId, smsg);
389     if (ret != DH_SUCCESS) {
390         DHLOGE("SendRelayUnprepareRequest srcId:%{public}s, sessionId:%{public}d, smsg:%{public}s, SendMsg error, "
391             "ret:%{public}d.", GetAnonyString(srcId).c_str(), sessionId, SetAnonyId(smsg).c_str(), ret);
392         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_PREPARE_FAIL;
393     }
394     DHLOGI("SendRelayUnprepareRequest srcId:%{public}s, sessionId:%{public}d, smsg:%{public}s.",
395         GetAnonyString(srcId).c_str(), sessionId, SetAnonyId(smsg).c_str());
396     return DH_SUCCESS;
397 }
398 
NotifyOriginPrepareResult(int32_t srcTsrcSeId,const std::string & srcId,const std::string & sinkId,int32_t status)399 int32_t DistributedInputSourceTransport::NotifyOriginPrepareResult(int32_t srcTsrcSeId, const std::string &srcId,
400     const std::string &sinkId, int32_t status)
401 {
402     std::unique_lock<std::mutex> sessionLock(operationMutex_);
403     nlohmann::json jsonStr;
404     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_TO_SOURCE_MSG_PREPARE_RESULT;
405     jsonStr[DINPUT_SOFTBUS_KEY_SRC_DEV_ID] = srcId;
406     jsonStr[DINPUT_SOFTBUS_KEY_SINK_DEV_ID] = sinkId;
407     jsonStr[DINPUT_SOFTBUS_KEY_RESP_VALUE] = status;
408 
409     std::string smsg = jsonStr.dump();
410     int32_t ret = SendMessage(srcTsrcSeId, smsg);
411     if (ret != DH_SUCCESS) {
412         DHLOGE("NotifyOriginPrepareResult srcTsrcSeId:%{public}d, smsg:%{public}s, SendMsg error, ret:%{public}d.",
413             srcTsrcSeId, SetAnonyId(smsg).c_str(), ret);
414         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_PREPARE_FAIL;
415     }
416     DHLOGI("NotifyOriginPrepareResult srcTsrcSeId:%{public}d, smsg:%{public}s.", srcTsrcSeId, SetAnonyId(smsg).c_str());
417     return DH_SUCCESS;
418 }
419 
NotifyOriginUnprepareResult(int32_t srcTsrcSeId,const std::string & srcId,const std::string & sinkId,int32_t status)420 int32_t DistributedInputSourceTransport::NotifyOriginUnprepareResult(int32_t srcTsrcSeId, const std::string &srcId,
421     const std::string &sinkId, int32_t status)
422 {
423     std::unique_lock<std::mutex> sessionLock(operationMutex_);
424     nlohmann::json jsonStr;
425     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_TO_SOURCE_MSG_UNPREPARE_RESULT;
426     jsonStr[DINPUT_SOFTBUS_KEY_SRC_DEV_ID] = srcId;
427     jsonStr[DINPUT_SOFTBUS_KEY_SINK_DEV_ID] = sinkId;
428     jsonStr[DINPUT_SOFTBUS_KEY_RESP_VALUE] = status;
429 
430     std::string smsg = jsonStr.dump();
431     int32_t ret = SendMessage(srcTsrcSeId, smsg);
432     if (ret != DH_SUCCESS) {
433         DHLOGE("NotifyOriginUnprepareResult srcTsrcSeId:%{public}d, smsg:%{public}s, SendMsg error, ret:%{public}d.",
434             srcTsrcSeId, SetAnonyId(smsg).c_str(), ret);
435         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_UNPREPARE_FAIL;
436     }
437     DHLOGI("NotifyOriginUnprepareResult srcTsrcSeId:%{public}d, smsg:%{public}s.", srcTsrcSeId,
438         SetAnonyId(smsg).c_str());
439     return DH_SUCCESS;
440 }
441 
NotifyOriginStartDhidResult(int32_t srcTsrcSeId,const std::string & srcId,const std::string & sinkId,int32_t status,const std::string & dhids)442 int32_t DistributedInputSourceTransport::NotifyOriginStartDhidResult(int32_t srcTsrcSeId, const std::string &srcId,
443     const std::string &sinkId, int32_t status, const std::string &dhids)
444 {
445     std::unique_lock<std::mutex> sessionLock(operationMutex_);
446     nlohmann::json jsonStr;
447     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_TO_SOURCE_MSG_START_DHID_RESULT;
448     jsonStr[DINPUT_SOFTBUS_KEY_SRC_DEV_ID] = srcId;
449     jsonStr[DINPUT_SOFTBUS_KEY_SINK_DEV_ID] = sinkId;
450     jsonStr[DINPUT_SOFTBUS_KEY_RESP_VALUE] = status;
451     jsonStr[DINPUT_SOFTBUS_KEY_VECTOR_DHID] = dhids;
452 
453     std::string smsg = jsonStr.dump();
454     int32_t ret = SendMessage(srcTsrcSeId, smsg);
455     if (ret != DH_SUCCESS) {
456         DHLOGE("NotifyOriginStartDhidResult srcTsrcSeId:%{public}d, smsg:%{public}s, SendMsg error, ret:%{public}d.",
457             srcTsrcSeId, SetAnonyId(smsg).c_str(), ret);
458         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_START_FAIL;
459     }
460     DHLOGI("NotifyOriginStartDhidResult srcTsrcSeId:%{public}d, smsg:%{public}s.", srcTsrcSeId,
461         SetAnonyId(smsg).c_str());
462     return DH_SUCCESS;
463 }
464 
NotifyOriginStopDhidResult(int32_t srcTsrcSeId,const std::string & srcId,const std::string & sinkId,int32_t status,const std::string & dhids)465 int32_t DistributedInputSourceTransport::NotifyOriginStopDhidResult(int32_t srcTsrcSeId, const std::string &srcId,
466     const std::string &sinkId, int32_t status, const std::string &dhids)
467 {
468     std::unique_lock<std::mutex> sessionLock(operationMutex_);
469     nlohmann::json jsonStr;
470     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_TO_SOURCE_MSG_STOP_DHID_RESULT;
471     jsonStr[DINPUT_SOFTBUS_KEY_SRC_DEV_ID] = srcId;
472     jsonStr[DINPUT_SOFTBUS_KEY_SINK_DEV_ID] = sinkId;
473     jsonStr[DINPUT_SOFTBUS_KEY_RESP_VALUE] = status;
474     jsonStr[DINPUT_SOFTBUS_KEY_VECTOR_DHID] = dhids;
475 
476     std::string smsg = jsonStr.dump();
477     int32_t ret = SendMessage(srcTsrcSeId, smsg);
478     if (ret != DH_SUCCESS) {
479         DHLOGE("NotifyOriginStopDhidResult srcTsrcSeId:%{public}d, smsg:%{public}s, SendMsg error, ret:%{public}d.",
480             srcTsrcSeId, SetAnonyId(smsg).c_str(), ret);
481         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_STOP_FAIL;
482     }
483     DHLOGI("NotifyOriginStopDhidResult srcTsrcSeId:%{public}d, smsg:%{public}s.", srcTsrcSeId,
484         SetAnonyId(smsg).c_str());
485     return DH_SUCCESS;
486 }
487 
NotifyOriginStartTypeResult(int32_t srcTsrcSeId,const std::string & srcId,const std::string & sinkId,int32_t status,uint32_t inputTypes)488 int32_t DistributedInputSourceTransport::NotifyOriginStartTypeResult(int32_t srcTsrcSeId, const std::string &srcId,
489     const std::string &sinkId, int32_t status, uint32_t inputTypes)
490 {
491     std::unique_lock<std::mutex> sessionLock(operationMutex_);
492     nlohmann::json jsonStr;
493     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_TO_SOURCE_MSG_START_TYPE_RESULT;
494     jsonStr[DINPUT_SOFTBUS_KEY_SRC_DEV_ID] = srcId;
495     jsonStr[DINPUT_SOFTBUS_KEY_SINK_DEV_ID] = sinkId;
496     jsonStr[DINPUT_SOFTBUS_KEY_RESP_VALUE] = status;
497     jsonStr[DINPUT_SOFTBUS_KEY_INPUT_TYPE] = inputTypes;
498 
499     std::string smsg = jsonStr.dump();
500     int32_t ret = SendMessage(srcTsrcSeId, smsg);
501     if (ret != DH_SUCCESS) {
502         DHLOGE("NotifyOriginStartTypeResult srcTsrcSeId:%{public}d, smsg:%{public}s, SendMsg error, ret:%{public}d.",
503             srcTsrcSeId, SetAnonyId(smsg).c_str(), ret);
504         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_START_FAIL;
505     }
506     DHLOGI("NotifyOriginStartTypeResult srcTsrcSeId:%{public}d, smsg:%{public}s.", srcTsrcSeId,
507         SetAnonyId(smsg).c_str());
508     return DH_SUCCESS;
509 }
510 
NotifyOriginStopTypeResult(int32_t srcTsrcSeId,const std::string & srcId,const std::string & sinkId,int32_t status,uint32_t inputTypes)511 int32_t DistributedInputSourceTransport::NotifyOriginStopTypeResult(int32_t srcTsrcSeId, const std::string &srcId,
512     const std::string &sinkId, int32_t status, uint32_t inputTypes)
513 {
514     std::unique_lock<std::mutex> sessionLock(operationMutex_);
515     nlohmann::json jsonStr;
516     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_TO_SOURCE_MSG_STOP_TYPE_RESULT;
517     jsonStr[DINPUT_SOFTBUS_KEY_SRC_DEV_ID] = srcId;
518     jsonStr[DINPUT_SOFTBUS_KEY_SINK_DEV_ID] = sinkId;
519     jsonStr[DINPUT_SOFTBUS_KEY_RESP_VALUE] = status;
520     jsonStr[DINPUT_SOFTBUS_KEY_INPUT_TYPE] = inputTypes;
521 
522     std::string smsg = jsonStr.dump();
523     int32_t ret = SendMessage(srcTsrcSeId, smsg);
524     if (ret != DH_SUCCESS) {
525         DHLOGE("NotifyOriginStopTypeResult srcTsrcSeId:%{public}d, smsg:%{public}s, SendMsg error, ret:%{public}d.",
526             srcTsrcSeId, SetAnonyId(smsg).c_str(), ret);
527         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_STOP_FAIL;
528     }
529     DHLOGI("NotifyOriginStopTypeResult srcTsrcSeId:%{public}d, smsg:%{public}s.", srcTsrcSeId,
530         SetAnonyId(smsg).c_str());
531     return DH_SUCCESS;
532 }
533 
StartRemoteInput(const std::string & deviceId,const uint32_t & inputTypes)534 int32_t DistributedInputSourceTransport::StartRemoteInput(const std::string &deviceId, const uint32_t &inputTypes)
535 {
536     int32_t sessionId = DistributedInputTransportBase::GetInstance().GetSessionIdByDevId(deviceId);
537     if (sessionId < 0) {
538         DHLOGE("StartRemoteInput error, not find this device:%{public}s.", GetAnonyString(deviceId).c_str());
539         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_START_FAIL;
540     }
541     DHLOGI("StartRemoteInput sessionId:%{public}d.", sessionId);
542 
543     nlohmann::json jsonStr;
544     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_MSG_START_TYPE;
545     jsonStr[DINPUT_SOFTBUS_KEY_DEVICE_ID] = deviceId;
546     jsonStr[DINPUT_SOFTBUS_KEY_SESSION_ID] = sessionId;
547     jsonStr[DINPUT_SOFTBUS_KEY_INPUT_TYPE] = inputTypes;
548     std::string smsg = jsonStr.dump();
549     int32_t ret = SendMessage(sessionId, smsg);
550     if (ret != DH_SUCCESS) {
551         DHLOGE("StartRemoteInput deviceId:%{public}s, sessionId:%{public}d, smsg:%{public}s, SendMsg error, "
552             "ret:%{public}d.", GetAnonyString(deviceId).c_str(), sessionId, SetAnonyId(smsg).c_str(), ret);
553         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_START_FAIL;
554     }
555     DHLOGI("StartRemoteInput deviceId:%{public}s, sessionId:%{public}d, smsg:%{public}s.",
556         GetAnonyString(deviceId).c_str(), sessionId, SetAnonyId(smsg).c_str());
557     return DH_SUCCESS;
558 }
559 
StopRemoteInput(const std::string & deviceId,const uint32_t & inputTypes)560 int32_t DistributedInputSourceTransport::StopRemoteInput(
561     const std::string &deviceId, const uint32_t &inputTypes)
562 {
563     int32_t sessionId = DistributedInputTransportBase::GetInstance().GetSessionIdByDevId(deviceId);
564     if (sessionId < 0) {
565         DHLOGE("StopRemoteInput error, not find this device:%{public}s.", GetAnonyString(deviceId).c_str());
566         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_STOP_FAIL;
567     }
568     DHLOGI("StopRemoteInput sessionId:%{public}d.", sessionId);
569 
570     nlohmann::json jsonStr;
571     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_MSG_STOP_TYPE;
572     jsonStr[DINPUT_SOFTBUS_KEY_DEVICE_ID] = deviceId;
573     jsonStr[DINPUT_SOFTBUS_KEY_SESSION_ID] = sessionId;
574     jsonStr[DINPUT_SOFTBUS_KEY_INPUT_TYPE] = inputTypes;
575     std::string smsg = jsonStr.dump();
576     int32_t ret = SendMessage(sessionId, smsg);
577     if (ret != DH_SUCCESS) {
578         DHLOGE("StopRemoteInput deviceId:%{public}s, sessionId:%{public}d, smsg:%{public}s, SendMsg error, "
579             "ret:%{public}d.", GetAnonyString(deviceId).c_str(), sessionId, SetAnonyId(smsg).c_str(), ret);
580         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_STOP_FAIL;
581     }
582     DHLOGI("StopRemoteInput deviceId:%{public}s, sessionId:%{public}d, smsg:%{public}s.",
583         GetAnonyString(deviceId).c_str(), sessionId, SetAnonyId(smsg).c_str());
584     return DH_SUCCESS;
585 }
586 
LatencyCount(const std::string & deviceId)587 int32_t DistributedInputSourceTransport::LatencyCount(const std::string &deviceId)
588 {
589     int32_t sessionId = DistributedInputTransportBase::GetInstance().GetSessionIdByDevId(deviceId);
590     if (sessionId < 0) {
591         DHLOGE("LatencyCount error, not find this device:%{public}s.", GetAnonyString(deviceId).c_str());
592         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_LATENCY_FAIL;
593     }
594 
595     nlohmann::json jsonStr;
596     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_MSG_LATENCY;
597     jsonStr[DINPUT_SOFTBUS_KEY_DEVICE_ID] = deviceId;
598     jsonStr[DINPUT_SOFTBUS_KEY_SESSION_ID] = sessionId;
599     std::string smsg = jsonStr.dump();
600     int32_t ret = SendMessage(sessionId, smsg);
601     if (ret != DH_SUCCESS) {
602         DHLOGE("LatencyCount deviceId:%{public}s, sessionId: %{public}d, smsg:%{public}s, SendMsg error, "
603             "ret:%{public}d.", GetAnonyString(deviceId).c_str(), sessionId, SetAnonyId(smsg).c_str(), ret);
604         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_LATENCY_FAIL;
605     }
606 
607     return DH_SUCCESS;
608 }
609 
StartLatencyCount(const std::string & deviceId)610 void DistributedInputSourceTransport::StartLatencyCount(const std::string &deviceId)
611 {
612     int32_t ret = pthread_setname_np(pthread_self(), LATENCY_COUNT_THREAD_NAME);
613     if (ret != 0) {
614         DHLOGE("StartLatencyCount setname failed.");
615     }
616     while (isLatencyThreadRunning_.load()) {
617         if (sendNum_ >= INPUT_LATENCY_DELAY_TIMES) {
618             uint64_t latency = (uint64_t)(deltaTimeAll_ / 2 / INPUT_LATENCY_DELAY_TIMES);
619             DHLOGI("LatencyCount average single-channel latency is %{public}" PRIu64 " us, send times is %{public}d, "
620                 "recive times is %{public}d.", latency, sendNum_, recvNum_);
621             DHLOGD("each RTT latency details is %{public}s", eachLatencyDetails_.c_str());
622             deltaTimeAll_ = 0;
623             sendNum_ = 0;
624             recvNum_ = 0;
625             eachLatencyDetails_ = "";
626         }
627         sendTime_ = GetCurrentTimeUs();
628         LatencyCount(deviceId);
629         sendNum_ += 1;
630         usleep(INPUT_LATENCY_DELAYTIME_US);
631     }
632 }
633 
StartLatencyThread(const std::string & deviceId)634 void DistributedInputSourceTransport::StartLatencyThread(const std::string &deviceId)
635 {
636     DHLOGI("start");
637     isLatencyThreadRunning_.store(true);
638     latencyThread_ = std::thread([this, deviceId]() { this->StartLatencyCount(deviceId); });
639     DHLOGI("end");
640 }
641 
StopLatencyThread()642 void DistributedInputSourceTransport::StopLatencyThread()
643 {
644     DHLOGI("start");
645     isLatencyThreadRunning_.store(false);
646     if (latencyThread_.joinable()) {
647         latencyThread_.join();
648     }
649     DHLOGI("end");
650 }
651 
NotifySessionClosed()652 void DistributedInputSourceTransport::DInputTransbaseSourceListener::NotifySessionClosed()
653 {
654     DistributedInputSourceTransport::GetInstance().SessionClosed();
655 }
656 
SessionClosed()657 void DistributedInputSourceTransport::SessionClosed()
658 {
659     if (injectThreadNum == 0) {
660         DHLOGI("InjectThread already stopped, or InjectThread not start.");
661     } else if (injectThreadNum > 1) {
662         injectThreadNum--;
663     } else if (injectThreadNum == 1) {
664         DHLOGI("InjectThread stopped.");
665         DistributedInputInject::GetInstance().StopInjectThread();
666         injectThreadNum--;
667     }
668 
669     if (latencyThreadNum == 0) {
670         DHLOGI("InjectThread already stopped, or InjectThread not start.");
671     } else if (latencyThreadNum > 1) {
672         latencyThreadNum--;
673     } else if (latencyThreadNum == 1) {
674         StopLatencyThread();
675         DHLOGI("LatencyThread stopped.");
676         latencyThreadNum--;
677     }
678 }
679 
StartRemoteInput(const std::string & deviceId,const std::vector<std::string> & dhids)680 int32_t DistributedInputSourceTransport::StartRemoteInput(const std::string &deviceId,
681     const std::vector<std::string> &dhids)
682 {
683     int32_t sessionId = DistributedInputTransportBase::GetInstance().GetSessionIdByDevId(deviceId);
684     if (sessionId < 0) {
685         DHLOGE("StartRemoteInput error, not find this device:%{public}s.", GetAnonyString(deviceId).c_str());
686         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_START_FAIL;
687     }
688     DHLOGI("StartRemoteInput sessionId:%{public}d.", sessionId);
689 
690     nlohmann::json jsonStr;
691     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_MSG_START_DHID;
692     jsonStr[DINPUT_SOFTBUS_KEY_DEVICE_ID] = deviceId;
693     jsonStr[DINPUT_SOFTBUS_KEY_SESSION_ID] = sessionId;
694     jsonStr[DINPUT_SOFTBUS_KEY_VECTOR_DHID] = JointDhIds(dhids);
695     std::string smsg = jsonStr.dump();
696     int32_t ret = SendMessage(sessionId, smsg);
697     if (ret != DH_SUCCESS) {
698         DHLOGE("StartRemoteInput deviceId:%{public}s, sessionId: %{public}d, smsg:%{public}s, SendMsg error, "
699             "ret:%{public}d.", GetAnonyString(deviceId).c_str(), sessionId, SetAnonyId(smsg).c_str(), ret);
700         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_START_FAIL;
701     }
702     DHLOGI("StartRemoteInput deviceId:%{public}s, sessionId: %{public}d, smsg:%{public}s.",
703         GetAnonyString(deviceId).c_str(), sessionId, SetAnonyId(smsg).c_str());
704     return DH_SUCCESS;
705 }
706 
ResetKeyboardKeyState(const std::string & deviceId,const std::vector<std::string> & dhids)707 void DistributedInputSourceTransport::ResetKeyboardKeyState(const std::string &deviceId,
708     const std::vector<std::string> &dhids)
709 {
710     std::vector<std::string> keyboardNodePaths;
711     DistributedInputInject::GetInstance().GetVirtualKeyboardPaths(deviceId, dhids, keyboardNodePaths);
712     DHLOGI("Try reset keyboard states, dhIds: %{public}s, nodePaths: %{public}s",
713         GetString(dhids).c_str(), GetString(keyboardNodePaths).c_str());
714     ResetVirtualDevicePressedKeys(keyboardNodePaths);
715 }
716 
StopRemoteInput(const std::string & deviceId,const std::vector<std::string> & dhids)717 int32_t DistributedInputSourceTransport::StopRemoteInput(const std::string &deviceId,
718     const std::vector<std::string> &dhids)
719 {
720     int32_t sessionId = DistributedInputTransportBase::GetInstance().GetSessionIdByDevId(deviceId);
721     if (sessionId < 0) {
722         DHLOGE("StopRemoteInput error, not find this device:%{public}s.", GetAnonyString(deviceId).c_str());
723         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_STOP_FAIL;
724     }
725     DHLOGI("StopRemoteInput sessionId:%{public}d.", sessionId);
726     ResetKeyboardKeyState(deviceId, dhids);
727 
728     nlohmann::json jsonStr;
729     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_MSG_STOP_DHID;
730     jsonStr[DINPUT_SOFTBUS_KEY_DEVICE_ID] = deviceId;
731     jsonStr[DINPUT_SOFTBUS_KEY_SESSION_ID] = sessionId;
732     jsonStr[DINPUT_SOFTBUS_KEY_VECTOR_DHID] = JointDhIds(dhids);
733     std::string smsg = jsonStr.dump();
734     int32_t ret = SendMessage(sessionId, smsg);
735     if (ret != DH_SUCCESS) {
736         DHLOGE("StopRemoteInput deviceId:%{public}s, sessionId: %{public}d, smsg:%{public}s, SendMsg error, "
737             "ret:%{public}d.",  GetAnonyString(deviceId).c_str(), sessionId, SetAnonyId(smsg).c_str(), ret);
738         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_STOP_FAIL;
739     }
740     DHLOGI("StopRemoteInput deviceId:%{public}s, sessionId: %{public}d, smsg:%{public}s.",
741         GetAnonyString(deviceId).c_str(),
742         sessionId, SetAnonyId(smsg).c_str());
743     return DH_SUCCESS;
744 }
745 
SendRelayStartDhidRequest(const std::string & srcId,const std::string & sinkId,const std::vector<std::string> & dhids)746 int32_t DistributedInputSourceTransport::SendRelayStartDhidRequest(const std::string &srcId, const std::string &sinkId,
747     const std::vector<std::string> &dhids)
748 {
749     int32_t sessionId = DistributedInputTransportBase::GetInstance().GetSessionIdByDevId(srcId);
750     if (sessionId < 0) {
751         DHLOGE("SendRelayStartDhidRequest error, not find this device:%{public}s.", GetAnonyString(srcId).c_str());
752         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_START_FAIL;
753     }
754     DHLOGI("SendRelayStartDhidRequest sessionId:%{public}d.", sessionId);
755 
756     nlohmann::json jsonStr;
757     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_TO_SOURCE_MSG_START_DHID;
758     jsonStr[DINPUT_SOFTBUS_KEY_DEVICE_ID] = sinkId;
759     jsonStr[DINPUT_SOFTBUS_KEY_VECTOR_DHID] = JointDhIds(dhids);
760     std::string smsg = jsonStr.dump();
761     int32_t ret = SendMessage(sessionId, smsg);
762     if (ret != DH_SUCCESS) {
763         DHLOGE("SendRelayStartDhidRequest srcId:%{public}s, sessionId:%{public}d, smsg:%{public}s, SendMsg error, "
764             "ret:%{public}d.", GetAnonyString(srcId).c_str(), sessionId, SetAnonyId(smsg).c_str(), ret);
765         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_START_FAIL;
766     }
767     DHLOGI("SendRelayStartDhidRequest srcId:%{public}s, sessionId:%{public}d, smsg:%{public}s.",
768         GetAnonyString(srcId).c_str(), sessionId, SetAnonyId(smsg).c_str());
769     return DH_SUCCESS;
770 }
771 
SendRelayStopDhidRequest(const std::string & srcId,const std::string & sinkId,const std::vector<std::string> & dhids)772 int32_t DistributedInputSourceTransport::SendRelayStopDhidRequest(const std::string &srcId, const std::string &sinkId,
773     const std::vector<std::string> &dhids)
774 {
775     int32_t sessionId = DistributedInputTransportBase::GetInstance().GetSessionIdByDevId(srcId);
776     if (sessionId < 0) {
777         DHLOGE("SendRelayStopDhidRequest error, not find this device:%{public}s.", GetAnonyString(srcId).c_str());
778         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_STOP_FAIL;
779     }
780     DHLOGI("SendRelayStopDhidRequest sessionId:%{public}d.", sessionId);
781 
782     nlohmann::json jsonStr;
783     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_TO_SOURCE_MSG_STOP_DHID;
784     jsonStr[DINPUT_SOFTBUS_KEY_DEVICE_ID] = sinkId;
785     jsonStr[DINPUT_SOFTBUS_KEY_VECTOR_DHID] = JointDhIds(dhids);
786     std::string smsg = jsonStr.dump();
787     int32_t ret = SendMessage(sessionId, smsg);
788     if (ret != DH_SUCCESS) {
789         DHLOGE("SendRelayStopDhidRequest srcId:%{public}s, sessionId:%{public}d, smsg:%{public}s, SendMsg error, "
790             "ret:%{public}d.", GetAnonyString(srcId).c_str(), sessionId, SetAnonyId(smsg).c_str(), ret);
791         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_STOP_FAIL;
792     }
793     DHLOGI("SendRelayStopDhidRequest srcId:%{public}s, sessionId:%{public}d, smsg:%{public}s.",
794         GetAnonyString(srcId).c_str(), sessionId, SetAnonyId(smsg).c_str());
795     return DH_SUCCESS;
796 }
797 
SendRelayStartTypeRequest(const std::string & srcId,const std::string & sinkId,const uint32_t & inputTypes)798 int32_t DistributedInputSourceTransport::SendRelayStartTypeRequest(const std::string &srcId, const std::string &sinkId,
799     const uint32_t &inputTypes)
800 {
801     int32_t sessionId = DistributedInputTransportBase::GetInstance().GetSessionIdByDevId(srcId);
802     if (sessionId < 0) {
803         DHLOGE("SendRelayStartTypeRequest error, not find this device:%{public}s.", GetAnonyString(srcId).c_str());
804         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_START_FAIL;
805     }
806     DHLOGI("SendRelayStartTypeRequest sessionId:%{public}d.", sessionId);
807 
808     nlohmann::json jsonStr;
809     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_TO_SOURCE_MSG_START_TYPE;
810     jsonStr[DINPUT_SOFTBUS_KEY_DEVICE_ID] = sinkId;
811     jsonStr[DINPUT_SOFTBUS_KEY_INPUT_TYPE] = inputTypes;
812     std::string smsg = jsonStr.dump();
813     int32_t ret = SendMessage(sessionId, smsg);
814     if (ret != DH_SUCCESS) {
815         DHLOGE("SendRelayStartTypeRequest srcId:%{public}s, sessionId:%{public}d, smsg:%{public}s, SendMsg error, "
816             "ret:%{public}d.", GetAnonyString(srcId).c_str(), sessionId, SetAnonyId(smsg).c_str(), ret);
817         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_START_FAIL;
818     }
819     DHLOGI("SendRelayStartTypeRequest srcId:%{public}s, sessionId:%{public}d, smsg:%{public}s.",
820         GetAnonyString(srcId).c_str(), sessionId, SetAnonyId(smsg).c_str());
821     return DH_SUCCESS;
822 }
823 
SendRelayStopTypeRequest(const std::string & srcId,const std::string & sinkId,const uint32_t & inputTypes)824 int32_t DistributedInputSourceTransport::SendRelayStopTypeRequest(const std::string &srcId, const std::string &sinkId,
825     const uint32_t &inputTypes)
826 {
827     int32_t sessionId = DistributedInputTransportBase::GetInstance().GetSessionIdByDevId(srcId);
828     if (sessionId < 0) {
829         DHLOGE("SendRelayStopTypeRequest error, not find this device:%{public}s.", GetAnonyString(srcId).c_str());
830         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_STOP_FAIL;
831     }
832     DHLOGI("SendRelayStopTypeRequest sessionId:%{public}d.", sessionId);
833 
834     nlohmann::json jsonStr;
835     jsonStr[DINPUT_SOFTBUS_KEY_CMD_TYPE] = TRANS_SOURCE_TO_SOURCE_MSG_STOP_TYPE;
836     jsonStr[DINPUT_SOFTBUS_KEY_DEVICE_ID] = sinkId;
837     jsonStr[DINPUT_SOFTBUS_KEY_INPUT_TYPE] = inputTypes;
838     std::string smsg = jsonStr.dump();
839     int32_t ret = SendMessage(sessionId, smsg);
840     if (ret != DH_SUCCESS) {
841         DHLOGE("SendRelayStopTypeRequest srcId:%{public}s, sessionId:%{public}d, smsg:%{public}s, SendMsg error, "
842             "ret:%{public}d.", GetAnonyString(srcId).c_str(), sessionId, SetAnonyId(smsg).c_str(), ret);
843         return ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_STOP_FAIL;
844     }
845     DHLOGI("SendRelayStopTypeRequest srcId:%{public}s, sessionId:%{public}d, smsg:%{public}s.",
846         GetAnonyString(srcId).c_str(), sessionId, SetAnonyId(smsg).c_str());
847     return DH_SUCCESS;
848 }
849 
SendMessage(int32_t sessionId,std::string & message)850 int32_t DistributedInputSourceTransport::SendMessage(int32_t sessionId, std::string &message)
851 {
852     return DistributedInputTransportBase::GetInstance().SendMsg(sessionId, message);
853 }
854 
GetCurrentSessionId()855 int32_t DistributedInputSourceTransport::GetCurrentSessionId()
856 {
857     return DistributedInputTransportBase::GetInstance().GetCurrentSessionId();
858 }
859 
DInputTransbaseSourceListener(DistributedInputSourceTransport * transport)860 DistributedInputSourceTransport::DInputTransbaseSourceListener::DInputTransbaseSourceListener(
861     DistributedInputSourceTransport *transport)
862 {
863     sourceTransportObj_ = transport;
864     DHLOGI("DInputTransbaseSourceListener init.");
865 }
866 
~DInputTransbaseSourceListener()867 DistributedInputSourceTransport::DInputTransbaseSourceListener::~DInputTransbaseSourceListener()
868 {
869     sourceTransportObj_ = nullptr;
870     DHLOGI("DInputTransbaseSourceListener destory.");
871 }
872 
NotifyResponsePrepareRemoteInput(int32_t sessionId,const nlohmann::json & recMsg)873 void DistributedInputSourceTransport::NotifyResponsePrepareRemoteInput(int32_t sessionId,
874     const nlohmann::json &recMsg)
875 {
876     DHLOGI("OnBytesReceived cmdType is TRANS_SINK_MSG_ONPREPARE.");
877     if (!IsBoolean(recMsg, DINPUT_SOFTBUS_KEY_RESP_VALUE) ||
878         !IsString(recMsg, DINPUT_SOFTBUS_KEY_WHITE_LIST)) {
879         DHLOGE("The key is invaild.");
880         return;
881     }
882     std::string deviceId = DistributedInputTransportBase::GetInstance().GetDevIdBySessionId(sessionId);
883     if (deviceId.empty()) {
884         DHLOGE("OnBytesReceived cmdType is TRANS_SINK_MSG_ONPREPARE, deviceId is error.");
885         return;
886     }
887     callback_->OnResponsePrepareRemoteInput(deviceId, recMsg[DINPUT_SOFTBUS_KEY_RESP_VALUE],
888         recMsg[DINPUT_SOFTBUS_KEY_WHITE_LIST]);
889 }
890 
NotifyResponseUnprepareRemoteInput(int32_t sessionId,const nlohmann::json & recMsg)891 void DistributedInputSourceTransport::NotifyResponseUnprepareRemoteInput(int32_t sessionId,
892     const nlohmann::json &recMsg)
893 {
894     DHLOGI("OnBytesReceived cmdType is TRANS_SINK_MSG_ONUNPREPARE.");
895     if (!IsBoolean(recMsg, DINPUT_SOFTBUS_KEY_RESP_VALUE)) {
896         DHLOGE("The key is invaild.");
897         return;
898     }
899     std::string deviceId = DistributedInputTransportBase::GetInstance().GetDevIdBySessionId(sessionId);
900     if (deviceId.empty()) {
901         DHLOGE("OnBytesReceived cmdType is TRANS_SINK_MSG_ONUNPREPARE, deviceId is error.");
902         return;
903     }
904     callback_->OnResponseUnprepareRemoteInput(deviceId, recMsg[DINPUT_SOFTBUS_KEY_RESP_VALUE]);
905     CloseInputSoftbus(deviceId, false);
906 }
907 
NotifyResponseStartRemoteInput(int32_t sessionId,const nlohmann::json & recMsg)908 void DistributedInputSourceTransport::NotifyResponseStartRemoteInput(int32_t sessionId, const nlohmann::json &recMsg)
909 {
910     DHLOGI("OnBytesReceived cmdType is TRANS_SINK_MSG_ONSTART.");
911     if (!IsUInt32(recMsg, DINPUT_SOFTBUS_KEY_INPUT_TYPE) ||
912         !IsBoolean(recMsg, DINPUT_SOFTBUS_KEY_RESP_VALUE)) {
913         DHLOGE("The key is invaild.");
914         return;
915     }
916     std::string deviceId = DistributedInputTransportBase::GetInstance().GetDevIdBySessionId(sessionId);
917     if (deviceId.empty()) {
918         DHLOGE("OnBytesReceived cmdType is TRANS_SINK_MSG_ONSTART, deviceId is error.");
919         return;
920     }
921     callback_->OnResponseStartRemoteInput(
922         deviceId, recMsg[DINPUT_SOFTBUS_KEY_INPUT_TYPE], recMsg[DINPUT_SOFTBUS_KEY_RESP_VALUE]);
923 }
924 
NotifyResponseStopRemoteInput(int32_t sessionId,const nlohmann::json & recMsg)925 void DistributedInputSourceTransport::NotifyResponseStopRemoteInput(int32_t sessionId, const nlohmann::json &recMsg)
926 {
927     DHLOGI("OnBytesReceived cmdType is TRANS_SINK_MSG_ONSTOP.");
928     if (!IsUInt32(recMsg, DINPUT_SOFTBUS_KEY_INPUT_TYPE) ||
929         !IsBoolean(recMsg, DINPUT_SOFTBUS_KEY_RESP_VALUE)) {
930         DHLOGE("The key is invaild.");
931         return;
932     }
933     std::string deviceId = DistributedInputTransportBase::GetInstance().GetDevIdBySessionId(sessionId);
934     if (deviceId.empty()) {
935         DHLOGE("OnBytesReceived cmdType TRANS_SINK_MSG_ONSTOP, deviceId is error.");
936         return;
937     }
938     callback_->OnResponseStopRemoteInput(
939         deviceId, recMsg[DINPUT_SOFTBUS_KEY_INPUT_TYPE], recMsg[DINPUT_SOFTBUS_KEY_RESP_VALUE]);
940 }
941 
NotifyResponseStartRemoteInputDhid(int32_t sessionId,const nlohmann::json & recMsg)942 void DistributedInputSourceTransport::NotifyResponseStartRemoteInputDhid(int32_t sessionId,
943     const nlohmann::json &recMsg)
944 {
945     DHLOGI("OnBytesReceived cmdType is TRANS_SINK_MSG_DHID_ONSTART.");
946     if (!IsString(recMsg, DINPUT_SOFTBUS_KEY_VECTOR_DHID) ||
947         !IsBoolean(recMsg, DINPUT_SOFTBUS_KEY_RESP_VALUE)) {
948         DHLOGE("The key is invaild.");
949         return;
950     }
951     std::string deviceId = DistributedInputTransportBase::GetInstance().GetDevIdBySessionId(sessionId);
952     if (deviceId.empty()) {
953         DHLOGE("OnBytesReceived cmdType is TRANS_SINK_MSG_DHID_ONSTART, deviceId is error.");
954         return;
955     }
956     callback_->OnResponseStartRemoteInputDhid(
957         deviceId, recMsg[DINPUT_SOFTBUS_KEY_VECTOR_DHID], recMsg[DINPUT_SOFTBUS_KEY_RESP_VALUE]);
958 }
959 
NotifyResponseStopRemoteInputDhid(int32_t sessionId,const nlohmann::json & recMsg)960 void DistributedInputSourceTransport::NotifyResponseStopRemoteInputDhid(int32_t sessionId, const nlohmann::json &recMsg)
961 {
962     DHLOGI("OnBytesReceived cmdType is TRANS_SINK_MSG_DHID_ONSTOP.");
963     if (!IsString(recMsg, DINPUT_SOFTBUS_KEY_VECTOR_DHID) ||
964         !IsBoolean(recMsg, DINPUT_SOFTBUS_KEY_RESP_VALUE)) {
965         DHLOGE("The key is invaild.");
966         return;
967     }
968     std::string deviceId = DistributedInputTransportBase::GetInstance().GetDevIdBySessionId(sessionId);
969     if (deviceId.empty()) {
970         DHLOGE("OnBytesReceived cmdType is TRANS_SINK_MSG_DHID_ONSTOP, deviceId is error.");
971         return;
972     }
973     callback_->OnResponseStopRemoteInputDhid(
974         deviceId, recMsg[DINPUT_SOFTBUS_KEY_VECTOR_DHID], recMsg[DINPUT_SOFTBUS_KEY_RESP_VALUE]);
975 }
976 
NotifyResponseKeyState(int32_t sessionId,const nlohmann::json & recMsg)977 void DistributedInputSourceTransport::NotifyResponseKeyState(int32_t sessionId, const nlohmann::json &recMsg)
978 {
979     DHLOGI("OnBytesReceived cmdType is TRANS_SINK_MSG_KEY_STATE.");
980     if (!IsString(recMsg, DINPUT_SOFTBUS_KEY_KEYSTATE_DHID) ||
981         !IsUInt32(recMsg, DINPUT_SOFTBUS_KEY_KEYSTATE_TYPE) ||
982         !IsUInt32(recMsg, DINPUT_SOFTBUS_KEY_KEYSTATE_CODE) ||
983         !IsUInt32(recMsg, DINPUT_SOFTBUS_KEY_KEYSTATE_VALUE)) {
984         DHLOGE("The key is invaild.");
985         return;
986     }
987     std::string deviceId = DistributedInputTransportBase::GetInstance().GetDevIdBySessionId(sessionId);
988     if (deviceId.empty()) {
989         DHLOGE("OnBytesReceived cmdType is TRANS_SINK_MSG_KEY_STATE, deviceId is error.");
990         return;
991     }
992     callback_->OnResponseKeyState(deviceId, recMsg[DINPUT_SOFTBUS_KEY_KEYSTATE_DHID],
993         recMsg[DINPUT_SOFTBUS_KEY_KEYSTATE_TYPE], recMsg[DINPUT_SOFTBUS_KEY_KEYSTATE_CODE],
994         recMsg[DINPUT_SOFTBUS_KEY_KEYSTATE_VALUE]);
995 }
996 
NotifyResponseKeyStateBatch(int32_t sessionId,const nlohmann::json & recMsg)997 void DistributedInputSourceTransport::NotifyResponseKeyStateBatch(int32_t sessionId, const nlohmann::json &recMsg)
998 {
999     DHLOGI("OnBytesReceived cmdType is TRANS_SINK_MSG_KEY_STATE_BATCH.");
1000     if (!IsString(recMsg, DINPUT_SOFTBUS_KEY_INPUT_DATA)) {
1001         DHLOGE("The DINPUT_SOFTBUS_KEY_INPUT_DATA is invalid");
1002         return;
1003     }
1004     std::string deviceId = DistributedInputTransportBase::GetInstance().GetDevIdBySessionId(sessionId);
1005     if (deviceId.empty()) {
1006         DHLOGE("OnBytesReceived cmdType is TRANS_SINK_MSG_KEY_STATE_BATCH, deviceId is error.");
1007         return;
1008     }
1009     std::string inputDataStr = recMsg[DINPUT_SOFTBUS_KEY_INPUT_DATA];
1010     callback_->OnResponseKeyStateBatch(deviceId, inputDataStr);
1011 }
1012 
NotifyReceivedEventRemoteInput(int32_t sessionId,const nlohmann::json & recMsg)1013 void DistributedInputSourceTransport::NotifyReceivedEventRemoteInput(int32_t sessionId, const nlohmann::json &recMsg)
1014 {
1015     DHLOGD("OnBytesReceived cmdType is TRANS_SINK_MSG_BODY_DATA.");
1016     if (!IsString(recMsg, DINPUT_SOFTBUS_KEY_INPUT_DATA)) {
1017         DHLOGE("The key is invaild.");
1018         return;
1019     }
1020 
1021     std::string deviceId = DistributedInputTransportBase::GetInstance().GetDevIdBySessionId(sessionId);
1022     if (deviceId.empty()) {
1023         DHLOGE("OnBytesReceived cmdType is TRANS_SINK_MSG_BODY_DATA, deviceId is error.");
1024         return;
1025     }
1026     std::string inputDataStr = recMsg[DINPUT_SOFTBUS_KEY_INPUT_DATA];
1027     callback_->OnReceivedEventRemoteInput(deviceId, inputDataStr);
1028 }
1029 
CalculateLatency(int32_t sessionId,const nlohmann::json & recMsg)1030 void DistributedInputSourceTransport::CalculateLatency(int32_t sessionId, const nlohmann::json &recMsg)
1031 {
1032     std::string deviceId = DistributedInputTransportBase::GetInstance().GetDevIdBySessionId(sessionId);
1033     if (deviceId.empty()) {
1034         DHLOGE("OnBytesReceived cmdType is TRANS_SINK_MSG_LATENCY, deviceId is error.");
1035         return;
1036     }
1037 
1038     uint64_t curTimeUs = GetCurrentTimeUs();
1039     if (curTimeUs <= sendTime_) {
1040         DHLOGE("Latency time error, currtime is before than send time, curTime: %{public}" PRIu64 " us, "
1041             "sendTime: %{public}" PRIu64 " us", curTimeUs, sendTime_);
1042         return;
1043     }
1044 
1045     deltaTime_ = curTimeUs - sendTime_;
1046     deltaTimeAll_ += deltaTime_;
1047     recvNum_ += 1;
1048     eachLatencyDetails_ += (std::to_string(deltaTime_) + DINPUT_SPLIT_COMMA);
1049     if (deltaTime_ >= MSG_LATENCY_ALARM_US) {
1050         DHLOGW("The RTT time between send req and receive rsp is too long: %{public}" PRIu64 " us", deltaTime_);
1051     }
1052 }
1053 
ReceiveSrcTSrcRelayPrepare(int32_t sessionId,const nlohmann::json & recMsg)1054 void DistributedInputSourceTransport::ReceiveSrcTSrcRelayPrepare(int32_t sessionId, const nlohmann::json &recMsg)
1055 {
1056     DHLOGI("OnBytesReceived cmdType is TRANS_SOURCE_TO_SOURCE_MSG_PREPARE.");
1057     if (!IsString(recMsg, DINPUT_SOFTBUS_KEY_DEVICE_ID)) {
1058         DHLOGE("The key is invaild.");
1059         return;
1060     }
1061     std::string deviceId = recMsg[DINPUT_SOFTBUS_KEY_DEVICE_ID];
1062 
1063     // continue notify to A_sink_trans
1064     int32_t ret = OpenInputSoftbus(deviceId, false);
1065     if (ret != DH_SUCCESS) {
1066         callback_->OnResponseRelayPrepareRemoteInput(sessionId, deviceId, false, "");
1067         return;
1068     }
1069 
1070     ret = PrepareRemoteInput(sessionId, deviceId);
1071     if (ret != DH_SUCCESS) {
1072         callback_->OnResponseRelayPrepareRemoteInput(sessionId, deviceId, false, "");
1073         return;
1074     }
1075 }
1076 
ReceiveSrcTSrcRelayUnprepare(int32_t sessionId,const nlohmann::json & recMsg)1077 void DistributedInputSourceTransport::ReceiveSrcTSrcRelayUnprepare(int32_t sessionId, const nlohmann::json &recMsg)
1078 {
1079     DHLOGI("OnBytesReceived cmdType is TRANS_SOURCE_TO_SOURCE_MSG_UNPREPARE.");
1080     if (!IsString(recMsg, DINPUT_SOFTBUS_KEY_DEVICE_ID)) {
1081         DHLOGE("The key is invaild.");
1082         return;
1083     }
1084 
1085     std::string deviceId = recMsg[DINPUT_SOFTBUS_KEY_DEVICE_ID];
1086     int32_t ret = UnprepareRemoteInput(sessionId, deviceId);
1087     if (ret != DH_SUCCESS) {
1088         DHLOGE("Can not send message by softbus, unprepare fail.");
1089         callback_->OnResponseRelayUnprepareRemoteInput(sessionId, deviceId, false);
1090         return;
1091     }
1092 }
1093 
NotifyResponseRelayPrepareRemoteInput(int32_t sessionId,const nlohmann::json & recMsg)1094 void DistributedInputSourceTransport::NotifyResponseRelayPrepareRemoteInput(int32_t sessionId,
1095     const nlohmann::json &recMsg)
1096 {
1097     DHLOGI("OnBytesReceived cmdType is TRANS_SINK_MSG_ON_RELAY_PREPARE.");
1098     if (!IsInt32(recMsg, DINPUT_SOFTBUS_KEY_SESSION_ID) ||
1099         !IsBoolean(recMsg, DINPUT_SOFTBUS_KEY_RESP_VALUE) ||
1100         !IsString(recMsg, DINPUT_SOFTBUS_KEY_WHITE_LIST)) {
1101         DHLOGE("The key is invaild.");
1102         return;
1103     }
1104     std::string sinkDevId = DistributedInputTransportBase::GetInstance().GetDevIdBySessionId(sessionId);
1105     if (sinkDevId.empty()) {
1106         DHLOGE("OnBytesReceived cmdType is TRANS_SINK_MSG_ON_RELAY_PREPARE, sinkDevId is error.");
1107         return;
1108     }
1109     callback_->OnResponseRelayPrepareRemoteInput(recMsg[DINPUT_SOFTBUS_KEY_SESSION_ID], sinkDevId,
1110         recMsg[DINPUT_SOFTBUS_KEY_RESP_VALUE], recMsg[DINPUT_SOFTBUS_KEY_WHITE_LIST]);
1111 }
1112 
NotifyResponseRelayUnprepareRemoteInput(int32_t sessionId,const nlohmann::json & recMsg)1113 void DistributedInputSourceTransport::NotifyResponseRelayUnprepareRemoteInput(int32_t sessionId,
1114     const nlohmann::json &recMsg)
1115 {
1116     DHLOGI("OnBytesReceived cmdType is TRANS_SINK_MSG_ON_RELAY_UNPREPARE.");
1117     if (!IsInt32(recMsg, DINPUT_SOFTBUS_KEY_SESSION_ID) ||
1118         !IsBoolean(recMsg, DINPUT_SOFTBUS_KEY_RESP_VALUE)) {
1119         DHLOGE("The key is invaild.");
1120         return;
1121     }
1122     std::string sinkDevId = DistributedInputTransportBase::GetInstance().GetDevIdBySessionId(sessionId);
1123     if (sinkDevId.empty()) {
1124         DHLOGE("OnBytesReceived cmdType is TRANS_SINK_MSG_ON_RELAY_UNPREPARE, sinkDevId is error.");
1125         return;
1126     }
1127     callback_->OnResponseRelayUnprepareRemoteInput(recMsg[DINPUT_SOFTBUS_KEY_SESSION_ID], sinkDevId,
1128         recMsg[DINPUT_SOFTBUS_KEY_RESP_VALUE]);
1129 
1130     int32_t toSrcSessionId = recMsg[DINPUT_SOFTBUS_KEY_SESSION_ID];
1131     if (toSrcSessionId != sessionId) {
1132         DHLOGE("Close to sink session.");
1133         CloseInputSoftbus(sinkDevId, false);
1134     }
1135 }
1136 
ReceiveRelayPrepareResult(int32_t sessionId,const nlohmann::json & recMsg)1137 void DistributedInputSourceTransport::ReceiveRelayPrepareResult(int32_t sessionId, const nlohmann::json &recMsg)
1138 {
1139     DHLOGI("OnBytesReceived cmdType is TRANS_SOURCE_TO_SOURCE_MSG_PREPARE_RESULT.");
1140     if (!IsString(recMsg, DINPUT_SOFTBUS_KEY_SRC_DEV_ID) ||
1141         !IsString(recMsg, DINPUT_SOFTBUS_KEY_SINK_DEV_ID) ||
1142         !IsInt32(recMsg, DINPUT_SOFTBUS_KEY_RESP_VALUE)) {
1143         DHLOGE("The key is invaild.");
1144         return;
1145     }
1146 
1147     std::string srcId = recMsg[DINPUT_SOFTBUS_KEY_SRC_DEV_ID];
1148     std::string sinkId = recMsg[DINPUT_SOFTBUS_KEY_SINK_DEV_ID];
1149     int32_t status = recMsg[DINPUT_SOFTBUS_KEY_RESP_VALUE];
1150     callback_->OnReceiveRelayPrepareResult(status, srcId, sinkId);
1151 }
1152 
ReceiveRelayUnprepareResult(int32_t sessionId,const nlohmann::json & recMsg)1153 void DistributedInputSourceTransport::ReceiveRelayUnprepareResult(int32_t sessionId, const nlohmann::json &recMsg)
1154 {
1155     DHLOGI("OnBytesReceived cmdType is TRANS_SOURCE_TO_SOURCE_MSG_UNPREPARE_RESULT.");
1156     if (!IsString(recMsg, DINPUT_SOFTBUS_KEY_SRC_DEV_ID) ||
1157         !IsString(recMsg, DINPUT_SOFTBUS_KEY_SINK_DEV_ID) ||
1158         !IsInt32(recMsg, DINPUT_SOFTBUS_KEY_RESP_VALUE)) {
1159         DHLOGE("The key is invaild.");
1160         return;
1161     }
1162 
1163     std::string srcId = recMsg[DINPUT_SOFTBUS_KEY_SRC_DEV_ID];
1164     std::string sinkId = recMsg[DINPUT_SOFTBUS_KEY_SINK_DEV_ID];
1165     int32_t status = recMsg[DINPUT_SOFTBUS_KEY_RESP_VALUE];
1166     callback_->OnReceiveRelayUnprepareResult(status, srcId, sinkId);
1167     CloseInputSoftbus(srcId, true);
1168 }
1169 
ReceiveSrcTSrcRelayStartDhid(int32_t sessionId,const nlohmann::json & recMsg)1170 void DistributedInputSourceTransport::ReceiveSrcTSrcRelayStartDhid(int32_t sessionId, const nlohmann::json &recMsg)
1171 {
1172     DHLOGI("OnBytesReceived cmdType is TRANS_SOURCE_TO_SOURCE_MSG_START_DHID.");
1173     if (!IsString(recMsg, DINPUT_SOFTBUS_KEY_DEVICE_ID) ||
1174         !IsString(recMsg, DINPUT_SOFTBUS_KEY_VECTOR_DHID)) {
1175         DHLOGE("The key is invaild.");
1176         return;
1177     }
1178     std::string deviceId = recMsg[DINPUT_SOFTBUS_KEY_DEVICE_ID];
1179     std::string dhids =  recMsg[DINPUT_SOFTBUS_KEY_VECTOR_DHID];
1180     int32_t ret = StartRemoteInputDhids(sessionId, deviceId, dhids);
1181     if (ret != DH_SUCCESS) {
1182         DHLOGE("Can not send message by softbus, start fail.");
1183         std::string localNetworkId = GetLocalNetworkId();
1184         if (localNetworkId.empty()) {
1185             DHLOGE("Could not get local device id.");
1186             return;
1187         }
1188         NotifyOriginStartDhidResult(sessionId, localNetworkId, deviceId,
1189             ERR_DH_INPUT_SERVER_SOURCE_MANAGER_START_MSG_IS_BAD, dhids);
1190     }
1191 }
1192 
ReceiveSrcTSrcRelayStopDhid(int32_t sessionId,const nlohmann::json & recMsg)1193 void DistributedInputSourceTransport::ReceiveSrcTSrcRelayStopDhid(int32_t sessionId, const nlohmann::json &recMsg)
1194 {
1195     DHLOGI("OnBytesReceived cmdType is TRANS_SOURCE_TO_SOURCE_MSG_STOP_DHID.");
1196     if (!IsString(recMsg, DINPUT_SOFTBUS_KEY_DEVICE_ID) ||
1197         !IsString(recMsg, DINPUT_SOFTBUS_KEY_VECTOR_DHID)) {
1198         DHLOGE("The key is invaild.");
1199         return;
1200     }
1201     std::string deviceId = recMsg[DINPUT_SOFTBUS_KEY_DEVICE_ID];
1202     std::string dhids =  recMsg[DINPUT_SOFTBUS_KEY_VECTOR_DHID];
1203     int32_t ret = StopRemoteInputDhids(sessionId, deviceId, dhids);
1204     if (ret != DH_SUCCESS) {
1205         DHLOGE("Can not send message by softbus, start fail.");
1206         std::string localNetworkId = GetLocalNetworkId();
1207         if (localNetworkId.empty()) {
1208             DHLOGE("Could not get local device id.");
1209             return;
1210         }
1211         NotifyOriginStopDhidResult(sessionId, localNetworkId, deviceId,
1212             ERR_DH_INPUT_SERVER_SOURCE_MANAGER_STOP_MSG_IS_BAD, dhids);
1213     }
1214 }
1215 
NotifyResponseRelayStartDhidRemoteInput(int32_t sessionId,const nlohmann::json & recMsg)1216 void DistributedInputSourceTransport::NotifyResponseRelayStartDhidRemoteInput(int32_t sessionId,
1217     const nlohmann::json &recMsg)
1218 {
1219     DHLOGI("OnBytesReceived cmdType is TRANS_SINK_MSG_ON_RELAY_STARTDHID.");
1220     if (!IsBoolean(recMsg, DINPUT_SOFTBUS_KEY_RESP_VALUE) ||
1221         !IsInt32(recMsg, DINPUT_SOFTBUS_KEY_SESSION_ID) ||
1222         !IsString(recMsg, DINPUT_SOFTBUS_KEY_VECTOR_DHID)) {
1223         DHLOGE("The key is invaild.");
1224         return;
1225     }
1226     std::string sinkDevId = DistributedInputTransportBase::GetInstance().GetDevIdBySessionId(sessionId);
1227     if (sinkDevId.empty()) {
1228         DHLOGE("OnBytesReceived cmdType is TRANS_SINK_MSG_ON_RELAY_STARTDHID, sinkDevId is error.");
1229         return;
1230     }
1231     std::string localNetworkId = GetLocalNetworkId();
1232     if (localNetworkId.empty()) {
1233         DHLOGE("Could not get local device id.");
1234         return;
1235     }
1236     int32_t srcTsrcSeId = recMsg[DINPUT_SOFTBUS_KEY_SESSION_ID];
1237     bool result = recMsg[DINPUT_SOFTBUS_KEY_RESP_VALUE];
1238     std::string dhids = recMsg[DINPUT_SOFTBUS_KEY_VECTOR_DHID];
1239     NotifyOriginStartDhidResult(srcTsrcSeId, localNetworkId, sinkDevId,
1240         result ? DH_SUCCESS : ERR_DH_INPUT_SERVER_SOURCE_MANAGER_START_MSG_IS_BAD, dhids);
1241 }
1242 
NotifyResponseRelayStopDhidRemoteInput(int32_t sessionId,const nlohmann::json & recMsg)1243 void DistributedInputSourceTransport::NotifyResponseRelayStopDhidRemoteInput(int32_t sessionId,
1244     const nlohmann::json &recMsg)
1245 {
1246     DHLOGI("OnBytesReceived cmdType is TRANS_SINK_MSG_ON_RELAY_STOPDHID.");
1247     if (!IsBoolean(recMsg, DINPUT_SOFTBUS_KEY_RESP_VALUE) ||
1248         !IsInt32(recMsg, DINPUT_SOFTBUS_KEY_SESSION_ID) ||
1249         !IsString(recMsg, DINPUT_SOFTBUS_KEY_VECTOR_DHID)) {
1250         DHLOGE("The key is invaild.");
1251         return;
1252     }
1253     std::string sinkDevId = DistributedInputTransportBase::GetInstance().GetDevIdBySessionId(sessionId);
1254     if (sinkDevId.empty()) {
1255         DHLOGE("OnBytesReceived cmdType is TRANS_SINK_MSG_ON_RELAY_STOPDHID, sinkDevId is error.");
1256         return;
1257     }
1258     std::string localNetworkId = GetLocalNetworkId();
1259     if (localNetworkId.empty()) {
1260         DHLOGE("Could not get local device id.");
1261         return;
1262     }
1263     int32_t srcTsrcSeId = recMsg[DINPUT_SOFTBUS_KEY_SESSION_ID];
1264     bool result = recMsg[DINPUT_SOFTBUS_KEY_RESP_VALUE];
1265     std::string dhids = recMsg[DINPUT_SOFTBUS_KEY_VECTOR_DHID];
1266     NotifyOriginStopDhidResult(srcTsrcSeId, localNetworkId, sinkDevId,
1267         result ? DH_SUCCESS : ERR_DH_INPUT_SERVER_SOURCE_MANAGER_STOP_MSG_IS_BAD, dhids);
1268 }
1269 
ReceiveRelayStartDhidResult(int32_t sessionId,const nlohmann::json & recMsg)1270 void DistributedInputSourceTransport::ReceiveRelayStartDhidResult(int32_t sessionId, const nlohmann::json &recMsg)
1271 {
1272     DHLOGI("OnBytesReceived cmdType is TRANS_SOURCE_TO_SOURCE_MSG_START_DHID_RESULT.");
1273     if (!IsInt32(recMsg, DINPUT_SOFTBUS_KEY_RESP_VALUE) ||
1274         !IsString(recMsg, DINPUT_SOFTBUS_KEY_VECTOR_DHID) ||
1275         !IsString(recMsg, DINPUT_SOFTBUS_KEY_SRC_DEV_ID) ||
1276         !IsString(recMsg, DINPUT_SOFTBUS_KEY_SINK_DEV_ID)) {
1277         DHLOGE("The key is invaild.");
1278         return;
1279     }
1280 
1281     std::string srcId = recMsg[DINPUT_SOFTBUS_KEY_SRC_DEV_ID];
1282     std::string sinkId = recMsg[DINPUT_SOFTBUS_KEY_SINK_DEV_ID];
1283     int32_t status = recMsg[DINPUT_SOFTBUS_KEY_RESP_VALUE];
1284     std::string dhids = recMsg[DINPUT_SOFTBUS_KEY_VECTOR_DHID];
1285     callback_->OnReceiveRelayStartDhidResult(status, srcId, sinkId, dhids);
1286 }
1287 
ReceiveRelayStopDhidResult(int32_t sessionId,const nlohmann::json & recMsg)1288 void DistributedInputSourceTransport::ReceiveRelayStopDhidResult(int32_t sessionId, const nlohmann::json &recMsg)
1289 {
1290     DHLOGI("OnBytesReceived cmdType is TRANS_SOURCE_TO_SOURCE_MSG_STOP_DHID_RESULT.");
1291     if (!IsInt32(recMsg, DINPUT_SOFTBUS_KEY_RESP_VALUE) ||
1292         !IsString(recMsg, DINPUT_SOFTBUS_KEY_VECTOR_DHID) ||
1293         !IsString(recMsg, DINPUT_SOFTBUS_KEY_SRC_DEV_ID) ||
1294         !IsString(recMsg, DINPUT_SOFTBUS_KEY_SINK_DEV_ID)) {
1295         DHLOGE("The key is invaild.");
1296         return;
1297     }
1298 
1299     std::string srcId = recMsg[DINPUT_SOFTBUS_KEY_SRC_DEV_ID];
1300     std::string sinkId = recMsg[DINPUT_SOFTBUS_KEY_SINK_DEV_ID];
1301     int32_t status = recMsg[DINPUT_SOFTBUS_KEY_RESP_VALUE];
1302     std::string dhids = recMsg[DINPUT_SOFTBUS_KEY_VECTOR_DHID];
1303     callback_->OnReceiveRelayStopDhidResult(status, srcId, sinkId, dhids);
1304 }
1305 
ReceiveSrcTSrcRelayStartType(int32_t sessionId,const nlohmann::json & recMsg)1306 void DistributedInputSourceTransport::ReceiveSrcTSrcRelayStartType(int32_t sessionId, const nlohmann::json &recMsg)
1307 {
1308     DHLOGI("OnBytesReceived cmdType is TRANS_SOURCE_TO_SOURCE_MSG_START_TYPE.");
1309     if (!IsString(recMsg, DINPUT_SOFTBUS_KEY_DEVICE_ID) ||
1310         !IsInt32(recMsg, DINPUT_SOFTBUS_KEY_INPUT_TYPE)) {
1311         DHLOGE("The key is invaild.");
1312         return;
1313     }
1314     std::string deviceId = recMsg[DINPUT_SOFTBUS_KEY_DEVICE_ID];
1315     int32_t inputTypes =  recMsg[DINPUT_SOFTBUS_KEY_INPUT_TYPE];
1316     int32_t ret = StartRemoteInputType(sessionId, deviceId, inputTypes);
1317     if (ret != DH_SUCCESS) {
1318         DHLOGE("Can not send message by softbus, start fail.");
1319         std::string localNetworkId = GetLocalNetworkId();
1320         if (localNetworkId.empty()) {
1321             DHLOGE("Could not get local device id.");
1322             return;
1323         }
1324         NotifyOriginStartTypeResult(sessionId, localNetworkId, deviceId,
1325             ERR_DH_INPUT_SERVER_SOURCE_MANAGER_START_MSG_IS_BAD, inputTypes);
1326     }
1327 }
1328 
ReceiveSrcTSrcRelayStopType(int32_t sessionId,const nlohmann::json & recMsg)1329 void DistributedInputSourceTransport::ReceiveSrcTSrcRelayStopType(int32_t sessionId, const nlohmann::json &recMsg)
1330 {
1331     DHLOGI("OnBytesReceived cmdType is TRANS_SOURCE_TO_SOURCE_MSG_STOP_TYPE.");
1332     if (!IsString(recMsg, DINPUT_SOFTBUS_KEY_DEVICE_ID) ||
1333         !IsInt32(recMsg, DINPUT_SOFTBUS_KEY_INPUT_TYPE)) {
1334         DHLOGE("The key is invaild.");
1335         return;
1336     }
1337     std::string deviceId = recMsg[DINPUT_SOFTBUS_KEY_DEVICE_ID];
1338     int32_t inputTypes =  recMsg[DINPUT_SOFTBUS_KEY_INPUT_TYPE];
1339     int32_t ret = StopRemoteInputType(sessionId, deviceId, inputTypes);
1340     if (ret != DH_SUCCESS) {
1341         DHLOGE("Can not send message by softbus, start fail.");
1342         std::string localNetworkId = GetLocalNetworkId();
1343         if (localNetworkId.empty()) {
1344             DHLOGE("Could not get local device id.");
1345             return;
1346         }
1347         NotifyOriginStopTypeResult(sessionId, localNetworkId, deviceId,
1348             ERR_DH_INPUT_SERVER_SOURCE_MANAGER_STOP_MSG_IS_BAD, inputTypes);
1349     }
1350 }
1351 
NotifyResponseRelayStartTypeRemoteInput(int32_t sessionId,const nlohmann::json & recMsg)1352 void DistributedInputSourceTransport::NotifyResponseRelayStartTypeRemoteInput(int32_t sessionId,
1353     const nlohmann::json &recMsg)
1354 {
1355     DHLOGI("OnBytesReceived cmdType is TRANS_SINK_MSG_ON_RELAY_STARTTYPE.");
1356     if (!IsInt32(recMsg, DINPUT_SOFTBUS_KEY_SESSION_ID) ||
1357         !IsBoolean(recMsg, DINPUT_SOFTBUS_KEY_RESP_VALUE) ||
1358         !IsUInt32(recMsg, DINPUT_SOFTBUS_KEY_INPUT_TYPE)) {
1359         DHLOGE("The key is invaild.");
1360         return;
1361     }
1362     std::string sinkDevId = DistributedInputTransportBase::GetInstance().GetDevIdBySessionId(sessionId);
1363     if (sinkDevId.empty()) {
1364         DHLOGE("OnBytesReceived cmdType is TRANS_SINK_MSG_ON_RELAY_STARTTYPE, sinkDevId is error.");
1365         return;
1366     }
1367     std::string localNetworkId = GetLocalNetworkId();
1368     if (localNetworkId.empty()) {
1369         DHLOGE("Could not get local device id.");
1370         return;
1371     }
1372     int32_t srcTsrcSeId = recMsg[DINPUT_SOFTBUS_KEY_SESSION_ID];
1373     bool result = recMsg[DINPUT_SOFTBUS_KEY_RESP_VALUE];
1374     uint32_t inputTypes = recMsg[DINPUT_SOFTBUS_KEY_INPUT_TYPE];
1375     NotifyOriginStartTypeResult(srcTsrcSeId, localNetworkId, sinkDevId,
1376         result ? DH_SUCCESS : ERR_DH_INPUT_SERVER_SOURCE_MANAGER_START_MSG_IS_BAD, inputTypes);
1377 }
1378 
NotifyResponseRelayStopTypeRemoteInput(int32_t sessionId,const nlohmann::json & recMsg)1379 void DistributedInputSourceTransport::NotifyResponseRelayStopTypeRemoteInput(int32_t sessionId,
1380     const nlohmann::json &recMsg)
1381 {
1382     DHLOGI("OnBytesReceived cmdType is TRANS_SINK_MSG_ON_RELAY_STOPTYPE.");
1383     if (!IsInt32(recMsg, DINPUT_SOFTBUS_KEY_SESSION_ID) ||
1384         !IsBoolean(recMsg, DINPUT_SOFTBUS_KEY_RESP_VALUE) ||
1385         !IsUInt32(recMsg, DINPUT_SOFTBUS_KEY_INPUT_TYPE)) {
1386         DHLOGE("The key is invaild.");
1387         return;
1388     }
1389     std::string sinkDevId = DistributedInputTransportBase::GetInstance().GetDevIdBySessionId(sessionId);
1390     if (sinkDevId.empty()) {
1391         DHLOGE("OnBytesReceived cmdType is TRANS_SINK_MSG_ON_RELAY_STOPTYPE, sinkDevId is error.");
1392         return;
1393     }
1394     std::string localNetworkId = GetLocalNetworkId();
1395     if (localNetworkId.empty()) {
1396         DHLOGE("Could not get local device id.");
1397         return;
1398     }
1399     int32_t srcTsrcSeId = recMsg[DINPUT_SOFTBUS_KEY_SESSION_ID];
1400     bool result = recMsg[DINPUT_SOFTBUS_KEY_RESP_VALUE];
1401     uint32_t inputTypes = recMsg[DINPUT_SOFTBUS_KEY_INPUT_TYPE];
1402     NotifyOriginStopTypeResult(srcTsrcSeId, localNetworkId, sinkDevId,
1403         result ? DH_SUCCESS : ERR_DH_INPUT_SERVER_SOURCE_MANAGER_STOP_MSG_IS_BAD, inputTypes);
1404 }
1405 
ReceiveRelayStartTypeResult(int32_t sessionId,const nlohmann::json & recMsg)1406 void DistributedInputSourceTransport::ReceiveRelayStartTypeResult(int32_t sessionId, const nlohmann::json &recMsg)
1407 {
1408     DHLOGI("OnBytesReceived cmdType is TRANS_SOURCE_TO_SOURCE_MSG_START_TYPE_RESULT.");
1409     if (!IsString(recMsg, DINPUT_SOFTBUS_KEY_SRC_DEV_ID) ||
1410         !IsString(recMsg, DINPUT_SOFTBUS_KEY_SINK_DEV_ID) ||
1411         !IsInt32(recMsg, DINPUT_SOFTBUS_KEY_RESP_VALUE) ||
1412         !IsUInt32(recMsg, DINPUT_SOFTBUS_KEY_INPUT_TYPE)) {
1413         DHLOGE("The key is invaild.");
1414         return;
1415     }
1416 
1417     std::string srcId = recMsg[DINPUT_SOFTBUS_KEY_SRC_DEV_ID];
1418     std::string sinkId = recMsg[DINPUT_SOFTBUS_KEY_SINK_DEV_ID];
1419     int32_t status = recMsg[DINPUT_SOFTBUS_KEY_RESP_VALUE];
1420     uint32_t inputTypes = recMsg[DINPUT_SOFTBUS_KEY_INPUT_TYPE];
1421     callback_->OnReceiveRelayStartTypeResult(status, srcId, sinkId, inputTypes);
1422 }
1423 
ReceiveRelayStopTypeResult(int32_t sessionId,const nlohmann::json & recMsg)1424 void DistributedInputSourceTransport::ReceiveRelayStopTypeResult(int32_t sessionId, const nlohmann::json &recMsg)
1425 {
1426     DHLOGI("OnBytesReceived cmdType is TRANS_SOURCE_TO_SOURCE_MSG_STOP_TYPE_RESULT.");
1427     if (!IsString(recMsg, DINPUT_SOFTBUS_KEY_SRC_DEV_ID) ||
1428         !IsString(recMsg, DINPUT_SOFTBUS_KEY_SINK_DEV_ID) ||
1429         !IsInt32(recMsg, DINPUT_SOFTBUS_KEY_RESP_VALUE) ||
1430         !IsUInt32(recMsg, DINPUT_SOFTBUS_KEY_INPUT_TYPE)) {
1431         DHLOGE("The key is invaild.");
1432         return;
1433     }
1434 
1435     std::string srcId = recMsg[DINPUT_SOFTBUS_KEY_SRC_DEV_ID];
1436     std::string sinkId = recMsg[DINPUT_SOFTBUS_KEY_SINK_DEV_ID];
1437     int32_t status = recMsg[DINPUT_SOFTBUS_KEY_RESP_VALUE];
1438     uint32_t inputTypes = recMsg[DINPUT_SOFTBUS_KEY_INPUT_TYPE];
1439     callback_->OnReceiveRelayStopTypeResult(status, srcId, sinkId, inputTypes);
1440 }
1441 
HandleEventSecond(int32_t sessionId,const nlohmann::json & recMsg)1442 void DistributedInputSourceTransport::HandleEventSecond(int32_t sessionId, const nlohmann::json &recMsg)
1443 {
1444     uint32_t cmdType = recMsg[DINPUT_SOFTBUS_KEY_CMD_TYPE];
1445     switch (cmdType) {
1446         case TRANS_SOURCE_TO_SOURCE_MSG_START_TYPE:
1447             ReceiveSrcTSrcRelayStartType(sessionId, recMsg);
1448             break;
1449         case TRANS_SOURCE_TO_SOURCE_MSG_STOP_TYPE:
1450             ReceiveSrcTSrcRelayStopType(sessionId, recMsg);
1451             break;
1452         case TRANS_SINK_MSG_ON_RELAY_STARTTYPE:
1453             NotifyResponseRelayStartTypeRemoteInput(sessionId, recMsg);
1454             break;
1455         case TRANS_SINK_MSG_ON_RELAY_STOPTYPE:
1456             NotifyResponseRelayStopTypeRemoteInput(sessionId, recMsg);
1457             break;
1458         case TRANS_SOURCE_TO_SOURCE_MSG_START_TYPE_RESULT:
1459             ReceiveRelayStartTypeResult(sessionId, recMsg);
1460             break;
1461         case TRANS_SOURCE_TO_SOURCE_MSG_STOP_TYPE_RESULT:
1462             ReceiveRelayStopTypeResult(sessionId, recMsg);
1463             break;
1464         default:
1465             DHLOGE("OnBytesReceived cmdType %{public}u is undefined.", cmdType);
1466     }
1467 }
1468 
HandleEventFirst(int32_t sessionId,const nlohmann::json & recMsg)1469 void DistributedInputSourceTransport::HandleEventFirst(int32_t sessionId, const nlohmann::json &recMsg)
1470 {
1471     uint32_t cmdType = recMsg[DINPUT_SOFTBUS_KEY_CMD_TYPE];
1472     switch (cmdType) {
1473         case TRANS_SINK_MSG_KEY_STATE_BATCH:
1474             NotifyResponseKeyStateBatch(sessionId, recMsg);
1475             break;
1476         case TRANS_SOURCE_TO_SOURCE_MSG_PREPARE:
1477             ReceiveSrcTSrcRelayPrepare(sessionId, recMsg);
1478             break;
1479         case TRANS_SINK_MSG_ON_RELAY_PREPARE:
1480             NotifyResponseRelayPrepareRemoteInput(sessionId, recMsg);
1481             break;
1482         case TRANS_SINK_MSG_ON_RELAY_UNPREPARE:
1483             NotifyResponseRelayUnprepareRemoteInput(sessionId, recMsg);
1484             break;
1485         case TRANS_SOURCE_TO_SOURCE_MSG_UNPREPARE:
1486             ReceiveSrcTSrcRelayUnprepare(sessionId, recMsg);
1487             break;
1488         case TRANS_SOURCE_TO_SOURCE_MSG_PREPARE_RESULT:
1489             ReceiveRelayPrepareResult(sessionId, recMsg);
1490             break;
1491         case TRANS_SOURCE_TO_SOURCE_MSG_UNPREPARE_RESULT:
1492             ReceiveRelayUnprepareResult(sessionId, recMsg);
1493             break;
1494         case TRANS_SOURCE_TO_SOURCE_MSG_START_DHID:
1495             ReceiveSrcTSrcRelayStartDhid(sessionId, recMsg);
1496             break;
1497         case TRANS_SOURCE_TO_SOURCE_MSG_STOP_DHID:
1498             ReceiveSrcTSrcRelayStopDhid(sessionId, recMsg);
1499             break;
1500         case TRANS_SINK_MSG_ON_RELAY_STARTDHID:
1501             NotifyResponseRelayStartDhidRemoteInput(sessionId, recMsg);
1502             break;
1503         case TRANS_SINK_MSG_ON_RELAY_STOPDHID:
1504             NotifyResponseRelayStopDhidRemoteInput(sessionId, recMsg);
1505             break;
1506         case TRANS_SOURCE_TO_SOURCE_MSG_START_DHID_RESULT:
1507             ReceiveRelayStartDhidResult(sessionId, recMsg);
1508             break;
1509         case TRANS_SOURCE_TO_SOURCE_MSG_STOP_DHID_RESULT:
1510             ReceiveRelayStopDhidResult(sessionId, recMsg);
1511             break;
1512         default:
1513             HandleEventSecond(sessionId, recMsg);
1514     }
1515 }
1516 
HandleSessionData(int32_t sessionId,const std::string & message)1517 void DistributedInputSourceTransport::DInputTransbaseSourceListener::HandleSessionData(int32_t sessionId,
1518     const std::string &message)
1519 {
1520     DistributedInputSourceTransport::GetInstance().HandleData(sessionId, message);
1521 }
1522 
HandleData(int32_t sessionId,const std::string & message)1523 void DistributedInputSourceTransport::HandleData(int32_t sessionId, const std::string &message)
1524 {
1525     if (callback_ == nullptr) {
1526         DHLOGE("OnBytesReceived the callback_ is null, the message:%{public}s abort.", SetAnonyId(message).c_str());
1527         return;
1528     }
1529     nlohmann::json recMsg = nlohmann::json::parse(message, nullptr, false);
1530     if (recMsg.is_discarded()) {
1531         DHLOGE("recMsg parse failed!");
1532         return;
1533     }
1534     if (!IsUInt32(recMsg, DINPUT_SOFTBUS_KEY_CMD_TYPE)) {
1535         DHLOGE("softbus cmd key is invalid");
1536         return;
1537     }
1538     uint32_t cmdType = recMsg[DINPUT_SOFTBUS_KEY_CMD_TYPE];
1539     switch (cmdType) {
1540         case TRANS_SINK_MSG_ONPREPARE:
1541             NotifyResponsePrepareRemoteInput(sessionId, recMsg);
1542             break;
1543         case TRANS_SINK_MSG_ONUNPREPARE:
1544             NotifyResponseUnprepareRemoteInput(sessionId, recMsg);
1545             break;
1546         case TRANS_SINK_MSG_ONSTART:
1547             NotifyResponseStartRemoteInput(sessionId, recMsg);
1548             break;
1549         case TRANS_SINK_MSG_ONSTOP:
1550             NotifyResponseStopRemoteInput(sessionId, recMsg);
1551             break;
1552         case TRANS_SINK_MSG_BODY_DATA:
1553             NotifyReceivedEventRemoteInput(sessionId, recMsg);
1554             break;
1555         case TRANS_SINK_MSG_LATENCY:
1556             CalculateLatency(sessionId, recMsg);
1557             break;
1558         case TRANS_SINK_MSG_DHID_ONSTART:
1559             NotifyResponseStartRemoteInputDhid(sessionId, recMsg);
1560             break;
1561         case TRANS_SINK_MSG_DHID_ONSTOP:
1562             NotifyResponseStopRemoteInputDhid(sessionId, recMsg);
1563             break;
1564         case TRANS_SINK_MSG_KEY_STATE:
1565             NotifyResponseKeyState(sessionId, recMsg);
1566             break;
1567         default:
1568             HandleEventFirst(sessionId, recMsg);
1569     }
1570 }
1571 } // namespace DistributedInput
1572 } // namespace DistributedHardware
1573 } // namespace OHOS
1574