SuperAPI AI Directory

store-screenshots

Coding & development

View repository

Updated 10-16 18:29

About this skill

Automate this: /mobile-release:screenshots regenerates the full set for both platforms, measures every output, and stops at files on disk without uploading. It needs no store credentials.

Produce screenshots at the exact pixel size each store slot demands, from a device state you can reproduce next release. Never upscale a capture to reach a target size — change the device, not the pixels.

Confidence marks used throughout this skill and its references: [verified] — read off a primary vendor source on 2026-08-05. [snippet] — secondary source only, plausible but unconfirmed. [unverified] — not confirmed anywhere; run the check given before relying on it.

Process:

  1. Build the capture plan before touching a device — which slots, how many shots each, which locales. See 1. Capture plan and references/store-slots.md.
  2. Lock determinism — seeded data, fixed clock, no notifications, no animations. references/determinism.md. Doing this after a bad run means recapturing everything.
  3. Drive the app to each target screen with a Maestro flow. references/maestro-flows.md.
  4. iOS: boot the simulator, override the status bar, capture with simctl io screenshot. See 2. iOS path; full size table in references/ios-devices.md.
  5. Android: create the AVD from a profile that actually exists on this SDK, enter demo mode, capture with adb exec-out screencap. See 3. Android path; profile table in references/android-devices.md.
  6. Once the shot list is stable, replace steps 4–5 with fastlane snapshot / fastlane screengrab so the set regenerates on demand. references/fastlane-setup.md.
  7. Only if a capture misses spec: resize/pad and strip alpha with ffmpeg. references/ffmpeg-images.md.
  8. Move the files to the paths deliver/supply read. See 5. Delivery paths.

Load only the reference you need.


Contents

  • 1. Capture plan
  • 2. iOS path
  • 3. Android path
  • 4. Automating the set
  • 5. Delivery paths
  • Output Format
  • References

1. Capture plan

Answer these before capturing. Emit the plan as a table (see Output Format) and get it confirmed.

  • Which stores — App Store, Play, or both.
  • Which device families the app actually declares. iOS: read TARGETED_DEVICE_FAMILY in the Xcode target — 1 is iPhone-only, the template default 1,2 declares iPad and makes iPad screenshots required in App Store Connect. Android: phone only, or tablets / Wear / TV as well.
  • How many per slot, and which locales. Apple requires the same screenshot size across all localizations [verified].
Store Slot Required? Count
App Store iPhone 6.9" Required if the app runs on iPhone [verified] 1–10 per localization [verified]
App Store iPad 13" Required if the app runs on iPad [verified] 1–10 per localization [verified]
App Store every other size Optional — Connect scales the required sets down [snippet] —
Play Phone Required min 2, max 8 [snippet]
Play 7" tablet / 10" tablet At least 4 each for large-screen eligibility [snippet] max 8 [snippet]
Play Wear OS min 1 if the app ships a Wear target [snippet] max 8 [snippet]

Apple's numbers came from Apple's own screenshot-specification page on developer.apple.com, fetched 2026-08-05. The Play numbers are secondary-source only — support.google.com was unreachable during recon — so re-check them against the Play Console upload dialog.

Minimum viable plan: iPhone 6.9" + iPad 13" for the App Store; phone + 7" + 10" for Play. Everything else is art direction, not compliance.


2. iOS path

xcrun simctl list devices available          # only devices with an installed runtime
xcrun simctl boot "iPhone 17 Pro Max"
xcrun simctl bootstatus "iPhone 17 Pro Max" -b   # blocks until fully booted [unverified: xcrun simctl help]

# Clean status bar. Cleared on reboot and set per-device — redo after every boot.
xcrun simctl status_bar booted override \
  --time "9:41" \
  --dataNetwork wifi --wifiMode active --wifiBars 3 \
  --cellularMode active --cellularBars 4 \
  --batteryState charged --batteryLevel 100 \
  --operatorName ""

xcrun simctl ui booted appearance light      # or: dark   [unverified: xcrun simctl help ui]

