React Native iOS端startObserving在Android原生模块的等效实现方案

可选实现方案 #

方案1：原生模块内置事件队列（推荐，完全对齐iOS逻辑） #

该方案和你iOS端的实现逻辑1:1对应，不依赖Activity生命周期，不受singleTask启动模式影响，是兼容性最好的方案。
核心原理是利用RN原生模块的监听生命周期回调，维护事件缓存队列，JS侧监听注册完成后自动推送缓存事件。

public class EventModule extends ReactContextBaseJavaModule implements LifecycleEventListener {
    private boolean hasListeners = false;
    private final List<WritableMap> delayedEvents = Collections.synchronizedList(new ArrayList<>());

    public EventModule(ReactApplicationContext reactContext) {
        super(reactContext);
        reactContext.addLifecycleEventListener(this);
    }

    @NonNull
    @Override
    public String getName() {
        return "EventModule";
    }

    // 对应iOS的startObserving，JS端添加监听时自动触发
    @ReactMethod
    public void addListener(String eventName) {
        if ("delayedEvents".equals(eventName)) {
            hasListeners = true;
            // 有缓存事件直接批量发送
            synchronized (delayedEvents) {
                if (!delayedEvents.isEmpty()) {
                    WritableArray eventArray = Arguments.createArray();
                    for (WritableMap event : delayedEvents) {
                        eventArray.pushMap(event);
                    }
                    sendEvent("delayedEvents", eventArray);
                    delayedEvents.clear();
                }
            }
        }
    }

    // 对应iOS的stopObserving，JS端移除监听时自动触发
    @ReactMethod
    public void removeListeners(Integer count) {
        hasListeners = false;
    }

    // 对外暴露的发事件方法，替代直接sendEvent
    public void sendOrQueueEvent(String name, @Nullable WritableMap data) {
        WritableMap event = Arguments.createMap();
        event.putString("name", name);
        event.putMap("data", data);
        if (hasListeners) {
            sendEvent("delayedEvents", event);
        } else {
            synchronized (delayedEvents) {
                delayedEvents.add(event);
            }
        }
    }

    private void sendEvent(String eventName, @Nullable WritableArray params) {
        getReactApplicationContext()
                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
                .emit(eventName, params);
    }
    
    private void sendEvent(String eventName, @Nullable WritableMap params) {
        getReactApplicationContext()
                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
                .emit(eventName, params);
    }

    // 可选：应用切后台销毁时清空状态避免内存泄漏
    @Override
    public void onHostResume() {}

    @Override
    public void onHostPause() {}

    @Override
    public void onHostDestroy() {
        hasListeners = false;
        synchronized (delayedEvents) {
            delayedEvents.clear();
        }
    }
}

JS侧用法和iOS完全一致，只需监听delayedEvents事件即可接收所有缓存和实时事件，无需区分应用前后台状态。

方案2：优化现有启动参数方案 #

针对你当前遇到的新旧事件冲突问题，可通过标记JS初始化状态、统一Intent处理逻辑修复：

public static class CustomReactActivityDelegate extends ReactActivityDelegate {
    private Bundle initialProps = null;
    private final ReactActivity activity;
    // 标记是否已经触发过JS加载
    private boolean isJsInitialized = false;

    public CustomReactActivityDelegate(ReactActivity activity, String mainComponentName) {
        super(activity, mainComponentName);
        this.activity = activity;
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // 先处理Intent，提取最新event
        processIntent(activity.getIntent());
        super.onCreate(savedInstanceState);
        isJsInitialized = true;
        // onCreate完成后补发事件，覆盖启动参数早于onNewIntent触发的场景
        if (initialProps != null && initialProps.containsKey("event")) {
            sendEventToJs("initEvent", initialProps.getBundle("event"));
            initialProps.remove("event");
        }
    }

    @Override
    public boolean onNewIntent(Intent intent) {
        processIntent(intent);
        // 如果JS已经加载完，直接发事件不用走启动参数
        if (isJsInitialized && initialProps != null && initialProps.containsKey("event")) {
            sendEventToJs("initEvent", initialProps.getBundle("event"));
            initialProps.remove("event");
            return true;
        }
        return super.onNewIntent(intent);
    }

    @Override
    protected Bundle getLaunchOptions() {
        return initialProps;
    }

    // 统一处理Intent提取event逻辑
    private void processIntent(Intent intent) {
        Bundle bundle = intent.getExtras();
        if (bundle != null && bundle.containsKey("event")) {
            Bundle event = bundle.getBundle("event");
            // 清空intent里的旧event，避免下次重建时重复读取
            intent.removeExtra("event");
            initialProps = new Bundle();
            initialProps.putBundle("event", event);
        }
    }

    // 直接给JS发事件的工具方法
    private void sendEventToJs(String eventName, Bundle event) {
        ReactInstanceManager reactInstanceManager = getReactInstanceManager();
        if (reactInstanceManager.getCurrentReactContext() == null) return;
        WritableMap map = Arguments.fromBundle(event);
        reactInstanceManager.getCurrentReactContext()
                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
                .emit(eventName, map);
    }
}

核心优化点：

• 统一Intent处理逻辑，每次提取完事件就清空Intent内的event参数，避免Activity重建时读取到过期事件
• 新增JS初始化状态标记，onNewIntent触发时若JS已加载完成，直接通过RCTDeviceEventEmitter推送新事件，无需走启动参数流程
• onCreate完成后补充一次事件推送，覆盖启动参数读取早于onNewIntent触发的场景

方案3：全局持久化缓存方案 #

如果需要在应用进程被杀死后仍保留事件，可使用SharedPreferences/本地存储持久化事件队列，JS加载完成后读取缓存事件并清空即可，适合推送事件等高优先级场景。

内容的提问来源于stack exchange，提问作者Duncan de Wet