1 /*
2 * Copyright (c) 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 <future>
17 #include <optional>
18 #include <utility>
19 #include <vector>
20
21 #include <unistd.h>
22
23 #include "accesstoken_kit.h"
24 #include "display_manager.h"
25 #include "display_info.h"
26 #include <gtest/gtest.h>
27 #include "input_device.h"
28 #include "input_manager.h"
29 #include "parcel.h"
30 #include "pointer_event.h"
31 #include "securec.h"
32
33 #include "coordination_message.h"
34 #include "devicestatus_define.h"
35 #include "devicestatus_errors.h"
36 #include "drag_data_util.h"
37 #include "interaction_manager.h"
38 #include "interaction_manager_test.h"
39 #include "nativetoken_kit.h"
40 #include "token_setproc.h"
41
42 #undef LOG_TAG
43 #define LOG_TAG "InteractionManagerTest"
44
45 namespace OHOS {
46 namespace Msdp {
47 namespace DeviceStatus {
48 using namespace testing::ext;
49 namespace {
50 constexpr int32_t TIME_WAIT_FOR_OP_MS { 20 };
51 constexpr int32_t TIME_WAIT_FOR_INJECT_MS { 80 };
52 constexpr int32_t TIME_WAIT_FOR_TOUCH_DOWN_MS { 1000 };
53 constexpr int32_t PROMISE_WAIT_SPAN_MS { 2000 };
54 constexpr int32_t TEST_PIXEL_MAP_WIDTH { 200 };
55 constexpr int32_t TEST_PIXEL_MAP_HEIGHT { 200 };
56 constexpr int32_t MAX_PIXEL_MAP_WIDTH { 600 };
57 constexpr int32_t MAX_PIXEL_MAP_HEIGHT { 600 };
58 constexpr int32_t MOUSE_POINTER_ID { 0 };
59 constexpr int32_t TOUCH_POINTER_ID { 1 };
60 constexpr int32_t MOUSE_POINTER_ID_INJECT { 10000 };
61 constexpr int32_t TOUCH_POINTER_ID_INJECT { 20001 };
62 constexpr int32_t DISPLAY_ID { 0 };
63 constexpr int32_t DRAG_SRC_X { 0 };
64 constexpr int32_t DRAG_SRC_Y { 0 };
65 constexpr int32_t DRAG_DST_X { 500 };
66 constexpr int32_t DRAG_DST_Y { 500 };
67 constexpr int32_t DRAG_NUM { 1 };
68 constexpr int32_t INT32_BYTE { 4 };
69 constexpr int32_t SUBSTR_UDKEY_LEN { 6 };
70 constexpr int32_t WINDOW_ID { -1 };
71 constexpr int32_t HOT_AREA_COOR { 220 };
72 constexpr int32_t HOT_AREA_STEP { 150 };
73 constexpr int32_t HOT_AREA_SPAN { 70 };
74 constexpr uint32_t RECIVE_LOOP_COUNT { 5 };
75 constexpr uint32_t DEFAULT_ICON_COLOR { 0xFF };
76 constexpr bool HAS_CANCELED_ANIMATION { true };
77 constexpr bool HAS_CUSTOM_ANIMATION { true };
78 constexpr int32_t MOVE_STEP { 10 };
79 constexpr int32_t FOREGROUND_COLOR_IN { 0x33FF0000 };
80 constexpr int32_t FOREGROUND_COLOR_OUT { 0x00000000 };
81 constexpr int32_t ANIMATION_DURATION { 500 };
82 constexpr int32_t SRC_MAIN_WINDOW { 0 };
83 constexpr int32_t TARGET_MAIN_WINDOW { 0 };
84 constexpr int64_t DOWN_TIME { 1 };
85 const std::string UD_KEY { "Unified data key" };
86 const std::string SYSTEM_CORE { "system_core" };
87 const std::string SYSTEM_BASIC { "system_basic" };
88 const std::string CURVE_NAME { "cubic-bezier" };
89 const std::string EXTRA_INFO { "{ \"drag_corner_radius\": 20, \"drag_allow_distributed\": false }" };
90 const std::string FILTER_INFO { "{ \"dip_scale\": 3.5 }" };
91 int32_t g_deviceMouseId { -1 };
92 int32_t g_deviceTouchId { -1 };
93 int32_t g_screenWidth { 720 };
94 int32_t g_screenHeight { 1280 };
95 const std::string INPUT = { "ohos.permission.INPUT_MONITORING" };
96 const std::string COOPERATE = { "ohos.permission.COOPERATE_MANAGER" };
97 const std::string INJECT = { "ohos.permission.INJECT_INPUT_EVENT" };
98 std::shared_ptr<MMI::KeyEvent> g_keyEvent = MMI::KeyEvent::Create();
99 std::mutex g_lockSetToken;
100 uint64_t g_shellTokenId = 0;
101 static constexpr int32_t DEFAULT_API_VERSION = 12;
102 static MockHapToken* g_mock = nullptr;
103 } // namespace
104
SetTestEvironment(uint64_t shellTokenId)105 void SetTestEvironment(uint64_t shellTokenId)
106 {
107 std::lock_guard<std::mutex> lock(g_lockSetToken);
108 g_shellTokenId = shellTokenId;
109 }
110
ResetTestEvironment()111 void ResetTestEvironment()
112 {
113 std::lock_guard<std::mutex> lock(g_lockSetToken);
114 g_shellTokenId = 0;
115 }
116
GetShellTokenId()117 uint64_t GetShellTokenId()
118 {
119 std::lock_guard<std::mutex> lock(g_lockSetToken);
120 return g_shellTokenId;
121 }
122
GetNativeTokenIdFromProcess(const std::string & process)123 uint64_t GetNativeTokenIdFromProcess(const std::string &process)
124 {
125 uint64_t selfTokenId = GetSelfTokenID();
126 EXPECT_EQ(0, SetSelfTokenID(GetShellTokenId()));
127
128 std::string dumpInfo;
129 Security::AccessToken::AtmToolsParamInfo info;
130 info.processName = process;
131 Security::AccessToken::AccessTokenKit::DumpTokenInfo(info, dumpInfo);
132 size_t pos = dumpInfo.find("\"tokenID\": ");
133 if (pos == std::string::npos) {
134 FI_HILOGE("tokenid not find");
135 return 0;
136 }
137 pos += std::string("\"tokenID\": ").length();
138 std::string numStr;
139 while (pos < dumpInfo.length() && std::isdigit(dumpInfo[pos])) {
140 numStr += dumpInfo[pos];
141 ++pos;
142 }
143 EXPECT_EQ(0, SetSelfTokenID(selfTokenId));
144
145 std::istringstream iss(numStr);
146 Security::AccessToken::AccessTokenID tokenID;
147 iss >> tokenID;
148 return tokenID;
149 }
150
AllocTestHapToken(const Security::AccessToken::HapInfoParams & hapInfo,Security::AccessToken::HapPolicyParams & hapPolicy,Security::AccessToken::AccessTokenIDEx & tokenIdEx)151 int32_t AllocTestHapToken(const Security::AccessToken::HapInfoParams& hapInfo,
152 Security::AccessToken::HapPolicyParams& hapPolicy, Security::AccessToken::AccessTokenIDEx& tokenIdEx)
153 {
154 uint64_t selfTokenId = GetSelfTokenID();
155 for (auto& permissionStateFull : hapPolicy.permStateList) {
156 Security::AccessToken::PermissionDef permDefResult;
157 if (Security::AccessToken::AccessTokenKit::GetDefPermission(permissionStateFull.permissionName, permDefResult)
158 != Security::AccessToken::RET_SUCCESS) {
159 continue;
160 }
161 if (permDefResult.availableLevel > hapPolicy.apl) {
162 hapPolicy.aclRequestedList.emplace_back(permissionStateFull.permissionName);
163 }
164 }
165 if (GetNativeTokenIdFromProcess("foundation") == selfTokenId) {
166 return Security::AccessToken::AccessTokenKit::InitHapToken(hapInfo, hapPolicy, tokenIdEx);
167 }
168 MockNativeToken mock("foundation");
169 int32_t ret = Security::AccessToken::AccessTokenKit::InitHapToken(hapInfo, hapPolicy, tokenIdEx);
170 EXPECT_EQ(0, SetSelfTokenID(selfTokenId));
171
172 return ret;
173 }
174
DeleteTestHapToken(Security::AccessToken::AccessTokenID tokenID)175 int32_t DeleteTestHapToken(Security::AccessToken::AccessTokenID tokenID)
176 {
177 uint64_t selfTokenId = GetSelfTokenID();
178 if (GetNativeTokenIdFromProcess("foundation") == selfTokenId) {
179 return Security::AccessToken::AccessTokenKit::DeleteToken(tokenID);
180 }
181 MockNativeToken mock("foundation");
182 int32_t ret = Security::AccessToken::AccessTokenKit::DeleteToken(tokenID);
183 EXPECT_EQ(0, SetSelfTokenID(selfTokenId));
184 return ret;
185 }
186
MockNativeToken(const std::string & process)187 MockNativeToken::MockNativeToken(const std::string& process)
188 {
189 selfToken_ = GetSelfTokenID();
190 uint32_t tokenId = GetNativeTokenIdFromProcess(process);
191 FI_HILOGI("selfToken_:%{public}" PRId64 ", tokenId:%{public}u", selfToken_, tokenId);
192 SetSelfTokenID(tokenId);
193 }
194
~MockNativeToken()195 MockNativeToken::~MockNativeToken()
196 {
197 SetSelfTokenID(selfToken_);
198 }
199
MockHapToken(const std::string & bundle,const std::vector<std::string> & reqPerm,bool isSystemApp)200 MockHapToken::MockHapToken(
201 const std::string& bundle, const std::vector<std::string>& reqPerm, bool isSystemApp)
202 {
203 selfToken_ = GetSelfTokenID();
204 Security::AccessToken::HapInfoParams infoParams = {
205 .userID = 0,
206 .bundleName = bundle,
207 .instIndex = 0,
208 .appIDDesc = "AccessTokenTestAppID",
209 .apiVersion = DEFAULT_API_VERSION,
210 .isSystemApp = isSystemApp,
211 .appDistributionType = "",
212 };
213
214 Security::AccessToken::HapPolicyParams policyParams = {
215 .apl = Security::AccessToken::APL_NORMAL,
216 .domain = "accesstoken_test_domain",
217 };
218 for (size_t i = 0; i < reqPerm.size(); ++i) {
219 Security::AccessToken::PermissionDef permDefResult;
220 if (Security::AccessToken::AccessTokenKit::GetDefPermission(reqPerm[i], permDefResult)
221 != Security::AccessToken::RET_SUCCESS) {
222 continue;
223 }
224 Security::AccessToken::PermissionStateFull permState = {
225 .permissionName = reqPerm[i],
226 .isGeneral = true,
227 .resDeviceID = {"local3"},
228 .grantStatus = {Security::AccessToken::PermissionState::PERMISSION_DENIED},
229 .grantFlags = {Security::AccessToken::PermissionFlag::PERMISSION_DEFAULT_FLAG}
230 };
231 policyParams.permStateList.emplace_back(permState);
232 if (permDefResult.availableLevel > policyParams.apl) {
233 policyParams.aclRequestedList.emplace_back(reqPerm[i]);
234 }
235 }
236
237 Security::AccessToken::AccessTokenIDEx tokenIdEx = {0};
238 EXPECT_EQ(Security::AccessToken::RET_SUCCESS, AllocTestHapToken(infoParams, policyParams, tokenIdEx));
239 mockToken_= tokenIdEx.tokenIdExStruct.tokenID;
240 EXPECT_NE(mockToken_, Security::AccessToken::INVALID_TOKENID);
241 EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx));
242 }
243
~MockHapToken()244 MockHapToken::~MockHapToken()
245 {
246 if (mockToken_ != Security::AccessToken::INVALID_TOKENID) {
247 EXPECT_EQ(0, DeleteTestHapToken(mockToken_));
248 }
249 EXPECT_EQ(0, SetSelfTokenID(selfToken_));
250 }
251
252 class DragListenerTest : public IDragListener {
253 public:
DragListenerTest()254 DragListenerTest() {}
DragListenerTest(const std::string & name)255 explicit DragListenerTest(const std::string& name) : moduleName_(name) {}
OnDragMessage(DragState state)256 void OnDragMessage(DragState state) override
257 {
258 if (moduleName_.empty()) {
259 moduleName_ = std::string("DragListenerTest");
260 }
261 FI_HILOGD("%{public}s, state:%{public}s", moduleName_.c_str(), PrintDragMessage(state).c_str());
262 }
263 private:
PrintDragMessage(DragState state)264 std::string PrintDragMessage(DragState state)
265 {
266 std::string type = "unknow";
267 const std::map<DragState, std::string> stateType = {
268 { DragState::ERROR, "error"},
269 { DragState::START, "start"},
270 { DragState::STOP, "stop"},
271 { DragState::CANCEL, "cancel"}
272 };
273 auto item = stateType.find(state);
274 if (item != stateType.end()) {
275 type = item->second;
276 }
277 return type;
278 }
279 private:
280 std::string moduleName_;
281 };
282
283 class SubscriptListenerTest : public ISubscriptListener {
284 public:
SubscriptListenerTest()285 SubscriptListenerTest() {}
SubscriptListenerTest(const std::string & name)286 explicit SubscriptListenerTest(const std::string& name) : moduleName_(name) {}
OnMessage(DragCursorStyle style)287 void OnMessage(DragCursorStyle style) override
288 {
289 SetDragSyle(style);
290 if (moduleName_.empty()) {
291 moduleName_ = std::string("SubscriptListenerTest");
292 }
293 FI_HILOGD("Received notification event for subscriptListener, %{public}s, state:%{public}s",
294 moduleName_.c_str(), PrintStyleMessage(style).c_str());
295 }
296
GetDragStyle()297 DragCursorStyle GetDragStyle()
298 {
299 return dragStyle_;
300 }
301
302 private:
SetDragSyle(DragCursorStyle style)303 void SetDragSyle(DragCursorStyle style)
304 {
305 dragStyle_ = style;
306 }
307
PrintStyleMessage(DragCursorStyle style)308 std::string PrintStyleMessage(DragCursorStyle style)
309 {
310 std::string type = "unknow";
311 const std::map<DragCursorStyle, std::string> cursorStyles = {
312 { DragCursorStyle::DEFAULT, "default"},
313 { DragCursorStyle::FORBIDDEN, "forbidden"},
314 { DragCursorStyle::COPY, "copy"},
315 { DragCursorStyle::MOVE, "move"}
316 };
317 auto item = cursorStyles.find(style);
318 if (item != cursorStyles.end()) {
319 type = item->second;
320 }
321 return type;
322 }
323
324 private:
325 DragCursorStyle dragStyle_ { DragCursorStyle::DEFAULT };
326 std::string moduleName_;
327 };
328
329 class UnitTestStartDragListener : public IStartDragListener {
330 public:
UnitTestStartDragListener(std::function<void (const DragNotifyMsg &)> function)331 explicit UnitTestStartDragListener(std::function<void(const DragNotifyMsg&)> function) : function_(function) { }
OnDragEndMessage(const DragNotifyMsg & msg)332 void OnDragEndMessage(const DragNotifyMsg &msg) override
333 {
334 FI_HILOGD("DisplayX:%{public}d, displayY:%{public}d, targetPid:%{public}d, result:%{public}d",
335 msg.displayX, msg.displayY, msg.targetPid, static_cast<int32_t>(msg.result));
336 if (function_ != nullptr) {
337 function_(msg);
338 }
339 FI_HILOGD("Unit test OnDragEndMessage");
340 }
341
OnHideIconMessage()342 void OnHideIconMessage() override
343 {
344 FI_HILOGI("Unit test OnHideIconMessage");
345 }
346 private:
347 std::function<void(const DragNotifyMsg&)> function_;
348 };
349
GetInputDeviceIds()350 std::vector<int32_t> InteractionManagerTest::GetInputDeviceIds()
351 {
352 std::vector<int32_t> realDeviceIds;
353 auto callback = [&realDeviceIds](std::vector<int32_t>& deviceIds) {
354 realDeviceIds = deviceIds;
355 };
356 int32_t ret = MMI::InputManager::GetInstance()->GetDeviceIds(callback);
357 if (ret != RET_OK) {
358 FI_HILOGE("Get device ids failed");
359 return {};
360 }
361 return realDeviceIds;
362 }
363
GetDevice(int32_t deviceId)364 std::shared_ptr<MMI::InputDevice> InteractionManagerTest::GetDevice(int32_t deviceId)
365 {
366 std::shared_ptr<MMI::InputDevice> inputDevice;
367 auto callback = [&inputDevice](std::shared_ptr<MMI::InputDevice> device) {
368 inputDevice = device;
369 };
370 int32_t ret = MMI::InputManager::GetInstance()->GetDevice(deviceId, callback);
371 if (ret != RET_OK || inputDevice == nullptr) {
372 FI_HILOGE("Get device failed");
373 return nullptr;
374 }
375 return inputDevice;
376 }
377
GetMouseAndTouch()378 std::pair<int32_t, int32_t> InteractionManagerTest::GetMouseAndTouch()
379 {
380 std::vector<int32_t> deviceIds = GetInputDeviceIds();
381 std::pair<int32_t, int32_t> mouseAndTouch { -1, -1 };
382 for (const auto& id : deviceIds) {
383 std::shared_ptr<MMI::InputDevice> device = GetDevice(id);
384 CHKPC(device);
385 if (device->HasCapability(MMI::InputDeviceCapability::INPUT_DEV_CAP_POINTER)) {
386 mouseAndTouch.first = device->GetId();
387 }
388 if (device->HasCapability(MMI::InputDeviceCapability::INPUT_DEV_CAP_TOUCH)) {
389 mouseAndTouch.second = device->GetId();
390 }
391 }
392 return mouseAndTouch;
393 }
394
SetUpTestCase()395 void InteractionManagerTest::SetUpTestCase()
396 {
397 auto mouseAndTouch = GetMouseAndTouch();
398 g_deviceMouseId = mouseAndTouch.first;
399 g_deviceTouchId = mouseAndTouch.second;
400 std::vector<std::string> reqPerm;
401 reqPerm.emplace_back(INPUT);
402 reqPerm.emplace_back(COOPERATE);
403 reqPerm.emplace_back(INJECT);
404 g_mock = new (std::nothrow) MockHapToken("InteractionManagerTest", reqPerm, true);
405 FI_HILOGI("SetUpTestCase ok.");
406 }
407
SetUp()408 void InteractionManagerTest::SetUp()
409 {
410 EnableCooperate();
411 }
412
TearDown()413 void InteractionManagerTest::TearDown()
414 {
415 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
416 }
417
EnableCooperate()418 void InteractionManagerTest::EnableCooperate()
419 {
420 std::promise<bool> promiseFlag;
421 std::future<bool> futureFlag = promiseFlag.get_future();
422 auto fun = [&promiseFlag](const std::string &listener, const CoordinationMsgInfo &coordinationMessages) {
423 FI_HILOGD("Prepare coordination success, listener:%{public}s", listener.c_str());
424 promiseFlag.set_value(true);
425 };
426 bool isCompatible = true;
427 int32_t ret = InteractionManager::GetInstance()->PrepareCoordination(fun, isCompatible);
428 #ifdef OHOS_BUILD_ENABLE_COORDINATION
429 if (ret == RET_OK) {
430 FI_HILOGI("PrepareCoordination successfully");
431 } else {
432 FI_HILOGE("PrepareCoordination failed");
433 }
434 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
435 #else
436 ASSERT_EQ(ret, ERROR_UNSUPPORT);
437 #endif // OHOS_BUILD_ENABLE_COORDINATION
438 }
439
CreatePixelMap(int32_t width,int32_t height)440 std::shared_ptr<Media::PixelMap> InteractionManagerTest::CreatePixelMap(int32_t width, int32_t height)
441 {
442 CALL_DEBUG_ENTER;
443 OHOS::Media::InitializationOptions opts;
444 opts.size.width = width;
445 opts.size.height = height;
446 opts.pixelFormat = Media::PixelFormat::BGRA_8888;
447 opts.alphaType = Media::AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
448 opts.scaleMode = Media::ScaleMode::FIT_TARGET_SIZE;
449
450 int32_t colorLen = width * height;
451 uint32_t* colors = new (std::nothrow) uint32_t[colorLen];
452 CHKPP(colors);
453 int32_t colorByteCount = colorLen * INT32_BYTE;
454 if (memset_s(colors, colorByteCount, DEFAULT_ICON_COLOR, colorByteCount) != EOK) {
455 delete[] colors;
456 FI_HILOGE("memset_s failed");
457 return nullptr;
458 }
459 std::shared_ptr<Media::PixelMap> pixelMap = Media::PixelMap::Create(colors, colorLen, opts);
460 if (pixelMap == nullptr) {
461 delete[] colors;
462 FI_HILOGE("Create pixelMap failed");
463 return nullptr;
464 }
465 delete[] colors;
466 return pixelMap;
467 }
468
CreateDragData(const std::pair<int32_t,int32_t> & pixelMapSize,int32_t sourceType,int32_t pointerId,int32_t displayId,const std::pair<int32_t,int32_t> & location)469 std::optional<DragData> InteractionManagerTest::CreateDragData(const std::pair<int32_t, int32_t> &pixelMapSize,
470 int32_t sourceType, int32_t pointerId, int32_t displayId, const std::pair<int32_t, int32_t> &location)
471 {
472 CALL_DEBUG_ENTER;
473 std::shared_ptr<Media::PixelMap> pixelMap = CreatePixelMap(pixelMapSize.first, pixelMapSize.second);
474 if (pixelMap == nullptr) {
475 FI_HILOGE("Create pixelmap failed");
476 return std::nullopt;
477 }
478 ShadowInfo shadowInfo { pixelMap, 0, 0 };
479 DragData dragData;
480 dragData.shadowInfos.push_back(shadowInfo);
481 dragData.buffer = std::vector<uint8_t>(MAX_BUFFER_SIZE, 0);
482 dragData.udKey = UD_KEY;
483 dragData.sourceType = sourceType;
484 dragData.pointerId = pointerId;
485 dragData.dragNum = DRAG_NUM;
486 dragData.displayX = location.first;
487 dragData.displayY = location.second;
488 dragData.displayId = displayId;
489 dragData.hasCanceledAnimation = HAS_CANCELED_ANIMATION;
490 dragData.extraInfo = EXTRA_INFO;
491 dragData.filterInfo = FILTER_INFO;
492 dragData.mainWindow = SRC_MAIN_WINDOW;
493 return dragData;
494 }
495
CreatePointerItem(int32_t pointerId,int32_t deviceId,const std::pair<int32_t,int32_t> & displayLocation,bool isPressed)496 MMI::PointerEvent::PointerItem InteractionManagerTest::CreatePointerItem(int32_t pointerId, int32_t deviceId,
497 const std::pair<int32_t, int32_t> &displayLocation, bool isPressed)
498 {
499 MMI::PointerEvent::PointerItem item;
500 item.SetPointerId(pointerId);
501 item.SetDeviceId(deviceId);
502 item.SetDisplayX(displayLocation.first);
503 item.SetDisplayY(displayLocation.second);
504 item.SetPressed(isPressed);
505 return item;
506 }
507
SetupPointerEvent(const std::pair<int32_t,int32_t> & displayLocation,int32_t action,int32_t sourceType,int32_t pointerId,bool isPressed)508 std::shared_ptr<MMI::PointerEvent> InteractionManagerTest::SetupPointerEvent(const std::pair<int32_t, int32_t>
509 &displayLocation, int32_t action, int32_t sourceType, int32_t pointerId, bool isPressed)
510 {
511 CALL_DEBUG_ENTER;
512 auto pointerEvent = MMI::PointerEvent::Create();
513 CHKPP(pointerEvent);
514 pointerEvent->SetPointerAction(action);
515 pointerEvent->SetSourceType(sourceType);
516 pointerEvent->SetPointerId(pointerId);
517 MMI::PointerEvent::PointerItem curPointerItem;
518 if (sourceType == MMI::PointerEvent::SOURCE_TYPE_MOUSE) {
519 curPointerItem = CreatePointerItem(pointerId, g_deviceMouseId, displayLocation, isPressed);
520 } else if (sourceType == MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN) {
521 curPointerItem = CreatePointerItem(pointerId, g_deviceTouchId, displayLocation, isPressed);
522 } else {
523 FI_HILOGE("Unknow sourceType:%{public}d", sourceType);
524 return nullptr;
525 }
526 pointerEvent->AddPointerItem(curPointerItem);
527 return pointerEvent;
528 }
529
SimulateDownPointerEvent(const std::pair<int32_t,int32_t> & location,int32_t sourceType,int32_t pointerId)530 void InteractionManagerTest::SimulateDownPointerEvent(const std::pair<int32_t, int32_t> &location, int32_t sourceType,
531 int32_t pointerId)
532 {
533 CALL_DEBUG_ENTER;
534 std::shared_ptr<MMI::PointerEvent> pointerEvent =
535 SetupPointerEvent(location, MMI::PointerEvent::POINTER_ACTION_DOWN, sourceType, pointerId, true);
536 CHKPV(pointerEvent);
537 FI_HILOGD("TEST:sourceType:%{public}d, pointerId:%{public}d, pointerAction:%{public}d",
538 pointerEvent->GetSourceType(), pointerEvent->GetPointerId(), pointerEvent->GetPointerAction());
539 MMI::InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
540 }
541
SimulateUpPointerEvent(const std::pair<int32_t,int32_t> & location,int32_t sourceType,int32_t pointerId)542 void InteractionManagerTest::SimulateUpPointerEvent(const std::pair<int32_t, int32_t> &location, int32_t sourceType,
543 int32_t pointerId)
544 {
545 CALL_DEBUG_ENTER;
546 std::shared_ptr<MMI::PointerEvent> pointerEvent = SetupPointerEvent(location,
547 MMI::PointerEvent::POINTER_ACTION_UP, sourceType, pointerId, false);
548 CHKPV(pointerEvent);
549 FI_HILOGD("TEST:sourceType:%{public}d, pointerId:%{public}d, pointerAction:%{public}d",
550 pointerEvent->GetSourceType(), pointerEvent->GetPointerId(), pointerEvent->GetPointerAction());
551 MMI::InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
552 }
553
SimulateMovePointerEvent(const std::pair<int32_t,int32_t> & srcLocation,const std::pair<int32_t,int32_t> & dstLocation,int32_t sourceType,int32_t pointerId,bool isPressed)554 void InteractionManagerTest::SimulateMovePointerEvent(const std::pair<int32_t, int32_t> &srcLocation,
555 const std::pair<int32_t, int32_t> &dstLocation, int32_t sourceType, int32_t pointerId, bool isPressed)
556 {
557 CALL_DEBUG_ENTER;
558 int32_t srcX = srcLocation.first;
559 int32_t srcY = srcLocation.second;
560 int32_t dstX = dstLocation.first;
561 int32_t dstY = dstLocation.second;
562 std::vector<std::pair<int32_t, int32_t>> coordinates;
563 if (dstX == srcX) {
564 for (int32_t y = srcY; y <= dstY; y += MOVE_STEP) {
565 coordinates.push_back({srcX, y});
566 }
567 for (int32_t y = srcY; y > dstY; y -= MOVE_STEP) {
568 coordinates.push_back({srcX, y});
569 }
570 } else {
571 double ratio = (dstY - srcY) * 1.0 / (dstX - srcX);
572 for (int32_t x = srcX; x < dstX; x += MOVE_STEP) {
573 coordinates.push_back({x, srcY + static_cast<int32_t>(ratio * (x - srcX))});
574 }
575 for (int32_t x = srcX; x >= dstX; x -= MOVE_STEP) {
576 coordinates.push_back({x, srcY + static_cast<int32_t>(ratio * (x - srcX))});
577 }
578 coordinates.push_back({dstX, dstY});
579 }
580 for (const auto& pointer : coordinates) {
581 std::shared_ptr<MMI::PointerEvent> pointerEvent =
582 SetupPointerEvent(pointer, MMI::PointerEvent::POINTER_ACTION_MOVE, sourceType, pointerId, isPressed);
583 CHKPC(pointerEvent);
584 FI_HILOGD("TEST:sourceType:%{public}d, pointerId:%{public}d, pointerAction:%{public}d",
585 pointerEvent->GetSourceType(), pointerEvent->GetPointerId(), pointerEvent->GetPointerAction());
586 MMI::InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
587 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_INJECT_MS));
588 }
589 }
590
TestAddMonitor(std::shared_ptr<MMI::IInputEventConsumer> consumer)591 int32_t InteractionManagerTest::TestAddMonitor(std::shared_ptr<MMI::IInputEventConsumer> consumer)
592 {
593 CHKPR(consumer, RET_ERR);
594 return MMI::InputManager::GetInstance()->AddMonitor(consumer);
595 }
596
TestRemoveMonitor(int32_t monitorId)597 void InteractionManagerTest::TestRemoveMonitor(int32_t monitorId)
598 {
599 MMI::InputManager::GetInstance()->RemoveMonitor(monitorId);
600 }
601
PrintDragData(const DragData & dragData)602 void InteractionManagerTest::PrintDragData(const DragData &dragData)
603 {
604 CALL_DEBUG_ENTER;
605 for (const auto &shadowInfo : dragData.shadowInfos) {
606 CHKPV(shadowInfo.pixelMap);
607 FI_HILOGD("PixelFormat:%{public}d, PixelAlphaType:%{public}d, PixelAllocatorType:%{public}d,"
608 " PixelWidth:%{public}d, PixelHeight:%{public}d, shadowX:%{public}d, shadowY:%{public}d",
609 static_cast<int32_t>(shadowInfo.pixelMap->GetPixelFormat()),
610 static_cast<int32_t>(shadowInfo.pixelMap->GetAlphaType()),
611 static_cast<int32_t>(shadowInfo.pixelMap->GetAllocatorType()),
612 shadowInfo.pixelMap->GetWidth(), shadowInfo.pixelMap->GetHeight(), shadowInfo.x, shadowInfo.y);
613 }
614 FI_HILOGD("SourceType:%{public}d, pointerId:%{public}d, displayId:%{public}d, displayX:%{public}d,"
615 " displayY:%{public}d, dragNum:%{public}d, hasCanceledAnimation:%{public}d, udKey:%{public}s",
616 dragData.sourceType, dragData.pointerId, dragData.displayId, dragData.displayX, dragData.displayY,
617 dragData.dragNum, dragData.hasCanceledAnimation, dragData.udKey.substr(0, SUBSTR_UDKEY_LEN).c_str());
618 }
619
SetupKeyEvent(int32_t action,int32_t key,bool isPressed)620 void InteractionManagerTest::SetupKeyEvent(
621 int32_t action, int32_t key, bool isPressed)
622 {
623 CALL_DEBUG_ENTER;
624 CHKPV(g_keyEvent);
625 MMI::KeyEvent::KeyItem keyItem;
626 keyItem.SetKeyCode(key);
627 keyItem.SetDeviceId(1);
628 keyItem.SetDownTime(DOWN_TIME);
629 g_keyEvent->SetKeyAction(action);
630 g_keyEvent->SetKeyCode(key);
631 if (action == MMI::KeyEvent::KEY_ACTION_DOWN) {
632 keyItem.SetPressed(isPressed);
633 } else if (action == MMI::KeyEvent::KEY_ACTION_UP) {
634 g_keyEvent->RemoveReleasedKeyItems(keyItem);
635 }
636 g_keyEvent->AddPressedKeyItems(keyItem);
637 }
638
ClearUpKeyEvent()639 void InteractionManagerTest::ClearUpKeyEvent()
640 {
641 CALL_DEBUG_ENTER;
642 CHKPV(g_keyEvent);
643 for (const auto& iter : g_keyEvent->GetKeyItems()) {
644 if (!iter.IsPressed()) {
645 FI_HILOGD("TEST:Clean keyItem, keyCode:%{public}d", iter.GetKeyCode());
646 g_keyEvent->RemoveReleasedKeyItems(iter);
647 return;
648 }
649 }
650 }
651
SimulateDownKeyEvent(int32_t key)652 void InteractionManagerTest::SimulateDownKeyEvent(int32_t key)
653 {
654 CALL_DEBUG_ENTER;
655 SetupKeyEvent(MMI::KeyEvent::KEY_ACTION_DOWN, key, true);
656 FI_HILOGD("TEST:keyCode:%{public}d, keyAction: KEY_ACTION_DOWN", key);
657 MMI::InputManager::GetInstance()->SimulateInputEvent(g_keyEvent);
658 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_INJECT_MS));
659 }
660
SimulateUpKeyEvent(int32_t key)661 void InteractionManagerTest::SimulateUpKeyEvent(int32_t key)
662 {
663 CALL_DEBUG_ENTER;
664 SetupKeyEvent(MMI::KeyEvent::KEY_ACTION_UP, key, false);
665 FI_HILOGD("TEST:keyCode:%{public}d, keyAction: KEY_ACTION_UP", key);
666 MMI::InputManager::GetInstance()->SimulateInputEvent(g_keyEvent);
667 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_INJECT_MS));
668 }
669
PrintDragAction(DragAction dragAction)670 void InteractionManagerTest::PrintDragAction(DragAction dragAction)
671 {
672 switch (dragAction) {
673 case DragAction::MOVE:{
674 FI_HILOGD("drag action: MOVE");
675 break;
676 }
677 case DragAction::COPY:{
678 FI_HILOGD("drag action: COPY");
679 break;
680 }
681 default:{
682 FI_HILOGD("drag action: UNKNOWN");
683 break;
684 }
685 }
686 }
687
AssignToAnimation(PreviewAnimation & animation)688 void InteractionManagerTest::AssignToAnimation(PreviewAnimation &animation)
689 {
690 animation.duration = ANIMATION_DURATION;
691 animation.curveName = CURVE_NAME;
692 animation.curve = { 0.33, 0, 0.67, 1 };
693 }
694
695 class InputEventCallbackTest : public MMI::IInputEventConsumer {
696 public:
InputEventCallbackTest()697 InputEventCallbackTest() {}
InputEventCallbackTest(std::function<void ()> callback)698 explicit InputEventCallbackTest(std::function<void()> callback) : callback_(callback) {}
OnInputEvent(std::shared_ptr<MMI::KeyEvent> keyEvent) const699 void OnInputEvent(std::shared_ptr<MMI::KeyEvent> keyEvent) const override {};
700 void OnInputEvent(std::shared_ptr<MMI::PointerEvent> pointerEvent) const override;
OnInputEvent(std::shared_ptr<MMI::AxisEvent> axisEvent) const701 void OnInputEvent(std::shared_ptr<MMI::AxisEvent> axisEvent) const override {};
702 private:
703 std::function<void()> callback_ { nullptr };
704 };
705
OnInputEvent(std::shared_ptr<MMI::PointerEvent> pointerEvent) const706 void InputEventCallbackTest::OnInputEvent(std::shared_ptr<MMI::PointerEvent> pointerEvent) const
707 {
708 CALL_DEBUG_ENTER;
709 ASSERT_TRUE(pointerEvent != nullptr);
710 auto pointerAction = pointerEvent->GetPointerAction();
711 ASSERT_TRUE(pointerAction == MMI::PointerEvent::POINTER_ACTION_PULL_MOVE ||
712 pointerAction == MMI::PointerEvent::POINTER_ACTION_PULL_UP ||
713 pointerAction == MMI::PointerEvent::POINTER_ACTION_PULL_IN_WINDOW ||
714 pointerAction == MMI::PointerEvent::POINTER_ACTION_PULL_OUT_WINDOW);
715 ASSERT_TRUE(!pointerEvent->GetBuffer().empty());
716 MMI::PointerEvent::PointerItem pointerItem;
717 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
718 if (callback_ != nullptr && pointerItem.GetDisplayX() == DRAG_DST_X && pointerItem.GetDisplayY() == DRAG_DST_Y) {
719 callback_();
720 }
721 }
722
723 /**
724 * @tc.name: InteractionManagerTest_PrepareCoordination
725 * @tc.desc: Prepare coordination
726 * @tc.type: FUNC
727 * @tc.require:
728 */
729 HWTEST_F(InteractionManagerTest, InteractionManagerTest_PrepareCoordination, TestSize.Level1)
730 {
731 CALL_TEST_DEBUG;
732 std::promise<bool> promiseFlag;
733 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c90502(const std::string &listener, const CoordinationMsgInfo &coordinationMessages) 734 auto fun = [&promiseFlag](const std::string &listener, const CoordinationMsgInfo &coordinationMessages) {
735 FI_HILOGD("Prepare coordination success, listener:%{public}s", listener.c_str());
736 promiseFlag.set_value(true);
737 };
738 bool isCompatible = true;
739 int32_t ret = InteractionManager::GetInstance()->PrepareCoordination(fun, isCompatible);
740 #ifdef OHOS_BUILD_ENABLE_COORDINATION
741 ASSERT_EQ(ret, RET_OK);
742 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
743 #else
744 ASSERT_EQ(ret, ERROR_UNSUPPORT);
745 #endif // OHOS_BUILD_ENABLE_COORDINATION
746 }
747
748 /**
749 * @tc.name: InteractionManagerTest_RegisterCoordinationListener_001
750 * @tc.desc: Register coordination listener
751 * @tc.type: FUNC
752 * @tc.require:
753 */
754 HWTEST_F(InteractionManagerTest, InteractionManagerTest_RegisterCoordinationListener_001, TestSize.Level1)
755 {
756 CALL_TEST_DEBUG;
757 std::shared_ptr<ICoordinationListener> consumer = nullptr;
758 bool isCompatible = true;
759 int32_t ret = InteractionManager::GetInstance()->RegisterCoordinationListener(consumer, isCompatible);
760 #ifdef OHOS_BUILD_ENABLE_COORDINATION
761 ASSERT_EQ(ret, RET_ERR);
762 #else
763 ASSERT_EQ(ret, ERROR_UNSUPPORT);
764 #endif // OHOS_BUILD_ENABLE_COORDINATION
765 }
766
767 /**
768 * @tc.name: InteractionManagerTest_RegisterCoordinationListener_002
769 * @tc.desc: Register coordination listener
770 * @tc.type: FUNC
771 * @tc.require:
772 */
773 HWTEST_F(InteractionManagerTest, InteractionManagerTest_RegisterCoordinationListener_002, TestSize.Level1)
774 {
775 CALL_DEBUG_ENTER;
776 class CoordinationListenerTest : public ICoordinationListener {
777 public:
CoordinationListenerTest()778 CoordinationListenerTest() : ICoordinationListener() {}
OnCoordinationMessage(const std::string & networkId,CoordinationMessage msg)779 void OnCoordinationMessage(const std::string &networkId, CoordinationMessage msg) override
780 {
781 FI_HILOGD("Register coordination listener test");
782 (void) networkId;
783 };
784 };
785 std::shared_ptr<CoordinationListenerTest> consumer =
786 std::make_shared<CoordinationListenerTest>();
787 bool isCompatible = true;
788 int32_t ret = InteractionManager::GetInstance()->RegisterCoordinationListener(consumer, isCompatible);
789 #ifdef OHOS_BUILD_ENABLE_COORDINATION
790 ASSERT_EQ(ret, RET_OK);
791 #else
792 ASSERT_EQ(ret, ERROR_UNSUPPORT);
793 #endif // OHOS_BUILD_ENABLE_COORDINATION
794 ret = InteractionManager::GetInstance()->UnregisterCoordinationListener(consumer, isCompatible);
795 #ifdef OHOS_BUILD_ENABLE_COORDINATION
796 ASSERT_EQ(ret, RET_OK);
797 #else
798 ASSERT_EQ(ret, ERROR_UNSUPPORT);
799 #endif // OHOS_BUILD_ENABLE_COORDINATION
800 }
801
802 /**
803 * @tc.name: InteractionManagerTest_RegisterCoordinationListener_003
804 * @tc.desc: Register coordination listener
805 * @tc.type: FUNC
806 * @tc.require:
807 */
808 HWTEST_F(InteractionManagerTest, InteractionManagerTest_RegisterCoordinationListener_003, TestSize.Level1)
809 {
810 CALL_TEST_DEBUG;
811 FI_HILOGD("InteractionManagerTest_RegisterCoordinationListener_003 enter");
812 class CoordinationListenerTest : public ICoordinationListener {
813 public:
CoordinationListenerTest()814 CoordinationListenerTest() : ICoordinationListener() {}
OnCoordinationMessage(const std::string & networkId,CoordinationMessage msg)815 void OnCoordinationMessage(const std::string &networkId, CoordinationMessage msg) override
816 {
817 FI_HILOGD("Register coordination listener test");
818 (void) networkId;
819 };
820 };
821 std::shared_ptr<CoordinationListenerTest> consumer =
822 std::make_shared<CoordinationListenerTest>();
823 bool isCompatible = true;
824 int32_t ret = InteractionManager::GetInstance()->RegisterCoordinationListener(consumer, isCompatible);
825 #ifdef OHOS_BUILD_ENABLE_COORDINATION
826 ASSERT_EQ(ret, RET_OK);
827 #else
828 ASSERT_EQ(ret, ERROR_UNSUPPORT);
829 #endif // OHOS_BUILD_ENABLE_COORDINATION
830 ret = InteractionManager::GetInstance()->RegisterCoordinationListener(consumer, isCompatible);
831 #ifdef OHOS_BUILD_ENABLE_COORDINATION
832 ASSERT_EQ(ret, RET_ERR);
833 #else
834 ASSERT_EQ(ret, ERROR_UNSUPPORT);
835 #endif // OHOS_BUILD_ENABLE_COORDINATION
836 ret = InteractionManager::GetInstance()->UnregisterCoordinationListener(consumer, isCompatible);
837 #ifdef OHOS_BUILD_ENABLE_COORDINATION
838 ASSERT_EQ(ret, RET_OK);
839 #else
840 ASSERT_EQ(ret, ERROR_UNSUPPORT);
841 #endif // OHOS_BUILD_ENABLE_COORDINATION
842 FI_HILOGD("InteractionManagerTest_RegisterCoordinationListener_003 finish");
843 }
844
845 /**
846 * @tc.name: InteractionManagerTest_ActivateCoordination
847 * @tc.desc: Activate coordination
848 * @tc.type: FUNC
849 * @tc.require:
850 */
851 HWTEST_F(InteractionManagerTest, InteractionManagerTest_ActivateCoordination, TestSize.Level1)
852 {
853 CALL_TEST_DEBUG;
854 std::string remoteNetworkId("");
855 int32_t startDeviceId = -1;
__anon501201c90602(const std::string &listener, const CoordinationMsgInfo &coordinationMessages) 856 auto fun = [](const std::string &listener, const CoordinationMsgInfo &coordinationMessages) {
857 FI_HILOGD("Start coordination success");
858 (void) listener;
859 };
860 bool isCompatible = true;
861 int32_t ret = InteractionManager::GetInstance()->ActivateCoordination(remoteNetworkId, startDeviceId,
862 fun, isCompatible);
863 #ifdef OHOS_BUILD_ENABLE_COORDINATION
864 ASSERT_TRUE((ret == RET_OK || ret == COMMON_PERMISSION_CHECK_ERROR || ret == COMMON_NOT_ALLOWED_DISTRIBUTED));
865 #else
866 ASSERT_EQ(ret, ERROR_UNSUPPORT);
867 #endif // OHOS_BUILD_ENABLE_COORDINATION
868 }
869
870 /**
871 * @tc.name: InteractionManagerTest_DeactivateCoordination
872 * @tc.desc: Deactivate coordination
873 * @tc.type: FUNC
874 * @tc.require:
875 */
876 HWTEST_F(InteractionManagerTest, InteractionManagerTest_DeactivateCoordination, TestSize.Level1)
877 {
878 CALL_TEST_DEBUG;
__anon501201c90702(const std::string &listener, const CoordinationMsgInfo &coordinationMessages) 879 auto fun = [](const std::string &listener, const CoordinationMsgInfo &coordinationMessages) {
880 FI_HILOGD("Stop coordination success");
881 (void) listener;
882 };
883 bool isCompatible = true;
884 int32_t ret = InteractionManager::GetInstance()->DeactivateCoordination(false, fun, isCompatible);
885 #ifdef OHOS_BUILD_ENABLE_COORDINATION
886 ASSERT_EQ(ret, RET_OK);
887 #else
888 ASSERT_EQ(ret, ERROR_UNSUPPORT);
889 ret = InteractionManager::GetInstance()->DeactivateCoordination(true, fun, isCompatible);
890 ASSERT_EQ(ret, ERROR_UNSUPPORT);
891 #endif // OHOS_BUILD_ENABLE_COORDINATION
892 }
893
894 /**
895 * @tc.name: InteractionManagerTest_GetCoordinationState_Abnormal
896 * @tc.desc: Get coordination state
897 * @tc.type: FUNC
898 * @tc.require:
899 */
900 HWTEST_F(InteractionManagerTest, InteractionManagerTest_GetCoordinationState_Abnormal, TestSize.Level1)
901 {
902 CALL_TEST_DEBUG;
903 const std::string networkId("");
__anon501201c90802(bool state) 904 auto fun = [](bool state) {
905 FI_HILOGD("Get coordination state failed, state:%{public}d", state);
906 };
907 bool isCompatible = true;
908 int32_t ret = InteractionManager::GetInstance()->GetCoordinationState(networkId, fun, isCompatible);
909 #ifdef OHOS_BUILD_ENABLE_COORDINATION
910 ASSERT_EQ(ret, RET_OK);
911 #else
912 ASSERT_EQ(ret, ERROR_UNSUPPORT);
913 #endif // OHOS_BUILD_ENABLE_COORDINATION
914 }
915
916 /**
917 * @tc.name: InteractionManagerTest_GetCoordinationState_Normal
918 * @tc.desc: Get coordination state
919 * @tc.type: FUNC
920 * @tc.require:
921 */
922 HWTEST_F(InteractionManagerTest, InteractionManagerTest_GetCoordinationState_Normal, TestSize.Level1)
923 {
924 CALL_TEST_DEBUG;
925 std::promise<bool> promiseFlag;
926 std::future<bool> futureFlag = promiseFlag.get_future();
927 const std::string networkId("networkId");
__anon501201c90902(bool state) 928 auto fun = [&promiseFlag](bool state) {
929 FI_HILOGD("Get coordination state success, state:%{public}d", state);
930 promiseFlag.set_value(true);
931 };
932 bool isCompatible = true;
933 int32_t ret = InteractionManager::GetInstance()->GetCoordinationState(networkId, fun, isCompatible);
934 #ifdef OHOS_BUILD_ENABLE_COORDINATION
935 ASSERT_EQ(ret, RET_OK);
936 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
937 #else
938 ASSERT_EQ(ret, ERROR_UNSUPPORT);
939 #endif // OHOS_BUILD_ENABLE_COORDINATION
940 }
941
942 /**
943 * @tc.name: InteractionManagerTest_GetCoordinationState_Sync
944 * @tc.desc: Get coordination state
945 * @tc.type: FUNC
946 * @tc.require:
947 */
948 HWTEST_F(InteractionManagerTest, InteractionManagerTest_GetCoordinationState_Sync, TestSize.Level1)
949 {
950 CALL_TEST_DEBUG;
951 const std::string udId("Default");
952 bool state { false };
953 int32_t ret = InteractionManager::GetInstance()->GetCoordinationState(udId, state);
954 #ifdef OHOS_BUILD_ENABLE_COORDINATION
955 ASSERT_EQ(ret, RET_OK);
956 #else
957 ASSERT_EQ(ret, ERROR_UNSUPPORT);
958 #endif // OHOS_BUILD_ENABLE_COORDINATION
959 }
960
961 /**
962 * @tc.name: InteractionManagerTest_UnregisterCoordinationListener
963 * @tc.desc: Unregister coordination listener
964 * @tc.type: FUNC
965 * @tc.require:
966 */
967 HWTEST_F(InteractionManagerTest, InteractionManagerTest_UnregisterCoordinationListener, TestSize.Level1)
968 {
969 CALL_TEST_DEBUG;
970 std::shared_ptr<ICoordinationListener> consumer = nullptr;
971 bool isCompatible = true;
972 int32_t ret = InteractionManager::GetInstance()->UnregisterCoordinationListener(consumer, isCompatible);
973 #ifdef OHOS_BUILD_ENABLE_COORDINATION
974 ASSERT_EQ(ret, RET_OK);
975 #else
976 ASSERT_EQ(ret, ERROR_UNSUPPORT);
977 #endif // OHOS_BUILD_ENABLE_COORDINATION
978 }
979
980 /**
981 * @tc.name: InteractionManagerTest_UnprepareCoordination
982 * @tc.desc: Prepare coordination
983 * @tc.type: FUNC
984 * @tc.require:
985 */
986 HWTEST_F(InteractionManagerTest, InteractionManagerTest_UnprepareCoordination, TestSize.Level1)
987 {
988 CALL_TEST_DEBUG;
989 std::promise<bool> promiseFlag;
990 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c90a02(const std::string &listener, const CoordinationMsgInfo &coordinationMessages) 991 auto fun = [&promiseFlag](const std::string &listener, const CoordinationMsgInfo &coordinationMessages) {
992 FI_HILOGD("Prepare coordination success, listener:%{public}s", listener.c_str());
993 promiseFlag.set_value(true);
994 };
995 bool isCompatible = true;
996 int32_t ret = InteractionManager::GetInstance()->UnprepareCoordination(fun, isCompatible);
997 #ifdef OHOS_BUILD_ENABLE_COORDINATION
998 ASSERT_EQ(ret, RET_OK);
999 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
1000 #else
1001 ASSERT_EQ(ret, ERROR_UNSUPPORT);
1002 #endif // OHOS_BUILD_ENABLE_COORDINATION
1003 }
1004
1005
1006 class HotAreaListenerTest : public IHotAreaListener {
1007 public:
HotAreaListenerTest()1008 HotAreaListenerTest() {}
HotAreaListenerTest(std::string name)1009 explicit HotAreaListenerTest(std::string name) : testName_(name) {}
OnHotAreaMessage(int32_t displayX,int32_t displayY,HotAreaType msg,bool isEdge)1010 void OnHotAreaMessage(int32_t displayX, int32_t displayY, HotAreaType msg, bool isEdge) override
1011 {
1012 if (testName_.empty()) {
1013 testName_ = std::string("HOT_AREA");
1014 }
1015 FI_HILOGD("%{public}s, type:%{public}s, isEdge:%{public}d, displayX:%{public}d, displayY:%{public}d",
1016 testName_.c_str(), ShowMessage(msg).c_str(), isEdge, displayX, displayY);
1017 };
1018
1019 private:
ShowMessage(HotAreaType msg)1020 std::string ShowMessage(HotAreaType msg)
1021 {
1022 std::string type = "none-area";
1023 const std::map<HotAreaType, std::string> areaType = {
1024 { HotAreaType::AREA_LEFT, "left-area"},
1025 { HotAreaType::AREA_RIGHT, "right-area"},
1026 { HotAreaType::AREA_TOP, "top-area"},
1027 { HotAreaType::AREA_BOTTOM, "bottom-area"}
1028 };
1029 auto item = areaType.find(msg);
1030 if (item != areaType.end()) {
1031 type = item->second;
1032 }
1033 return type;
1034 }
1035
1036 private:
1037 std::string testName_;
1038 };
1039
1040 /**
1041 * @tc.name: AddHotAreaListener_001
1042 * @tc.desc: Add hot area listener
1043 * @tc.type: FUNC
1044 * @tc.require:
1045 */
1046 HWTEST_F(InteractionManagerTest, AddHotAreaListener_001, TestSize.Level1)
1047 {
1048 CALL_TEST_DEBUG;
1049 auto listener = std::make_shared<HotAreaListenerTest>(std::string("HOT_AREA"));
1050 int32_t ret = InteractionManager::GetInstance()->AddHotAreaListener(listener);
1051 #ifdef OHOS_BUILD_ENABLE_COORDINATION
1052 ASSERT_EQ(ret, RET_OK);
1053 #else
1054 ASSERT_EQ(ret, ERROR_UNSUPPORT);
1055 #endif // OHOS_BUILD_ENABLE_COORDINATION
1056 ret = InteractionManager::GetInstance()->RemoveHotAreaListener(listener);
1057 #ifdef OHOS_BUILD_ENABLE_COORDINATION
1058 ASSERT_EQ(ret, RET_OK);
1059 #else
1060 ASSERT_EQ(ret, ERROR_UNSUPPORT);
1061 #endif // OHOS_BUILD_ENABLE_COORDINATION
1062 }
1063
1064 /**
1065 * @tc.name: AddHotAreaListener_002
1066 * @tc.desc: Add hot area listener
1067 * @tc.type: FUNC
1068 * @tc.require:
1069 */
1070 HWTEST_F(InteractionManagerTest, AddHotAreaListener_002, TestSize.Level1)
1071 {
1072 CALL_DEBUG_ENTER;
1073 #ifndef OHOS_BUILD_PC_PRODUCT
1074 sptr<Rosen::Display> display = Rosen::DisplayManager::GetInstance().GetDisplayById(0);
1075 #else
1076 auto display = Rosen::DisplayManager::GetInstance().GetVisibleAreaDisplayInfoById(0);
1077 #endif // OHOS_BUILD_PC_PRODUCT
1078 CHKPV(display);
1079 g_screenWidth = display->GetWidth();
1080 g_screenHeight = display->GetHeight();
1081 auto listener = std::make_shared<HotAreaListenerTest>(std::string("HOT_AREA"));
1082 int32_t ret = InteractionManager::GetInstance()->AddHotAreaListener(listener);
1083 #ifdef OHOS_BUILD_ENABLE_COORDINATION
1084 ASSERT_EQ(ret, RET_OK);
1085 #else
1086 ASSERT_EQ(ret, ERROR_UNSUPPORT);
1087 #endif // OHOS_BUILD_ENABLE_COORDINATION
1088 SimulateMovePointerEvent({ HOT_AREA_STEP, HOT_AREA_COOR }, { HOT_AREA_STEP - HOT_AREA_SPAN, HOT_AREA_COOR },
1089 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
1090 SimulateMovePointerEvent({ HOT_AREA_COOR, HOT_AREA_STEP }, { HOT_AREA_COOR, HOT_AREA_STEP - HOT_AREA_SPAN },
1091 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
1092 SimulateMovePointerEvent({ g_screenWidth - HOT_AREA_STEP, HOT_AREA_COOR },
1093 { g_screenWidth - HOT_AREA_SPAN, HOT_AREA_COOR },
1094 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
1095 SimulateMovePointerEvent({ HOT_AREA_COOR, g_screenHeight - HOT_AREA_STEP },
1096 { HOT_AREA_COOR, g_screenHeight - HOT_AREA_SPAN },
1097 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
1098 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_TOUCH_DOWN_MS));
1099 ret = InteractionManager::GetInstance()->RemoveHotAreaListener(listener);
1100 #ifdef OHOS_BUILD_ENABLE_COORDINATION
1101 ASSERT_EQ(ret, RET_OK);
1102 #else
1103 ASSERT_EQ(ret, ERROR_UNSUPPORT);
1104 #endif // OHOS_BUILD_ENABLE_COORDINATION
1105 }
1106
1107 /**
1108 * @tc.name: Set
1109 * @tc.desc: Set dampling coefficient.
1110 * @tc.type: FUNC
1111 * @tc.require:
1112 */
1113 HWTEST_F(InteractionManagerTest, InteractionManagerTest_SetDamplingCoefficient, TestSize.Level1)
1114 {
1115 CALL_TEST_DEBUG;
1116 constexpr double damplingCoefficient { 0.1 };
1117 auto ret = InteractionManager::GetInstance()->SetDamplingCoefficient(
1118 COORDINATION_DAMPLING_RIGHT, damplingCoefficient);
1119 ASSERT_NE(ret, RET_OK);
1120 }
1121
1122 /**
1123 * @tc.name: InteractionManagerTest_Draglistener_Mouse
1124 * @tc.desc: Drag listener
1125 * @tc.type: FUNC
1126 * @tc.require:
1127 */
1128 HWTEST_F(InteractionManagerTest, InteractionManagerTest_Draglistener_Mouse, TestSize.Level1)
1129 {
1130 CALL_TEST_DEBUG;
1131 if (g_deviceMouseId < 0) {
1132 ASSERT_TRUE(g_deviceMouseId < 0);
1133 } else {
1134 auto listener = std::make_shared<DragListenerTest>(std::string("Draglistener_Mouse"));
1135 int32_t ret = InteractionManager::GetInstance()->AddDraglistener(listener);
1136 ASSERT_EQ(ret, RET_OK);
1137 std::promise<bool> promiseFlag;
1138 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c90b02(const DragNotifyMsg& notifyMessage) 1139 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1140 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1141 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1142 promiseFlag.set_value(true);
1143 };
1144 SimulateDownPointerEvent(
1145 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
1146 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1147 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1148 ASSERT_TRUE(dragData);
1149 ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1150 std::make_shared<UnitTestStartDragListener>(callback));
1151 ASSERT_EQ(ret, RET_OK);
1152 ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
1153 EXPECT_EQ(ret, RET_OK);
1154 SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
1155 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
1156 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1157 InteractionManager::GetInstance()->StopDrag(dropResult);
1158 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1159 std::future_status::timeout);
1160 ret = InteractionManager::GetInstance()->RemoveDraglistener(listener);
1161 ASSERT_EQ(ret, RET_OK);
1162 }
1163 }
1164
1165 /**
1166 * @tc.name: InteractionManagerTest_Draglistener_Touch
1167 * @tc.desc: Drag listener
1168 * @tc.type: FUNC
1169 * @tc.require:
1170 */
1171 HWTEST_F(InteractionManagerTest, InteractionManagerTest_Draglistener_Touch, TestSize.Level1)
1172 {
1173 CALL_TEST_DEBUG;
1174 if (g_deviceTouchId < 0) {
1175 ASSERT_TRUE(g_deviceTouchId < 0);
1176 } else {
1177 auto dragListener = std::make_shared<DragListenerTest>(std::string("Draglistener_Touch"));
1178 int32_t ret = InteractionManager::GetInstance()->AddDraglistener(dragListener);
1179 ASSERT_EQ(ret, RET_OK);
1180 std::promise<bool> promiseFlag;
1181 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c90c02(const DragNotifyMsg& notifyMessage) 1182 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1183 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, target:%{public}d, result:%{public}d",
1184 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.targetPid, notifyMessage.result);
1185 promiseFlag.set_value(true);
1186 };
1187 SimulateDownPointerEvent(
1188 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
1189 std::optional<DragData> dragData = CreateDragData({ MAX_PIXEL_MAP_WIDTH, MAX_PIXEL_MAP_HEIGHT },
1190 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1191 ASSERT_TRUE(dragData);
1192 ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1193 std::make_shared<UnitTestStartDragListener>(callback));
1194 ASSERT_EQ(ret, RET_OK);
1195 SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
1196 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
1197 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1198 InteractionManager::GetInstance()->StopDrag(dropResult);
1199 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1200 std::future_status::timeout);
1201 ret = InteractionManager::GetInstance()->RemoveDraglistener(dragListener);
1202 ASSERT_EQ(ret, RET_OK);
1203 }
1204 }
1205
1206 /**
1207 * @tc.name: InteractionManagerTest_Draglistener
1208 * @tc.desc: Drag listener
1209 * @tc.type: FUNC
1210 * @tc.require:
1211 */
1212 HWTEST_F(InteractionManagerTest, InteractionManagerTest_Draglistener, TestSize.Level1)
1213 {
1214 CALL_TEST_DEBUG;
1215 if (g_deviceTouchId < 0) {
1216 ASSERT_TRUE(g_deviceTouchId < 0);
1217 } else {
1218 int32_t ret = RET_ERR;
1219 std::vector<std::shared_ptr<DragListenerTest>> dragListeners;
1220 constexpr size_t listenerCount = 5;
1221 for (size_t i = 0; i < listenerCount; ++i) {
1222 std::string moduleName = "Draglistener_" + std::to_string(i);
1223 auto listener = std::make_shared<DragListenerTest>(moduleName);
1224 ret = InteractionManager::GetInstance()->AddDraglistener(listener);
1225 if (ret == RET_OK) {
1226 dragListeners.push_back(listener);
1227 }
1228 }
1229 SimulateDownPointerEvent(
1230 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
1231 std::optional<DragData> dragData = CreateDragData({ MAX_PIXEL_MAP_WIDTH, MAX_PIXEL_MAP_HEIGHT },
1232 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1233 ASSERT_TRUE(dragData);
1234 std::promise<bool> promiseFlag;
1235 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c90d02(const DragNotifyMsg& notifyMessage) 1236 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1237 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1238 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1239 promiseFlag.set_value(true);
1240 };
1241 ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1242 std::make_shared<UnitTestStartDragListener>(callback));
1243 ASSERT_EQ(ret, RET_OK);
1244 SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
1245 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
1246 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1247 InteractionManager::GetInstance()->StopDrag(dropResult);
1248 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1249 std::future_status::timeout);
1250 for (const auto &listener : dragListeners) {
1251 ret = InteractionManager::GetInstance()->RemoveDraglistener(listener);
1252 EXPECT_EQ(ret, RET_OK);
1253 }
1254 }
1255 }
1256
1257 /**
1258 * @tc.name: InteractionManagerTest_SubscriptListener_001
1259 * @tc.desc: SubscriptListener
1260 * @tc.type: FUNC
1261 * @tc.require:
1262 */
1263 HWTEST_F(InteractionManagerTest, InteractionManagerTest_SubscriptListener_001, TestSize.Level1)
1264 {
1265 CALL_TEST_DEBUG;
1266 if (g_deviceTouchId < 0) {
1267 ASSERT_TRUE(g_deviceTouchId < 0);
1268 } else {
1269 int32_t ret = RET_ERR;
1270 std::vector<std::shared_ptr<SubscriptListenerTest>> subscriptListeners;
1271 for (size_t i = 0; i < RECIVE_LOOP_COUNT; ++i) {
1272 std::string moduleName = "SubscriptListener_" + std::to_string(i);
1273 auto listener = std::make_shared<SubscriptListenerTest>(moduleName);
1274 ret = InteractionManager::GetInstance()->AddSubscriptListener(listener);
1275 EXPECT_EQ(ret, RET_OK);
1276 subscriptListeners.push_back(listener);
1277 }
1278 std::promise<bool> promiseFlag;
1279 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c90e02(const DragNotifyMsg& notifyMessage) 1280 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1281 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1282 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1283 promiseFlag.set_value(true);
1284 };
1285 std::optional<DragData> dragData = CreateDragData({ MAX_PIXEL_MAP_WIDTH, MAX_PIXEL_MAP_HEIGHT },
1286 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1287 ASSERT_TRUE(dragData);
1288 ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1289 std::make_shared<UnitTestStartDragListener>(callback));
1290 ASSERT_EQ(ret, RET_OK);
1291 SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
1292 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
1293 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1294 InteractionManager::GetInstance()->StopDrag(dropResult);
1295 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1296 std::future_status::timeout);
1297 for (auto listener : subscriptListeners) {
1298 ret = InteractionManager::GetInstance()->RemoveSubscriptListener(listener);
1299 EXPECT_EQ(ret, RET_OK);
1300 }
1301 }
1302 }
1303
1304 /**
1305 * @tc.name: InteractionManagerTest_SubscriptListener_002
1306 * @tc.desc: SubscriptListener
1307 * @tc.type: FUNC
1308 * @tc.require:
1309 */
1310 HWTEST_F(InteractionManagerTest, InteractionManagerTest_SubscriptListener_002, TestSize.Level1)
1311 {
1312 CALL_TEST_DEBUG;
1313 if (g_deviceTouchId < 0) {
1314 ASSERT_TRUE(g_deviceTouchId < 0);
1315 } else {
1316 int32_t ret = RET_ERR;
1317 auto listener = std::make_shared<SubscriptListenerTest>("SubscriptListener");
1318 ret = InteractionManager::GetInstance()->AddSubscriptListener(listener);
1319 ASSERT_EQ(ret, RET_OK);
1320 std::promise<bool> promiseFlag;
1321 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c90f02(const DragNotifyMsg& notifyMessage) 1322 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1323 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1324 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1325 promiseFlag.set_value(true);
1326 };
1327 std::optional<DragData> dragData = CreateDragData({ MAX_PIXEL_MAP_WIDTH, MAX_PIXEL_MAP_HEIGHT },
1328 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1329 ASSERT_TRUE(dragData);
1330 ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1331 std::make_shared<UnitTestStartDragListener>(callback));
1332 ASSERT_EQ(ret, RET_OK);
1333 ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
1334 ASSERT_EQ(ret, RET_OK);
1335 DragCursorStyle style = DragCursorStyle::COPY;
1336 ret = InteractionManager::GetInstance()->UpdateDragStyle(style);
1337 ASSERT_EQ(ret, RET_OK);
1338 style = DragCursorStyle::MOVE;
1339 ret = InteractionManager::GetInstance()->UpdateDragStyle(style);
1340 ASSERT_EQ(ret, RET_OK);
1341 SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
1342 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
1343 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1344 InteractionManager::GetInstance()->StopDrag(dropResult);
1345 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1346 std::future_status::timeout);
1347 DragCursorStyle recvStyle = listener->GetDragStyle();
1348 FI_HILOGD("Recived style:%{public}d, expected style:%{public}d", static_cast<int32_t>(recvStyle),
1349 static_cast<int32_t>(style));
1350 ret = InteractionManager::GetInstance()->RemoveSubscriptListener(listener);
1351 ASSERT_EQ(ret, RET_OK);
1352 }
1353 }
1354
1355 /**
1356 * @tc.name: InteractionManagerTest_StartDrag_Mouse
1357 * @tc.desc: Start Drag
1358 * @tc.type: FUNC
1359 * @tc.require:
1360 */
1361 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_Mouse, TestSize.Level1)
1362 {
1363 CALL_TEST_DEBUG;
1364 if (g_deviceMouseId < 0) {
1365 ASSERT_TRUE(g_deviceMouseId < 0);
1366 } else {
1367 std::promise<bool> promiseFlag;
1368 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c91002(const DragNotifyMsg& notifyMessage) 1369 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1370 FI_HILOGD("Param displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1371 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1372 promiseFlag.set_value(true);
1373 };
1374 SimulateDownPointerEvent(
1375 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
1376 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1377 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1378 ASSERT_TRUE(dragData);
1379 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1380 std::make_shared<UnitTestStartDragListener>(callback));
1381 ASSERT_EQ(ret, RET_OK);
1382 ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
1383 InteractionManager::GetInstance()->SetDragWindowScreenId(TOUCH_POINTER_ID, TOUCH_POINTER_ID);
1384 EXPECT_EQ(ret, RET_OK);
1385 SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
1386 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
1387 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1388 InteractionManager::GetInstance()->StopDrag(dropResult);
1389 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1390 std::future_status::timeout);
1391 }
1392 }
1393
1394 /**
1395 * @tc.name: InteractionManagerTest_StartDrag_Failed_Mouse
1396 * @tc.desc: Start Drag
1397 * @tc.type: FUNC
1398 * @tc.require:
1399 */
1400 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_Failed_Mouse, TestSize.Level1)
1401 {
1402 CALL_TEST_DEBUG;
1403 if (g_deviceMouseId < 0) {
1404 ASSERT_TRUE(g_deviceMouseId < 0);
1405 } else {
1406 std::promise<bool> promiseFlag;
1407 std::future<bool> futureFlag = promiseFlag.get_future();
1408 SimulateDownPointerEvent(
1409 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
__anon501201c91102(const DragNotifyMsg& notifyMessage) 1410 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1411 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1412 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1413 promiseFlag.set_value(true);
1414 };
1415 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1416 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1417 ASSERT_TRUE(dragData);
1418
1419 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(), nullptr);
1420 ASSERT_EQ(ret, RET_ERR);
1421 dragData->shadowInfos = {};
1422 ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1423 std::make_shared<UnitTestStartDragListener>(callback));
1424 ASSERT_EQ(ret, ERR_INVALID_VALUE);
1425 }
1426 }
1427
1428 /**
1429 * @tc.name: InteractionManagerTest_StopDrag_Mouse
1430 * @tc.desc: Stop drag
1431 * @tc.type: FUNC
1432 * @tc.require:
1433 */
1434 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StopDrag_Mouse, TestSize.Level1)
1435 {
1436 CALL_TEST_DEBUG;
1437 if (g_deviceMouseId < 0) {
1438 ASSERT_TRUE(g_deviceMouseId < 0);
1439 } else {
1440 std::promise<bool> promiseFlag;
1441 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c91202(const DragNotifyMsg& notifyMessage) 1442 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1443 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, target:%{public}d, result:%{public}d",
1444 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.targetPid, notifyMessage.result);
1445 promiseFlag.set_value(true);
1446 };
1447 SimulateDownPointerEvent(
1448 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
1449 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1450 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1451 ASSERT_TRUE(dragData);
1452 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1453 std::make_shared<UnitTestStartDragListener>(callback));
1454 ASSERT_EQ(ret, RET_OK);
1455 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1456 InteractionManager::GetInstance()->StopDrag(dropResult);
1457 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1458 std::future_status::timeout);
1459 }
1460 }
1461
1462 /**
1463 * @tc.name: InteractionManagerTest_StopDrag_Failed_Mouse
1464 * @tc.desc: Stop drag
1465 * @tc.type: FUNC
1466 * @tc.require:
1467 */
1468 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StopDrag_Failed_Mouse, TestSize.Level1)
1469 {
1470 CALL_TEST_DEBUG;
1471 if (g_deviceMouseId < 0) {
1472 ASSERT_TRUE(g_deviceMouseId < 0);
1473 } else {
1474 SimulateDownPointerEvent(
1475 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
1476 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1477 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1478 ASSERT_TRUE(dragData);
1479 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(), nullptr);
1480 ASSERT_EQ(ret, RET_ERR);
1481 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1482 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1483 ASSERT_EQ(ret, RET_ERR);
1484 }
1485 }
1486
1487 /**
1488 * @tc.name: InteractionManagerTest_StartDrag_Touch
1489 * @tc.desc: Start Drag
1490 * @tc.type: FUNC
1491 * @tc.require:
1492 */
1493 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_Touch, TestSize.Level1)
1494 {
1495 CALL_TEST_DEBUG;
1496 if (g_deviceTouchId < 0) {
1497 ASSERT_TRUE(g_deviceTouchId < 0);
1498 } else {
1499 SimulateDownPointerEvent(
1500 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
1501 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_TOUCH_DOWN_MS));
1502 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1503 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1504 ASSERT_TRUE(dragData);
1505 std::promise<bool> promiseFlag;
1506 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c91302(const DragNotifyMsg& notifyMessage) 1507 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1508 FI_HILOGD("Start drag, displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1509 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1510 promiseFlag.set_value(true);
1511 };
1512 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1513 std::make_shared<UnitTestStartDragListener>(callback));
1514 ASSERT_EQ(ret, RET_OK);
1515 ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
1516 EXPECT_EQ(ret, RET_OK);
1517 SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
1518 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
1519 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1520 InteractionManager::GetInstance()->StopDrag(dropResult);
1521 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1522 std::future_status::timeout);
1523 }
1524 }
1525
1526 /**
1527 * @tc.name: InteractionManagerTest_StopDrag_Touch
1528 * @tc.desc: Stop drag
1529 * @tc.type: FUNC
1530 * @tc.require:
1531 */
1532 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StopDrag_Touch, TestSize.Level1)
1533 {
1534 CALL_TEST_DEBUG;
1535 if (g_deviceTouchId < 0) {
1536 ASSERT_TRUE(g_deviceTouchId < 0);
1537 } else {
1538 std::promise<bool> promiseFlag;
1539 std::future<bool> future = promiseFlag.get_future();
__anon501201c91402(const DragNotifyMsg& notifyMessage) 1540 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1541 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1542 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1543 promiseFlag.set_value(true);
1544 };
1545 SimulateDownPointerEvent(
1546 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
1547 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_TOUCH_DOWN_MS));
1548 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1549 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1550 ASSERT_TRUE(dragData);
1551 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1552 std::make_shared<UnitTestStartDragListener>(callback));
1553 ASSERT_EQ(ret, RET_OK);
1554 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1555 InteractionManager::GetInstance()->StopDrag(dropResult);
1556 ASSERT_TRUE(future.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1557 std::future_status::timeout);
1558 }
1559 }
1560
1561 /**
1562 * @tc.name: GetDragTargetPid_Mouse
1563 * @tc.desc: Get the target pid dragged by the mouse
1564 * @tc.type: FUNC
1565 * @tc.require:
1566 */
1567 HWTEST_F(InteractionManagerTest, GetDragTargetPid_Mouse, TestSize.Level1)
1568 {
1569 CALL_TEST_DEBUG;
1570 if (g_deviceMouseId < 0) {
1571 ASSERT_TRUE(g_deviceMouseId < 0);
1572 } else {
1573 std::promise<bool> promiseStopFlag;
1574 std::future<bool> futureStopFlag = promiseStopFlag.get_future();
__anon501201c91502(const DragNotifyMsg& notifyMessage) 1575 auto callback = [&promiseStopFlag](const DragNotifyMsg& notifyMessage) {
1576 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1577 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1578 promiseStopFlag.set_value(true);
1579 };
1580 SimulateDownPointerEvent(
1581 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
1582 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1583 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1584 ASSERT_TRUE(dragData);
1585 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1586 std::make_shared<UnitTestStartDragListener>(callback));
1587 ASSERT_EQ(ret, RET_OK);
1588 ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
1589 EXPECT_EQ(ret, RET_OK);
1590 ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::DEFAULT);
1591 ASSERT_EQ(ret, RET_OK);
1592 int32_t pid = InteractionManager::GetInstance()->GetDragTargetPid();
1593 FI_HILOGI("Target pid:%{public}d", pid);
1594 ASSERT_TRUE(pid > 0);
1595 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1596 InteractionManager::GetInstance()->StopDrag(dropResult);
1597 ASSERT_TRUE(futureStopFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1598 std::future_status::timeout);
1599 }
1600 }
1601
1602 /**
1603 * @tc.name: GetDragTargetPid_Touch
1604 * @tc.desc: Get the target pid dragged by the touchscreen
1605 * @tc.type: FUNC
1606 * @tc.require:
1607 */
1608 HWTEST_F(InteractionManagerTest, GetDragTargetPid_Touch, TestSize.Level1)
1609 {
1610 CALL_TEST_DEBUG;
1611 if (g_deviceTouchId < 0) {
1612 ASSERT_TRUE(g_deviceTouchId < 0);
1613 } else {
1614 std::promise<bool> promiseStopFlag;
1615 std::future<bool> futureStopFlag = promiseStopFlag.get_future();
__anon501201c91602(const DragNotifyMsg& notifyMessage) 1616 auto callback = [&promiseStopFlag](const DragNotifyMsg& notifyMessage) {
1617 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1618 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1619 promiseStopFlag.set_value(true);
1620 };
1621 SimulateDownPointerEvent(
1622 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
1623 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_TOUCH_DOWN_MS));
1624 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1625 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1626 ASSERT_TRUE(dragData);
1627 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1628 std::make_shared<UnitTestStartDragListener>(callback));
1629 ASSERT_EQ(ret, RET_OK);
1630 ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
1631 EXPECT_EQ(ret, RET_OK);
1632 ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::COPY);
1633 ASSERT_EQ(ret, RET_OK);
1634 int32_t pid = InteractionManager::GetInstance()->GetDragTargetPid();
1635 FI_HILOGI("Target pid:%{public}d", pid);
1636 ASSERT_TRUE(pid > 0);
1637 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1638 InteractionManager::GetInstance()->StopDrag(dropResult);
1639 ASSERT_TRUE(futureStopFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1640 std::future_status::timeout);
1641 }
1642 }
1643
1644 /**
1645 * @tc.name: TouchEventDispatch
1646 * @tc.desc: Dispatch the touchscreen events
1647 * @tc.type: FUNC
1648 * @tc.require:
1649 */
1650 HWTEST_F(InteractionManagerTest, TouchEventDispatch, TestSize.Level1)
1651 {
1652 CALL_TEST_DEBUG;
1653 if (g_deviceTouchId < 0) {
1654 ASSERT_TRUE(g_deviceTouchId < 0);
1655 } else {
1656 std::promise<bool> promiseFlag;
1657 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c91702(const DragNotifyMsg& notifyMessage) 1658 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1659 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1660 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1661 promiseFlag.set_value(true);
1662 };
1663 SimulateDownPointerEvent(
1664 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
1665 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_TOUCH_DOWN_MS));
1666 std::optional<DragData> dragDataInfo = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1667 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID_INJECT, DISPLAY_ID,
1668 { DRAG_SRC_X, DRAG_SRC_Y });
1669 ASSERT_TRUE(dragDataInfo);
1670 int32_t result = InteractionManager::GetInstance()->StartDrag(dragDataInfo.value(),
1671 std::make_shared<UnitTestStartDragListener>(callback));
1672 ASSERT_EQ(result, RET_OK);
1673 result = InteractionManager::GetInstance()->SetDragWindowVisible(true);
1674 EXPECT_EQ(result, RET_OK);
1675 std::promise<bool> promiseEventFlag;
1676 std::future<bool> futureEventFlag = promiseEventFlag.get_future();
1677 auto callbackPtr = std::make_shared<InputEventCallbackTest>(
__anon501201c91802null1678 [&promiseEventFlag]{promiseEventFlag.set_value(true);});
1679 int32_t monitorId = TestAddMonitor(callbackPtr);
1680 SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
1681 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
1682 ASSERT_TRUE(futureEventFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1683 std::future_status::timeout);
1684 TestRemoveMonitor(monitorId);
1685 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1686 result = InteractionManager::GetInstance()->StopDrag(dropResult);
1687 ASSERT_EQ(result, RET_OK);
1688 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1689 std::future_status::timeout);
1690 }
1691 }
1692
1693 /**
1694 * @tc.name: MouseEventDispatch
1695 * @tc.desc: Dispatch the mouse events
1696 * @tc.type: FUNC
1697 * @tc.require:
1698 */
1699 HWTEST_F(InteractionManagerTest, MouseEventDispatch, TestSize.Level1)
1700 {
1701 CALL_TEST_DEBUG;
1702 if (g_deviceMouseId < 0) {
1703 ASSERT_TRUE(g_deviceMouseId < 0);
1704 } else {
1705 std::promise<bool> promiseFlag;
1706 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c91902(const DragNotifyMsg& notifyMessage) 1707 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1708 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1709 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1710 promiseFlag.set_value(true);
1711 };
1712 SimulateDownPointerEvent(
1713 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, 0);
1714 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1715 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID_INJECT, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1716 ASSERT_TRUE(dragData);
1717 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1718 std::make_shared<UnitTestStartDragListener>(callback));
1719 ASSERT_EQ(ret, RET_OK);
1720 ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
1721 EXPECT_EQ(ret, RET_OK);
1722 std::promise<bool> promiseEventFlag;
1723 std::future<bool> futureEventFlag = promiseEventFlag.get_future();
1724 auto callbackPtr = std::make_shared<InputEventCallbackTest>(
__anon501201c91a02null1725 [&promiseEventFlag]{promiseEventFlag.set_value(true);});
1726 int32_t monitorId = TestAddMonitor(callbackPtr);
1727 SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
1728 MMI::PointerEvent::SOURCE_TYPE_MOUSE, TOUCH_POINTER_ID, true);
1729 ASSERT_TRUE(futureEventFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1730 std::future_status::timeout);
1731 TestRemoveMonitor(monitorId);
1732 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1733 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1734 ASSERT_EQ(ret, RET_OK);
1735 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1736 std::future_status::timeout);
1737 }
1738 }
1739
1740 /**
1741 * @tc.name: InteractionManagerTest_SetDragWindowVisible
1742 * @tc.desc: Set Drag Window Visible
1743 * @tc.type: FUNC
1744 * @tc.require:
1745 */
1746 HWTEST_F(InteractionManagerTest, InteractionManagerTest_SetDragWindowVisible, TestSize.Level1)
1747 {
1748 CALL_TEST_DEBUG;
1749 int32_t ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
1750 FI_HILOGD("ret:%{public}d", ret);
1751 ASSERT_EQ(ret, RET_ERR);
1752 ret = InteractionManager::GetInstance()->SetDragWindowVisible(false);
1753 FI_HILOGD("ret:%{public}d", ret);
1754 ASSERT_EQ(ret, RET_ERR);
1755 }
1756
1757 /**
1758 * @tc.name: InteractionManagerTest_GetShadowOffset
1759 * @tc.desc: Get Shadow Offset
1760 * @tc.type: FUNC
1761 * @tc.require:
1762 */
1763 HWTEST_F(InteractionManagerTest, InteractionManagerTest_GetShadowOffset, TestSize.Level1)
1764 {
1765 CALL_TEST_DEBUG;
1766 int32_t offsetX = 0;
1767 int32_t offsetY = 0;
1768 int32_t width = 0;
1769 int32_t height = 0;
1770 std::promise<bool> promise;
1771 std::future<bool> futureFlag = promise.get_future();
__anon501201c91b02(const DragNotifyMsg& notifyMessage) 1772 auto callback = [&promise](const DragNotifyMsg& notifyMessage) {
1773 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1774 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1775 promise.set_value(true);
1776 };
1777 SimulateDownPointerEvent(
1778 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
1779 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_TOUCH_DOWN_MS));
1780 std::optional<DragData> dragDataInfo = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1781 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1782 ASSERT_TRUE(dragDataInfo);
1783 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragDataInfo.value(),
1784 std::make_shared<UnitTestStartDragListener>(callback));
1785 ASSERT_EQ(ret, RET_OK);
1786 ret = InteractionManager::GetInstance()->GetShadowOffset(offsetX, offsetY, width, height);
1787 FI_HILOGD("offsetX:%{public}d, offsetY:%{public}d, width:%{public}d, height:%{public}d",
1788 offsetX, offsetY, width, height);
1789 ASSERT_EQ(ret, RET_OK);
1790 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1791 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1792 ASSERT_EQ(ret, RET_OK);
1793 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
1794 }
1795
1796 /**
1797 * @tc.name: GetUdKey_Mouse
1798 * @tc.desc: Get the udKey dragged by the mouse
1799 * @tc.type: FUNC
1800 * @tc.require:
1801 */
1802 HWTEST_F(InteractionManagerTest, GetUdKey_Mouse, TestSize.Level1)
1803 {
1804 CALL_TEST_DEBUG;
1805 if (g_deviceMouseId < 0) {
1806 ASSERT_TRUE(g_deviceMouseId < 0);
1807 } else {
1808 SimulateDownPointerEvent(
1809 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
1810 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1811 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1812 ASSERT_TRUE(dragData);
1813 std::promise<bool> promiseFlag;
1814 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c91c02(const DragNotifyMsg& notifyMessage) 1815 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1816 FI_HILOGD("Get ud key, displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1817 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1818 promiseFlag.set_value(true);
1819 };
1820 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1821 std::make_shared<UnitTestStartDragListener>(callback));
1822 ASSERT_EQ(ret, RET_OK);
1823 std::string udKey;
1824 ret = InteractionManager::GetInstance()->GetUdKey(udKey);
1825 ASSERT_EQ(ret, RET_OK);
1826 ASSERT_EQ(udKey, UD_KEY);
1827 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1828 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1829 ASSERT_EQ(ret, RET_OK);
1830 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1831 std::future_status::timeout);
1832 }
1833 }
1834
1835 /**
1836 * @tc.name: GetUdKey_Touch
1837 * @tc.desc: Get the udKey dragged by the touchscreen
1838 * @tc.type: FUNC
1839 * @tc.require:
1840 */
1841 HWTEST_F(InteractionManagerTest, GetUdKey_Touch, TestSize.Level1)
1842 {
1843 CALL_TEST_DEBUG;
1844 if (g_deviceTouchId < 0) {
1845 ASSERT_TRUE(g_deviceTouchId < 0);
1846 } else {
1847 std::promise<bool> promiseFlag;
1848 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c91d02(const DragNotifyMsg& notifyMessage) 1849 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1850 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, target:%{public}d, result:%{public}d",
1851 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.targetPid, notifyMessage.result);
1852 promiseFlag.set_value(true);
1853 };
1854 SimulateDownPointerEvent(
1855 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
1856 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_TOUCH_DOWN_MS));
1857 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1858 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1859 ASSERT_TRUE(dragData);
1860 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1861 std::make_shared<UnitTestStartDragListener>(callback));
1862 ASSERT_EQ(ret, RET_OK);
1863 std::string udKey;
1864 ret = InteractionManager::GetInstance()->GetUdKey(udKey);
1865 ASSERT_EQ(ret, RET_OK);
1866 ASSERT_EQ(udKey, UD_KEY);
1867 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1868 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1869 ASSERT_EQ(ret, RET_OK);
1870 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1871 std::future_status::timeout);
1872 }
1873 }
1874
1875 /**
1876 * @tc.name: GetDragData_Success
1877 * @tc.desc: Get the dragData from interface successfully
1878 * @tc.type: FUNC
1879 * @tc.require:
1880 */
1881 HWTEST_F(InteractionManagerTest, GetDragData_Success, TestSize.Level1)
1882 {
1883 CALL_TEST_DEBUG;
1884 if (g_deviceTouchId < 0) {
1885 ASSERT_TRUE(g_deviceTouchId < 0);
1886 } else {
1887 std::promise<bool> promiseFlag;
1888 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c91e02(const DragNotifyMsg& notifyMessage) 1889 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1890 FI_HILOGD("Get drag data, displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1891 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1892 promiseFlag.set_value(true);
1893 };
1894 SimulateDownPointerEvent(
1895 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
1896 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1897 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1898 ASSERT_TRUE(dragData);
1899 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1900 std::make_shared<UnitTestStartDragListener>(callback));
1901 ASSERT_EQ(ret, RET_OK);
1902
1903 DragData replyDragData;
1904 ret = InteractionManager::GetInstance()->GetDragData(replyDragData);
1905 ASSERT_EQ(ret, RET_OK);
1906 ASSERT_EQ(replyDragData, dragData.value());
1907 PrintDragData(replyDragData);
1908 SimulateUpPointerEvent(
1909 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
1910 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1911 InteractionManager::GetInstance()->StopDrag(dropResult);
1912 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1913 std::future_status::timeout);
1914 }
1915 }
1916
1917 /**
1918 * @tc.name: GetDragData_Failed
1919 * @tc.desc: Get the dragData from interface failed
1920 * @tc.type: FUNC
1921 * @tc.require:
1922 */
1923 HWTEST_F(InteractionManagerTest, GetDragData_Failed, TestSize.Level1)
1924 {
1925 CALL_TEST_DEBUG;
1926 if (g_deviceTouchId < 0) {
1927 ASSERT_TRUE(g_deviceTouchId < 0);
1928 } else {
1929 SimulateDownPointerEvent(
1930 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
1931 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_TOUCH_DOWN_MS));
1932 DragData dragData;
1933 int32_t ret = InteractionManager::GetInstance()->GetDragData(dragData);
1934 SimulateUpPointerEvent(
1935 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
1936 ASSERT_EQ(ret, RET_ERR);
1937 }
1938 }
1939
1940 /**
1941 * @tc.name: GetDragState
1942 * @tc.desc: Get the dragState from interface
1943 * @tc.type: FUNC
1944 * @tc.require:
1945 */
1946 HWTEST_F(InteractionManagerTest, GetDragState, TestSize.Level1)
1947 {
1948 CALL_TEST_DEBUG;
1949 std::promise<bool> promiseFlag;
1950 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c91f02(const DragNotifyMsg& notifyMessage) 1951 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1952 FI_HILOGD("Drag state, displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1953 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1954 promiseFlag.set_value(true);
1955 };
1956 SimulateDownPointerEvent(
1957 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
1958 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1959 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1960 ASSERT_TRUE(dragData);
1961 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1962 std::make_shared<UnitTestStartDragListener>(callback));
1963 ASSERT_EQ(ret, RET_OK);
1964
1965 DragState dragState;
1966 ret = InteractionManager::GetInstance()->GetDragState(dragState);
1967 FI_HILOGD("InteractionManager::dragState:%{public}d", dragState);
1968 EXPECT_EQ(ret, RET_OK);
1969 EXPECT_EQ(dragState, DragState::START);
1970
1971 SimulateUpPointerEvent(
1972 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
1973 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1974 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1975 ASSERT_EQ(ret, RET_OK);
1976 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1977 std::future_status::timeout);
1978 ret = InteractionManager::GetInstance()->GetDragState(dragState);
1979 FI_HILOGD("dragState:%{public}d", dragState);
1980 EXPECT_EQ(ret, RET_OK);
1981 EXPECT_EQ(dragState, DragState::STOP);
1982 }
1983
1984 /**
1985 * @tc.name: IsDragStart
1986 * @tc.desc: IsDragStart from interface
1987 * @tc.type: FUNC
1988 * @tc.require:
1989 */
1990 HWTEST_F(InteractionManagerTest, IsDragStart, TestSize.Level1)
1991 {
1992 CALL_TEST_DEBUG;
1993 std::promise<bool> promiseFlag;
1994 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c92002(const DragNotifyMsg& notifyMessage) 1995 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1996 FI_HILOGD("Drag state, displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1997 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1998 promiseFlag.set_value(true);
1999 };
2000 SimulateDownPointerEvent(
2001 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
2002 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2003 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2004 ASSERT_TRUE(dragData);
2005 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2006 std::make_shared<UnitTestStartDragListener>(callback));
2007 ASSERT_EQ(ret, RET_OK);
2008
2009 auto flag = InteractionManager::GetInstance()->IsDragStart();
2010 EXPECT_TRUE(flag);
2011
2012 SimulateUpPointerEvent(
2013 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
2014 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2015 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
2016 ASSERT_EQ(ret, RET_OK);
2017 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2018 std::future_status::timeout);
2019 flag = InteractionManager::GetInstance()->IsDragStart();
2020 EXPECT_FALSE(flag);
2021 }
2022
2023 /**
2024 * @tc.name: InteractionManagerTest_GetDragSummary
2025 * @tc.desc: Get drag summarys
2026 * @tc.type: FUNC
2027 * @tc.require:
2028 */
2029 HWTEST_F(InteractionManagerTest, InteractionManagerTest_GetDragSummary, TestSize.Level1)
2030 {
2031 CALL_TEST_DEBUG;
2032 std::promise<bool> promiseFlag;
2033 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c92102(const DragNotifyMsg& notifyMessage) 2034 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2035 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2036 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2037 promiseFlag.set_value(true);
2038 };
2039 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2040 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2041 ASSERT_TRUE(dragData);
2042 const std::string udType = "general.message";
2043 constexpr int64_t recordSize = 20;
2044 std::map<std::string, int64_t> summarys = { { udType, recordSize } };
2045 dragData.value().summarys = summarys;
2046 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2047 std::make_shared<UnitTestStartDragListener>(callback));
2048 ASSERT_EQ(ret, RET_OK);
2049 summarys.clear();
2050 ret = InteractionManager::GetInstance()->GetDragSummary(summarys);
2051 EXPECT_EQ(ret, RET_OK);
2052 EXPECT_EQ(summarys[udType], recordSize);
2053 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2054 InteractionManager::GetInstance()->StopDrag(dropResult);
2055 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2056 std::future_status::timeout);
2057 }
2058
2059 /**
2060 * @tc.name: InteractionManagerTest_UpdatePreviewStyle
2061 * @tc.desc: Update drag item style
2062 * @tc.type: FUNC
2063 * @tc.require:
2064 */
2065 HWTEST_F(InteractionManagerTest, InteractionManagerTest_UpdatePreviewStyle, TestSize.Level1)
2066 {
2067 CALL_TEST_DEBUG;
2068 std::promise<bool> promiseFlag;
2069 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c92202(const DragNotifyMsg& notifyMessage) 2070 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2071 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2072 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2073 promiseFlag.set_value(true);
2074 };
2075 SimulateDownPointerEvent(
2076 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
2077 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2078 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2079 ASSERT_TRUE(dragData);
2080 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2081 std::make_shared<UnitTestStartDragListener>(callback));
2082 ASSERT_EQ(ret, RET_OK);
2083 ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
2084 EXPECT_EQ(ret, RET_OK);
2085 std::pair<int32_t, int32_t> enterPos { 500, 50 };
2086 std::pair<int32_t, int32_t> leavePos { 500, 200 };
2087 SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { enterPos.first, enterPos.second },
2088 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
2089 PreviewStyle previewStyleIn;
2090 previewStyleIn.types = { PreviewType::FOREGROUND_COLOR };
2091 previewStyleIn.foregroundColor = FOREGROUND_COLOR_IN;
2092 ret = InteractionManager::GetInstance()->UpdatePreviewStyle(previewStyleIn);
2093 EXPECT_EQ(ret, RET_OK);
2094 SimulateMovePointerEvent({ enterPos.first, enterPos.second }, { leavePos.first, leavePos.second },
2095 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
2096 PreviewStyle previewStyleOut;
2097 previewStyleOut.types = { PreviewType::FOREGROUND_COLOR };
2098 previewStyleOut.foregroundColor = FOREGROUND_COLOR_OUT;
2099 ret = InteractionManager::GetInstance()->UpdatePreviewStyle(previewStyleOut);
2100 EXPECT_EQ(ret, RET_OK);
2101 SimulateMovePointerEvent({ leavePos.first, leavePos.second }, { DRAG_DST_X, DRAG_DST_Y },
2102 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
2103 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2104 InteractionManager::GetInstance()->StopDrag(dropResult);
2105 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2106 std::future_status::timeout);
2107 }
2108
2109
2110 /**
2111 * @tc.name: InteractionManagerTest_UpdatePreviewStyleWithAnimation
2112 * @tc.desc: Update drag item style with animation
2113 * @tc.type: FUNC
2114 * @tc.require:
2115 */
2116 HWTEST_F(InteractionManagerTest, InteractionManagerTest_UpdatePreviewStyleWithAnimation, TestSize.Level1)
2117 {
2118 CALL_TEST_DEBUG;
2119 std::promise<bool> promiseFlag;
2120 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c92302(const DragNotifyMsg& notifyMessage) 2121 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2122 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2123 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2124 promiseFlag.set_value(true);
2125 };
2126 SimulateDownPointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
2127 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2128 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2129 ASSERT_TRUE(dragData);
2130 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2131 std::make_shared<UnitTestStartDragListener>(callback));
2132 ASSERT_EQ(ret, RET_OK);
2133 ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
2134 EXPECT_EQ(ret, RET_OK);
2135 std::pair<int32_t, int32_t> enterPos { 500, 50 };
2136 std::pair<int32_t, int32_t> leavePos { 500, 200 };
2137 SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { enterPos.first, enterPos.second },
2138 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
2139 PreviewStyle previewStyleIn;
2140 previewStyleIn.types = { PreviewType::FOREGROUND_COLOR };
2141 previewStyleIn.foregroundColor = FOREGROUND_COLOR_IN;
2142 PreviewAnimation animationIn;
2143 AssignToAnimation(animationIn);
2144 ret = InteractionManager::GetInstance()->UpdatePreviewStyleWithAnimation(previewStyleIn, animationIn);
2145 EXPECT_EQ(ret, RET_OK);
2146 SimulateMovePointerEvent({ enterPos.first, enterPos.second }, { leavePos.first, leavePos.second },
2147 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
2148 PreviewStyle previewStyleOut;
2149 previewStyleOut.types = { PreviewType::FOREGROUND_COLOR };
2150 previewStyleOut.foregroundColor = FOREGROUND_COLOR_OUT;
2151 PreviewAnimation animationOut;
2152 AssignToAnimation(animationOut);
2153 ret = InteractionManager::GetInstance()->UpdatePreviewStyleWithAnimation(previewStyleOut, animationOut);
2154 EXPECT_EQ(ret, RET_OK);
2155 SimulateMovePointerEvent({ leavePos.first, leavePos.second }, { DRAG_DST_X, DRAG_DST_Y },
2156 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
2157 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2158 InteractionManager::GetInstance()->StopDrag(dropResult);
2159 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2160 std::future_status::timeout);
2161 }
2162
2163 /**
2164 * @tc.name: InteractionManagerTest_GetExtraInfo
2165 * @tc.desc: Get extraInfo
2166 * @tc.type: FUNC
2167 * @tc.require:
2168 */
2169 HWTEST_F(InteractionManagerTest, InteractionManagerTest_GetExtraInfo, TestSize.Level1)
2170 {
2171 CALL_TEST_DEBUG;
2172 if (g_deviceMouseId >= 0) {
2173 SimulateDownPointerEvent(
2174 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
2175 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2176 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2177 ASSERT_TRUE(dragData);
2178 std::promise<bool> promiseFlag;
2179 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c92402(const DragNotifyMsg& notifyMessage) 2180 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2181 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2182 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2183 promiseFlag.set_value(true);
2184 };
2185 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2186 std::make_shared<UnitTestStartDragListener>(callback));
2187 ASSERT_EQ(ret, RET_OK);
2188 std::string extraInfo;
2189 ret = InteractionManager::GetInstance()->GetExtraInfo(extraInfo);
2190 ASSERT_EQ(ret, RET_OK);
2191 ASSERT_EQ(extraInfo, EXTRA_INFO);
2192 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2193 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
2194 ASSERT_EQ(ret, RET_OK);
2195 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2196 std::future_status::timeout);
2197 }
2198 }
2199
2200 /**
2201 * @tc.name: TestDragDataUtil_Packer
2202 * @tc.desc: Pack up dragData
2203 * @tc.type: FUNC
2204 * @tc.require:
2205 */
2206 HWTEST_F(InteractionManagerTest, TestDragDataUtil_Packer, TestSize.Level1)
2207 {
2208 CALL_TEST_DEBUG;
2209 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2210 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2211 ASSERT_TRUE(dragData);
2212 Parcel parcel;
2213 int32_t ret = DragDataUtil::Marshalling(dragData.value(), parcel, false);
2214 ASSERT_EQ(ret, RET_OK);
2215 DragData dragDataFromParcel;
2216 ret = DragDataUtil::UnMarshalling(parcel, dragDataFromParcel, false);
2217 ASSERT_EQ(ret, RET_OK);
2218 ASSERT_EQ(dragData.value(), dragDataFromParcel);
2219 }
2220
2221 /**
2222 * @tc.name: TestDragDataUtil_Packer_Cross
2223 * @tc.desc: Pack up dragData
2224 * @tc.type: FUNC
2225 * @tc.require:
2226 */
2227 HWTEST_F(InteractionManagerTest, TestDragDataUtil_Packer_Cross, TestSize.Level1)
2228 {
2229 CALL_TEST_DEBUG;
2230 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2231 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2232 ASSERT_TRUE(dragData);
2233 Parcel parcel;
2234 int32_t ret = DragDataUtil::Marshalling(dragData.value(), parcel, true);
2235 ASSERT_EQ(ret, RET_OK);
2236 DragData dragDataFromParcel;
2237 ret = DragDataUtil::UnMarshalling(parcel, dragDataFromParcel, true);
2238 ASSERT_EQ(ret, RET_OK);
2239 ASSERT_EQ(dragData.value(), dragDataFromParcel);
2240 }
2241
2242 /**
2243 * @tc.name: InteractionManagerTest_GetDragAction_001
2244 * @tc.desc: Get drag action with no keyboard events of keys in dragging
2245 * @tc.type: FUNC
2246 * @tc.require:
2247 */
2248 HWTEST_F(InteractionManagerTest, GetDragAction_001, TestSize.Level1)
2249 {
2250 CALL_TEST_DEBUG;
2251 std::promise<bool> promiseFlag;
2252 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c92502(const DragNotifyMsg& notifyMessage) 2253 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2254 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2255 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2256 promiseFlag.set_value(true);
2257 };
2258 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2259 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2260 ASSERT_TRUE(dragData);
2261 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2262 std::make_shared<UnitTestStartDragListener>(callback));
2263 ASSERT_EQ(ret, RET_OK);
2264 DragAction dragAction { DragAction::INVALID };
2265 ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2266 EXPECT_EQ(ret, RET_OK);
2267 EXPECT_EQ(dragAction, DragAction::MOVE);
2268 PrintDragAction(dragAction);
2269 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2270 InteractionManager::GetInstance()->StopDrag(dropResult);
2271 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2272 std::future_status::timeout);
2273 ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2274 EXPECT_EQ(ret, RET_ERR);
2275 }
2276
2277 /**
2278 * @tc.name: InteractionManagerTest_GetDragAction_002
2279 * @tc.desc: Get drag action with simple press and release keyboard events of keys in dragging
2280 * @tc.type: FUNC
2281 * @tc.require:
2282 */
2283 HWTEST_F(InteractionManagerTest, GetDragAction_002, TestSize.Level1)
2284 {
2285 CALL_TEST_DEBUG;
2286 std::promise<bool> promiseFlag;
2287 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c92602(const DragNotifyMsg& notifyMessage) 2288 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2289 FI_HILOGD("DisplayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2290 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2291 promiseFlag.set_value(true);
2292 };
2293 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_INJECT_MS));
2294 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2295 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID_INJECT, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2296 ASSERT_TRUE(dragData);
2297 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2298 std::make_shared<UnitTestStartDragListener>(callback));
2299 ASSERT_EQ(ret, RET_OK);
2300 ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
2301 ASSERT_EQ(ret, RET_OK);
2302 SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
2303 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
2304 SimulateDownKeyEvent(MMI::KeyEvent::KEYCODE_CTRL_LEFT);
2305 DragAction dragAction { DragAction::INVALID };
2306 ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2307 EXPECT_EQ(ret, RET_OK);
2308 EXPECT_EQ(dragAction, DragAction::COPY);
2309 PrintDragAction(dragAction);
2310 SimulateUpKeyEvent(MMI::KeyEvent::KEYCODE_CTRL_LEFT);
2311 ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2312 EXPECT_EQ(ret, RET_OK);
2313 EXPECT_EQ(dragAction, DragAction::MOVE);
2314 PrintDragAction(dragAction);
2315 ClearUpKeyEvent();
2316 SimulateDownKeyEvent(MMI::KeyEvent::KEYCODE_A);
2317 ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2318 EXPECT_EQ(ret, RET_OK);
2319 EXPECT_EQ(dragAction, DragAction::MOVE);
2320 PrintDragAction(dragAction);
2321 SimulateUpKeyEvent(MMI::KeyEvent::KEYCODE_A);
2322 ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2323 EXPECT_EQ(ret, RET_OK);
2324 EXPECT_EQ(dragAction, DragAction::MOVE);
2325 PrintDragAction(dragAction);
2326 ClearUpKeyEvent();
2327 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2328 InteractionManager::GetInstance()->StopDrag(dropResult);
2329 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2330 std::future_status::timeout);
2331 ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2332 EXPECT_EQ(ret, RET_ERR);
2333 }
2334
2335 /**
2336 * @tc.name: InteractionManagerTest_GetDragAction_003
2337 * @tc.desc: Get drag action with simple press and release keyboard events of keys in start drag
2338 * @tc.type: FUNC
2339 * @tc.require:
2340 */
2341 HWTEST_F(InteractionManagerTest, GetDragAction_003, TestSize.Level1)
2342 {
2343 CALL_TEST_DEBUG;
2344 if (g_deviceMouseId < 0) {
2345 ASSERT_TRUE(g_deviceMouseId < 0);
2346 } else {
2347 int32_t ret = RET_ERR;
2348 std::promise<bool> promiseFlag;
2349 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c92702(const DragNotifyMsg& notifyMessage) 2350 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2351 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2352 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2353 promiseFlag.set_value(true);
2354 };
2355 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2356 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2357 ASSERT_TRUE(dragData);
2358 ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2359 std::make_shared<UnitTestStartDragListener>(callback));
2360 ASSERT_EQ(ret, RET_OK);
2361 ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
2362 ASSERT_EQ(ret, RET_OK);
2363 DragAction dragAction { DragAction::INVALID };
2364 ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2365 EXPECT_EQ(ret, RET_OK);
2366 EXPECT_EQ(dragAction, DragAction::MOVE);
2367 PrintDragAction(dragAction);
2368 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2369 InteractionManager::GetInstance()->StopDrag(dropResult);
2370 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2371 std::future_status::timeout);
2372 ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2373 EXPECT_EQ(ret, RET_ERR);
2374 }
2375 }
2376
2377 /**
2378 * @tc.name: InteractionManagerTest_GetDragAction_004
2379 * @tc.desc: Get drag action with multiple press and release keyboard events of keys in dragging
2380 * @tc.type: FUNC
2381 * @tc.require:
2382 */
2383 HWTEST_F(InteractionManagerTest, GetDragAction_004, TestSize.Level1)
2384 {
2385 CALL_TEST_DEBUG;
2386 std::promise<bool> promiseFlag;
2387 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c92802(const DragNotifyMsg& notifyMessage) 2388 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2389 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2390 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2391 promiseFlag.set_value(true);
2392 };
2393 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2394 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID_INJECT, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2395 ASSERT_TRUE(dragData);
2396 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2397 std::make_shared<UnitTestStartDragListener>(callback));
2398 ASSERT_EQ(ret, RET_OK);
2399 ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
2400 ASSERT_EQ(ret, RET_OK);
2401 SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
2402 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
2403 SimulateDownKeyEvent(MMI::KeyEvent::KEYCODE_CTRL_LEFT);
2404 SimulateDownKeyEvent(MMI::KeyEvent::KEYCODE_A);
2405 DragAction dragAction { DragAction::INVALID };
2406 ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2407 EXPECT_EQ(ret, RET_OK);
2408 EXPECT_EQ(dragAction, DragAction::COPY);
2409 SimulateUpKeyEvent(MMI::KeyEvent::KEYCODE_A);
2410 ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2411 EXPECT_EQ(ret, RET_OK);
2412 EXPECT_EQ(dragAction, DragAction::COPY);
2413 ClearUpKeyEvent();
2414 SimulateDownKeyEvent(MMI::KeyEvent::KEYCODE_B);
2415 ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2416 EXPECT_EQ(ret, RET_OK);
2417 EXPECT_EQ(dragAction, DragAction::COPY);
2418 SimulateUpKeyEvent(MMI::KeyEvent::KEYCODE_CTRL_LEFT);
2419 ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2420 EXPECT_EQ(ret, RET_OK);
2421 EXPECT_EQ(dragAction, DragAction::MOVE);
2422 ClearUpKeyEvent();
2423 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2424 InteractionManager::GetInstance()->StopDrag(dropResult);
2425 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2426 std::future_status::timeout);
2427 ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2428 EXPECT_EQ(ret, RET_ERR);
2429 }
2430
2431 /**
2432 * @tc.name: InteractionManagerTest_GetDragAction_005
2433 * @tc.desc: Get style notification with multiple press and release keyboard events of keys in dragging
2434 * @tc.type: FUNC
2435 * @tc.require:
2436 */
2437
2438 HWTEST_F(InteractionManagerTest, GetDragAction_005, TestSize.Level1)
2439 {
2440 CALL_TEST_DEBUG;
2441 auto listener = std::make_shared<SubscriptListenerTest>("SubscriptListener");
2442 int32_t ret = InteractionManager::GetInstance()->AddSubscriptListener(listener);
2443 ASSERT_EQ(ret, RET_OK);
2444 std::promise<bool> promiseFlag;
2445 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c92902(const DragNotifyMsg& notifyMessage) 2446 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2447 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2448 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2449 promiseFlag.set_value(true);
2450 };
2451 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2452 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID_INJECT, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2453 ASSERT_TRUE(dragData);
2454 ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2455 std::make_shared<UnitTestStartDragListener>(callback));
2456 ASSERT_EQ(ret, RET_OK);
2457 ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
2458 ASSERT_EQ(ret, RET_OK);
2459 SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
2460 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
2461 DragCursorStyle recvStyle = listener->GetDragStyle();
2462 EXPECT_EQ(recvStyle, DragCursorStyle::MOVE);
2463 SimulateDownKeyEvent(MMI::KeyEvent::KEYCODE_CTRL_LEFT);
2464 SimulateDownKeyEvent(MMI::KeyEvent::KEYCODE_B);
2465 recvStyle = listener->GetDragStyle();
2466 EXPECT_EQ(recvStyle, DragCursorStyle::COPY);
2467 SimulateUpKeyEvent(MMI::KeyEvent::KEYCODE_CTRL_LEFT);
2468 ClearUpKeyEvent();
2469 recvStyle = listener->GetDragStyle();
2470 EXPECT_EQ(recvStyle, DragCursorStyle::MOVE);
2471 SimulateDownKeyEvent(MMI::KeyEvent::KEYCODE_CTRL_RIGHT);
2472 recvStyle = listener->GetDragStyle();
2473 EXPECT_EQ(recvStyle, DragCursorStyle::COPY);
2474 SimulateUpKeyEvent(MMI::KeyEvent::KEYCODE_B);
2475 ClearUpKeyEvent();
2476 recvStyle = listener->GetDragStyle();
2477 EXPECT_EQ(recvStyle, DragCursorStyle::COPY);
2478 SimulateUpKeyEvent(MMI::KeyEvent::KEYCODE_CTRL_RIGHT);
2479 ClearUpKeyEvent();
2480 recvStyle = listener->GetDragStyle();
2481 EXPECT_EQ(recvStyle, DragCursorStyle::MOVE);
2482 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2483 InteractionManager::GetInstance()->StopDrag(dropResult);
2484 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2485 std::future_status::timeout);
2486 ret = InteractionManager::GetInstance()->RemoveSubscriptListener(listener);
2487 ASSERT_EQ(ret, RET_OK);
2488 }
2489
2490 /**
2491 * @tc.name: InteractionManagerTest_CheckDragBehavior_001
2492 * @tc.desc: Check drag behavior
2493 * @tc.type: FUNC
2494 * @tc.require:
2495 */
2496 HWTEST_F(InteractionManagerTest, CheckDragBehavior_001, TestSize.Level1)
2497 {
2498 CALL_TEST_DEBUG;
2499 std::promise<bool> promiseFlag;
2500 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c92a02(const DragNotifyMsg& notifyMessage) 2501 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2502 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, dragBehavior:%{public}d",
2503 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.dragBehavior);
2504 ASSERT_EQ(notifyMessage.dragBehavior, DragBehavior::COPY);
2505 promiseFlag.set_value(true);
2506 };
2507 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2508 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2509 ASSERT_TRUE(dragData);
2510 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2511 std::make_shared<UnitTestStartDragListener>(callback));
2512 ASSERT_EQ(ret, RET_OK);
2513 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION,
2514 TARGET_MAIN_WINDOW, DragBehavior::COPY };
2515 InteractionManager::GetInstance()->StopDrag(dropResult);
2516 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2517 std::future_status::timeout);
2518 }
2519
2520 /**
2521 * @tc.name: InteractionManagerTest_CheckDragBehavior_002
2522 * @tc.desc: Check drag behavior
2523 * @tc.type: FUNC
2524 * @tc.require:
2525 */
2526 HWTEST_F(InteractionManagerTest, CheckDragBehavior_002, TestSize.Level1)
2527 {
2528 CALL_TEST_DEBUG;
2529 std::promise<bool> promiseFlag;
2530 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c92b02(const DragNotifyMsg& notifyMessage) 2531 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2532 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, dragBehavior:%{public}d",
2533 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.dragBehavior);
2534 ASSERT_EQ(notifyMessage.dragBehavior, DragBehavior::MOVE);
2535 promiseFlag.set_value(true);
2536 };
2537 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2538 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2539 ASSERT_TRUE(dragData);
2540 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2541 std::make_shared<UnitTestStartDragListener>(callback));
2542 ASSERT_EQ(ret, RET_OK);
2543 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION,
2544 TARGET_MAIN_WINDOW, DragBehavior::MOVE };
2545 InteractionManager::GetInstance()->StopDrag(dropResult);
2546 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2547 std::future_status::timeout);
2548 }
2549
2550 /**
2551 * @tc.name: InteractionManagerTest_CheckDragBehavior_003
2552 * @tc.desc: Check drag behavior
2553 * @tc.type: FUNC
2554 * @tc.require:
2555 */
2556 HWTEST_F(InteractionManagerTest, CheckDragBehavior_003, TestSize.Level1)
2557 {
2558 CALL_TEST_DEBUG;
2559 std::promise<bool> promiseFlag;
2560 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c92c02(const DragNotifyMsg& notifyMessage) 2561 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2562 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, dragBehavior:%{public}d",
2563 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.dragBehavior);
2564 ASSERT_EQ(notifyMessage.dragBehavior, DragBehavior::COPY);
2565 promiseFlag.set_value(true);
2566 };
2567 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2568 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2569 ASSERT_TRUE(dragData);
2570 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2571 std::make_shared<UnitTestStartDragListener>(callback));
2572 ASSERT_EQ(ret, RET_OK);
2573 ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::COPY);
2574 ASSERT_EQ(ret, RET_OK);
2575 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
2576 InteractionManager::GetInstance()->StopDrag(dropResult);
2577 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2578 std::future_status::timeout);
2579 }
2580
2581 /**
2582 * @tc.name: InteractionManagerTest_CheckDragBehavior_004
2583 * @tc.desc: Check drag behavior
2584 * @tc.type: FUNC
2585 * @tc.require:
2586 */
2587 HWTEST_F(InteractionManagerTest, CheckDragBehavior_004, TestSize.Level1)
2588 {
2589 CALL_TEST_DEBUG;
2590 std::promise<bool> promiseFlag;
2591 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c92d02(const DragNotifyMsg& notifyMessage) 2592 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2593 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, dragBehavior:%{public}d",
2594 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.dragBehavior);
2595 ASSERT_EQ(notifyMessage.dragBehavior, DragBehavior::MOVE);
2596 promiseFlag.set_value(true);
2597 };
2598 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2599 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2600 ASSERT_TRUE(dragData);
2601 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2602 std::make_shared<UnitTestStartDragListener>(callback));
2603 ASSERT_EQ(ret, RET_OK);
2604 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
2605 InteractionManager::GetInstance()->StopDrag(dropResult);
2606 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2607 std::future_status::timeout);
2608 }
2609
2610 /**
2611 * @tc.name: InteractionManagerTest_CheckDragBehavior_005
2612 * @tc.desc: Check drag behavior
2613 * @tc.type: FUNC
2614 * @tc.require:
2615 */
2616 HWTEST_F(InteractionManagerTest, CheckDragBehavior_005, TestSize.Level1)
2617 {
2618 CALL_TEST_DEBUG;
2619 std::promise<bool> promiseFlag;
2620 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c92e02(const DragNotifyMsg& notifyMessage) 2621 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2622 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, dragBehavior:%{public}d",
2623 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.dragBehavior);
2624 ASSERT_EQ(notifyMessage.dragBehavior, DragBehavior::COPY);
2625 promiseFlag.set_value(true);
2626 };
2627 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2628 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2629 ASSERT_TRUE(dragData);
2630 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2631 std::make_shared<UnitTestStartDragListener>(callback));
2632 ASSERT_EQ(ret, RET_OK);
2633 int32_t targetMainWindow = 1;
2634 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, targetMainWindow };
2635 InteractionManager::GetInstance()->StopDrag(dropResult);
2636 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2637 std::future_status::timeout);
2638 }
2639
2640 /**
2641 * @tc.name: InteractionManagerTest_CheckDragBehavior_006
2642 * @tc.desc: Check drag behavior
2643 * @tc.type: FUNC
2644 * @tc.require:
2645 */
2646 HWTEST_F(InteractionManagerTest, CheckDragBehavior_006, TestSize.Level1)
2647 {
2648 CALL_TEST_DEBUG;
2649 std::promise<bool> promiseFlag;
2650 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c92f02(const DragNotifyMsg& notifyMessage) 2651 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2652 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, dragBehavior:%{public}d",
2653 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.dragBehavior);
2654 ASSERT_EQ(notifyMessage.dragBehavior, DragBehavior::UNKNOWN);
2655 promiseFlag.set_value(true);
2656 };
2657 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2658 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2659 ASSERT_TRUE(dragData);
2660 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2661 std::make_shared<UnitTestStartDragListener>(callback));
2662 ASSERT_EQ(ret, RET_OK);
2663 DragDropResult dropResult { DragResult::DRAG_FAIL, HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
2664 InteractionManager::GetInstance()->StopDrag(dropResult);
2665 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2666 std::future_status::timeout);
2667 }
2668
2669 /**
2670 * @tc.name: InteractionManagerTest_StartDrag_Shadow
2671 * @tc.desc: Check drag shadow
2672 * @tc.type: FUNC
2673 * @tc.require:
2674 */
2675 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_Shadow, TestSize.Level1)
2676 {
2677 CALL_TEST_DEBUG;
2678 std::promise<bool> promiseFlag;
2679 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c93002(const DragNotifyMsg& notifyMessage) 2680 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2681 FI_HILOGD("Param displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2682 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2683 promiseFlag.set_value(true);
2684 };
2685 SimulateDownPointerEvent(
2686 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
2687 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2688 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2689 ASSERT_TRUE(dragData);
2690 dragData->filterInfo = "{ \"dip_scale\": 3.5, \"drag_shadow_offsetX\": 30, \"drag_shadow_offsetY\": 30, "
2691 "\"drag_shadow_argb\": 4294967295, \"drag_shadow_path\": \"M 10 10 H 80 V 80 H 10 L 10 10\", "
2692 "\"shadow_color_strategy\": 0, \"shadow_is_hardwareacceleration\": true, \"shadow_elevation\": 120, "
2693 "\"drag_type\": \"text\", \"shadow_enable\": true }";
2694 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2695 std::make_shared<UnitTestStartDragListener>(callback));
2696 ASSERT_EQ(ret, RET_OK);
2697 ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
2698 EXPECT_EQ(ret, RET_OK);
2699 SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
2700 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
2701 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2702 InteractionManager::GetInstance()->StopDrag(dropResult);
2703 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2704 std::future_status::timeout);
2705 }
2706
2707 /**
2708 * @tc.name: InteractionManagerTest_StartDrag_ShadowAlpha
2709 * @tc.desc: Check drag shadow alpha
2710 * @tc.type: FUNC
2711 * @tc.require:
2712 */
2713 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_ShadowAlpha, TestSize.Level1)
2714 {
2715 CALL_TEST_DEBUG;
2716 std::promise<bool> promiseFlag;
2717 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c93102(const DragNotifyMsg& notifyMessage) 2718 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2719 FI_HILOGD("Param displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2720 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2721 promiseFlag.set_value(true);
2722 };
2723 SimulateDownPointerEvent(
2724 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
2725 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2726 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2727 ASSERT_TRUE(dragData);
2728 dragData->filterInfo = "{ \"dip_scale\": 3.5, \"drag_shadow_offsetX\": 30, \"drag_shadow_offsetY\": 30, "
2729 "\"drag_shadow_argb\": 872415231, \"drag_shadow_path\": \"M 10 10 H 80 V 80 H 10 L 10 10\", "
2730 "\"shadow_color_strategy\": 0, \"shadow_is_hardwareacceleration\": true, \"shadow_elevation\": 120, "
2731 "\"drag_type\": \"text\", \"shadow_enable\": true }";
2732 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2733 std::make_shared<UnitTestStartDragListener>(callback));
2734 ASSERT_EQ(ret, RET_OK);
2735 ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
2736 EXPECT_EQ(ret, RET_OK);
2737 SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
2738 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
2739 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2740 InteractionManager::GetInstance()->StopDrag(dropResult);
2741 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2742 std::future_status::timeout);
2743 }
2744
2745 /**
2746 * @tc.name: InteractionManagerTest_StartDrag_ShadowColor
2747 * @tc.desc: Check drag shadow color
2748 * @tc.type: FUNC
2749 * @tc.require:
2750 */
2751 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_ShadowColor, TestSize.Level1)
2752 {
2753 CALL_TEST_DEBUG;
2754 std::promise<bool> promiseFlag;
2755 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c93202(const DragNotifyMsg& notifyMessage) 2756 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2757 FI_HILOGD("Param displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2758 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2759 promiseFlag.set_value(true);
2760 };
2761 SimulateDownPointerEvent(
2762 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
2763 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2764 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2765 ASSERT_TRUE(dragData);
2766 dragData->filterInfo = "{ \"dip_scale\": 3.5, \"drag_shadow_offsetX\": 30, \"drag_shadow_offsetY\": 30, "
2767 "\"drag_shadow_argb\": 872415231, \"drag_shadow_path\": \"M 10 10 H 80 V 80 H 10 L 10 10\", "
2768 "\"shadow_color_strategy\": 0, \"shadow_is_hardwareacceleration\": true, \"shadow_elevation\": 120, "
2769 "\"drag_type\": \"text\", \"shadow_enable\": true }";
2770 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2771 std::make_shared<UnitTestStartDragListener>(callback));
2772 ASSERT_EQ(ret, RET_OK);
2773 ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
2774 EXPECT_EQ(ret, RET_OK);
2775 SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
2776 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
2777 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2778 InteractionManager::GetInstance()->StopDrag(dropResult);
2779 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2780 std::future_status::timeout);
2781 }
2782
2783 /**
2784 * @tc.name: InteractionManagerTest_StartDrag_ShadowOffset
2785 * @tc.desc: Check drag shadow offset
2786 * @tc.type: FUNC
2787 * @tc.require:
2788 */
2789 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_ShadowOffset, TestSize.Level1)
2790 {
2791 CALL_TEST_DEBUG;
2792 std::promise<bool> promiseFlag;
2793 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c93302(const DragNotifyMsg& notifyMessage) 2794 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2795 FI_HILOGD("Param displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2796 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2797 promiseFlag.set_value(true);
2798 };
2799 SimulateDownPointerEvent(
2800 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
2801 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2802 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2803 ASSERT_TRUE(dragData);
2804 dragData->filterInfo = "{ \"dip_scale\": 3.5, \"drag_shadow_offsetX\": 50, \"drag_shadow_offsetY\": 50, "
2805 "\"drag_shadow_argb\": 872415231, \"drag_shadow_path\": \"M 10 10 H 80 V 80 H 10 L 10 10\", "
2806 "\"shadow_color_strategy\": 0, \"shadow_is_hardwareacceleration\": true, \"shadow_elevation\": 120, "
2807 "\"drag_type\": \"text\", \"shadow_enable\": true }";
2808 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2809 std::make_shared<UnitTestStartDragListener>(callback));
2810 ASSERT_EQ(ret, RET_OK);
2811 ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
2812 EXPECT_EQ(ret, RET_OK);
2813 SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
2814 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
2815 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2816 InteractionManager::GetInstance()->StopDrag(dropResult);
2817 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2818 std::future_status::timeout);
2819 }
2820
2821 /**
2822 * @tc.name: InteractionManagerTest_StartDrag_ShadowCornerRadius
2823 * @tc.desc: Check drag shadow corner radius
2824 * @tc.type: FUNC
2825 * @tc.require:
2826 */
2827 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_ShadowCornerRadius, TestSize.Level1)
2828 {
2829 CALL_TEST_DEBUG;
2830 std::promise<bool> promiseFlag;
2831 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c93402(const DragNotifyMsg& notifyMessage) 2832 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2833 FI_HILOGD("Param displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2834 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2835 promiseFlag.set_value(true);
2836 };
2837 SimulateDownPointerEvent(
2838 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
2839 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2840 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2841 ASSERT_TRUE(dragData);
2842 dragData->filterInfo = "{ \"dip_scale\": 3.5, \"drag_shadow_offsetX\": 30, \"drag_shadow_offsetY\": 30, "
2843 "\"drag_shadow_argb\": 872415231, \"drag_shadow_path\": \"M 10 10 H 80 V 80 H 10 L 10 10\", "
2844 "\"shadow_color_strategy\": 0, \"shadow_is_hardwareacceleration\": false, \"shadow_corner\": 120, "
2845 "\"drag_type\": \"text\", \"shadow_enable\": true }";
2846 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2847 std::make_shared<UnitTestStartDragListener>(callback));
2848 ASSERT_EQ(ret, RET_OK);
2849 ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
2850 EXPECT_EQ(ret, RET_OK);
2851 SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
2852 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
2853 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2854 InteractionManager::GetInstance()->StopDrag(dropResult);
2855 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2856 std::future_status::timeout);
2857 }
2858
2859 /**
2860 * @tc.name: InteractionManagerTest_StartDrag_ShadowPath001
2861 * @tc.desc: Check drag shadow path
2862 * @tc.type: FUNC
2863 * @tc.require:
2864 */
2865 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_ShadowPath001, TestSize.Level1)
2866 {
2867 CALL_TEST_DEBUG;
2868 std::promise<bool> promiseFlag;
2869 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c93502(const DragNotifyMsg& notifyMessage) 2870 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2871 FI_HILOGD("Param displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2872 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2873 promiseFlag.set_value(true);
2874 };
2875 SimulateDownPointerEvent(
2876 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
2877 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2878 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2879 ASSERT_TRUE(dragData);
2880 dragData->filterInfo = "{ \"dip_scale\": 3.5, \"drag_shadow_offsetX\": 50, \"drag_shadow_offsetY\": 50, "
2881 "\"drag_shadow_argb\": 872415231, \"drag_shadow_path\": \"M 10 10 H 90 V 90 H 10 L 10 10\", "
2882 "\"shadow_color_strategy\": 0, \"shadow_is_hardwareacceleration\": true, \"shadow_elevation\": 120, "
2883 "\"drag_type\": \"text\", \"shadow_enable\": true }";
2884 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2885 std::make_shared<UnitTestStartDragListener>(callback));
2886 ASSERT_EQ(ret, RET_OK);
2887 ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
2888 EXPECT_EQ(ret, RET_OK);
2889 SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
2890 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
2891 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2892 InteractionManager::GetInstance()->StopDrag(dropResult);
2893 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2894 std::future_status::timeout);
2895 }
2896
2897 /**
2898 * @tc.name: InteractionManagerTest_StartDrag_ShadowPath002
2899 * @tc.desc: Check drag shadow path
2900 * @tc.type: FUNC
2901 * @tc.require:
2902 */
2903 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_ShadowPath002, TestSize.Level1)
2904 {
2905 CALL_TEST_DEBUG;
2906 std::promise<bool> promiseFlag;
2907 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c93602(const DragNotifyMsg& notifyMessage) 2908 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2909 FI_HILOGD("Param displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2910 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2911 promiseFlag.set_value(true);
2912 };
2913 SimulateDownPointerEvent(
2914 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
2915 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2916 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2917 ASSERT_TRUE(dragData);
2918 dragData->filterInfo = "{ \"dip_scale\": 3.5, \"drag_shadow_offsetX\": 50, \"drag_shadow_offsetY\": 50, "
2919 "\"drag_shadow_argb\": 872415231, "
2920 "\"shadow_color_strategy\": 0, \"shadow_is_hardwareacceleration\": true, \"shadow_elevation\": 120, "
2921 "\"drag_type\": \"text\", \"shadow_enable\": true }";
2922 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2923 std::make_shared<UnitTestStartDragListener>(callback));
2924 ASSERT_EQ(ret, RET_OK);
2925 ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
2926 EXPECT_EQ(ret, RET_OK);
2927 SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
2928 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
2929 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2930 InteractionManager::GetInstance()->StopDrag(dropResult);
2931 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2932 std::future_status::timeout);
2933 }
2934
2935 /**
2936 * @tc.name: InteractionManagerTest_StartDrag_NonTextShadow
2937 * @tc.desc: Check non-text drag shadow
2938 * @tc.type: FUNC
2939 * @tc.require:
2940 */
2941 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_NonTextShadow, TestSize.Level1)
2942 {
2943 CALL_TEST_DEBUG;
2944 std::promise<bool> promiseFlag;
2945 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c93702(const DragNotifyMsg& notifyMessage) 2946 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2947 FI_HILOGD("Param displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2948 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2949 promiseFlag.set_value(true);
2950 };
2951 SimulateDownPointerEvent(
2952 { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
2953 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2954 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2955 ASSERT_TRUE(dragData);
2956 dragData->filterInfo = "{ \"dip_scale\": 3.5, \"drag_shadow_offsetX\": 50, \"drag_shadow_offsetY\": 50, "
2957 "\"drag_shadow_argb\": 872415231, "
2958 "\"shadow_color_strategy\": 0, \"shadow_is_hardwareacceleration\": true, \"shadow_elevation\": 120, "
2959 "\"drag_type\": \"non-text\", \"shadow_enable\": true }";
2960 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2961 std::make_shared<UnitTestStartDragListener>(callback));
2962 ASSERT_EQ(ret, RET_OK);
2963 ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
2964 EXPECT_EQ(ret, RET_OK);
2965 SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
2966 MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
2967 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2968 InteractionManager::GetInstance()->StopDrag(dropResult);
2969 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2970 std::future_status::timeout);
2971 ret = InteractionManager::GetInstance()->EraseMouseIcon();
2972 EXPECT_NE(ret, RET_OK);
2973 ret = InteractionManager::GetInstance()->SetMouseDragMonitorState(0);
2974 EXPECT_EQ(ret, RET_OK);
2975 }
2976
2977 /**
2978 * @tc.name: InteractionManagerTest_SetDragSwitchState
2979 * @tc.desc: Get drag summarys
2980 * @tc.type: FUNC
2981 * @tc.require:
2982 */
2983 HWTEST_F(InteractionManagerTest, InteractionManagerTest_SetDragSwitchState, TestSize.Level1)
2984 {
2985 CALL_TEST_DEBUG;
2986 std::promise<bool> promiseFlag;
2987 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c93802(const DragNotifyMsg& notifyMessage) 2988 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2989 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2990 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2991 promiseFlag.set_value(true);
2992 };
2993 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2994 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2995 ASSERT_TRUE(dragData);
2996 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2997 std::make_shared<UnitTestStartDragListener>(callback));
2998 ASSERT_EQ(ret, RET_OK);
2999 ret = InteractionManager::GetInstance()->SetDragSwitchState(true, true);
3000 EXPECT_EQ(ret, RET_OK);
3001 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
3002 InteractionManager::GetInstance()->StopDrag(dropResult);
3003 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
3004 std::future_status::timeout);
3005 }
3006
3007 /**
3008 * @tc.name: InteractionManagerTest_SetDraggableState
3009 * @tc.desc: Get drag summarys
3010 * @tc.type: FUNC
3011 * @tc.require:
3012 */
3013 HWTEST_F(InteractionManagerTest, InteractionManagerTest_SetDraggableState, TestSize.Level1)
3014 {
3015 CALL_TEST_DEBUG;
3016 std::promise<bool> promiseFlag;
3017 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c93902(const DragNotifyMsg& notifyMessage) 3018 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
3019 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
3020 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
3021 promiseFlag.set_value(true);
3022 };
3023 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
3024 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
3025 ASSERT_TRUE(dragData);
3026 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
3027 std::make_shared<UnitTestStartDragListener>(callback));
3028 ASSERT_EQ(ret, RET_OK);
3029
3030 ret = InteractionManager::GetInstance()->SetDraggableState(true);
3031 EXPECT_EQ(ret, RET_OK);
3032 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
3033 InteractionManager::GetInstance()->StopDrag(dropResult);
3034 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
3035 std::future_status::timeout);
3036 }
3037
3038 /**
3039 * @tc.name: InteractionManagerTest_SetAppDragSwitchState
3040 * @tc.desc: Get drag summarys
3041 * @tc.type: FUNC
3042 * @tc.require:
3043 */
3044 HWTEST_F(InteractionManagerTest, InteractionManagerTest_SetAppDragSwitchState, TestSize.Level1)
3045 {
3046 CALL_TEST_DEBUG;
3047 std::promise<bool> promiseFlag;
3048 std::future<bool> futureFlag = promiseFlag.get_future();
__anon501201c93a02(const DragNotifyMsg& notifyMessage) 3049 auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
3050 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
3051 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
3052 promiseFlag.set_value(true);
3053 };
3054 std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
3055 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
3056 ASSERT_TRUE(dragData);
3057 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
3058 std::make_shared<UnitTestStartDragListener>(callback));
3059 ASSERT_EQ(ret, RET_OK);
3060 const std::string pkgName = "testpkgName";
3061 ret = InteractionManager::GetInstance()->SetAppDragSwitchState(true, pkgName, true);
3062 EXPECT_EQ(ret, RET_OK);
3063 DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
3064 InteractionManager::GetInstance()->StopDrag(dropResult);
3065 ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
3066 std::future_status::timeout);
3067 }
3068 } // namespace DeviceStatus
3069 } // namespace Msdp
3070 } // namespace OHOS
3071
3072