xcrun simctl io booted screenshot --type png --mask ignored 01_home.png

xcrun simctl status_bar booted clear

--mask ignored saves the unmasked framebuffer [snippet]. Use it — alpha and black put transparency or black into the rounded corners, and the App Store rejects alpha channels [verified].

For a light/dark pair, capture the whole set twice into separate output directories. Neither store has a dark-mode slot; you are choosing which set to upload.

The two required slots:

Simulator Native px (portrait) Store slot Confidence
iPhone 17 Pro Max / iPhone 16 Pro Max 1320 × 2868 iPhone 6.9" (alt size) target px [verified], device mapping [snippet]
iPhone Air 1260 × 2736 iPhone 6.9" (primary size) target px [verified], device mapping [snippet]
iPad Pro 13-inch (M4) 2064 × 2752 iPad 13" (primary size) target px [verified], device mapping [unverified] (points × scale arithmetic)

Full table, including the optional classes, in references/ios-devices.md. The device-name → pixel-size half of that table is not verified. Confirm empirically on the first capture:

sips -g pixelWidth -g pixelHeight 01_home.png

If the number is wrong, pick a different simulator — do not scale up.


3. Android path

sdkmanager "platform-tools" "emulator" "system-images;android-34;google_apis;x86_64"

# Profile ids drift between SDK versions. ALWAYS list before creating.
avdmanager list device -c
avdmanager create avd -n store_phone -k "system-images;android-34;google_apis;x86_64" -d pixel_7 -f

avdmanager create avd has no documented -d/--device flag on Google's avdmanager page [verified: the flag is absent from the documented option list]; the flag works in practice [snippet]. That is exactly why you run avdmanager list device -c first and pass an id from real output rather than a hardcoded one.

emulator -avd store_phone -no-window -gpu swiftshader_indirect \
  -no-audio -no-boot-anim -no-snapshot -port 5554 &

adb wait-for-device
adb shell 'while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done'   # [unverified]
adb shell input keyevent 82        # dismiss keyguard

# Animations off (screengrab does this itself via --no-window-animation)
adb shell settings put global window_animation_scale 0      # [unverified: adb shell settings list global]
adb shell settings put global transition_animation_scale 0
adb shell settings put global animator_duration_scale 0

# Clean status bar via SystemUI demo mode
adb shell settings put global sysui_demo_allowed 1
adb shell am broadcast -a com.android.systemui.demo -e command enter
adb shell am broadcast -a com.android.systemui.demo -e command clock -e hhmm 0941
adb shell am broadcast -a com.android.systemui.demo -e command battery -e level 100 -e plugged false
adb shell am broadcast -a com.android.systemui.demo -e command network -e wifi show -e level 4
adb shell am broadcast -a com.android.systemui.demo -e command notifications -e visible false

adb exec-out screencap -p > 01_home.png

adb shell am broadcast -a com.android.systemui.demo -e command exit

Demo mode is only certified on Nexus and Pixel devices — Google states the commands "might not work on all devices" [verified]. Check the first capture visually.

To hit a profile the AVD does not natively match (adb shell wm size reset / wm density reset afterwards, always):

adb shell wm size 1080x1920 && adb shell wm density 420

wm size/wm density syntax is [snippet] — not on any Google page fetched; confirm with adb shell wm help. Prefer a correctly-sized AVD: wm size changes the framebuffer while leaving the panel's DPI relationship intact, which can render UI at the wrong visual scale.

screencap always captures at the current framebuffer resolution, so the AVD choice is the output size. Play slot → profile mapping in references/android-devices.md (all [snippet]/[unverified] — reconcile with avdmanager list device).


4. Automating the set

