The Private Screen That Lingers in the App Switcher — Hiding the Snapshot iOS Takes the Moment You Background Your App

Why background alone can't protect you

The very thing I tripped on in my first implementation was this ordering. I started by thinking "hide it once we drop to the background," covering only when next === "background" — and the App Switcher thumbnail still showed the contents, plain as day.

// ❌ Doesn't work: waiting for background misses the capture
const handle = (next: AppStateStatus) => {
  setShielded(next === "background");
};

// ✅ Correct: cover on anything other than active (don't miss inactive)
const handle = (next: AppStateStatus) => {
  setShielded(next !== "active");
};

The reason, as above, is that the iOS snapshot is taken at inactive, before reaching background. Falling to the shielded side for everything that isn't active catches inactive without leaking. Writing it symmetrically — reveal only when we return to active — means even tiny transitions, like nudging Control Center down and immediately coming back, don't break it.

You may be tempted to add a delay because the shield flickers briefly on every inactive. Don't. A delay opens exactly the gap in which the snapshot is taken. Treat the flicker as proof the defense works, and reduce the friction by designing the overlay to sit naturally within your brand.

Android: FLAG_SECURE is an entirely different mechanism

If you stop here feeling safe, the Android side stays defenseless. Android's Recents screen shows a preview the same way, but the defense is unrelated to iOS.

Android has a window flag, FLAG_SECURE. Raise it and the Recents preview goes blank, and on top of that screenshots and screen recording are blocked at the OS level. In Expo, expo-screen-capture's preventScreenCaptureAsync() sets this flag.

npx expo install expo-screen-capture

// Android: raise FLAG_SECURE to blank Recents + block screenshots
import * as ScreenCapture from "expo-screen-capture";
import { Platform } from "react-native";
 
export async function enableAndroidSecureFlag() {
  if (Platform.OS !== "android") return;
  // This alone blanks the Recents thumbnail and stops screenshots/recording
  await ScreenCapture.preventScreenCaptureAsync("privacy-screen");
}
 
export async function disableAndroidSecureFlag() {
  if (Platform.OS !== "android") return;
  await ScreenCapture.allowScreenCaptureAsync("privacy-screen");
}

The key point: the iOS overlay and Android's FLAG_SECURE protect different things. FLAG_SECURE does nothing for the iOS Recents snapshot (iOS has no equivalent flag). Conversely, the overlay you built for iOS does not blank Android's Recents or block screenshots. Only by using both together do you get "no contents left in the App Switcher / Recents" on both platforms. Implementing one and assuming the whole thing is covered is the easiest mistake to make.

Scope it to sensitive screens, not the whole app

Leaving FLAG_SECURE raised app-wide means users can't screenshot any screen at all. Reporting a bug on the settings screen, showing a favorites list to a friend — taking away those legitimate actions too is going too far. I raise the flag only when entering a sensitive screen and restore it on the way out.

With Expo Router or React Navigation's useFocusEffect, you can control this cleanly in step with the screen appearing and disappearing.

// Inside a sensitive screen component (e.g. the journal editor)
import { useFocusEffect } from "expo-router";
import { useCallback, useContext } from "react";
import {
  enableAndroidSecureFlag,
  disableAndroidSecureFlag,
} from "../lib/secureFlag";
import { PrivacyContext } from "../lib/PrivacyContext";
 
function JournalEditorScreen() {
  const { setSensitive } = useContext(PrivacyContext);
 
  useFocusEffect(
    useCallback(() => {
      // On entering: enable the iOS overlay, set FLAG_SECURE on Android
      setSensitive(true);        // flip the iOS overlay's enabled to true
      enableAndroidSecureFlag(); // blank Android Recents + block screenshots
 
      return () => {
        // On leaving: restore everything
        setSensitive(false);
        disableAndroidSecureFlag();
      };
    }, [setSensitive])
  );
 
  // ...screen body
}

PrivacyContext is a paper-thin Context whose only job is to toggle the enabled of the PrivacyShield above. setSensitive(true) enables the iOS overlay and, in the same moment, raises the Android flag. That lines up "protect on both platforms only while on a sensitive screen." Forgetting to restore on exit leads to accidents, so always pair the restore in the useFocusEffect cleanup function.

Detect what slips through after the fact

Beyond prevention, being able to notice that something was captured has value on some screens. expo-screen-capture has a listener that fires the moment a screenshot is taken. There's nothing wrong with the owner saving their own record, but for, say, a shared family account where a personal entry gets captured, you can quietly inform the owner.

import * as ScreenCapture from "expo-screen-capture";
import { useEffect } from "react";
 
function useScreenshotNotice(onShot: () => void) {
  useEffect(() => {
    // Screenshot detection works on both iOS and Android
    // (pair with isCaptured for recording detection)
    const sub = ScreenCapture.addScreenshotListener(() => {
      onShot();
    });
    return () => sub.remove();
  }, [onShot]);
}

Detection is a trigger for a notice or a log; it has no power to stop the screenshot itself (that's the job of Android's FLAG_SECURE). So the realistic use is as a supporting line: for the iOS screenshot you can't block, quietly let only the owner know. Over-warning just stokes anxiety, so keep the wording plain and show it once.

A table for where to apply what

You don't need to defend every screen uniformly. The stronger the defense, the more you take away legitimate user actions (sharing via screenshot, reporting bugs). Decide how far to go per the nature of each screen.

There's a single axis for the decision: "Would it cause harm for this screen's contents to be seen, even for an instant, by someone other than the owner?" If yes, defend it; if it's a screen you want shared, leave it open. In apps like wallpaper apps that I want shown and spread, I apply none of this, and reserve it for the relevant screens of apps that handle personal records.

Try it on one screen first

As a first step, pick the single most personal screen in your app — the journal editor, a health-data detail — and wire the iOS overlay enable and Android FLAG_SECURE together there via useFocusEffect. Send a real device to the home screen and visually confirm, in both the App Switcher (iOS) and Recents (Android), that the thumbnail is shielded or blank. Once that's confirmed, you can quietly extend to the rest of your sensitive screens along the table above.

The essence of this defense isn't a flashy feature — it's the single fact that a user can move their hands in peace, trusting that "what I write here is mine alone." I hope this helps anyone building apps that handle personal records the same way.