[$250] Android - Classic - Foreground push notifications do not show

[izarutskaya]

If you haven’t already, check out our contributing guidelines for onboarding. To join our Slack channel, fill out this form.

---

Version Number: 9.4.44-0
Reproducible in staging?: Yes
Reproducible in production?: Yes
If this was caught during regression testing, add the test name, ID and link from BrowserStack: https://github.com/Expensify/Mobile-Expensify/pull/14022
Email or phone of affected tester (no customers):
Logs: https://stackoverflow.com/c/expensify/questions/4856
Expensify/Expensify Issue URL:
Issue reported by:
Slack conversation (hyperlinked to channel name): #expensify_quality

Action Performed:

1. Open the App
2. Create group workspace chat on device A using account A
3. On device B sign in to account that uses classic experience (OldDot app)
4. Send message on group chat from device A > check notifications on device B

Expected Result:

User can see notifications about new messages.

Actual Result:

There is no notification.

Workaround:

Unknown

Platforms:

Select the officially supported platforms where the issue was reproduced:

• Android: App
• Android: mWeb Chrome
• iOS: App
• iOS: mWeb Safari
• iOS: mWeb Chrome
• Windows: Chrome
• MacOS: Chrome / Safari

Screenshots/Videos

Screen.Recording.20260724.102034.Expensify.mp4

2026-07-24.2.45.37.PM.mp4

View all open jobs on GitHub

Upwork Automation - Do Not Edit

• Upwork Job URL: https://www.upwork.com/jobs/~022080677636518787245
• Upwork Job ID: 2080677636518787245
• Last Price Increase: 2026-07-24

[MelvinBot]

Issue Analysis

Root Cause (outside the App repo): The missing Android push is not caused by NewDot (App) code. On the Android HybridApp, the App deliberately does not register the Airship device identity itself — it delegates that to the OldDot/YAPL side after sign‑in (index.native.ts:88-92). Because the affected user is on the Classic (OldDot) experience on device B, whether a push is delivered depends entirely on (a) the shared Airship device→account binding set by Mobile-Expensify (OldDot) during sign‑in, and (b) whether the backend (Web-Expensify MobilePushNotifications.php) emits a reportComment/reportAction push for a group workspace chat (policyExpenseChat) to a Classic recipient. Both live outside Expensify/App.

Recommended next step: This needs an internal engineer with access to Mobile-Expensify and/or Web-Expensify/Auth to confirm which side drops the notification. The App team cannot fix this in the App repo.

Investigation details & evidence

The App (NewDot) side is behaving as designed:

• NewDot's push registration is triggered only when the backend provides nvp_private_pushNotificationID (subscribeToPushNotifications.ts:28-49).
• On the HybridApp, NewDot and OldDot share a single Airship instance / device channel, and NewDot explicitly returns early so the Airship contact identity is set by the OldDot/YAPL side after sign‑in (index.native.ts:88-115). signInToOldDot runs for every HybridApp user before a Classic user is redirected to OldDot via closeReactNativeApp (HybridApp.ts:108, HybridApp.ts:121).
• isSingleNewDotEntry only gates tap‑navigation (subscribeToPushNotifications.ts:129), so it does not explain "no notification appears at all."

Two candidate root causes to verify (both outside App):

1. Airship identity ownership (Mobile-Expensify): Because there is one shared device channel and one named‑user/contact slot, whichever side last calls Airship.contact.identify() (or reset()) owns which account the device token is bound to. If OldDot's sign‑in doesn't correctly bind (or a NewDot↔OldDot race resets) the channel for the Classic account, pushes are misrouted or dropped.
2. Backend send gating (Web-Expensify/Auth): Whether a policyExpenseChat message even generates a push for a Classic recipient is decided in MobilePushNotifications.php — not in App. A group workspace chat message is sent as a generic reportComment/reportAction, so there is no App‑side type missing.

Note on regression scope: Related issue #88158 (below) documented Classic users receiving and tapping workspace‑chat push notifications, so delivery worked for that case at that time. If delivery is now fully absent (v9.4.44‑0), this may be a regression on the Mobile-Expensify/backend side rather than a long‑standing gap.

Confidence: Medium — the App‑side behavior is confirmed from code, but the definitive failing component is in repos not available here (Mobile-Expensify, Web-Expensify/Auth). Confirming it requires those checkouts plus production logs for a repro account (search MobilePushNotifications for the recipient's accountID at message time, and the device's Airship named‑user binding).

Possibly related issues

