A tap can select a button, but it cannot scroll a list, drag an item, move a slider, or reveal content beyond the visible screen. Those interactions need a gesture with a clear start and destination. Replaying it reliably also requires more than guessing two coordinates.
EmuloAgent includes a Swipe (x, y) action for Android emulator macros on Windows. You draw the gesture over a current emulator screenshot, then configure its trajectory, speed, repetitions, and the gap between repeats. This guide shows how to build that action and test it without turning a simple scroll into a fragile step.
Automate only where the app, game, or service allows it. A swipe action reproduces an interface gesture; it does not change third-party rules or access controls.
Choose Swipe when the movement matters
Use Swipe (x, y) when the interface must receive a drag from one point to another. Typical examples include:
- scrolling a list up or down;
- moving between pages in a horizontal carousel;
- dragging an item into a target area;
- moving a slider to an approximate position;
- repeating the same directional gesture several times.
Do not use a swipe just to reach a visible button. A tap action is simpler for a fixed point, while Click on image is more appropriate when the target can move and has a stable visual reference. The action should express the interaction the Android interface actually expects.
Prepare the emulator screen before capturing the gesture
Open the emulator profile at the exact screen where the drag will happen. Make sure the visible content, orientation, and resolution match the state expected during execution.
The swipe stores an origin and destination in emulator-screen coordinates. If the macro is captured at one resolution and later runs at another, the same coordinates may point to different interface areas. Keep the profile resolution stable and follow the one-profile stabilization checklist before expanding execution.
If EmuloAgent cannot capture or control the emulator, confirm its ADB connection first. The emulator preparation guide covers MuMu Player, BlueStacks, LDPlayer, and Nox.
How to add a swipe action in EmuloAgent
1. Start a new action
Open the macro in the builder, select Add Action, and choose New Action. In the Gesture section, select Swipe (x, y).
EmuloAgent opens the gesture picker over a screenshot of the selected emulator profile. The line on that capture represents the movement the macro will send to Android.
2. Place the origin and destination
Move the first handle to the point where the gesture should begin and the second handle to where it should end.
Direction is significant:
- to scroll the visible content downward and reveal items below, the finger-like movement usually starts lower and travels upward;
- to return toward earlier content, it usually starts higher and travels downward;
- for a horizontal carousel, place both points at a similar vertical position and move left or right.
Leave the endpoints away from navigation bars, thin screen edges, and unrelated controls. A long list usually needs a gesture in a quiet central area, not directly over a button that could react to the initial touch.
3. Choose a straight or curved trajectory
The Trajectory field offers Straight and Curved.
Use Straight for ordinary list scrolling, horizontal paging, and most direct drags. It is the default and sends one native Android swipe per repetition.
Use Curved only when the path itself must avoid an interface area or approximate a non-linear drag. The picker exposes control points for shaping the curve. Internally, EmuloAgent approximates that curve with consecutive short swipes, so it is not identical to one uninterrupted finger contact. Test it on the real target interaction before depending on it.
Set speed for the interface, not for appearance
The action provides Slow, Medium, and Fast speed presets. Start with Medium.
Choose Slow when the interface treats a quick movement as a fling, when an item must remain pressed while being dragged, or when the destination needs more control. Choose Fast when the application clearly accepts a short flick and the next step does not depend on a precise stopping point.
Speed can change the result even when the endpoints stay the same. A fast upward swipe may advance much farther through a list than a slow drag. Treat speed as part of the action’s behavior, not as a cosmetic setting.
Repeat the gesture without hiding the screen state
EmuloAgent can repeat the same swipe from 1 to 20 times and insert a 0 to 1,000 ms gap between repetitions. Repeats are useful when a known screen always needs several page-length movements.
Avoid selecting a high count merely to guarantee that the macro reaches the bottom. The list may be shorter on another account, content can load between gestures, or a button may move under the swipe area. Prefer the smallest predictable count.
When the destination depends on what appears, split the movement into controlled steps:
- perform one swipe;
- wait for the screen to settle;
- check an image, color, or text signal;
- swipe again only if the target state is still absent.
The guide to combining AND and OR conditions explains how to protect an action with screen-state checks.
Practical example: reveal an item in a settings list
Suppose a settings page always opens at the top and the required option appears after two controlled scrolls.
Configure the action like this:
- origin: a quiet point in the lower-middle part of the list;
- destination: a point in the upper-middle part of the list;
- trajectory: Straight;
- speed: Medium;
- repetitions: 2;
- gap: enough time for the interface to finish the first movement before the second begins.
After the swipe action, add a condition to the next action that confirms the option is actually visible. Do not assume that two gestures always produce the same final pixels if the list contains dynamic content.
For a carousel, use one horizontal swipe and verify the next page by a stable title or image. For a drag-and-drop interaction, begin inside the draggable object, end inside the target, and test Slow before increasing speed.
Test the gesture as an action and as part of the macro
Use this checklist before saving the workflow as ready:
- run the swipe action on the expected starting screen;
- confirm that the direction and stopping area are correct;
- test every repetition, not only the first one;
- verify that the gap allows the interface to settle;
- try the action from a slightly different content position;
- test the next action to confirm it sees the expected result;
- save, close, reopen, and run the full macro on one profile.
If the gesture begins correctly but the macro later drifts, reduce the number of repeats and add a visual check between movements. If it starts from the wrong place, review the captured resolution and endpoints. If a curved drag fails while a straight one works, the target may require continuous contact that the approximated curve does not provide.
Keep each swipe tied to an observable result
A reliable swipe macro does not just move from A to B. It starts from a known screen, uses a deliberate direction and speed, and confirms what the movement revealed. Capture the endpoints on the real emulator screen, begin with a straight medium-speed gesture, and add repetition only after one pass behaves consistently.