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