fix(android): track Activity early to fix cold-start init

Author: fadi-george

android/build.gradle

@@ -27,6 +27,12 @@ android {
 dependencies {
     implementation "com.facebook.react:react-native:${safeExtGet('reactNativeVersion', '+')}"
 
+    // androidx.startup runs our OneSignalInitializer during Application.onCreate so we can register
+    // an ActivityLifecycleCallbacks before MainActivity.onResume fires. This avoids the cold-start
+    // race where ReactApplicationContext.getCurrentActivity() returns null and the OneSignal SDK
+    // ends up holding an ApplicationContext instead of the real Activity.
+    implementation 'androidx.startup:startup-runtime:1.1.1'
+
     // api is used instead of implementation so the parent :app project can access any of the OneSignal Java
     //   classes if needed. Such as com.onesignal.NotificationExtenderService
     //

android/src/main/AndroidManifest.xml

@@ -1,2 +1,14 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          xmlns:tools="http://schemas.android.com/tools">
+    <application>
+        <provider
+            android:name="androidx.startup.InitializationProvider"
+            android:authorities="${applicationId}.androidx-startup"
+            android:exported="false"
+            tools:node="merge">
+            <meta-data
+                android:name="com.onesignal.rnonesignalandroid.OneSignalInitializer"
+                android:value="androidx.startup" />
+        </provider>
+    </application>
 </manifest>

android/src/main/java/com/onesignal/rnonesignalandroid/ActivityLifecycleTracker.java

@@ -0,0 +1,72 @@
+package com.onesignal.rnonesignalandroid;
+
+import android.app.Activity;
+import android.app.Application;
+import android.os.Bundle;
+import androidx.annotation.Nullable;
+import java.lang.ref.WeakReference;
+
+/**
+ * Tracks the host app's current Activity from Application.onCreate onward.
+ *
+ * <p>Registered very early via {@link OneSignalInitializer} (androidx.startup) so it captures the
+ * first {@code MainActivity.onResume} that fires before the React Native bridge has loaded the JS
+ * bundle. Without this, {@link com.facebook.react.bridge.ReactApplicationContext#getCurrentActivity()}
+ * frequently returns {@code null} during cold start in bridgeless mode, causing
+ * {@code RNOneSignal.initialize} to hand the OneSignal SDK an ApplicationContext instead of the
+ * real Activity. That in turn leaves {@code ApplicationService.current == null} and queues
+ * {@code requestPermission()} until the next foreground.
+ */
+public class ActivityLifecycleTracker implements Application.ActivityLifecycleCallbacks {
+    private static final ActivityLifecycleTracker INSTANCE = new ActivityLifecycleTracker();
+
+    private WeakReference<Activity> currentActivity = new WeakReference<>(null);
+
+    private ActivityLifecycleTracker() {}
+
+    public static ActivityLifecycleTracker getInstance() {
+        return INSTANCE;
+    }
+
+    @Nullable
+    public Activity getCurrentActivity() {
+        return currentActivity.get();
+    }
+
+    @Override
+    public void onActivityCreated(Activity activity, @Nullable Bundle savedInstanceState) {
+        currentActivity = new WeakReference<>(activity);
+    }
+
+    @Override
+    public void onActivityStarted(Activity activity) {
+        currentActivity = new WeakReference<>(activity);
+    }
+
+    @Override
+    public void onActivityResumed(Activity activity) {
+        currentActivity = new WeakReference<>(activity);
+    }
+
+    @Override
+    public void onActivityPaused(Activity activity) {
+        // Intentionally no-op: keep the reference so a transient overlay (e.g. permission dialog,
+        // PermissionsActivity) doesn't blank out the current Activity for callers that race with it.
+    }
+
+    @Override
+    public void onActivityStopped(Activity activity) {
+        // Intentionally no-op for the same reason as onActivityPaused.
+    }
+
+    @Override
+    public void onActivitySaveInstanceState(Activity activity, Bundle outState) {}
+
+    @Override
+    public void onActivityDestroyed(Activity activity) {
+        Activity current = currentActivity.get();
+        if (current == activity) {
+            currentActivity = new WeakReference<>(null);
+        }
+    }
+}

android/src/main/java/com/onesignal/rnonesignalandroid/OneSignalInitializer.java

@@ -0,0 +1,37 @@
+package com.onesignal.rnonesignalandroid;
+
+import android.app.Application;
+import android.content.Context;
+import androidx.annotation.NonNull;
+import androidx.startup.Initializer;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * androidx.startup entry point that registers {@link ActivityLifecycleTracker} against the host
+ * {@link Application} during {@code Application.onCreate}, before any Activity is created.
+ *
+ * <p>This does NOT initialize the OneSignal SDK itself: the App ID is supplied at runtime by JS
+ * via {@code OneSignal.initialize(appId)}. The job here is purely to capture the current Activity
+ * early so that when JS later calls initialize, {@code RNOneSignal} can hand a real Activity to
+ * {@code OneSignal.initWithContext}.
+ */
+public class OneSignalInitializer implements Initializer<ActivityLifecycleTracker> {
+
+    @NonNull
+    @Override
+    public ActivityLifecycleTracker create(@NonNull Context context) {
+        ActivityLifecycleTracker tracker = ActivityLifecycleTracker.getInstance();
+        Context appContext = context.getApplicationContext();
+        if (appContext instanceof Application) {
+            ((Application) appContext).registerActivityLifecycleCallbacks(tracker);
+        }
+        return tracker;
+    }
+
+    @NonNull
+    @Override
+    public List<Class<? extends Initializer<?>>> dependencies() {
+        return Collections.emptyList();
+    }
+}

android/src/main/java/com/onesignal/rnonesignalandroid/RNOneSignal.java

@@ -238,11 +238,20 @@ public void initialize(String appId) {
         }
 
         ReactApplicationContext reactContext = getReactApplicationContext();
-        Context context = reactContext.getCurrentActivity();
+        // Prefer the Activity captured by ActivityLifecycleTracker (registered via androidx.startup
+        // before MainActivity.onResume), then fall back to ReactApplicationContext's accessor and
+        // finally the ApplicationContext. Passing the real Activity lets the OneSignal SDK populate
+        // ApplicationService.current immediately, so requestPermission() can launch the OS dialog
+        // on the first cold-start instead of waiting for the next foreground event.
+        Context context = ActivityLifecycleTracker.getInstance().getCurrentActivity();
+        if (context == null) {
+            context = reactContext.getCurrentActivity();
+        }
         if (context == null) {
             context = reactContext.getApplicationContext();
         }
 
+        Logging.debug("OneSignal initialize using context: " + context.getClass().getSimpleName(), null);
         OneSignal.initWithContext(context, appId);
         oneSignalInitDone = true;
     }

examples/demo/bun.lock

@@ -1,5 +1,5 @@
-import { useFocusEffect, useNavigation } from '@react-navigation/native';
-import React, { useCallback, useRef, useState } from 'react';
+import { useNavigation } from '@react-navigation/native';
+import React, { useEffect, useState } from 'react';
 import { Platform, ScrollView, StyleSheet, View } from 'react-native';
 
 import ActionButton from '../components/ActionButton';
@@ -32,18 +32,9 @@ export default function HomeScreen() {
   const [tooltipVisible, setTooltipVisible] = useState(false);
   const [activeTooltip, setActiveTooltip] = useState<TooltipData | null>(null);
 
-  // Prompt for push only after the screen is actually focused so the Android
-  // Activity is resumed and can present the OS dialog. Otherwise the request
-  // gets queued and the prompt only appears after the next foreground.
-  const hasPromptedRef = useRef(false);
-  useFocusEffect(
-    useCallback(() => {
-      if (os.isReady && !hasPromptedRef.current) {
-        hasPromptedRef.current = true;
-        os.promptPush();
-      }
-    }, [os.isReady, os.promptPush]),
-  );
+  useEffect(() => {
+    if (os.isReady) os.promptPush();
+  }, [os.isReady, os.promptPush]);
 
   const showTooltipModal = (key: string) => {
     const tooltip = TooltipHelper.getInstance().getTooltip(key);