# The foreground-service video

The Play Console's foreground-service declaration for `FOREGROUND_SERVICE_DATA_SYNC` requires a video
of the user *triggering* the local import/export, not just a description. This is that video, and the
record of how it was made. The All files access declaration has its own video and page:
[PERMISSION_VIDEO](PERMISSION_VIDEO.md).

## The file

| file | length | what it is |
|---|---|---|
| `store-assets/video/fgs-import-export.mp4` | **18.0 s** | The submission copy: 1080×2400, H.264, **no audio**, English captions burned in |
| `store-assets/video/fgs-import-export-uncaptioned.mp4` | 16.8 s | The same cut without captions, for a voice-over |
| `store-assets/video/fgs-import-export.srt` | — | The five captions and their timings |

**The file is not a link.** Upload it to YouTube **Unlisted**, or Drive shared with "anyone with the
link", and paste that URL into the foreground-service declaration. A private upload cannot be
reviewed.

## What it shows

| time | on screen | what it proves |
|---|---|---|
| 0:00 | `AADemo`, with `Source` selected and **Copy** in the action bar | The user starts a local import/export |
| 0:03 | `Target`, then the overflow's **Paste here** | The user chooses the local destination and triggers it |
| 0:10 | The notification shade: **Copying files** with a moving progress bar | The `dataSync` foreground service is doing the work and reporting it |
| 0:12 | `Target` with `Source` and the snackbar **Copied 121 items** | The operation completed at the destination |

The captions, in order:

1. *Copy a 1.8 GB folder to another folder*
2. *Paste here starts a local copy*
3. *The copy runs in the dataSync service*
4. *The ongoing notification reports progress*
5. *Done: the folder is at the destination*

## What was cut, and why

The raw take was **35.2 s**; the published copy is three pieces of it:

| kept | what it is |
|---|---|
| 0–10 s | Select `Source`, Copy, open `Target`, Paste here |
| 17–19.5 s | The shade with **Copying files** and its progress bar |
| 22–27 s | The completed `Target` and its snackbar |

The two gaps are elapsed time, not evidence: the wait between Paste and the notification appearing,
and the wait between the shade closing and the listing refreshing. **The app's target listing stays
empty until the copy finishes and then refreshes itself**, so the empty frames are the operation in
progress, not a failure. The notification and the result are from the same take.

Nothing else is edited. No home screen, launcher or library view appears — the recording starts inside
`AADemo`. The shade was cleared of the phone's weather and Play cards before the take; what remains
besides the app's notification is Android's generic USB debugging/transfer pair. The quick-settings
panel shows only icons, battery and data totals; the Wi-Fi name exists in the accessibility tree but
is not drawn on screen.

Every filename is synthetic: the source is `AADemo/Source/file001.bin` … `file120.bin`, made from
`/dev/zero`, and the destination is `AADemo/Target`.

## Re-shooting it

Create the fixture first — 120 files of 16 MB, so the copy lasts long enough to read the notification:

```bash
adb shell 'rm -rf /sdcard/AADemo/Target; mkdir -p /sdcard/AADemo/Source /sdcard/AADemo/Target
for i in $(seq -w 1 120); do
  dd if=/dev/zero of=/sdcard/AADemo/Source/file$i.bin bs=1M count=16 2>/dev/null
done'
```

Clear the notification shade before recording: open it, tap **Clear all**, and check with
`adb shell cmd notification list`. The phone's own weather, Play and messaging cards must not appear
in a video that will be published; USB debugging/transfer cards are generic and may stay.

Open the app on **Internal storage → AADemo**, long-press `Source`, and verify the bar says
**1 item** with **Copy** before recording. Then:

```bash
adb shell rm -f /sdcard/fgs.mp4
adb shell screenrecord --size 1080x2400 --bit-rate 8000000 --time-limit 50 /sdcard/fgs.mp4 &
sleep 1.5
adb shell input tap 231 2155     # Copy in the selection bar
sleep 1.5
adb shell input tap 540 644      # Target — already inside AADemo
sleep 2
adb shell input tap 1003 181     # overflow
sleep 1.5
adb shell input tap 864 335      # Paste here
# The notification exists only after Paste. Wait for it, or the shade shows only USB cards.
for i in $(seq 1 16); do
  adb shell cmd notification list | grep -q 'de.softwareapp_hb.filemanager' && break
  sleep 0.5
done
adb shell cmd statusbar expand-notifications
sleep 4
adb shell cmd statusbar collapse
sleep 18                         # the copy must finish and the listing refresh
adb shell pkill -INT screenrecord
adb pull /sdcard/fgs.mp4
```

Cut the two waits, keeping the trigger, the notification and the result:

```bash
ffmpeg -y -i fgs.mp4 -filter_complex \
  "[0:v]trim=0:10,setpts=PTS-STARTPTS[a];[0:v]trim=17:19.5,setpts=PTS-STARTPTS[b];[0:v]trim=22:27,setpts=PTS-STARTPTS[c];[a][b][c]concat=n=3:v=1[v]" \
  -map "[v]" -c:v libx264 -crf 20 -pix_fmt yuv420p -an fgs-cut.mp4
```

The times are this take's; check the frames before reusing them.

Two traps cost takes here:

- **Do not press Up after Copy.** The selection is made *in* `AADemo`; Copy clears the bar and
  `Target` is the next row. An extra Up goes to the card root, the following taps open `AADemo`
  again, and Paste then targets `AADemo` — which already holds `Source`, so the app correctly asks
  **“Items already exist here”**. The first attempt did exactly that.
- **Open the shade only once the notification exists.** Opening it straight after Paste can beat the
  service's first post and shows nothing but Android's USB cards — a video with the trigger and the
  result but no evidence of the service. The `cmd notification list` loop above is the guard.

Also expect the target listing to stay **empty** until the copy completes and the ViewModel reloads
it. That is the operation still running, not a missed Paste; `du -sh /sdcard/AADemo/Target` is the
independent check.

The captions are five PNG overlays at **y = 1900**, not the 2130 used by the all-files video: the
selection bar sits at 2133–2177 on this phone, and a caption there hides the Copy button — the very
action the video exists to show.

## Uploading it

Upload `store-assets/video/fgs-import-export.mp4` to YouTube **Unlisted** or Drive with link sharing,
and paste the URL into the **foreground-service** declaration. This is a different field from the
All files access video: the permission video shows browsing a whole volume, this one shows the local
copy that the `dataSync` service keeps alive.