Rebuilding the same login, navigation, or screen-check action in every Android emulator macro wastes time and invites small configuration differences. If a working action already exists in another EmuloAgent macro, you can copy it into the workflow you are editing and use it as a tested starting point.
The copy includes the action configuration and its conditions. EmuloAgent also handles the local image assets used by supported conditions and virtual-keyboard steps. The destination still needs a review: coordinates, visual references, and timing only remain useful when the new workflow reaches a compatible screen at the expected emulator resolution.
This guide shows how to reuse an action without treating the copy as automatically ready to run.
When copying an action is the right shortcut
Copy an action when the destination macro needs the same small, well-understood behavior as an existing macro. Common examples include:
- opening the same app panel from a known screen;
- pressing an Android navigation key after a visual check;
- repeating a swipe recorded for the same emulator layout;
- reusing a tap protected by image, color, or text conditions;
- bringing a virtual-keyboard action into a related workflow.
Copying is less useful when the new macro starts from a different screen, uses another app language or theme, or targets a different layout. In those cases, the copied action may still save setup time, but its conditions and coordinates should be treated as a draft.
If the action itself is not stable yet, fix it in the source workflow first. The macro stabilization checklist explains how to validate starting states, guarded actions, waits, and stop behavior.
Prepare the destination macro and profile
Open the destination macro in the EmuloAgent builder and select an active emulator profile. A profile is required because EmuloAgent needs the destination resolution to place copied image templates correctly.
Before copying, compare the source and destination environments:
- emulator resolution and display scale;
- app version, language, and theme;
- the screen that should be visible before the action runs;
- the screen region used by each visual condition;
- any coordinates used by taps or swipes.
The closer these match, the less adjustment the copied action should need. Do not rely on the macro name as proof that the environments are equivalent.
How to copy an existing action into another macro
1. Add an action in the destination
In the destination macro, use the add control. EmuloAgent asks whether you want to create a new action or use an existing one. Choose the existing-action path.
2. Choose the source macro
The builder lists the macros available in your vault. Select the macro that already contains the behavior you want to reuse. Descriptions help here, so naming macros and actions by purpose makes later reuse faster.
3. Choose the action to copy
EmuloAgent loads the source macro and shows its actions with their position, type, and description when one is available. Select the specific action, not merely the first item that looks similar.
For coordinate-based actions, compare the displayed coordinates with the destination layout before confirming. A tap copied faithfully can still be wrong for a different screen.
4. Read any copy warning
EmuloAgent adds the copied action even when it detects a recoverable issue, then reports what needs attention:
- If an image template cannot be found in the source, the warning identifies it so you can recalibrate that reference.
- If a template is found under another source resolution, EmuloAgent can copy it but warns that coordinates may need adjustment.
Do not dismiss these messages as informational noise. They identify the exact parts of the step that have not yet been proven in the destination environment.
5. Save and test the destination macro
Review the copied action, save the macro, and run a supervised test on the destination profile. Confirm both sides of the step: the condition must recognize the intended screen, and the action must produce the intended next state.
What is copied and what still needs validation
The copied item is independent from the source action in the builder: EmuloAgent creates new internal identifiers, so later edits to the destination step do not rewrite the original step.
For image conditions and virtual-keyboard references supported by this flow, EmuloAgent copies the corresponding local templates into the destination macro’s asset area. If a required file is missing, it keeps the workflow editable and asks you to recalibrate instead of silently claiming that the reference is valid.
Several facts remain specific to the destination and must be checked:
- Coordinates: taps and swipes keep their configured points.
- Resolution: a different resolution can move targets or change how a reference appears.
- Screen state: the copied conditions only help if the new macro reaches the same kind of screen.
- Timing: a step that follows a fast local transition may need a different readiness check in another workflow.
- External state: account, app, or emulator state may change the result even when the pixels look similar.
For help choosing a stronger visual signal, use the image, color, and text detection guide.
Practical example: reuse a guarded settings action
Suppose one QA macro already opens an Android app’s settings panel. Its action taps the settings entry only when a small reference image confirms that the dashboard is visible.
A second macro needs the same transition before checking a different option. Instead of rebuilding the tap and image condition:
- Open the second macro with its target profile selected.
- Add an existing action.
- Choose the first QA macro as the source.
- Select the described settings action.
- Confirm that no template warning appears.
- Open the copied step and verify its image region and tap point.
- Run the second macro from the dashboard and watch the transition.
- Add the destination-specific checks only after the shared action passes.
This keeps the reusable part narrow. You copy one proven transition, then build the new macro’s unique logic around it.
Reuse conditions and compound actions with care
Within the same macro, the builder can also reuse an existing condition from another step. Compound blocks can reuse actions already present elsewhere in the workflow, including nested sub-actions shown by the selector. EmuloAgent creates independent copies of their local image assets when available.
These shortcuts are useful for repeated guards and recovery blocks, but they do not create a live link. If you later improve the source condition, existing copies are not automatically updated. Review each copy as part of the macro that owns it.
Avoid creating a large library of nearly identical actions without clear descriptions. A reusable step should state what screen it expects and what result it produces. That makes the selection dialog useful and reduces the chance of copying the wrong behavior.
A post-copy test checklist
Before relying on the destination macro, verify:
- The destination profile was selected during the copy.
- Source and destination resolutions are compatible.
- No missing-template warning remains unresolved.
- Image, color, or text conditions target the intended region.
- Tap and swipe coordinates match the destination screen.
- The action starts only from a known state.
- A supervised run reaches the expected next state.
- The original macro still behaves as expected after you edit the copy.
After the new macro is stable, you can keep it available across Windows PCs or hand it off using the workflow in the cloud sync and macro sharing guide.
Build new workflows from actions you have already validated
Reusing an action is valuable because it shortens setup, not because it removes testing. Select a compatible source, copy the smallest useful step, act on resolution or template warnings, and validate the result on the destination profile. That turns an existing action into a reliable starting point instead of an unchecked shortcut.
Explore EmuloAgent to build Android emulator macros on Windows with visual conditions, reusable actions, profiles, and controlled execution. You can also get it from the Microsoft Store.