React Native：从原生端（Swift/Objective-C）访问Redux Store

Great question! Let's break down how to handle this scenario in React Native, since accessing the Redux Store directly from native termination events isn't straightforward.

Short answer: No. The Redux Store lives entirely in the React Native JavaScript runtime, and native code (Swift/Obj-C for iOS, Kotlin/Java for Android) can't directly read or interact with JS memory objects. We need workarounds to get the data we need for cleanup and analytics.

1. Sync Critical Redux State to Native Storage When App Enters Background #

This is the most reliable approach, since it ensures native code has all necessary data before the app might be terminated.

• Step 1: In React Native JS layer
  Listen for the app entering the background, then pull critical data from the Redux Store and pass it to native modules for storage.

  import { AppState, NativeModules } from 'react-native';
  import { useSelector } from 'react-redux';
  import store from './path-to-your-redux-store';
  
  // In your root component or initialization logic
  useEffect(() => {
    const handleAppBackground = () => {
      // Grab only the data you need for cleanup/analytics
      const criticalData = store.getState() => ({
        userId: store.getState().user.id,
        activeSessionId: store.getState().session.id,
        pendingAnalyticsEvents: store.getState().analytics.pendingEvents
      });
      // Send data to native module
      NativeModules.AppTerminationHelper.saveCriticalData(criticalData);
    };
  
    AppState.addEventListener('background', handleAppBackground);
    return () => AppState.removeEventListener('background', handleAppBackground);
  }, []);
  

• Step 2: In Native Code
  Store the data in a native persistent storage (like UserDefaults on iOS, SharedPreferences on Android), then retrieve it when the termination event fires.
  • iOS (Swift):

    @objc class AppTerminationHelper: NSObject {
      static let shared = AppTerminationHelper()
      private let defaults = UserDefaults.standard
      private let storageKey = "AppCriticalTerminationData"
    
      @objc func saveCriticalData(_ data: [String: Any]) {
        defaults.set(data, forKey: storageKey)
        defaults.synchronize()
      }
    
      private func getCriticalData() -> [String: Any]? {
        return defaults.dictionary(forKey: storageKey)
      }
    }
    
    // In AppDelegate.swift
    func applicationWillTerminate(_ application: UIApplication) {
      guard let data = AppTerminationHelper.shared.getCriticalData() else { return }
      
      // Perform cleanup: e.g., clear cached tokens
      UserDefaults.standard.removeObject(forKey: "AuthToken")
      
      // Send analytics data: e.g., call your analytics SDK
      AnalyticsService.sendTerminationEvent(
        userId: data["userId"] as? String,
        sessionId: data["activeSessionId"] as? String
      )
    }
    

  • Android (Kotlin):

    class AppTerminationHelperModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
      private val sharedPrefs = reactContext.getSharedPreferences("AppCriticalData", Context.MODE_PRIVATE)
    
      override fun getName() = "AppTerminationHelper"
    
      @ReactMethod
      fun saveCriticalData(data: ReadableMap) {
        val editor = sharedPrefs.edit()
        // Map JS data to native storage types
        data.toHashMap().forEach { (key, value) ->
          when (value) {
            is String -> editor.putString(key, value)
            is Int -> editor.putInt(key, value)
            is Boolean -> editor.putBoolean(key, value)
          }
        }
        editor.apply()
      }
    
      fun getCriticalData(): HashMap<String, Any> {
        val dataMap = HashMap<String, Any>()
        sharedPrefs.all.forEach { (key, value) ->
          dataMap[key] = value ?: ""
        }
        return dataMap
      }
    }
    
    // In your custom Application class
    override fun onTaskRemoved(rootIntent: Intent?) {
      super.onTaskRemoved(rootIntent)
      val data = AppTerminationHelperModule(applicationContext).getCriticalData()
      
      // Cleanup and analytics logic here
      AnalyticsManager.sendTerminationEvent(data["userId"] as? String)
    }
    

2. Sync Redux State to Native in Real-Time (Using a Middleware) #

If you need the absolute latest state (not just when the app enters background), create a Redux middleware that automatically syncs critical state changes to native storage whenever relevant actions are dispatched.

import { NativeModules } from 'react-native';

const nativeSyncMiddleware = store => next => action => {
  const result = next(action);
  
  // Sync only when specific actions are triggered
  if (['USER_UPDATED', 'SESSION_REFRESHED', 'ANALYTICS_EVENT_ADDED'].includes(action.type)) {
    const criticalData = store.getState() => ({
      userId: store.getState().user.id,
      activeSessionId: store.getState().session.id,
      pendingAnalyticsEvents: store.getState().analytics.pendingEvents
    });
    NativeModules.AppTerminationHelper.saveCriticalData(criticalData);
  }
  
  return result;
};

// Add this middleware to your Redux Store configuration
const store = configureStore({
  reducer: rootReducer,
  middleware: (getDefaultMiddleware) => getDefaultMiddleware().concat(nativeSyncMiddleware)
});

3. Trigger a JS Callback from Native (Less Reliable) #

You can try to trigger a JS function from native code during termination to fetch Redux data, but this is risky: when the app is force-terminated, the JS thread may already be suspended, so the callback might not execute. Use this only if the above options don't fit your use case.

• iOS (Swift):

  func applicationWillTerminate(_ application: UIApplication) {
    RCTBridge.current()?.enqueueJSCall(
      "AppTerminationHandler",
      method: "onTerminate",
      args: nil
    ) { result, error in
      if let terminationData = result as? [String: Any] {
        // Handle data here
      }
    }
  }
  

• RN JS layer:

  // Attach a global handler for native to call
  global.AppTerminationHandler = {
    onTerminate: () => {
      return store.getState().criticalData;
    }
  };
  

Stick with Solution 1 or 2—they're far more reliable for handling app termination scenarios, as they ensure native code has all necessary data before the app might be killed. The real-time sync middleware (Solution 2) is ideal if your critical state changes frequently and you need the latest data at termination time.

内容的提问来源于stack exchange，提问作者Jonovono