Starting an Android macro is only part of running it safely. You also need a control that remains available when the target app is in front: pause before handling an unexpected screen, resume after checking the context, or stop the session when the routine should end.
EmuloMobile provides that control as a draggable bubble over the Android screen. After you prepare a macro, the expanded bubble shows Play, Pause, and Stop. It can also collapse into one status button when you need more screen space.
This guide explains the complete operating flow and, most importantly, the difference between pausing and stopping an automation.
When an on-screen control is useful
A target app does not always stay in the expected state. A system dialog can appear, a login can expire, a notification can cover a region, or you may need to inspect the result before allowing the next action.
The floating control gives you a manual checkpoint without returning to EmuloMobile. It is useful when you want to:
- watch the first cycles of a new macro closely;
- pause before interacting manually with the target app;
- inspect an unexpected screen without ending the prepared session;
- stop immediately when the intended routine is complete;
- keep the controls reachable while another app occupies the screen.
The bubble is an operating control, not a replacement for good conditions. Actions should still be protected by image, color, text, or variable checks appropriate to the flow. If you are building your first macro, start with the guide to on-device Android automation.
Prepare the macro before opening the target app
EmuloMobile validates the environment before showing a prepared execution. Three details matter:
- the EmuloMobile accessibility service must be enabled;
- the current resolution and orientation must match the values stored with the macro;
- no other macro can already have an active execution on that device.
The accessibility service performs the gestures you configured and provides the control overlay. Screen analysis uses the screen-capture session. If capture consent is not already active, Android asks for it while you prepare the execution.
One EmuloMobile execution runs at a time on a device. To switch to another unrelated macro manually, stop the current session first, then prepare the next one.
How to start a macro with the floating controls
Open Automations in EmuloMobile and find the macro you want to run.
1. Check the device mode
Confirm that the phone or emulator is using the same resolution and portrait or landscape orientation in which the macro was created. EmuloMobile blocks preparation when either value differs, because saved regions and coordinates belong to that display geometry.
2. Select the macro’s Play control
Select Play on the macro card. This prepares the execution; it does not immediately let the flow act on the screen. If a requirement is missing, EmuloMobile shows why preparation could not continue.
3. Grant screen capture when Android asks
Approve the Android screen-capture prompt if there is no active capture session. EmuloMobile uses captured pixels for the visual conditions in the macro. The Tap Text OCR tutorial shows one example of an action that reads those pixels on the device.
4. Wait for the bubble, then open the target screen
When preparation finishes, the floating bubble appears in a waiting state. Navigate to the intended starting screen and move the bubble by dragging it if it covers an important control or detection region.
5. Tap Play in the bubble
Tap the bubble’s Play button only when the target app is in the expected initial state. The Play control lights in green and the bubble border indicates that the execution is live.
Pause without discarding the current session
Tap Pause when you need the macro to stop evaluating and acting temporarily. The Pause control lights in a different accent so you can distinguish the paused state from a live execution.
Pausing keeps the current executor and its runtime state. It does not rebuild the macro or initialize its variables again. That makes pause appropriate for a short manual intervention or inspection.
The screen can still change while the macro is paused. Before resuming, return the target app to a state the flow can recognize. Conditions are evaluated against the current screen after the execution continues; pausing does not restore the interface to the point where you pressed the button.
If the macro uses counters or flags, review the guide to variables and conditional actions before testing pause and resume in the middle of a cycle.
Resume from the same control
To continue, tap Play again. EmuloMobile leaves the paused state and resumes the prepared executor instead of starting a separate execution.
Use this short checklist before resuming:
- dismiss any system dialog that is not part of the macro;
- return to the expected app and screen;
- confirm that the bubble is not covering a control you need to see;
- tap Play;
- watch at least the next decision and action.
If the screen is no longer recoverable—for example, the app has returned to a login screen that the macro does not handle—stop the session instead of repeatedly resuming into an unknown state.
Stop when the execution must end
Stop is different from Pause. It ends the active execution and releases the prepared session. Use it when the routine is finished, the wrong macro was selected, or the current state should not be continued.
After stopping, prepare the macro again before another run. Runtime variables begin from their configured defaults in that new execution. Stop is therefore the right choice when you want a clean operational boundary, not a temporary interruption.
The macro remains saved in Automations. Stopping a run does not delete the macro or its captured assets.
Collapse the bubble without triggering an action
Select the chevron at the end of the expanded control to reduce it to one circular button. The collapsed button reflects the current state: it uses the Play appearance while live or waiting and the Pause appearance while paused.
Tapping the collapsed circle only expands the controls. It deliberately does not play or pause the macro, which helps prevent an accidental command while you are trying to reopen the bubble. EmuloMobile remembers the expanded or collapsed preference for later executions.
You can drag either presentation to a less intrusive part of the screen. Keep it away from targets the macro needs to tap and from small areas you need to monitor visually.
Practical example: inspect an unexpected confirmation
Suppose a macro waits for a label, taps Continue, and then expects a confirmation screen. During a supervised test, a different confirmation appears.
Use the controls in this order:
- tap Pause before interacting with the unexpected screen;
- inspect the message and decide whether it represents a valid new state;
- if you can return to a known screen, do so and tap Play;
- if the flow needs a new condition or action, tap Stop;
- edit and save the macro, then prepare a fresh test.
Do not use pause to hide a missing condition permanently. If the same exception can happen again, update the flow so it can recognize and handle that state explicitly.
Troubleshoot a control that does not appear or continue
If preparation is blocked, read the message before changing the macro. The usual checks are accessibility service status, screen resolution, orientation, and whether another execution is active.
If Android or the emulator ends the screen-capture session, EmuloMobile interrupts execution and asks you to prepare it again. A paused bubble cannot revive a capture session that the system has already closed.
If Play does not produce the expected action, verify the macro’s initial conditions on the current screen. The control starts the executor; it does not force a condition to become true.
Keep manual control within reach
Play, Pause, and Stop turn execution into an observable operating cycle: prepare deliberately, start from a known screen, pause for inspection, resume only when the context is valid, and stop at a clear boundary.
Explore EmuloMobile and control visual Android automations directly on the device.