1 /*
2 * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "distributed_input_sourceinject_test.h"
17
18 #include <cstring>
19 #include <fcntl.h>
20 #include <iostream>
21 #include <thread>
22 #include <unistd.h>
23
24 #include <linux/input.h>
25
26 #include "event_handler.h"
27 #include "nlohmann/json.hpp"
28
29 #include "dinput_errcode.h"
30 #include "softbus_bus_center.h"
31
32 using namespace testing::ext;
33 using namespace OHOS::DistributedHardware::DistributedInput;
34 using namespace std;
35 namespace OHOS {
36 namespace DistributedHardware {
37 namespace DistributedInput {
SetUp()38 void DistributedInputSourceInjectTest::SetUp()
39 {
40 }
41
TearDown()42 void DistributedInputSourceInjectTest::TearDown()
43 {
44 }
45
SetUpTestCase()46 void DistributedInputSourceInjectTest::SetUpTestCase()
47 {
48 }
49
TearDownTestCase()50 void DistributedInputSourceInjectTest::TearDownTestCase()
51 {
52 }
53
OnNodeOnLine(const std::string & srcDevId,const std::string & sinkDevId,const std::string & sinkNodeId,const std::string & sinkNodeDesc)54 void DistributedInputSourceInjectTest::TestInputNodeListener::OnNodeOnLine(const std::string &srcDevId,
55 const std::string &sinkDevId, const std::string &sinkNodeId, const std::string &sinkNodeDesc)
56 {
57 (void)srcDevId;
58 (void)sinkDevId;
59 (void)sinkNodeId;
60 (void)sinkNodeDesc;
61 }
62
OnNodeOffLine(const std::string & srcDevId,const std::string & sinkDevId,const std::string & sinkNodeId)63 void DistributedInputSourceInjectTest::TestInputNodeListener::OnNodeOffLine(const std::string &srcDevId,
64 const std::string &sinkDevId, const std::string &sinkNodeId)
65 {
66 (void)srcDevId;
67 (void)sinkDevId;
68 (void)sinkNodeId;
69 }
70
OnResult(const std::string & devId,const uint32_t status)71 void DistributedInputSourceInjectTest::TestRegisterSessionStateCallbackStub::OnResult(const std::string &devId,
72 const uint32_t status)
73 {
74 (void)devId;
75 (void)status;
76 }
77
78 HWTEST_F(DistributedInputSourceInjectTest, RegisterDistributedHardware01, testing::ext::TestSize.Level1)
79 {
80 InputDevice pBuffer;
81 pBuffer.name = "uinput_name_keyboard";
82 pBuffer.bus = 0x03;
83 pBuffer.vendor = 0x1234;
84 pBuffer.product = 0xfedc;
85 pBuffer.version = 1;
86 pBuffer.physicalPath = "usb-hiusb-ehci-2.1/input1";
87 pBuffer.uniqueId = "1";
88 pBuffer.classes = INPUT_DEVICE_CLASS_KEYBOARD;
89 pBuffer.descriptor = "afv4s8b1dr1b8er1bd65fb16redb1dfb18d1b56df1b68d";
90
91 std::string devId = "y4umjym16tgn21m896f1nt2y1894ty61nty651m89t1m";
92 std::string dhId = pBuffer.descriptor;
93 std::string parameters;
94 DistributedInputInject::GetInstance().StructTransJson(pBuffer, parameters);
95 int32_t ret = DistributedInputInject::GetInstance().RegisterDistributedHardware(devId, dhId, parameters);
96 EXPECT_EQ(DH_SUCCESS, ret);
97 }
98
99 HWTEST_F(DistributedInputSourceInjectTest, RegisterDistributedHardware02, testing::ext::TestSize.Level1)
100 {
101 InputDevice pBuffer;
102 pBuffer.name = "uinput_name_mouse";
103 pBuffer.bus = 0x03;
104 pBuffer.vendor = 0x1222;
105 pBuffer.product = 0xfeda;
106 pBuffer.version = 2;
107 pBuffer.physicalPath = "usb-hiusb-ehci-2.1/input1";
108 pBuffer.uniqueId = "2";
109 pBuffer.classes = INPUT_DEVICE_CLASS_CURSOR;
110 pBuffer.descriptor = "rt12r1nr81n521be8rb1erbe1w8bg1erb18";
111
112 std::string devId = "1sdvsd1v5w1v2d1v8d1v562sd11v5sd1";
113 std::string dhId = pBuffer.descriptor;
114 std::string parameters;
115 DistributedInputInject::GetInstance().StructTransJson(pBuffer, parameters);
116 int32_t ret = DistributedInputInject::GetInstance().RegisterDistributedHardware(devId, dhId, parameters);
117 EXPECT_EQ(DH_SUCCESS, ret);
118 }
119
120 HWTEST_F(DistributedInputSourceInjectTest, RegisterDistributedHardware03, testing::ext::TestSize.Level1)
121 {
122 InputDevice pBuffer;
123 pBuffer.name = "uinput_name_touch";
124 pBuffer.bus = 0x03;
125 pBuffer.vendor = 0x1233;
126 pBuffer.product = 0xfedb;
127 pBuffer.version = 3;
128 pBuffer.physicalPath = "usb-hiusb-ehci-2.1/input1";
129 pBuffer.uniqueId = "3";
130 pBuffer.classes = INPUT_DEVICE_CLASS_TOUCH;
131 pBuffer.descriptor = "1ds56v18e1v21v8v1erv15r1v8r1j1ty8";
132
133 std::string devId = "umkyu1b165e1be98151891erbe8r91ev";
134 std::string dhId = pBuffer.descriptor;
135 std::string parameters;
136 DistributedInputInject::GetInstance().StructTransJson(pBuffer, parameters);
137 int32_t ret = DistributedInputInject::GetInstance().RegisterDistributedHardware(devId, dhId, parameters);
138 EXPECT_EQ(DH_SUCCESS, ret);
139 }
140
141 HWTEST_F(DistributedInputSourceInjectTest, UnregisterDistributedHardware_001, testing::ext::TestSize.Level1)
142 {
143 std::string devId = "umkyu1b165e1be98151891erbe8r91ev";
144 std::string dhId = "1ds56v18e1v21v8v1erv15r1v8r1j1ty8";
145 int32_t ret = DistributedInputInject::GetInstance().UnregisterDistributedHardware(devId, dhId);
146 EXPECT_EQ(DH_SUCCESS, ret);
147 }
148
149 HWTEST_F(DistributedInputSourceInjectTest, RegisterDistributedHardware04, testing::ext::TestSize.Level1)
150 {
151 std::string devId = "umkyu1b165e1be98151891erbe8r91ev";
152 std::string dhId = "1ds56v18e1v21v8v1erv15r1v8r1j1ty8";
153 std::string parameters;
154 DistributedInputInject::GetInstance().inputNodeManager_ = nullptr;
155 int32_t ret = DistributedInputInject::GetInstance().RegisterDistributedHardware(devId, dhId, parameters);
156 EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_INJECT_NODE_MANAGER_IS_NULL, ret);
157 }
158
159 HWTEST_F(DistributedInputSourceInjectTest, UnregisterDistributedHardware_002, testing::ext::TestSize.Level1)
160 {
161 std::string devId = "umkyu1b165e1be98151891erbe8r91ev";
162 std::string dhId = "1ds56v18e1v21v8v1erv15r1v8r1j1ty8";
163 DistributedInputInject::GetInstance().inputNodeManager_ = nullptr;
164 int32_t ret = DistributedInputInject::GetInstance().UnregisterDistributedHardware(devId, dhId);
165 EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_INJECT_NODE_MANAGER_IS_NULL, ret);
166 }
167
168 HWTEST_F(DistributedInputSourceInjectTest, RegisterDistributedEvent01, testing::ext::TestSize.Level1)
169 {
170 RawEvent event1 = {
171 .when = 0,
172 .type = EV_KEY,
173 .code = KEY_D,
174 .value = 1,
175 .descriptor = "afv4s8b1dr1b8er1bd65fb16redb1dfb18d1b56df1b68d"
176 };
177 RawEvent event2 = {
178 .when = 1,
179 .type = EV_KEY,
180 .code = KEY_D,
181 .value = 0,
182 .descriptor = "afv4s8b1dr1b8er1bd65fb16redb1dfb18d1b56df1b68d"
183 };
184 RawEvent event3 = {
185 .when = 2,
186 .type = EV_KEY,
187 .code = KEY_D,
188 .value = 1,
189 .descriptor = "afv4s8b1dr1b8er1bd65fb16redb1dfb18d1b56df1b68d"
190 };
191 RawEvent event4 = {
192 .when = 3,
193 .type = EV_KEY,
194 .code = KEY_D,
195 .value = 0,
196 .descriptor = "afv4s8b1dr1b8er1bd65fb16redb1dfb18d1b56df1b68d"
197 };
198 std::vector<RawEvent> writeBuffer = { event1, event2, event3, event4 };
199
200 DistributedInputInject::GetInstance().inputNodeManager_ = std::make_unique<DistributedInputNodeManager>();
201 DistributedInputInject::GetInstance().StartInjectThread();
202 DistributedInputInject::GetInstance().StopInjectThread();
203 std::string deviceId = "aefbg1nr81n521be8rb1erbe1w8bg1erb18";
204 int32_t ret = DistributedInputInject::GetInstance().RegisterDistributedEvent(deviceId, writeBuffer);
205 EXPECT_EQ(DH_SUCCESS, ret);
206 }
207
208 HWTEST_F(DistributedInputSourceInjectTest, RegisterDistributedEvent02, testing::ext::TestSize.Level1)
209 {
210 RawEvent event1 = {
211 .when = 0,
212 .type = EV_REL,
213 .code = REL_X,
214 .value = 2,
215 .descriptor = "rt12r1nr81n521be8rb1erbe1w8bg1erb18"
216 };
217 RawEvent event2 = {
218 .when = 1,
219 .type = EV_REL,
220 .code = REL_Y,
221 .value = 2,
222 .descriptor = "rt12r1nr81n521be8rb1erbe1w8bg1erb18"
223 };
224 RawEvent event3 = {
225 .when = 2,
226 .type = EV_REL,
227 .code = REL_X,
228 .value = 3,
229 .descriptor = "rt12r1nr81n521be8rb1erbe1w8bg1erb18"
230 };
231 RawEvent event4 = {
232 .when = 3,
233 .type = EV_REL,
234 .code = REL_Y,
235 .value = 3,
236 .descriptor = "rt12r1nr81n521be8rb1erbe1w8bg1erb18"
237 };
238 RawEvent event5 = {
239 .when = 4,
240 .type = EV_SYN,
241 .code = SYN_REPORT,
242 .value = 0,
243 .descriptor = "rt12r1nr81n521be8rb1erbe1w8bg1erb18"
244 };
245 std::vector<RawEvent> writeBuffer = { event1, event2, event3, event4, event5 };
246 std::string deviceId = "aefbg1nr81n521be8rb1erbe1w8bg1erb18";
247 int32_t ret = DistributedInputInject::GetInstance().RegisterDistributedEvent(deviceId, writeBuffer);
248 EXPECT_EQ(DH_SUCCESS, ret);
249 }
250
251 HWTEST_F(DistributedInputSourceInjectTest, RegisterDistributedEvent03, testing::ext::TestSize.Level1)
252 {
253 RawEvent event1 = {
254 .when = 0,
255 .type = EV_ABS,
256 .code = ABS_X,
257 .value = 1,
258 .descriptor = "1ds56v18e1v21v8v1erv15r1v8r1j1ty8"
259 };
260 RawEvent event2 = {
261 .when = 1,
262 .type = EV_ABS,
263 .code = ABS_X,
264 .value = 2,
265 .descriptor = "1ds56v18e1v21v8v1erv15r1v8r1j1ty8"
266 };
267 RawEvent event3 = {
268 .when = 2,
269 .type = EV_ABS,
270 .code = ABS_X,
271 .value = 3,
272 .descriptor = "1ds56v18e1v21v8v1erv15r1v8r1j1ty8"
273 };
274 RawEvent event4 = {
275 .when = 3,
276 .type = EV_ABS,
277 .code = ABS_X,
278 .value = 4,
279 .descriptor = "1ds56v18e1v21v8v1erv15r1v8r1j1ty8"
280 };
281 std::vector<RawEvent> writeBuffer = { event1, event2, event3, event4 };
282 std::string deviceId = "aefbg1nr81n521be8rb1erbe1w8bg1erb18";
283 int32_t ret = DistributedInputInject::GetInstance().RegisterDistributedEvent(deviceId, writeBuffer);
284 EXPECT_EQ(DH_SUCCESS, ret);
285 }
286
287 HWTEST_F(DistributedInputSourceInjectTest, RegisterDistributedEvent04, testing::ext::TestSize.Level1)
288 {
289 std::string deviceId = "aefbg1nr81n521be8rb1erbe1w8bg1erb18";
290 std::vector<RawEvent> writeBuffer(4);
291 DistributedInputInject::GetInstance().inputNodeManager_ = nullptr;
292 int32_t ret = DistributedInputInject::GetInstance().RegisterDistributedEvent(deviceId, writeBuffer);
293 EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_INJECT_NODE_MANAGER_IS_NULL, ret);
294 }
295
296 HWTEST_F(DistributedInputSourceInjectTest, GenerateVirtualTouchScreenDHId_001, testing::ext::TestSize.Level1)
297 {
298 std::string ret = DistributedInputInject::GetInstance().GenerateVirtualTouchScreenDHId(1, 1860, 980);
299 EXPECT_NE(0, ret.size());
300 }
301
302 HWTEST_F(DistributedInputSourceInjectTest, CreateVirtualTouchScreenNode_001, testing::ext::TestSize.Level1)
303 {
304 std::string devId = "umkyu1b165e1be98151891erbe8r91ev";
305 std::string dhId = "1ds56v18e1v21v8v1erv15r1v8r1j1ty8";
306 DistributedInputInject::GetInstance().inputNodeManager_ = std::make_unique<DistributedInputNodeManager>();
307 int32_t ret = DistributedInputInject::GetInstance().CreateVirtualTouchScreenNode(devId, dhId, 1, 1860, 980);
308 EXPECT_EQ(DH_SUCCESS, ret);
309 }
310
311 HWTEST_F(DistributedInputSourceInjectTest, GetVirtualTouchScreenFd_001, testing::ext::TestSize.Level1)
312 {
313 int32_t ret = DistributedInputInject::GetInstance().GetVirtualTouchScreenFd();
314 EXPECT_NE(-1, ret);
315 }
316
317 HWTEST_F(DistributedInputSourceInjectTest, RemoveVirtualTouchScreenNode_001, testing::ext::TestSize.Level1)
318 {
319 std::string devId = "umkyu1b165e1be98151891erbe8r91ev";
320 std::string dhId = "1ds56v18e1v21v8v1erv15r1v8r1j1ty8";
321 int32_t ret = DistributedInputInject::GetInstance().RemoveVirtualTouchScreenNode(devId, dhId);
322 EXPECT_EQ(DH_SUCCESS, ret);
323 }
324
325 HWTEST_F(DistributedInputSourceInjectTest, CreateVirtualTouchScreenNode_002, testing::ext::TestSize.Level1)
326 {
327 std::string devId = "umkyu1b165e1be98151891erbe8r91ev";
328 std::string dhId = "1ds56v18e1v21v8v1erv15r1v8r1j1ty8";
329 DistributedInputInject::GetInstance().inputNodeManager_ = nullptr;
330 int32_t ret = DistributedInputInject::GetInstance().CreateVirtualTouchScreenNode(devId, dhId, 1, 1860, 980);
331 EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_INJECT_NODE_MANAGER_IS_NULL, ret);
332 }
333
334 HWTEST_F(DistributedInputSourceInjectTest, RemoveVirtualTouchScreenNode_002, testing::ext::TestSize.Level1)
335 {
336 std::string devId = "umkyu1b165e1be98151891erbe8r91ev";
337 std::string dhId = "1ds56v18e1v21v8v1erv15r1v8r1j1ty8";
338 DistributedInputInject::GetInstance().inputNodeManager_ = nullptr;
339 int32_t ret = DistributedInputInject::GetInstance().RemoveVirtualTouchScreenNode(devId, dhId);
340 EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_INJECT_NODE_MANAGER_IS_NULL, ret);
341 }
342
343 HWTEST_F(DistributedInputSourceInjectTest, GetVirtualTouchScreenFd_002, testing::ext::TestSize.Level1)
344 {
345 DistributedInputInject::GetInstance().inputNodeManager_ = nullptr;
346 int32_t ret = DistributedInputInject::GetInstance().GetVirtualTouchScreenFd();
347 EXPECT_EQ(-1, ret);
348 }
349
350 HWTEST_F(DistributedInputSourceInjectTest, CreateVirtualTouchScreenNode_003, testing::ext::TestSize.Level1)
351 {
352 std::string devId = "umkyu1b165e1be98151891erbe8r91ev";
353 std::string dhId = "1ds56v18e1v21v8v1erv15r1v8r1j1ty8";
354 const uint64_t srcWinId = 1;
355 DistributedInputInject::GetInstance().inputNodeManager_ = std::make_unique<DistributedInputNodeManager>();
356 int32_t ret = DistributedInputInject::GetInstance().inputNodeManager_->
357 CreateVirtualTouchScreenNode(devId, dhId, srcWinId, 1860, 980);
358 EXPECT_EQ(DH_SUCCESS, ret);
359 }
360
361 HWTEST_F(DistributedInputSourceInjectTest, RemoveVirtualTouchScreenNode_003, testing::ext::TestSize.Level1)
362 {
363 std::string devId = "umkyu1b165e1be98151891erbe8r91ev";
364 std::string dhId = "1ds56v18e1v21v8v1erv15r1v8r1j1ty8";
365 int32_t ret = DistributedInputInject::GetInstance().inputNodeManager_->RemoveVirtualTouchScreenNode(devId, dhId);
366 EXPECT_EQ(DH_SUCCESS, ret);
367 }
368
369 HWTEST_F(DistributedInputSourceInjectTest, GetDevice_001, testing::ext::TestSize.Level1)
370 {
371 std::string deviceId = "umkyu1b165e1be98151891erbe8r91ev";
372 std::string dhId = "1ds56v18e1v21v8v1erv15r1v8r1j1ty8";
373 VirtualDevice* device = nullptr;
374 int32_t ret = DistributedInputInject::GetInstance().inputNodeManager_->GetDevice(deviceId, dhId, device);
375 EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_GET_DEVICE_FAIL, ret);
376 }
377
378 HWTEST_F(DistributedInputSourceInjectTest, OpenDevicesNode_001, testing::ext::TestSize.Level1)
379 {
380 std::string devId = "umkyu1b165e1be98151891erbe8r91ev";
381 std::string dhId = "1ds56v18e1v21v8v1erv15r1v8r1j1ty8";
382 std::string parameters = "";
383 int32_t ret = DistributedInputInject::GetInstance().inputNodeManager_->OpenDevicesNode(devId, dhId, parameters);
384 EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_OPEN_DEVICE_NODE_FAIL, ret);
385
386 devId = "";
387 parameters = "parameters_test";
388 ret = DistributedInputInject::GetInstance().inputNodeManager_->OpenDevicesNode(devId, dhId, parameters);
389 EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_OPEN_DEVICE_NODE_FAIL, ret);
390
391 devId = "umkyu1b165e1be98151891erbe8r91ev";
392 dhId = "";
393 ret = DistributedInputInject::GetInstance().inputNodeManager_->OpenDevicesNode(devId, dhId, parameters);
394 EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_OPEN_DEVICE_NODE_FAIL, ret);
395 }
396
397 HWTEST_F(DistributedInputSourceInjectTest, OpenDevicesNode_002, testing::ext::TestSize.Level1)
398 {
399 std::string devId(DEV_ID_LENGTH_MAX + 1, 'a');
400 std::string dhId = "1ds56v18e1v21v8v1erv15r1v8r1j1ty8";
401 std::string parameters = "parameters_test";
402 int32_t ret = DistributedInputInject::GetInstance().inputNodeManager_->OpenDevicesNode(devId, dhId, parameters);
403 EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_OPEN_DEVICE_NODE_FAIL, ret);
404
405 devId = "umkyu1b165e1be98151891erbe8r91ev";
406 std::string dhIds(DH_ID_LENGTH_MAX + 1, 'a');
407 ret = DistributedInputInject::GetInstance().inputNodeManager_->OpenDevicesNode(devId, dhIds, parameters);
408 EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_OPEN_DEVICE_NODE_FAIL, ret);
409
410 std::string dhIdtest = "1ds56v18e1v21v8v1erv15r1v8r1j1ty8";
411 std::string param(STRING_MAX_SIZE + 1, 'a');
412 ret = DistributedInputInject::GetInstance().inputNodeManager_->OpenDevicesNode(devId, dhIdtest, param);
413 EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_OPEN_DEVICE_NODE_FAIL, ret);
414 }
415
416 HWTEST_F(DistributedInputSourceInjectTest, RegisterInjectEventCb_001, testing::ext::TestSize.Level1)
417 {
418 sptr<ISessionStateCallback> callback = nullptr;
419 auto ret = DistributedInputInject::GetInstance().RegisterInjectEventCb(callback);
420 EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_MANAGER_INJECT_EVENT_CB_IS_NULL, ret);
421 }
422
423 HWTEST_F(DistributedInputSourceInjectTest, RegisterInjectEventCb_002, testing::ext::TestSize.Level1)
424 {
425 sptr<TestRegisterSessionStateCallbackStub> callback(new TestRegisterSessionStateCallbackStub());
426 auto ret = DistributedInputInject::GetInstance().RegisterInjectEventCb(callback);
427 EXPECT_EQ(DH_SUCCESS, ret);
428 }
429
430 HWTEST_F(DistributedInputSourceInjectTest, GetVirtualKeyboardPaths_001, testing::ext::TestSize.Level1)
431 {
432 std::string devId;
433 std::vector<std::string> dhIds;
434 std::vector<std::string> virKeyboardPaths;
435 DistributedInputInject::GetInstance().inputNodeManager_ = nullptr;
436 DistributedInputInject::GetInstance().GetVirtualKeyboardPaths(devId, dhIds, virKeyboardPaths);
437
438 std::string dhId;
439 DistributedInputInject::GetInstance().NotifyNodeMgrScanVirNode(devId, dhId);
440
441 DistributedInputInject::GetInstance().inputNodeManager_ = std::make_unique<DistributedInputNodeManager>();
442 DistributedInputInject::GetInstance().NotifyNodeMgrScanVirNode(devId, dhId);
443
444 auto ret = DistributedInputInject::GetInstance().UnregisterInjectEventCb();
445 EXPECT_EQ(DH_SUCCESS, ret);
446 }
447
448 HWTEST_F(DistributedInputSourceInjectTest, MatchAndSavePhysicalPath_001, testing::ext::TestSize.Level1)
449 {
450 std::string devicePath = "";
451 std::string devId = "";
452 std::string dhId = "";
453 auto ret =
454 DistributedInputInject::GetInstance().inputNodeManager_->MatchAndSavePhysicalPath(devicePath, devId, dhId);
455 EXPECT_EQ(false, ret);
456
457 DistributedInputInject::GetInstance().inputNodeManager_->isInjectThreadCreated_.store(true);
458 DistributedInputInject::GetInstance().inputNodeManager_->StartInjectThread();
459 DistributedInputInject::GetInstance().inputNodeManager_->isInjectThreadCreated_.store(false);
460 DistributedInputInject::GetInstance().inputNodeManager_->StopInjectThread();
461 }
462 } // namespace DistributedInput
463 } // namespace DistributedHardware
464 } // namespace OHOS
465