A manual screenshot often comes too late: by the time you notice an error or confirmation, the screen has already changed. In a repeated routine, watching every cycle just to press the Android screenshot buttons at the right moment is not practical either.
EmuloMobile includes a Take screenshot action. When the macro reaches that action, it records the current screen as a PNG. Guarding the step with a text, image, or color condition lets you keep only a meaningful state, such as a completed confirmation or a message that needs review.
This guide shows how to build that checkpoint, test it, and avoid filling the device with repeated screenshots.
Capture only screens and data you are authorized to record. Review personal information, notifications, and other visible content before sharing the file.
When an automatic screenshot is useful
The action helps when the screen itself represents an observable result. Practical examples include:
- recording the final confirmation of a routine;
- keeping an error message for later diagnosis;
- comparing the visual state before and after a change;
- documenting one stage during a supervised test;
- confirming what was visible when a condition passed.
A screenshot is not a structured report, and it does not prove by itself that every preceding step worked. It records what was on screen at that moment. Treat it as operational evidence for review, not as a replacement for clear conditions and flow testing.
If you are building your first automation, start with the guide to Android macros without a PC, ADB, or root.
Define the state worth recording
Before opening the builder, complete this sentence:
Save the screen when ______ is visible.
Fill the blank with a specific signal. For example: the Completed label is visible in the header or the error icon appears inside the dialog.
This definition separates two jobs:
- the condition decides whether the screen is in the expected state;
- Take screenshot saves the image after the step is allowed to run.
Avoid using only a delay as the trigger. The timer can end before or after the target app responds. A visual condition describes the result that should actually be present.
How to add a screenshot in EmuloMobile
Open the automation in the builder and place the new step after the action that produces the result you want to record.
1. Add the Take screenshot action
Select Add Action, choose New Action, and select Take screenshot. The editor explains that the screen at execution time is saved to the gallery under Pictures/Screenshots on supported Android versions.
Add a short step note, such as Record final confirmation. It does not change execution, but it explains why the screenshot exists when you review the macro later.
2. Guard the step with a visual condition
Add a condition to the screenshot step itself. Choose the most stable signal available in the interface:
- Text on Screen for a specific, readable label;
- Image visible for an icon or visual component that identifies the state;
- Color for a point or region with a characteristic color;
- a variable condition when the decision depends on the macro’s internal state.
Restrict the search region when possible. Looking for Completed only inside the header reduces the chance of matching the same word elsewhere. The Tap Text with OCR tutorial explains how a smaller region can make screen reading less ambiguous.
3. Save explicitly
Confirm the action, return to the builder, and select Save. EmuloMobile keeps builder changes pending until you use that command. Leaving without saving can discard the new action or its condition.
Example: record one confirmation instead of every cycle
Suppose a macro submits an operation and then waits for a screen titled Completed. Build its final section like this:
- run the action that submits the operation;
- wait for an observable state instead of assuming a fixed response time;
- add Take screenshot;
- guard the screenshot with Text on Screen: Completed;
- restrict OCR to the confirmation header;
- after the capture, leave that state or advance the macro to its next stage.
The last detail prevents repetition. If the flow returns to the same step while the title remains visible, the condition can stay true in later cycles. When the macro structure requires that return, use a Boolean variable such as screenshot_saved to allow the action once, then update it immediately afterward. The variables and conditional actions guide shows how to build this kind of guard.
Where the file is stored
EmuloMobile creates a PNG with its date and time in the filename, using the format Screenshot_yyyyMMdd_HHmmss.png.
The location depends on the Android version:
- on Android 10 or later, the image is registered through the media library under Pictures/Screenshots and can appear in the gallery;
- on Android 9, the image is stored in EmuloMobile’s app-specific external directory, in a Pictures/Screenshots folder under
Android/data, accessible through a file manager that can browse that location.
This distinction matters because the older storage model does not provide the same gallery integration.
Test the action in a controlled run
Do not wait for a long routine to finish before discovering that the trigger was too broad. Run a short test:
- save the macro;
- prepare execution and grant screen-capture consent when Android asks;
- open the target app on a screen where the condition should fail;
- confirm that no new file was created;
- move the interface into the expected state;
- run the section and check that one PNG appears;
- open the image and verify that the relevant state is readable;
- repeat the cycle to make sure the macro does not create unwanted duplicates.
During the first tests, keep the floating Play, Pause, and Stop controls available. Pause if you need to inspect the screen, and stop if the flow enters a state you did not design for.
Troubleshoot common problems
If there is no new file, first check whether the condition actually passed. Test the text, image, or color on the same screen and region used during execution. A false condition prevents the action from running; it is not a file-saving failure.
If Android ends the screen-capture session, prepare execution again and approve the system prompt. The action needs a current frame before it can write the PNG.
If several identical screenshots appear, check whether the flow revisits the step while the signal remains visible. Move the macro into another state after saving, or add a variable that records that the screenshot has already been taken.
If the image contains content that should not be stored, do not rely on fixing it only after sharing. Narrow the state that triggers the action, change what is visible at that point, or remove the step from that flow.
Turn a visual state into a reviewable record
An automatic screenshot is most useful when it has a precise purpose: a specific condition releases one record, the macro moves on, and the file is checked in a controlled test. That removes the need to watch the routine and manually chase the right moment.
Explore EmuloMobile and build Android macros with visual conditions and on-device screenshots.