• Investigate why push notifications navigation for Classic users isn't working #88158 — "Investigate why push notifications navigation for Classic users isn't working" (about tap/navigation for Classic users; this issue is about the notification not appearing at all)

---

Next Steps for Contributor+ team:
This root cause is outside the App repo — please escalate to an internal engineer with Mobile-Expensify / Web-Expensify/Auth access to determine whether OldDot's Airship registration or the backend send logic is dropping the push for Classic users. A code fix in Expensify/App is not applicable here.
To refine: @MelvinBot <your feedback>

[mukhrr]

Proposal

What is the root cause of that problem?

I found that NewDot initializes its push-notification subscription on every startup, including Android headless/background launches.

App/src/setup/index.ts

Lines 85 to 87 in cae5618

	// Must be imported after Onyx.init() and outside the React lifecycle so that push notification
	// handlers are registered before any push arrives, including Android headless/background wake-ups.
	import('@libs/Notification/PushNotification/subscribeToPushNotifications');

The subscription watches NewDot’s NVP_PRIVATE_PUSH_NOTIFICATION_ID. When the classic-experience account does not provide that NewDot value, the callback treats it as a sign-out and calls PushNotification.deregister().

App/src/libs/Notification/PushNotification/subscribeToPushNotifications.ts

Lines 27 to 47 in cae5618

	// We do not depend on updates on the UI for notifications, so we can use `connectWithoutView` here.
	Onyx.connectWithoutView({
	key: ONYXKEYS.NVP_PRIVATE_PUSH_NOTIFICATION_ID,
	callback: (notificationID) => {
	if (notificationID) {
	PushNotification.register(notificationID);
	PushNotification.init();
	// Subscribe handlers for different push notification types
	PushNotification.onReceived(PushNotification.TYPE.REPORT_COMMENT, applyOnyxData);
	PushNotification.onSelected(PushNotification.TYPE.REPORT_COMMENT, navigateToReport);
	PushNotification.onReceived(PushNotification.TYPE.REPORT_ACTION, applyOnyxData);
	PushNotification.onSelected(PushNotification.TYPE.REPORT_ACTION, navigateToReport);
	PushNotification.onReceived(PushNotification.TYPE.TRANSACTION, applyOnyxData);
	PushNotification.onSelected(PushNotification.TYPE.TRANSACTION, navigateToReport);
	} else {
	PushNotification.deregister();
	PushNotification.clearNotifications();
	}

deregister() then unconditionally calls Airship.contact.reset(), removing the Airship identity that OldDot registered. Consequently, Airship no longer associates this Android device with the classic account, so messages do not produce push notifications.

App/src/libs/Notification/PushNotification/index.native.ts

Lines 122 to 132 in cae5618

	/**
	* Deregister this device from push notifications.
	*/
	const deregister: Deregister = () => {
	Log.info('[PushNotification] Unsubscribing from push notifications.');
	Airship.contact.reset();
	Airship.removeAllListeners(EventType.PushReceived);
	Airship.removeAllListeners(EventType.NotificationResponse);
	ForegroundNotifications.disableForegroundNotifications();
	ShortcutManager.removeAllDynamicShortcuts();
	};

The existing registration code already documents that the HybridApp shares one Airship instance and that YAPL/OldDot owns its identity after sign-in.

App/src/libs/Notification/PushNotification/index.native.ts

Lines 84 to 115 in cae5618

	const register: Register = (notificationID) => {
	Airship.contact
	.getNamedUserId()
	.then((userID) => {
	// In the HybridApp, the contact identity is set on the YAPL side after sign-in.
	// Since the Airship instance is shared between NewDot and OldDot,
	// NewDot users won't see the push notification permission prompt as we return early in this case.
	// Therefore, we cannot handle the HybridApp scenario here.
	if (!CONFIG.IS_HYBRID_APP && userID === notificationID.toString()) {
	// No need to register again for this notificationID.
	return;
	}
	// Get permissions to display push notifications if not determined (prompts user on iOS, but not Android)
	Airship.push.getNotificationStatus().then(({notificationPermissionStatus}) => {
	if (notificationPermissionStatus !== PermissionStatus.NotDetermined) {
	return;
	}
	Airship.push.enableUserNotifications().then((isEnabled) => {
	if (isEnabled) {
	return;
	}
	Log.info('[PushNotification] User has disabled visible push notifications for this app.');
	});
	});
	// Register this device as a named user in AirshipAPI.
	// Regardless of the user's opt-in status, we still want to receive silent push notifications.
	Log.info(`[PushNotification] Subscribing to notifications`);
	Airship.contact.identify(notificationID.toString());

History shows that HybridApp-aware handling was added to register(), but the adjacent deregister() implementation was left with its unconditional reset. That created an ownership mismatch: NewDot respects OldDot’s shared identity when registering, but can still erase it when deregistering.

App/src/libs/Notification/PushNotification/index.native.ts

Lines 79 to 125 in 379a27a

	const register: Register = (notificationID) => {
	Airship.contact
	.getNamedUserId()
	.then((userID) => {
	// In the HybridApp, the contact identity is set on the YAPL side after sign-in.
	// Since the Airship instance is shared between NewDot and OldDot,
	// NewDot users won't see the push notification permission prompt as we return early in this case.
	// Therefore, we cannot handle the HybridApp scenario here.
	if (!CONFIG.IS_HYBRID_APP && userID === notificationID.toString()) {
	// No need to register again for this notificationID.
	return;
	}
	// Get permissions to display push notifications if not determined (prompts user on iOS, but not Android)
	Airship.push.getNotificationStatus().then(({notificationPermissionStatus}) => {
	if (notificationPermissionStatus !== PermissionStatus.NotDetermined) {
	return;
	}
	Airship.push.enableUserNotifications().then((isEnabled) => {
	if (isEnabled) {
	return;
	}
	Log.info('[PushNotification] User has disabled visible push notifications for this app.');
	});
	});
	// Register this device as a named user in AirshipAPI.
	// Regardless of the user's opt-in status, we still want to receive silent push notifications.
	Log.info(`[PushNotification] Subscribing to notifications`);
	Airship.contact.identify(notificationID.toString());
	})
	.catch((error: Record<string, unknown>) => {
	Log.warn('[PushNotification] Failed to register for push notifications! Reason: ', error);
	});
	};
	/**
	* Deregister this device from push notifications.
	*/
	const deregister: Deregister = () => {
	Log.info('[PushNotification] Unsubscribing from push notifications.');
	Airship.contact.reset();
	Airship.removeAllListeners(EventType.PushReceived);
	Airship.removeAllListeners(EventType.NotificationResponse);
	ForegroundNotifications.disableForegroundNotifications();

What changes do you think we should make in order to solve the problem?

I think we should update PushNotification.deregister() in src/libs/Notification/PushNotification/index.native.ts so NewDot resets the Airship contact only in the standalone app. In HybridApp, YAPL/OldDot owns the shared contact identity, while NewDot should still remove its listeners, disable foreground handling, and clear shortcuts as it does today.

- Airship.contact.reset();
+ if (!CONFIG.IS_HYBRID_APP) {
+     Airship.contact.reset();
+ }

I would add unit coverage using the existing Airship mock to verify that:

• contact.reset() is not called when CONFIG.IS_HYBRID_APP is true.
• contact.reset() is still called in standalone NewDot.
• The local listener and foreground-notification cleanup still runs in both modes.

This does not change standalone registration or sign-out behavior. It also does not affect valid NewDot notification IDs, which continue through register() and Airship.contact.identify(). HybridApp sign-in/sign-out remains owned by YAPL as the existing code requires, so classic users keep their Airship identity instead of having it removed by NewDot.

[ahmdshrif]

Proposal

Please re-state the problem that we are trying to solve in this issue.

On Android, push notifications are broken — incoming pushes fail to display (and/or their tap/receive callbacks don't run), so users stop getting notified of new report activity.

What is the root cause of that problem?

The Android foreground-display path is gated by an unguarded predicate. configureForegroundNotifications() wires Airship's Android foreground predicate directly to shouldShowPushNotification(pushPayload) with no try/catch:

App/src/libs/Notification/PushNotification/ForegroundNotifications/index.android.ts

Line 8 in a88a598

Airship.push.android.setForegroundDisplayPredicate((pushPayload) => Promise.resolve(shouldShowPushNotification(pushPayload)));

Inside that predicate, shouldShowPushNotification was recently changed to derive the topmost one-transaction-thread id and pass extra args into shouldShowReportActionNotification, reading several Onyx collections synchronously:

App/src/libs/Notification/PushNotification/shouldShowPushNotification.ts

Lines 60 to 62 in a88a598

	const topmostReportActions = allReportActions?.[`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${topmostReportID}`];
	const topmostOneTransactionThreadReportID = ReportActionUtils.getOneTransactionThreadReportID(topmostReport, topmostChatReport, topmostReportActions, getIsOffline());
	shouldShow = Report.shouldShowReportActionNotification(String(data.reportID), topmostOneTransactionThreadReportID, currentUserAccountID, reportAction, true);

Because this runs in Android's headless/background context (where connectWithoutView callbacks may not have populated allReports/allReportActions), any throw in this chain rejects the predicate promise. Airship then suppresses the notification, which surfaces exactly as "push notifications are broken" on Android only (iOS does not use this Android foreground predicate). I'm moderately confident on the layer; the precise throwing line should be confirmed against device logs.

What changes do you think we should make in order to solve the problem?

Make the Android foreground predicate fail-open and defensive so a transient/undefined-Onyx error never silently drops a push:

Airship.push.android.setForegroundDisplayPredicate((pushPayload) => {
    try {
        return Promise.resolve(shouldShowPushNotification(pushPayload));
    } catch (error) {
        Log.warn('[PushNotification] predicate threw, defaulting to show', {error});
        return Promise.resolve(true);
    }
});

and guard the Onyx-derived reads in shouldShowPushNotification (default missing collections to show rather than throw). Regression note: defaulting to true on error only affects the show/suppress decision for foreground pushes on Android — it cannot hide a notification that should appear, it only prevents legitimately-broken suppression.

[melvin-bot]

Triggered auto assignment to Contributor-plus team member for initial proposal review - @huult (External)

[godzillaxbox19982014-lgtm]

Proposal

Please re-state the problem that we are trying to solve in this issue.

Android - Push notifications are broken

What is the root cause of that problem?

I traced this to the path that handles OldDot:

• src/libs/Notification/PushNotification/ForegroundNotifications/index.ios.ts:19 (setForegroundPresentationOptionsCallback): Airship.push.iOS.setForegroundPresentationOptionsCallback((pushPayload) => Promise.resolve(shouldShowPushNotification(pushPayload) ? null : []));
• src/libs/Notification/PushNotification/parsePushNotificationPayload.ts:21 (parsePushNotificationPayload): return payload as AnyPushNotificationData;
• src/libs/Notification/PushNotification/parsePushNotificationPayload.ts:33 (parsePushNotificationPayload): return jsonObject as AnyPushNotificationData;
• src/libs/Notification/PushNotification/parsePushNotificationPayload.ts:40 (parse): return JSON.parse(payload) as JsonObject as AnyPushNotificationData;
• src/libs/Notification/PushNotification/ForegroundNotifications/index.ios.ts:19 is the first concrete decision that matches OldDot, and src/libs/Notification/PushNotification/parsePushNotificationPayload.ts:21 is the next matching consumer/mutation. The failing behavior is introduced at this handoff: the second path does not preserve the condition/state established by the first path for the repro case.

What changes do you think we should make in order to solve the problem?

• Change the issue-matching decision at src/libs/Notification/PushNotification/ForegroundNotifications/index.ios.ts:19 so the OldDot repro state is represented before src/libs/Notification/PushNotification/parsePushNotificationPayload.ts:21 consumes it.
• Keep the patch at this first decision/consumer boundary (map the API error to the user-facing translation at the action boundary) instead of masking the downstream UI symptom.
• Keep the change inside the Auth, Login, Onboarding, Account Details surface and avoid changing account/login flows, auth tokens.

What specific scenarios should we cover in automated tests to prevent reintroducing this issue in the future?

1. Add or update a regression in tests/unit/Session*.ts for the exact issue flow: Android - Push notifications are broken.
2. Cover the counter-case near src/libs/Notification/PushNotification/ForegroundNotifications/index.ios.ts:19 so valid existing OldDot behavior still works.
3. Manually repeat the issue steps after the patch and confirm the visible state/action is no longer stale.

What alternative solutions did you explore? (Optional)

• I would not add a broad new condition outside these referenced paths; the safer fix is to keep OldDot consistent at the first read/write boundary shown above.

[melvin-bot]

Job added to Upwork: https://www.upwork.com/jobs/~022080677636518787245

[lorretheboy]

Proposal

What is the root cause of that problem?

When a HybridApp account uses the classic experience, NewDot closes itself before the auth screens ever mount, so OpenApp never runs and nvp_private_pushNotificationID is never stored in NewDot's Onyx:

App/src/libs/HybridApp.ts

Lines 118 to 126 in cae5618

	if (tryNewDot !== undefined) {
	setUseNewDotSignInPage(false).then(() => {
	if (shouldUseOldApp(tryNewDot) && (!account?.needsTwoFactorAuthSetup || account?.requiresTwoFactorAuth)) {
	closeReactNativeApp({shouldSetNVP: false, isTrackingGPS: false});
	} else {
	setReadyToShowAuthScreens(true);
	}
	});
	}

Meanwhile subscribeToPushNotifications is imported unconditionally on every NewDot JS boot — including the Android Headless JS wake-up that runs each time a push arrives:

App/src/setup/index.ts

Lines 85 to 87 in cae5618

	// Must be imported after Onyx.init() and outside the React lifecycle so that push notification
	// handlers are registered before any push arrives, including Android headless/background wake-ups.
	import('@libs/Notification/PushNotification/subscribeToPushNotifications');

Its Onyx callback fires immediately with undefined (the key was never set), so it falls into the else branch and calls PushNotification.deregister():

App/src/libs/Notification/PushNotification/subscribeToPushNotifications.ts

Lines 28 to 49 in cae5618

	Onyx.connectWithoutView({
	key: ONYXKEYS.NVP_PRIVATE_PUSH_NOTIFICATION_ID,
	callback: (notificationID) => {
	if (notificationID) {
	PushNotification.register(notificationID);
	PushNotification.init();
	// Subscribe handlers for different push notification types
	PushNotification.onReceived(PushNotification.TYPE.REPORT_COMMENT, applyOnyxData);
	PushNotification.onSelected(PushNotification.TYPE.REPORT_COMMENT, navigateToReport);
	PushNotification.onReceived(PushNotification.TYPE.REPORT_ACTION, applyOnyxData);
	PushNotification.onSelected(PushNotification.TYPE.REPORT_ACTION, navigateToReport);
	PushNotification.onReceived(PushNotification.TYPE.TRANSACTION, applyOnyxData);
	PushNotification.onSelected(PushNotification.TYPE.TRANSACTION, navigateToReport);
	} else {
	PushNotification.deregister();
	PushNotification.clearNotifications();
	}
	},
	});

deregister() calls Airship.contact.reset():

App/src/libs/Notification/PushNotification/index.native.ts

Lines 125 to 132 in cae5618

	const deregister: Deregister = () => {
	Log.info('[PushNotification] Unsubscribing from push notifications.');
	Airship.contact.reset();
	Airship.removeAllListeners(EventType.PushReceived);
	Airship.removeAllListeners(EventType.NotificationResponse);
	ForegroundNotifications.disableForegroundNotifications();
	ShortcutManager.removeAllDynamicShortcuts();
	};

Airship is a single instance shared by OldDot and NewDot, and for HybridApp the contact (named user) is identified on the OldDot/native side after sign-in — as the comment in register itself notes:

App/src/libs/Notification/PushNotification/index.native.ts

Lines 88 to 95 in cae5618

	// In the HybridApp, the contact identity is set on the YAPL side after sign-in.
	// Since the Airship instance is shared between NewDot and OldDot,
	// NewDot users won't see the push notification permission prompt as we return early in this case.
	// Therefore, we cannot handle the HybridApp scenario here.
	if (!CONFIG.IS_HYBRID_APP && userID === notificationID.toString()) {
	// No need to register again for this notificationID.
	return;
	}

So the chain is: classic user never gets the push NVP in NewDot → every NewDot JS boot (notably the headless boot triggered by an incoming push) treats "no notification ID" as "signed out" → Airship.contact.reset() wipes the named-user association OldDot created → the backend can no longer target the device → no notifications. It's Android-only because only Android wakes the NewDot JS context via Headless JS on push receipt; on iOS the JS never runs while the user stays in OldDot.

What changes do you think we should make in order to solve the problem?

In the Onyx callback in subscribeToPushNotifications.ts, stop treating "key absent at boot" as a sign-out. Only deregister when the notification ID transitions from set to cleared (a real sign-out), e.g.:

let previousNotificationID: string | undefined;
callback: (notificationID) => {
    if (notificationID) {
        // register + init + bind handlers as today
    } else if (previousNotificationID) {
        PushNotification.deregister();
        PushNotification.clearNotifications();
    }
    previousNotificationID = notificationID;
},

This is the single convergence point — it's the only caller of deregister() — so booting the JS context with an empty Onyx (classic HybridApp users, headless wake-ups, logged-out state) becomes a no-op, while real sign-outs still reset the Airship contact. Sign-out from NewDot in HybridApp additionally signs out OldDot, which manages its contact natively, so nothing is lost there.

What alternative solutions did you explore? (Optional)

Guard the else branch with CONFIG.IS_HYBRID_APP so NewDot never resets the shared Airship contact in HybridApp (mirroring the existing HybridApp carve-out in register), leaving the contact lifecycle entirely to the native/OldDot side. Simpler, but doesn't fix the standalone quirk of resetting the contact on every logged-out boot.

[annaweber830]

🚨 Edited by proposal-police: This proposal was edited at 2026-07-24 15:41:37 UTC.

Proposal

Please re-state the problem that we are trying to solve in this issue.

On Android HybridApp, a user in the Classic experience does not see a notification when another member sends a message in a workspace group chat.

What is the root cause of that problem?

NewDot owns the Android foreground-notification predicate even after the HybridApp has switched to Classic. Depending on whether NewDot has a push notification ID, there are two different paths to the same result: the Classic notification is suppressed.

The second recording keeps the recipient in Classic in the foreground, sends a message, and then opens Android's notification shade. That makes the foreground-display path directly relevant.

NewDot's push subscription is imported after Onyx.init() and outside React so that it also runs in Android headless/background contexts:

App/src/setup/index.ts

Lines 83 to 88 in 1fb14eb

	});
	// Must be imported after Onyx.init() and outside the React lifecycle so that push notification
	// handlers are registered before any push arrives, including Android headless/background wake-ups.
	import('@libs/Notification/PushNotification/subscribeToPushNotifications');

Case 1: NewDot's notification ID is absent

The initial Onyx callback treats an absent key as a sign-out:

App/src/libs/Notification/PushNotification/subscribeToPushNotifications.ts

Lines 28 to 47 in 1fb14eb

	Onyx.connectWithoutView({
	key: ONYXKEYS.NVP_PRIVATE_PUSH_NOTIFICATION_ID,
	callback: (notificationID) => {
	if (notificationID) {
	PushNotification.register(notificationID);
	PushNotification.init();
	// Subscribe handlers for different push notification types
	PushNotification.onReceived(PushNotification.TYPE.REPORT_COMMENT, applyOnyxData);
	PushNotification.onSelected(PushNotification.TYPE.REPORT_COMMENT, navigateToReport);
	PushNotification.onReceived(PushNotification.TYPE.REPORT_ACTION, applyOnyxData);
	PushNotification.onSelected(PushNotification.TYPE.REPORT_ACTION, navigateToReport);
	PushNotification.onReceived(PushNotification.TYPE.TRANSACTION, applyOnyxData);
	PushNotification.onSelected(PushNotification.TYPE.TRANSACTION, navigateToReport);
	} else {
	PushNotification.deregister();
	PushNotification.clearNotifications();
	}

It calls deregister(), which mutates the shared Airship instance:

App/src/libs/Notification/PushNotification/index.native.ts

Lines 123 to 131 in 1fb14eb

	* Deregister this device from push notifications.
	*/
	const deregister: Deregister = () => {
	Log.info('[PushNotification] Unsubscribing from push notifications.');
	Airship.contact.reset();
	Airship.removeAllListeners(EventType.PushReceived);
	Airship.removeAllListeners(EventType.NotificationResponse);
	ForegroundNotifications.disableForegroundNotifications();
	ShortcutManager.removeAllDynamicShortcuts();

Airship.contact.reset();
Airship.removeAllListeners(EventType.PushReceived);
Airship.removeAllListeners(EventType.NotificationResponse);
ForegroundNotifications.disableForegroundNotifications();

On Android, disableForegroundNotifications() does not restore Airship's default behavior. It installs a predicate that always returns false:

App/src/libs/Notification/PushNotification/ForegroundNotifications/index.android.ts

Lines 7 to 13 in 1fb14eb

	function configureForegroundNotifications() {
	Airship.push.android.setForegroundDisplayPredicate((pushPayload) => Promise.resolve(shouldShowPushNotification(pushPayload)));
	}
	function disableForegroundNotifications() {
	Airship.push.android.setForegroundDisplayPredicate(() => Promise.resolve(false));
	}

This can both reset the Classic account's shared Airship contact and suppress every foreground notification.

The callback then calls clearNotifications() as well. On an Android headless boot caused by an incoming push, an initial missing key can therefore clear the notification that just woke the JavaScript runtime.

Case 2: NewDot's notification ID is present

The callback calls init(), which installs NewDot's foreground predicate on that same Airship instance:

App/src/libs/Notification/PushNotification/index.native.ts

Lines 63 to 79 in 1fb14eb

	/**
	* Configure push notifications and register callbacks. This is separate from namedUser registration because it needs to be executed
	* from a headless JS process, outside of any react lifecycle.
	*
	* WARNING: Moving or changing this code could break Push Notification processing in non-obvious ways.
	* DO NOT ALTER UNLESS YOU KNOW WHAT YOU'RE DOING. See this PR for details: https://github.com/Expensify/App/pull/3877
	*/
	const init: Init = () => {
	// Setup event listeners
	Airship.addListener(EventType.PushReceived, (notification) => pushNotificationEventCallback(EventType.PushReceived, notification.pushPayload));
	// Note: the NotificationResponse event has a nested PushReceived event,
	// so event.notification refers to the same thing as notification above ^
	Airship.addListener(EventType.NotificationResponse, (event) => pushNotificationEventCallback(EventType.NotificationResponse, event.pushPayload));
	ForegroundNotifications.configureForegroundNotifications();
	};

That predicate evaluates the notification using NewDot's Onyx reports:

App/src/libs/Notification/PushNotification/shouldShowPushNotification.ts

Lines 44 to 66 in 1fb14eb

	export default function shouldShowPushNotification(pushPayload: PushPayload): boolean {
	Log.info('[PushNotification] push notification received', false, {pushPayload});
	const data = parsePushNotificationPayload(pushPayload.extras.payload);
	if (!data) {
	return true;
	}
	let shouldShow = false;
	if (data.type === 'transaction') {
	shouldShow = true;
	} else {
	const reportAction = ReportActionUtils.getLatestReportActionFromOnyxData(data.onyxData ?? null);
	const topmostReportID = Navigation.getTopmostReportId();
	const topmostReport = allReports?.[`${ONYXKEYS.COLLECTION.REPORT}${topmostReportID}`];
	const topmostChatReport = allReports?.[`${ONYXKEYS.COLLECTION.REPORT}${topmostReport?.chatReportID}`];
	const topmostReportActions = allReportActions?.[`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${topmostReportID}`];
	const topmostOneTransactionThreadReportID = ReportActionUtils.getOneTransactionThreadReportID(topmostReport, topmostChatReport, topmostReportActions, getIsOffline());
	shouldShow = Report.shouldShowReportActionNotification(String(data.reportID), topmostOneTransactionThreadReportID, currentUserAccountID, reportAction, true);
	}
	Log.info(`[PushNotification] ${shouldShow ? 'Showing' : 'Not showing'} notification`);
	return shouldShow;

For a Classic-owned foreground screen, NewDot is not the correct source of visibility state. Its report collection can be absent, stale, or missing the workspace chat. An absent report defaults to the HIDDEN notification preference and shouldShowReportActionNotification() returns false, so Airship suppresses the notification.

The HybridApp already records the ownership transition explicitly. Immediately before NewDot closes and Classic becomes active, closeReactNativeApp() writes closingReactNativeApp: true:

App/src/libs/actions/HybridApp/index.ts

Lines 103 to 123 in 1fb14eb

	function closeReactNativeApp({shouldSetNVP, isTrackingGPS, shouldIgnoreTryNewDotLoading = false}: CloseReactNativeAppParams) {
	if (isLockedToNewApp(currentTryNewDot)) {
	return;
	}
	if (isTrackingGPS) {
	setIsGPSInProgressModalOpen(true);
	return;
	}
	if (!shouldIgnoreTryNewDotLoading && shouldBlockOldAppExit(currentTryNewDot, isLoadingTryNewDot, shouldSetNVP)) {
	return;
	}
	Navigation.clearPreloadedRoutes();
	if (CONFIG.IS_HYBRID_APP) {
	Onyx.merge(ONYXKEYS.HYBRID_APP, {closingReactNativeApp: true});
	}
	// eslint-disable-next-line no-restricted-properties
	HybridAppModule.closeReactNativeApp({shouldSetNVP});

When NewDot becomes active again, setupNewDotAfterTransitionFromOldDot() resets it to false:

App/src/libs/actions/Session/index.ts

Lines 784 to 798 in 1fb14eb

	.then(resetDidUserLoginDuringSessionIfNeeded)
	.then(() => {
	const hybridAppUpdate = {
	...hybridApp,
	closingReactNativeApp: false,
	readyToShowAuthScreens: !hybridApp?.useNewDotSignInPage,
	};
	const onyxUpdates: Array<OnyxUpdate<typeof ONYXKEYS.HYBRID_APP | keyof typeof newDotOnyxValues>> = [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: ONYXKEYS.HYBRID_APP,
	value: hybridAppUpdate,
	},
	];

The notification code does not use that ownership signal. It therefore applies NewDot's contact teardown or NewDot's report-based suppression while Classic is the active experience.

This is why the existing single-path proposals are incomplete:

• Guarding only the initial undefined callback does not help when the ID exists and init() installs NewDot's predicate.
• Returning true only when the report is absent does not help if deregister() has replaced the predicate with an always-false callback, or if stale NewDot data contains that report.
• Guarding only Airship.contact.reset() still leaves the suppress-all foreground predicate and clearNotifications() in place.

The recording proves the foreground display failure, but it does not contain native delivery logs. The proposal therefore does not assume whether this run had an absent or present NewDot notification ID; it fixes both concrete App-side paths.

What changes do you think we should make in order to solve the problem?

Make foreground-notification ownership follow the active HybridApp experience and distinguish initial hydration from a real sign-out.

1. Do not treat an initially absent ID as a sign-out

Track whether this JavaScript runtime initialized NewDot push handling:

let hasInitializedPushNotifications = false;

Onyx.connectWithoutView({
    key: ONYXKEYS.NVP_PRIVATE_PUSH_NOTIFICATION_ID,
    callback: (notificationID) => {
        if (notificationID) {
            PushNotification.register(notificationID);
            PushNotification.init();
            // Existing handler registration.
            hasInitializedPushNotifications = true;
            return;
        }

        // A Classic-only HybridApp runtime can start without this NewDot key.
        // It does not own the shared Airship state and must not clear the delivered push.
        if (CONFIG.IS_HYBRID_APP && !hasInitializedPushNotifications) {
            return;
        }

        hasInitializedPushNotifications = false;
        PushNotification.deregister();
        PushNotification.clearNotifications();
    },
});

This preserves standalone behavior and the existing valid-ID-to-empty-ID sign-out transition. It only makes the ambiguous initial absence a no-op in HybridApp. A real sign-out after NewDot initialized the ID still uses the current complete deregister() and clearNotifications() cleanup.

2. Bypass NewDot suppression while Classic owns the foreground

Subscribe to ONYXKEYS.HYBRID_APP in shouldShowPushNotification.ts alongside the existing non-React Onyx subscriptions:

let isClassicExperienceActive = false;

Onyx.connectWithoutView({
    key: ONYXKEYS.HYBRID_APP,
    callback: (hybridApp) => {
        isClassicExperienceActive = CONFIG.IS_HYBRID_APP && !!hybridApp?.closingReactNativeApp;
    },
});

Then let Airship display notifications while Classic is active:

export default function shouldShowPushNotification(pushPayload: PushPayload): boolean {
    if (isClassicExperienceActive) {
        return true;
    }

    // Existing NewDot visibility checks.
}

Also fail open for a report that is not loaded in NewDot:

const reportID = String(data.reportID);
const report = allReports?.[`${ONYXKEYS.COLLECTION.REPORT}${reportID}`];

if (CONFIG.IS_HYBRID_APP && !report) {
    return true;
}

The missing-report fallback matters for Android headless startup, where not every Onyx subscription is guaranteed to have populated before Airship asks for the foreground decision. NewDot should suppress a HybridApp notification only when NewDot is active and has enough state to make that decision.

Together, these changes cover both notification-ID states:

• no ID: initial hydration no longer deregisters or clears the incoming notification;
• valid ID: the configured predicate delegates to display while Classic is active;
• valid ID later cleared: the existing real sign-out cleanup still runs;
• active NewDot: existing own-message, muted-report, and currently-open-report suppression remains unchanged;
• standalone NewDot: registration and sign-out behavior remains unchanged.

No payload or backend change is required for the concrete foreground suppression shown in the issue. Native Airship logs should still be captured during QA to confirm that the device remains correctly associated with the Classic account.

What alternative solutions did you explore? (Optional)

• Only skip the initial undefined callback: Incomplete. A valid ID takes the init() path and still installs NewDot's predicate over Classic.
• Only return true for an unknown report: Incomplete. The absent-ID path replaces the predicate itself with () => false, so shouldShowPushNotification() is never called.
• Only guard Airship.contact.reset() in HybridApp: Incomplete. disableForegroundNotifications() still suppresses every foreground notification, and the subscription still clears the notification shade.
• Never run the full deregister() cleanup in HybridApp: Too broad. A real NewDot sign-out still needs the existing cleanup; the bug is specifically that initial absence is mistaken for that transition.
• Always display unknown reports on every platform: Too broad. The fail-open behavior is needed at the HybridApp ownership boundary; standalone NewDot can keep its existing policy.
• Change backend targeting: The video has no delivery logs, and the client contains deterministic foreground suppression in either local NVP state. Backend investigation can continue independently if Airship logs show that no push reaches the device.
• Move push setup into React: This would lose the Android headless processing that the current setup deliberately preserves.