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