Branch.io React Native iOS: Subscribe Inconsistency Fix

// ✅ Correct approach - Subscribe immediately after Branch initialization
import { Branch } from 'react-native-branch';

const initBranch = async () => {
  try {
    await Branch.initSession();
    
    // Subscribe immediately after initialization
    Branch.subscribe(({ error, params, uri }) => {
      if (error) {
        console.error('Error from Branch:', error);
        return;
      }
      
      // ✅ Always check for clicked_branch_link before processing
      if (!params['+clicked_branch_link']) {
        return; // Exit if not a Branch link click
      }
      
      console.log('Deep link params:', params);
      // Handle your deep link logic here
    });
    
  } catch (error) {
    console.error('Branch initialization error:', error);
  }
};

// Call this as early as possible in your app startup
initBranch();

// In AppDelegate.swift - Check which type of link you're receiving
func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([Any]?) -> Void) -> Bool {
    if userActivity.activityType == NSUserActivityTypeBrowsingWeb {
        // This is a universal link
        let handled = RNBranch.continue(userActivity)
        return handled
    }
    return false
}

import { Linking } from 'react-native';
import { Branch } from 'react-native-branch';

const handleDeepLinks = () => {
  // Handle initial deep link
  Branch.subscribe(({ error, params, uri }) => {
    if (error) console.error('Branch error:', error);
    if (params && params['+clicked_branch_link']) {
      handleBranchDeepLink(params);
    }
  });

  // ✅ IMPORTANT: Add Linking listener for background/foreground state
  const subscription = Linking.addEventListener('url', (event) => {
    if (event.url) {
      // Check if this is a Branch link
      if (event.url.includes('myapp.app.link') || event.url.includes('myapp.test-app.link')) {
        // Parse the Branch link
        Branch.parseUniversalLink(event.url).then(params => {
          if (params && params['+clicked_branch_link']) {
            handleBranchDeepLink(params);
          }
        });
      }
    }
  });

  return () => {
    subscription.remove();
  };
};

const handleBranchDeepLink = (params) => {
  console.log('Processing deep link:', params);
  // Your deep link logic here
};

class BranchManager {
  constructor() {
    this.isInitialized = false;
    this.subscription = null;
  }

  async initialize() {
    if (this.isInitialized) return;
    
    try {
      await Branch.initSession();
      this.setupSubscription();
      this.isInitialized = true;
    } catch (error) {
      console.error('Branch initialization failed:', error);
    }
  }

  setupSubscription() {
    // Clean up existing subscription
    if (this.subscription) {
      this.subscription.remove();
    }

    this.subscription = Branch.subscribe(({ error, params, uri }) => {
      if (error) {
        console.error('Branch error:', error);
        return;
      }

      if (!params || !params['+clicked_branch_link']) {
        return;
      }

      console.log('Received deep link:', params);
      // Handle your deep link logic
    });
  }

  // Call this when you need to resubscribe (e.g., after navigation changes)
  resubscribe() {
    if (this.isInitialized) {
      this.setupSubscription();
    }
  }
}

// Usage
const branchManager = new BranchManager();
branchManager.initialize();

// In AppDelegate.swift, add:
import RNBranch

RNBranch.enableLogging()

// Check for existing deep links on app start
const checkExistingDeepLinks = async () => {
  const latestParams = await Branch.getLatestReferringParams();
  const installParams = await Branch.getFirstReferringParams();
  
  if (latestParams && latestParams['+clicked_branch_link']) {
    handleBranchDeepLink(latestParams);
  }
};

const setupBranchListeners = () => {
  // Subscribe to Branch events
  Branch.subscribe(handleBranchEvent);
  
  // Listen for app state changes
  AppState.addEventListener('change', (nextAppState) => {
    if (nextAppState === 'active') {
      // App came to foreground - check for pending deep links
      Branch.getLatestReferringParams().then(params => {
        if (params && params['+clicked_branch_link']) {
          handleBranchDeepLink(params);
        }
      });
    }
  });
};