Once the shot list stops changing, move to fastlane so the whole set regenerates in one command. Full Snapfile, Screengrabfile, Gradle deps, manifest permissions, and test-target code in references/fastlane-setup.md.

  • iOS — fastlane snapshot. fastlane snapshot init, add the generated SnapshotHelper.swift to a UI Test target with a shared scheme, call setupSnapshot(app) in setUp() and snapshot("01Home") at each screen. Two defaults surprise people: headless defaults to true and concurrent_simulators defaults to true [verified]. Set erase_simulator(true) and override_status_bar(true) for determinism.
  • Android — fastlane screengrab. androidTestImplementation 'tools.fastlane:screengrab:x.x.x', @ClassRule LocaleTestRule, Screengrab.screenshot("name") in an androidx instrumentation test, driven by a Screengrabfile. Correction worth knowing: screengrab's -w is passed through to am instrument and means wait for instrumentation to finish — it is not a clear-app-data flag [verified: screengrab runner.rb]. For a clean state use reinstall_app: true [verified: options.rb] or adb shell pm clear <package> before the run.

5. Delivery paths

iOS — fastlane deliver uploads screenshots from fastlane/screenshots [verified]. snapshot writes <simulator>-<name>.png [verified: SnapshotHelper.swift]; the per-locale directory nesting (fastlane/screenshots/<locale>/<simulator>-<name>.png) is [unverified] — run fastlane snapshot once and read the real tree before wiring a script to it.

Android — fastlane supply reads fastlane/metadata/android/<locale>/images/<type>Screenshots/ [verified: supply setup.rb], where <type> is one of phone, sevenInch, tenInch, tv, wear [verified: screengrab options.rb + supply constants]. On upload supply globs *.{png,jpg,jpeg} and orders lexicographically, so prefix files numerically: 1_en-US.png, 2_en-US.png [verified: setup.rb + uploader.rb]. screengrab's default output_directory is fastlane/metadata/android [verified], which lines up with supply.


Output Format

Report the plan, then the produced files with their measured dimensions, then anything blocked. Never report a file as done without measuring it.

Example output:

Capture plan

Store Slot Target px Device Shots Locales
App Store iPhone 6.9" 1320 × 2868 iPhone 17 Pro Max 5 en-US, de-DE
App Store iPad 13" 2064 × 2752 iPad Pro 13-inch (M4) 5 en-US, de-DE
Play Phone 1080 × 1920 AVD store_phone (pixel_7) 5 en-US

Produced

fastlane/screenshots/en-US/iPhone 17 Pro Max-01Home.png      1320x2868  no alpha  OK
fastlane/screenshots/en-US/iPhone 17 Pro Max-02Search.png    1320x2868  no alpha  OK
fastlane/metadata/android/en-US/images/phoneScreenshots/1_en-US.png  1080x2400  no alpha  MISMATCH

1080x2400 is pixel_7's native size, not the planned 1080×1920 — and at 2.22:1 it also breaks Play's "longer side ≤ 2 × shorter side" rule. Recreate the AVD on a 16:9 profile (preferred), or pad. Do not upscale:

ffmpeg -i 1_en-US.png \
  -vf "pad=1200:2400:(ow-iw)/2:0:color=#0B0B0F" \
  -pix_fmt rgb24 1_en-US_fixed.png

Blocked

  • iPhone Air is not installed in this Xcode. Captured the 6.9" set on iPhone 17 Pro Max (1320 × 2868, the alt size) — both are valid 6.9" uploads.

End of example.


References

  • references/store-slots.md — every App Store and Play screenshot slot, dimensions, counts, formats, file-size caps, with per-row confidence.
  • references/ios-devices.md — full simulator → native-pixel table, simctl command surface, status-bar flag enumerations.
  • references/android-devices.md — Play slot → AVD profile mapping, avdmanager/emulator/sdkmanager flags, SystemUI demo-mode command surface.
  • references/fastlane-setup.md — complete Snapfile, Screengrabfile, UI-test code, Gradle deps, manifest permissions, and the full option tables for snapshot and screengrab.
  • references/maestro-flows.md — Maestro flow YAML for driving the app to each screen, and why to capture with the native tool rather than takeScreenshot.
  • references/determinism.md — seeded demo data, locale switching, notifications, animations, fixed clock, frozen device set.
  • references/ffmpeg-images.md — exact scale+pad invocations, alpha stripping, and verification commands.