1 /*
2 * Copyright (c) 2023-2025 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 "dsoftbus_handler.h"
17
18 #include "ipc_skeleton.h"
19 #include "token_setproc.h"
20
21 #include "cooperate_hisysevent.h"
22 #include "device.h"
23 #include "devicestatus_define.h"
24 #include "utility.h"
25
26 #undef LOG_TAG
27 #define LOG_TAG "DSoftbusHandler"
28
29 namespace OHOS {
30 namespace Msdp {
31 namespace DeviceStatus {
32 namespace Cooperate {
33 constexpr int32_t MAX_INPUT_DEV_NUM { 100 };
34 constexpr int32_t INVALID_DEVICE_ID { -1 };
35
DSoftbusHandler(IContext * env)36 DSoftbusHandler::DSoftbusHandler(IContext *env)
37 : env_(env)
38 {
39 handles_ = {
40 { static_cast<int32_t>(MessageId::DSOFTBUS_START_COOPERATE),
41 [this] (const std::string &networkId, NetPacket &packet) {
42 this->OnStartCooperate(networkId, packet);}},
43 { static_cast<int32_t>(MessageId::DSOFTBUS_STOP_COOPERATE),
44 [this] (const std::string &networkId, NetPacket &packet) {
45 this->OnStopCooperate(networkId, packet);}},
46 { static_cast<int32_t>(MessageId::DSOFTBUS_COME_BACK),
47 [this] (const std::string &networkId, NetPacket &packet) {
48 this->OnComeBack(networkId, packet);}},
49 { static_cast<int32_t>(MessageId::DSOFTBUS_COME_BACK_WITH_OPTIONS),
50 [this] (const std::string &networkId, NetPacket &packet) {
51 this->OnComeBackWithOptions(networkId, packet);}},
52 { static_cast<int32_t>(MessageId::DSOFTBUS_RELAY_COOPERATE),
53 [this] (const std::string &networkId, NetPacket &packet) {
54 this->OnRelayCooperate(networkId, packet);}},
55 { static_cast<int32_t>(MessageId::DSOFTBUS_RELAY_COOPERATE_FINISHED),
56 [this] (const std::string &networkId, NetPacket &packet) {
57 this->OnRelayCooperateFinish(networkId, packet);}},
58 { static_cast<int32_t>(MessageId::DSOFTBUS_SUBSCRIBE_MOUSE_LOCATION),
59 [this] (const std::string &networkId, NetPacket &packet) {
60 this->OnSubscribeMouseLocation(networkId, packet);}},
61 { static_cast<int32_t>(MessageId::DSOFTBUS_UNSUBSCRIBE_MOUSE_LOCATION),
62 [this] (const std::string &networkId, NetPacket &packet) {
63 this->OnUnSubscribeMouseLocation(networkId, packet);}},
64 { static_cast<int32_t>(MessageId::DSOFTBUS_REPLY_SUBSCRIBE_MOUSE_LOCATION),
65 [this] (const std::string &networkId, NetPacket &packet) {
66 this->OnReplySubscribeLocation(networkId, packet);}},
67 { static_cast<int32_t>(MessageId::DSOFTBUS_REPLY_UNSUBSCRIBE_MOUSE_LOCATION),
68 [this] (const std::string &networkId, NetPacket &packet) {
69 this->OnReplyUnSubscribeLocation(networkId, packet);}},
70 { static_cast<int32_t>(MessageId::DSOFTBUS_MOUSE_LOCATION),
71 [this] (const std::string &networkId, NetPacket &packet) {
72 this->OnRemoteMouseLocation(networkId, packet);}},
73 { static_cast<int32_t>(MessageId::DSOFTBUS_INPUT_DEV_SYNC),
74 [this] (const std::string &networkId, NetPacket &packet) {
75 this->OnRemoteInputDevice(networkId, packet);}},
76 { static_cast<int32_t>(MessageId::DSOFTBUS_INPUT_DEV_HOT_PLUG),
77 [this] (const std::string &networkId, NetPacket &packet) {
78 this->OnRemoteHotPlug(networkId, packet);}},
79 { static_cast<int32_t>(MessageId::DSOFTBUS_COOPERATE_WITH_OPTIONS),
80 [this] (const std::string &networkId, NetPacket &packet) {
81 this->OnStartCooperateWithOptions(networkId, packet);}},
82 { static_cast<int32_t>(MessageId::DSOFTBUS_RELAY_COOPERATE_WITHOPTIONS),
83 [this] (const std::string &networkId, NetPacket &packet) {
84 this->OnRelayCooperateWithOptions(networkId, packet);}},
85 { static_cast<int32_t>(MessageId::DSOFTBUS_RELAY_COOPERATE_WITHOPTIONS_FINISHED),
86 [this] (const std::string &networkId, NetPacket &packet) {
87 this->OnRelayCooperateWithOptionsFinish(networkId, packet);}}
88 };
89 observer_ = std::make_shared<DSoftbusObserver>(*this);
90 CHKPV(env_);
91 env_->GetDSoftbus().AddObserver(observer_);
92 }
93
~DSoftbusHandler()94 DSoftbusHandler::~DSoftbusHandler()
95 {
96 CHKPV(env_);
97 env_->GetDSoftbus().RemoveObserver(observer_);
98 }
99
AttachSender(Channel<CooperateEvent>::Sender sender)100 void DSoftbusHandler::AttachSender(Channel<CooperateEvent>::Sender sender)
101 {
102 CALL_DEBUG_ENTER;
103 std::lock_guard guard(lock_);
104 sender_ = sender;
105 }
106
CheckDeviceOnline(const std::string & networkId)107 int32_t DSoftbusHandler::CheckDeviceOnline(const std::string &networkId)
108 {
109 CHKPR(env_, RET_ERR);
110 int32_t ret = env_->GetDSoftbus().CheckDeviceOnline(networkId);
111 return ret;
112 }
113
OpenSession(const std::string & networkId)114 int32_t DSoftbusHandler::OpenSession(const std::string &networkId)
115 {
116 CALL_INFO_TRACE;
117 CHKPR(env_, RET_ERR);
118 auto tokenId = OHOS::IPCSkeleton::GetCallingTokenID();
119 int ret = SetFirstCallerTokenID(tokenId);
120 if (ret != RET_OK) {
121 FI_HILOGW("Failed to SetFirstCallerTokenID, ret:%{public}d", ret);
122 }
123 ret = env_->GetDSoftbus().OpenSession(networkId);
124 if (ret == RET_OK) {
125 env_->GetDSoftbus().StartHeartBeat(networkId);
126 }
127 return ret;
128 }
129
CloseSession(const std::string & networkId)130 void DSoftbusHandler::CloseSession(const std::string &networkId)
131 {
132 CALL_INFO_TRACE;
133 CHKPV(env_);
134 env_->GetDSoftbus().CloseSession(networkId);
135 }
136
CloseAllSessions()137 void DSoftbusHandler::CloseAllSessions()
138 {
139 CALL_INFO_TRACE;
140 CHKPV(env_);
141 env_->GetDSoftbus().CloseAllSessions();
142 }
143
StartCooperate(const std::string & networkId,const DSoftbusStartCooperate & event)144 int32_t DSoftbusHandler::StartCooperate(const std::string &networkId, const DSoftbusStartCooperate &event)
145 {
146 CALL_INFO_TRACE;
147 CHKPR(env_, RET_ERR);
148 NetPacket packet(MessageId::DSOFTBUS_START_COOPERATE);
149 packet << event.originNetworkId << event.cursorPos.x
150 << event.cursorPos.y << event.success << event.extra.priv << event.pointerSpeed
151 << event.touchPadSpeed << event.uid;
152 if (packet.ChkRWError()) {
153 FI_HILOGE("Failed to write data packet");
154 CooperateRadarInfo radarInfo {
155 .funcName = __FUNCTION__,
156 .bizState = static_cast<int32_t> (BizState::STATE_END),
157 .bizStage = static_cast<int32_t> (BizCooperateStage::STAGE_SERIALIZE_INSTRUCTION),
158 .stageRes = static_cast<int32_t> (BizCooperateStageRes::RES_FAIL),
159 .bizScene = static_cast<int32_t> (BizCooperateScene::SCENE_ACTIVE),
160 .errCode = static_cast<int32_t> (CooperateRadarErrCode::SERIALIZE_INSTRUCTION_FAILED),
161 .hostName = "",
162 .localNetId = Utility::DFXRadarAnonymize(event.originNetworkId.c_str()),
163 .peerNetId = Utility::DFXRadarAnonymize(networkId.c_str())
164 };
165 CooperateRadar::ReportCooperateRadarInfo(radarInfo);
166 return RET_ERR;
167 }
168 int32_t ret = env_->GetDSoftbus().SendPacket(networkId, packet);
169 if (ret != RET_OK) {
170 OnCommunicationFailure(networkId);
171 CooperateRadarInfo radarInfo {
172 .funcName = __FUNCTION__,
173 .bizState = static_cast<int32_t> (BizState::STATE_END),
174 .bizStage = static_cast<int32_t> (BizCooperateStage::STAGE_SEND_INSTRUCTION_TO_REMOTE),
175 .stageRes = static_cast<int32_t> (BizCooperateStageRes::RES_FAIL),
176 .bizScene = static_cast<int32_t> (BizCooperateScene::SCENE_ACTIVE),
177 .errCode = static_cast<int32_t> (CooperateRadarErrCode::SEND_INSTRUCTION_TO_REMOTE_FAILED),
178 .hostName = "",
179 .localNetId = Utility::DFXRadarAnonymize(event.originNetworkId.c_str()),
180 .peerNetId = Utility::DFXRadarAnonymize(networkId.c_str())
181 };
182 CooperateRadar::ReportCooperateRadarInfo(radarInfo);
183 }
184 return ret;
185 }
186
StartCooperateWithOptions(const std::string & networkId,const DSoftbusCooperateOptions & event)187 int32_t DSoftbusHandler::StartCooperateWithOptions(const std::string &networkId, const DSoftbusCooperateOptions &event)
188 {
189 CALL_INFO_TRACE;
190 CHKPR(env_, RET_ERR);
191 NetPacket packet(MessageId::DSOFTBUS_COOPERATE_WITH_OPTIONS);
192 packet << event.originNetworkId << event.cooperateOptions.displayX << event.cooperateOptions.displayY
193 << event.cooperateOptions.displayId << event.success << event.extra.priv << event.pointerSpeed
194 << event.touchPadSpeed;
195 if (packet.ChkRWError()) {
196 FI_HILOGE("Failed to write data packet");
197 CooperateRadarInfo radarInfo {
198 .funcName = __FUNCTION__,
199 .bizState = static_cast<int32_t> (BizState::STATE_END),
200 .bizStage = static_cast<int32_t> (BizCooperateStage::STAGE_SERIALIZE_INSTRUCTION),
201 .stageRes = static_cast<int32_t> (BizCooperateStageRes::RES_FAIL),
202 .bizScene = static_cast<int32_t> (BizCooperateScene::SCENE_ACTIVE),
203 .errCode = static_cast<int32_t> (CooperateRadarErrCode::SERIALIZE_INSTRUCTION_FAILED),
204 .hostName = "",
205 .localNetId = Utility::DFXRadarAnonymize(event.originNetworkId.c_str()),
206 .peerNetId = Utility::DFXRadarAnonymize(networkId.c_str())
207 };
208 CooperateRadar::ReportCooperateRadarInfo(radarInfo);
209 return RET_ERR;
210 }
211 int32_t ret = env_->GetDSoftbus().SendPacket(networkId, packet);
212 if (ret != RET_OK) {
213 OnCommunicationFailure(networkId);
214 CooperateRadarInfo radarInfo {
215 .funcName = __FUNCTION__,
216 .bizState = static_cast<int32_t> (BizState::STATE_END),
217 .bizStage = static_cast<int32_t> (BizCooperateStage::STAGE_SEND_INSTRUCTION_TO_REMOTE),
218 .stageRes = static_cast<int32_t> (BizCooperateStageRes::RES_FAIL),
219 .bizScene = static_cast<int32_t> (BizCooperateScene::SCENE_ACTIVE),
220 .errCode = static_cast<int32_t> (CooperateRadarErrCode::SEND_INSTRUCTION_TO_REMOTE_FAILED),
221 .hostName = "",
222 .localNetId = Utility::DFXRadarAnonymize(event.originNetworkId.c_str()),
223 .peerNetId = Utility::DFXRadarAnonymize(networkId.c_str())
224 };
225 CooperateRadar::ReportCooperateRadarInfo(radarInfo);
226 }
227 return ret;
228 }
229
StopCooperate(const std::string & networkId,const DSoftbusStopCooperate & event)230 int32_t DSoftbusHandler::StopCooperate(const std::string &networkId, const DSoftbusStopCooperate &event)
231 {
232 CALL_INFO_TRACE;
233 CHKPR(env_, RET_ERR);
234 NetPacket packet(MessageId::DSOFTBUS_STOP_COOPERATE);
235 int32_t ret = env_->GetDSoftbus().SendPacket(networkId, packet);
236 if (ret != RET_OK) {
237 OnCommunicationFailure(networkId);
238 }
239 return ret;
240 }
241
ComeBack(const std::string & networkId,const DSoftbusComeBack & event)242 int32_t DSoftbusHandler::ComeBack(const std::string &networkId, const DSoftbusComeBack &event)
243 {
244 CALL_INFO_TRACE;
245 CHKPR(env_, RET_ERR);
246 NetPacket packet(MessageId::DSOFTBUS_COME_BACK);
247 packet << event.originNetworkId << event.cursorPos.x << event.cursorPos.y << event.extra.priv << event.uid;
248 if (packet.ChkRWError()) {
249 FI_HILOGE("Failed to write data packet");
250 return RET_ERR;
251 }
252 int32_t ret = env_->GetDSoftbus().SendPacket(networkId, packet);
253 if (ret != RET_OK) {
254 OnCommunicationFailure(networkId);
255 }
256 return ret;
257 }
258
ComeBackWithOptions(const std::string & networkId,const DSoftbusComeBackWithOptions & event)259 int32_t DSoftbusHandler::ComeBackWithOptions(const std::string &networkId, const DSoftbusComeBackWithOptions &event)
260 {
261 CALL_INFO_TRACE;
262 CHKPR(env_, RET_ERR);
263 NetPacket packet(MessageId::DSOFTBUS_COME_BACK_WITH_OPTIONS);
264 packet << event.originNetworkId << event.cooperateOptions.displayX << event.cooperateOptions.displayY
265 << event.cooperateOptions.displayId << event.extra.priv;
266 if (packet.ChkRWError()) {
267 FI_HILOGE("Failed to write data packet");
268 return RET_ERR;
269 }
270 int32_t ret = env_->GetDSoftbus().SendPacket(networkId, packet);
271 if (ret != RET_OK) {
272 OnCommunicationFailure(networkId);
273 }
274 return ret;
275 }
276
RelayCooperate(const std::string & networkId,const DSoftbusRelayCooperate & event)277 int32_t DSoftbusHandler::RelayCooperate(const std::string &networkId, const DSoftbusRelayCooperate &event)
278 {
279 CALL_INFO_TRACE;
280 CHKPR(env_, RET_ERR);
281 NetPacket packet(MessageId::DSOFTBUS_RELAY_COOPERATE);
282 packet << event.targetNetworkId << event.pointerSpeed << event.touchPadSpeed << event.uid;
283 if (packet.ChkRWError()) {
284 FI_HILOGE("Failed to write data packet");
285 return RET_ERR;
286 }
287 int32_t ret = env_->GetDSoftbus().SendPacket(networkId, packet);
288 if (ret != RET_OK) {
289 OnCommunicationFailure(networkId);
290 }
291 return ret;
292 }
293
RelayCooperateFinish(const std::string & networkId,const DSoftbusRelayCooperateFinished & event)294 int32_t DSoftbusHandler::RelayCooperateFinish(const std::string &networkId, const DSoftbusRelayCooperateFinished &event)
295 {
296 CALL_INFO_TRACE;
297 CHKPR(env_, RET_ERR);
298 NetPacket packet(MessageId::DSOFTBUS_RELAY_COOPERATE_FINISHED);
299 packet << event.targetNetworkId << event.normal << event.uid;
300 if (packet.ChkRWError()) {
301 FI_HILOGE("Failed to write data packet");
302 return RET_ERR;
303 }
304 int32_t ret = env_->GetDSoftbus().SendPacket(networkId, packet);
305 if (ret != RET_OK) {
306 OnCommunicationFailure(networkId);
307 }
308 return ret;
309 }
310
RelayCooperateWithOptions(const std::string & networkId,const DSoftbusRelayCooperate & event)311 int32_t DSoftbusHandler::RelayCooperateWithOptions(const std::string &networkId, const DSoftbusRelayCooperate &event)
312 {
313 CALL_INFO_TRACE;
314 CHKPR(env_, RET_ERR);
315 NetPacket packet(MessageId::DSOFTBUS_RELAY_COOPERATE_WITHOPTIONS);
316 packet << event.targetNetworkId << event.pointerSpeed << event.touchPadSpeed;
317 if (packet.ChkRWError()) {
318 FI_HILOGE("Failed to write data packet");
319 return RET_ERR;
320 }
321 int32_t ret = env_->GetDSoftbus().SendPacket(networkId, packet);
322 if (ret != RET_OK) {
323 OnCommunicationFailure(networkId);
324 }
325 return ret;
326 }
327
RelayCooperateWithOptionsFinish(const std::string & networkId,const DSoftbusRelayCooperateFinished & event)328 int32_t DSoftbusHandler::RelayCooperateWithOptionsFinish(const std::string &networkId,
329 const DSoftbusRelayCooperateFinished &event)
330 {
331 CALL_INFO_TRACE;
332 CHKPR(env_, RET_ERR);
333 NetPacket packet(MessageId::DSOFTBUS_RELAY_COOPERATE_WITHOPTIONS_FINISHED);
334 packet << event.targetNetworkId << event.normal;
335 if (packet.ChkRWError()) {
336 FI_HILOGE("Failed to write data packet");
337 return RET_ERR;
338 }
339 int32_t ret = env_->GetDSoftbus().SendPacket(networkId, packet);
340 if (ret != RET_OK) {
341 OnCommunicationFailure(networkId);
342 }
343 return ret;
344 }
345
GetLocalNetworkId()346 std::string DSoftbusHandler::GetLocalNetworkId()
347 {
348 return IDSoftbusAdapter::GetLocalNetworkId();
349 }
350
OnBind(const std::string & networkId)351 void DSoftbusHandler::OnBind(const std::string &networkId)
352 {
353 FI_HILOGI("Bind to \'%{public}s\'", Utility::Anonymize(networkId).c_str());
354 SendEvent(CooperateEvent(
355 CooperateEventType::DSOFTBUS_SESSION_OPENED,
356 DSoftbusSessionOpened {
357 .networkId = networkId
358 }));
359 }
360
OnShutdown(const std::string & networkId)361 void DSoftbusHandler::OnShutdown(const std::string &networkId)
362 {
363 FI_HILOGI("Connection with \'%{public}s\' shutdown", Utility::Anonymize(networkId).c_str());
364 SendEvent(CooperateEvent(
365 CooperateEventType::DSOFTBUS_SESSION_CLOSED,
366 DSoftbusSessionClosed {
367 .networkId = networkId
368 }));
369 }
370
OnConnected(const std::string & networkId)371 void DSoftbusHandler::OnConnected(const std::string &networkId)
372 {
373 FI_HILOGI("Connection to \'%{public}s\' successfully", Utility::Anonymize(networkId).c_str());
374 SendEvent(CooperateEvent(
375 CooperateEventType::DSOFTBUS_SESSION_OPENED,
376 DSoftbusSessionOpened {
377 .networkId = networkId
378 }));
379 }
380
OnPacket(const std::string & networkId,NetPacket & packet)381 bool DSoftbusHandler::OnPacket(const std::string &networkId, NetPacket &packet)
382 {
383 CALL_DEBUG_ENTER;
384 int32_t messageId = static_cast<int32_t>(packet.GetMsgId());
385 auto it = handles_.find(messageId);
386 if (it != handles_.end()) {
387 (it->second)(networkId, packet);
388 return true;
389 }
390 FI_HILOGD("Unsupported messageId: %{public}d from %{public}s", messageId,
391 Utility::Anonymize(networkId).c_str());
392 return false;
393 }
394
SendEvent(const CooperateEvent & event)395 void DSoftbusHandler::SendEvent(const CooperateEvent &event)
396 {
397 std::lock_guard guard(lock_);
398 auto ret = sender_.Send(event);
399 if (ret != Channel<CooperateEvent>::NO_ERROR) {
400 FI_HILOGE("Failed to send event via channel, error:%{public}d", ret);
401 }
402 }
403
OnCommunicationFailure(const std::string & networkId)404 void DSoftbusHandler::OnCommunicationFailure(const std::string &networkId)
405 {
406 env_->GetDSoftbus().CloseSession(networkId);
407 FI_HILOGI("Notify communication failure with peer(%{public}s)", Utility::Anonymize(networkId).c_str());
408 SendEvent(CooperateEvent(
409 CooperateEventType::DSOFTBUS_SESSION_CLOSED,
410 DSoftbusSessionClosed {
411 .networkId = networkId
412 }));
413 }
414
OnStartCooperate(const std::string & networkId,NetPacket & packet)415 void DSoftbusHandler::OnStartCooperate(const std::string &networkId, NetPacket &packet)
416 {
417 CALL_INFO_TRACE;
418 DSoftbusStartCooperate event {
419 .networkId = networkId,
420 };
421 packet >> event.originNetworkId >> event.cursorPos.x
422 >> event.cursorPos.y >> event.success;
423 CooperateRadarInfo radarInfo {
424 .funcName = __FUNCTION__,
425 .bizState = static_cast<int32_t> (BizState::STATE_BEGIN),
426 .bizScene = static_cast<int32_t> (BizCooperateScene::SCENE_PASSIVE),
427 .hostName = "",
428 .localNetId = Utility::DFXRadarAnonymize(event.originNetworkId.c_str()),
429 .peerNetId = Utility::DFXRadarAnonymize(networkId.c_str())
430 };
431 if (packet.ChkRWError()) {
432 FI_HILOGE("Failed to read data packet");
433 radarInfo.bizStage = static_cast<int32_t> (BizCooperateStage::STAGE_PASSIVE_DEASERIALIZATION);
434 radarInfo.stageRes = static_cast<int32_t> (BizCooperateStageRes::RES_FAIL);
435 radarInfo.errCode = static_cast<int32_t> (CooperateRadarErrCode::PASSIVE_DEASERIALIZATION_FAILED);
436 CooperateRadar::ReportCooperateRadarInfo(radarInfo);
437 return;
438 }
439 packet >> event.extra.priv;
440 if (packet.ChkRWError()) {
441 event.extra.priv = 0;
442 }
443 packet >> event.pointerSpeed;
444 if (packet.ChkRWError()) {
445 event.pointerSpeed = -1;
446 }
447 packet >> event.touchPadSpeed;
448 if (packet.ChkRWError()) {
449 event.touchPadSpeed = -1;
450 }
451 packet >> event.uid;
452 if (packet.ChkRWError()) {
453 event.uid = 0;
454 }
455 FI_HILOGI("Cur pointerSpeed:%{public}d, touchPadSpeed:%{public}d, uid:%{public}d",
456 event.pointerSpeed, event.touchPadSpeed, event.uid);
457 SendEvent(CooperateEvent(
458 CooperateEventType::DSOFTBUS_START_COOPERATE,
459 event));
460 radarInfo.bizStage = static_cast<int32_t> (BizCooperateStage::STAGE_PASSIVE_DEASERIALIZATION);
461 radarInfo.stageRes = static_cast<int32_t> (BizCooperateStageRes::RES_SUCCESS);
462 radarInfo.errCode = static_cast<int32_t> (CooperateRadarErrCode::CALLING_COOPERATE_SUCCESS);
463 CooperateRadar::ReportCooperateRadarInfo(radarInfo);
464 RemoteStartCooperate();
465 }
466
RemoteStartCooperate()467 void DSoftbusHandler::RemoteStartCooperate()
468 {
469 CHKPV(env_);
470 auto motionDrag = env_->GetPluginManager().LoadMotionDrag();
471 if (motionDrag == nullptr) {
472 FI_HILOGE("Failed to load motion drag");
473 return;
474 }
475 motionDrag->OnRemoteStartCooperateSetPointerButtonDown();
476 }
477
OnStopCooperate(const std::string & networkId,NetPacket & packet)478 void DSoftbusHandler::OnStopCooperate(const std::string &networkId, NetPacket &packet)
479 {
480 CALL_INFO_TRACE;
481 DSoftbusStopCooperate event {
482 .networkId = networkId,
483 .normal = true,
484 };
485 SendEvent(CooperateEvent(
486 CooperateEventType::DSOFTBUS_STOP_COOPERATE,
487 event));
488 }
489
OnStartCooperateWithOptions(const std::string & networkId,NetPacket & packet)490 void DSoftbusHandler::OnStartCooperateWithOptions(const std::string &networkId, NetPacket &packet)
491 {
492 CALL_INFO_TRACE;
493 DSoftbusCooperateOptions event {
494 .networkId = networkId,
495 };
496 packet >> event.originNetworkId >> event.cooperateOptions.displayX
497 >> event.cooperateOptions.displayY >> event.cooperateOptions.displayId
498 >> event.success;
499 CooperateRadarInfo radarInfo {
500 .funcName = __FUNCTION__,
501 .bizState = static_cast<int32_t> (BizState::STATE_BEGIN),
502 .bizScene = static_cast<int32_t> (BizCooperateScene::SCENE_PASSIVE),
503 .hostName = "",
504 .localNetId = Utility::DFXRadarAnonymize(event.originNetworkId.c_str()),
505 .peerNetId = Utility::DFXRadarAnonymize(networkId.c_str())
506 };
507 if (packet.ChkRWError()) {
508 FI_HILOGE("Failed to read data packet");
509 radarInfo.bizStage = static_cast<int32_t> (BizCooperateStage::STAGE_PASSIVE_DEASERIALIZATION);
510 radarInfo.stageRes = static_cast<int32_t> (BizCooperateStageRes::RES_FAIL);
511 radarInfo.errCode = static_cast<int32_t> (CooperateRadarErrCode::PASSIVE_DEASERIALIZATION_FAILED);
512 CooperateRadar::ReportCooperateRadarInfo(radarInfo);
513 return;
514 }
515 packet >> event.extra.priv;
516 if (packet.ChkRWError()) {
517 event.extra.priv = 0;
518 }
519 packet >> event.pointerSpeed;
520 if (packet.ChkRWError()) {
521 event.pointerSpeed = -1;
522 }
523 packet >> event.touchPadSpeed;
524 if (packet.ChkRWError()) {
525 event.touchPadSpeed = -1;
526 }
527 SendEvent(CooperateEvent(
528 CooperateEventType::DSOFTBUS_COOPERATE_WITH_OPTIONS,
529 event));
530 radarInfo.bizStage = static_cast<int32_t> (BizCooperateStage::STAGE_PASSIVE_DEASERIALIZATION);
531 radarInfo.stageRes = static_cast<int32_t> (BizCooperateStageRes::RES_SUCCESS);
532 radarInfo.errCode = static_cast<int32_t> (CooperateRadarErrCode::CALLING_COOPERATE_SUCCESS);
533 CooperateRadar::ReportCooperateRadarInfo(radarInfo);
534 RemoteStartCooperate();
535 }
536
OnComeBack(const std::string & networkId,NetPacket & packet)537 void DSoftbusHandler::OnComeBack(const std::string &networkId, NetPacket &packet)
538 {
539 CALL_INFO_TRACE;
540 DSoftbusComeBack event {
541 .networkId = networkId,
542 .success = true,
543 };
544 packet >> event.originNetworkId >> event.cursorPos.x >> event.cursorPos.y;
545 if (packet.ChkRWError()) {
546 FI_HILOGE("Failed to read data packet");
547 return;
548 }
549 packet >> event.extra.priv;
550 if (packet.ChkRWError()) {
551 event.extra.priv = 0;
552 }
553 packet >> event.uid;
554 if (packet.ChkRWError()) {
555 event.uid = 0;
556 }
557 SendEvent(CooperateEvent(
558 CooperateEventType::DSOFTBUS_COME_BACK,
559 event));
560 }
561
OnComeBackWithOptions(const std::string & networkId,NetPacket & packet)562 void DSoftbusHandler::OnComeBackWithOptions(const std::string &networkId, NetPacket &packet)
563 {
564 CALL_INFO_TRACE;
565 DSoftbusComeBackWithOptions event {
566 .networkId = networkId,
567 .success = true,
568 };
569 packet >> event.originNetworkId >> event.cooperateOptions.displayX >>
570 event.cooperateOptions.displayY >> event.cooperateOptions.displayId;
571 if (packet.ChkRWError()) {
572 FI_HILOGE("Failed to read data packet");
573 return;
574 }
575 packet >> event.extra.priv;
576 if (packet.ChkRWError()) {
577 event.extra.priv = 0;
578 }
579 SendEvent(CooperateEvent(
580 CooperateEventType::DSOFTBUS_COME_BACK_WITH_OPTIONS,
581 event));
582 }
583
OnRelayCooperate(const std::string & networkId,NetPacket & packet)584 void DSoftbusHandler::OnRelayCooperate(const std::string &networkId, NetPacket &packet)
585 {
586 CALL_INFO_TRACE;
587 DSoftbusRelayCooperate event {
588 .networkId = networkId,
589 .normal = true,
590 };
591 packet >> event.targetNetworkId;
592 if (packet.ChkRWError()) {
593 FI_HILOGE("Failed to read data packet");
594 return;
595 }
596 packet >> event.pointerSpeed;
597 if (packet.ChkRWError()) {
598 event.pointerSpeed = -1;
599 }
600 FI_HILOGI("Cur pointerSpeed:%{public}d", event.pointerSpeed);
601 packet >> event.touchPadSpeed;
602 if (packet.ChkRWError()) {
603 event.touchPadSpeed = -1;
604 }
605 FI_HILOGI("Cur touchPadSpeed:%{public}d", event.touchPadSpeed);
606 packet >> event.uid;
607 if (packet.ChkRWError()) {
608 event.uid = 0;
609 }
610 FI_HILOGI("Cur uid:%{public}d", event.uid);
611 SendEvent(CooperateEvent(
612 CooperateEventType::DSOFTBUS_RELAY_COOPERATE,
613 event));
614 }
615
OnRelayCooperateFinish(const std::string & networkId,NetPacket & packet)616 void DSoftbusHandler::OnRelayCooperateFinish(const std::string &networkId, NetPacket &packet)
617 {
618 CALL_INFO_TRACE;
619 DSoftbusRelayCooperate event {
620 .networkId = networkId,
621 };
622 packet >> event.targetNetworkId >> event.normal;
623 if (packet.ChkRWError()) {
624 FI_HILOGE("Failed to read data packet");
625 return;
626 }
627 packet >> event.uid;
628 if (packet.ChkRWError()) {
629 event.uid = 0;
630 FI_HILOGD("Cur uid:%{public}d", event.uid);
631 }
632 SendEvent(CooperateEvent(
633 CooperateEventType::DSOFTBUS_RELAY_COOPERATE_FINISHED,
634 event));
635 }
636
OnRelayCooperateWithOptions(const std::string & networkId,NetPacket & packet)637 void DSoftbusHandler::OnRelayCooperateWithOptions(const std::string &networkId, NetPacket &packet)
638 {
639 CALL_INFO_TRACE;
640 DSoftbusRelayCooperate event {
641 .networkId = networkId,
642 .normal = true,
643 };
644 packet >> event.targetNetworkId;
645 if (packet.ChkRWError()) {
646 FI_HILOGE("Failed to read data packet");
647 return;
648 }
649 packet >> event.pointerSpeed;
650 if (packet.ChkRWError()) {
651 event.pointerSpeed = -1;
652 }
653 FI_HILOGI("Cur pointerSpeed:%{public}d", event.pointerSpeed);
654 packet >> event.touchPadSpeed;
655 if (packet.ChkRWError()) {
656 event.touchPadSpeed = -1;
657 }
658 FI_HILOGI("Cur touchPadSpeed:%{public}d", event.touchPadSpeed);
659 SendEvent(CooperateEvent(
660 CooperateEventType::DSOFTBUS_RELAY_COOPERATE_WITHOPTIONS,
661 event));
662 }
663
OnRelayCooperateWithOptionsFinish(const std::string & networkId,NetPacket & packet)664 void DSoftbusHandler::OnRelayCooperateWithOptionsFinish(const std::string &networkId, NetPacket &packet)
665 {
666 CALL_INFO_TRACE;
667 DSoftbusRelayCooperate event {
668 .networkId = networkId,
669 };
670 packet >> event.targetNetworkId >> event.normal;
671 if (packet.ChkRWError()) {
672 FI_HILOGE("Failed to read data packet");
673 return;
674 }
675 SendEvent(CooperateEvent(
676 CooperateEventType::DSOFTBUS_RELAY_COOPERATE_WITHOPTIONS_FINISHED,
677 event));
678 }
679
OnSubscribeMouseLocation(const std::string & networKId,NetPacket & packet)680 void DSoftbusHandler::OnSubscribeMouseLocation(const std::string &networKId, NetPacket &packet)
681 {
682 CALL_INFO_TRACE;
683 DSoftbusSubscribeMouseLocation event;
684 packet >> event.networkId >> event.remoteNetworkId;
685 if (packet.ChkRWError()) {
686 FI_HILOGE("Failed to read data packet");
687 return;
688 }
689 SendEvent(CooperateEvent(
690 CooperateEventType::DSOFTBUS_SUBSCRIBE_MOUSE_LOCATION,
691 event));
692 }
693
OnUnSubscribeMouseLocation(const std::string & networKId,NetPacket & packet)694 void DSoftbusHandler::OnUnSubscribeMouseLocation(const std::string& networKId, NetPacket &packet)
695 {
696 CALL_INFO_TRACE;
697 DSoftbusUnSubscribeMouseLocation event;
698 packet >> event.networkId >> event.remoteNetworkId;
699 if (packet.ChkRWError()) {
700 FI_HILOGE("Failed to read data packet");
701 return;
702 }
703 SendEvent(CooperateEvent(
704 CooperateEventType::DSOFTBUS_UNSUBSCRIBE_MOUSE_LOCATION,
705 event));
706 }
707
OnReplySubscribeLocation(const std::string & networKId,NetPacket & packet)708 void DSoftbusHandler::OnReplySubscribeLocation(const std::string& networKId, NetPacket &packet)
709 {
710 CALL_INFO_TRACE;
711 DSoftbusReplySubscribeMouseLocation event;
712 packet >> event.networkId >> event.remoteNetworkId >> event.result;
713 if (packet.ChkRWError()) {
714 FI_HILOGE("Failed to read data packet");
715 return;
716 }
717 SendEvent(CooperateEvent(
718 CooperateEventType::DSOFTBUS_REPLY_SUBSCRIBE_MOUSE_LOCATION,
719 event));
720 }
721
OnReplyUnSubscribeLocation(const std::string & networKId,NetPacket & packet)722 void DSoftbusHandler::OnReplyUnSubscribeLocation(const std::string& networKId, NetPacket &packet)
723 {
724 CALL_INFO_TRACE;
725 DSoftbusReplyUnSubscribeMouseLocation event;
726 packet >> event.networkId >> event.remoteNetworkId >> event.result;
727 if (packet.ChkRWError()) {
728 FI_HILOGE("Failed to read data packet");
729 return;
730 }
731 SendEvent(CooperateEvent(
732 CooperateEventType::DSOFTBUS_REPLY_UNSUBSCRIBE_MOUSE_LOCATION,
733 event));
734 }
735
OnRemoteMouseLocation(const std::string & networKId,NetPacket & packet)736 void DSoftbusHandler::OnRemoteMouseLocation(const std::string& networKId, NetPacket &packet)
737 {
738 CALL_DEBUG_ENTER;
739 DSoftbusSyncMouseLocation event;
740 packet >> event.networkId >> event.remoteNetworkId >> event.mouseLocation.displayX >>
741 event.mouseLocation.displayY >> event.mouseLocation.displayWidth >> event.mouseLocation.displayHeight;
742 if (packet.ChkRWError()) {
743 FI_HILOGE("Failed to read data packet");
744 return;
745 }
746 SendEvent(CooperateEvent(
747 CooperateEventType::DSOFTBUS_MOUSE_LOCATION,
748 event));
749 }
750
OnRemoteInputDevice(const std::string & networkId,NetPacket & packet)751 void DSoftbusHandler::OnRemoteInputDevice(const std::string& networkId, NetPacket &packet)
752 {
753 CALL_INFO_TRACE;
754 DSoftbusSyncInputDevice event;
755 int32_t devNum { -1 };
756 packet >> devNum;
757 event.networkId = networkId;
758 FI_HILOGI("devNum:%{public}d", devNum);
759 if (devNum <= 0 || devNum >= MAX_INPUT_DEV_NUM) {
760 FI_HILOGE("Invalid devNum:%{public}d", devNum);
761 return;
762 }
763 for (int32_t i = 0; i < devNum; i++) {
764 auto device = std::make_shared<Device>(INVALID_DEVICE_ID);
765 if (DeserializeDevice(device, packet) != RET_OK) {
766 FI_HILOGE("DeserializeDevice failed");
767 return;
768 }
769 event.devices.push_back(device);
770 }
771 SendEvent(CooperateEvent(
772 CooperateEventType::DSOFTBUS_INPUT_DEV_SYNC,
773 event));
774 }
775
OnRemoteHotPlug(const std::string & networkId,NetPacket & packet)776 void DSoftbusHandler::OnRemoteHotPlug(const std::string &networkId, NetPacket &packet)
777 {
778 CALL_INFO_TRACE;
779 DSoftbusHotPlugEvent event;
780 packet >> event.type;
781 FI_HILOGI("Hot plug type:%{public}d", event.type);
782 auto device = std::make_shared<Device>(INVALID_DEVICE_ID);
783 if (DeserializeDevice(device, packet) != RET_OK) {
784 FI_HILOGE("DeserializeDevice failed");
785 return;
786 }
787 event.device = device;
788 SendEvent(CooperateEvent(
789 CooperateEventType::DSOFTBUS_INPUT_DEV_HOT_PLUG,
790 event));
791 }
792
DeserializeDevice(std::shared_ptr<IDevice> device,NetPacket & packet)793 int32_t DSoftbusHandler::DeserializeDevice(std::shared_ptr<IDevice> device, NetPacket &packet)
794 {
795 CALL_DEBUG_ENTER;
796 CHKPR(device, RET_ERR);
797 int32_t data;
798 std::string str;
799 packet >> data;
800 device->SetId(data);
801 packet >> str;
802 device->SetDevPath(str);
803 packet >> str;
804 device->SetSysPath(str);
805 packet >> data;
806 device->SetBus(data);
807 packet >> data;
808 device->SetVendor(data);
809 packet >> data;
810 device->SetProduct(data);
811 packet >> data;
812 device->SetVersion(data);
813 packet >> str;
814 device->SetName(str);
815 packet >> str;
816 device->SetPhys(str);
817 packet >> str;
818 device->SetUniq(str);
819 bool isPointerDevice { false };
820 packet >> isPointerDevice;
821 if (isPointerDevice) {
822 device->AddCapability(IDevice::Capability::DEVICE_CAP_POINTER);
823 }
824 bool isKeyboard { false };
825 packet >> isKeyboard;
826 if (isKeyboard) {
827 device->AddCapability(IDevice::Capability::DEVICE_CAP_KEYBOARD);
828 }
829 int32_t keyboardType { static_cast<int32_t> (IDevice::KeyboardType::KEYBOARD_TYPE_NONE) };
830 packet >> keyboardType;
831 device->SetKeyboardType(static_cast<IDevice::KeyboardType>(keyboardType));
832 if (packet.ChkRWError()) {
833 FI_HILOGE("Packet read type failed");
834 return RET_ERR;
835 }
836 return RET_OK;
837 }
838 } // namespace Cooperate
839 } // namespace DeviceStatus
840 } // namespace Msdp
841 } // namespace OHOS
842