expo-facebook-analytics 1.1.0 → 1.1.2

package/README.md

@@ -47,8 +47,9 @@ logPurchase(29.99, 'USD');
 ```
 
 For deferred (consent-gated) initialization, set `isAutoInitEnabled: false` in the
-plugin and call `initialize()` yourself. Enable the Facebook SDK's native logging
-with `setLoggingEnabled(true)`. See the [documentation](https://jasperaelvoet.github.io/expo-facebook-analytics/) for the full API.
+plugin and call `initialize()` yourself; with `autoLogAppEventsEnabled: false`, also
+call `activateApp()` so Meta still receives the install event. Enable the Facebook
+SDK's native logging with `setLoggingEnabled(true)`. See the [documentation](https://jasperaelvoet.github.io/expo-facebook-analytics/) for the full API.
 
 See the **[documentation](https://jasperaelvoet.github.io/expo-facebook-analytics/)** for the full API,
 config-plugin options, manual initialization, and predefined constants.

package/android/build.gradle

@@ -31,7 +31,10 @@ android {
         externalNativeBuild {
             cmake {
                 cppFlags "-O2", "-frtti", "-fexceptions", "-Wall", "-std=c++20"
-                arguments "-DANDROID_STL=c++_shared"
+                arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+                // Match React Native and Nitro, including Expo's single-ABI dev builds.
+                abiFilters(*((rootProject.findProperty('reactNativeArchitectures') ?:
+                    'armeabi-v7a,x86,x86_64,arm64-v8a').split(',')))
             }
         }
     }

package/android/src/main/java/com/nitrofbanalytics/HybridFacebookAnalytics.kt

@@ -1,5 +1,6 @@
 package com.margelo.nitro.com.nitrofbanalytics
 
+import android.app.Application
 import android.os.Bundle
 import com.facebook.FacebookSdk
 import com.facebook.LoggingBehavior
@@ -29,6 +30,10 @@ class HybridFacebookAnalytics : HybridFacebookAnalyticsSpec() {
         FacebookSdk.fullyInitialize()
     }
 
+    override fun setAutoInitEnabled(enabled: Boolean) {
+        FacebookSdk.setAutoInitEnabled(enabled)
+    }
+
     override fun setAutoLogAppEventsEnabled(enabled: Boolean) {
         FacebookSdk.setAutoLogAppEventsEnabled(enabled)
     }
@@ -66,6 +71,15 @@ class HybridFacebookAnalytics : HybridFacebookAnalyticsSpec() {
 
     // region Event Logging
 
+    override fun activateApp() {
+        // Publishes the install (with the Play install referrer) once per device,
+        // then the launch event — the only path that does so when automatic
+        // event logging is off.
+        val application = FacebookSdk.getApplicationContext() as? Application
+            ?: throw IllegalStateException("The Facebook SDK has no Application context; call initialize() first")
+        AppEventsLogger.activateApp(application)
+    }
+
     override fun logEvent(eventName: String, valueToSum: Double, params: Map<String, String>) {
         val bundle = mapToBundle(params)
         logger.logEvent(eventName, valueToSum, bundle)

package/ios/HybridFacebookAnalytics.swift

@@ -13,6 +13,11 @@ class HybridFacebookAnalytics: HybridFacebookAnalyticsSpec {
         ApplicationDelegate.shared.initializeSDK()
     }
 
+    func setAutoInitEnabled(enabled: Bool) throws {
+        // The iOS SDK dropped auto-initialization in v9; `initialize()` is the
+        // only way it starts, so there is nothing to persist or undo here.
+    }
+
     func setAutoLogAppEventsEnabled(enabled: Bool) throws {
         Settings.shared.isAutoLogAppEventsEnabled = enabled
     }
@@ -44,6 +49,14 @@ class HybridFacebookAnalytics: HybridFacebookAnalyticsSpec {
 
     // MARK: - Event Logging
 
+    func activateApp() throws {
+        // Publishes the install and launch events. The SDK insists on the main
+        // thread for this call; Nitro calls arrive on the JS thread.
+        DispatchQueue.main.async {
+            AppEvents.shared.activateApp()
+        }
+    }
+
     func logEvent(eventName: String, valueToSum: Double, params: [String: String]) throws {
         let fbParams: [AppEvents.ParameterName: Any] = params.reduce(into: [:]) { result, pair in
             result[AppEvents.ParameterName(pair.key)] = pair.value

package/lib/index.d.ts

@@ -9,6 +9,15 @@ export { AppEventParams, AppEvents } from "./types";
  * after optionally configuring the app ID / client token at runtime.
  */
 export declare function initialize(): void;
+/**
+ * Turn the native SDK's auto-init flag on or off at runtime.
+ *
+ * `initialize()` switches it on, and Android persists the flag, so an app that
+ * gates the SDK behind consent should call `setAutoInitEnabled(false)` when
+ * consent is withdrawn — otherwise the next launch initializes the SDK before
+ * JavaScript runs. No-op on iOS, which has had no auto-init since SDK 9.
+ */
+export declare function setAutoInitEnabled(enabled: boolean): void;
 /**
  * Enable or disable automatic logging of app events at runtime.
  */
@@ -40,6 +49,16 @@ export declare function setLoggingEnabled(enabled: boolean): void;
  * @param args - Optional valueToSum (number) and/or params object
  */
 export declare function logEvent(eventName: string, ...args: Array<number | Params>): void;
+/**
+ * Log an app activation.
+ *
+ * Publishes the install event (carrying the Google Play install referrer on
+ * Android) the first time it runs on a device, then the launch event. The
+ * Facebook SDK only does this by itself when automatic event logging is on, so
+ * call it once per launch after {@link initialize} whenever
+ * `autoLogAppEventsEnabled` is off — without it Meta cannot attribute installs.
+ */
+export declare function activateApp(): void;
 /**
  * Log a purchase event.
  */

package/lib/index.js

@@ -2,12 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AppEvents = exports.AppEventParams = void 0;
 exports.initialize = initialize;
+exports.setAutoInitEnabled = setAutoInitEnabled;
 exports.setAutoLogAppEventsEnabled = setAutoLogAppEventsEnabled;
 exports.setAdvertiserIDCollectionEnabled = setAdvertiserIDCollectionEnabled;
 exports.setAppID = setAppID;
 exports.setClientToken = setClientToken;
 exports.setLoggingEnabled = setLoggingEnabled;
 exports.logEvent = logEvent;
+exports.activateApp = activateApp;
 exports.logPurchase = logPurchase;
 exports.logPushNotificationOpen = logPushNotificationOpen;
 exports.setUserID = setUserID;
@@ -56,6 +58,17 @@ function toStringParams(params) {
 function initialize() {
     NativeFBAnalytics.initialize();
 }
+/**
+ * Turn the native SDK's auto-init flag on or off at runtime.
+ *
+ * `initialize()` switches it on, and Android persists the flag, so an app that
+ * gates the SDK behind consent should call `setAutoInitEnabled(false)` when
+ * consent is withdrawn — otherwise the next launch initializes the SDK before
+ * JavaScript runs. No-op on iOS, which has had no auto-init since SDK 9.
+ */
+function setAutoInitEnabled(enabled) {
+    NativeFBAnalytics.setAutoInitEnabled(enabled);
+}
 /**
  * Enable or disable automatic logging of app events at runtime.
  */
@@ -115,6 +128,18 @@ function logEvent(eventName, ...args) {
         NativeFBAnalytics.logEventWithoutParams(eventName, valueToSum);
     }
 }
+/**
+ * Log an app activation.
+ *
+ * Publishes the install event (carrying the Google Play install referrer on
+ * Android) the first time it runs on a device, then the launch event. The
+ * Facebook SDK only does this by itself when automatic event logging is on, so
+ * call it once per launch after {@link initialize} whenever
+ * `autoLogAppEventsEnabled` is off — without it Meta cannot attribute installs.
+ */
+function activateApp() {
+    NativeFBAnalytics.activateApp();
+}
 /**
  * Log a purchase event.
  */

package/lib/specs/FacebookAnalytics.nitro.d.ts

@@ -4,6 +4,12 @@ export interface FacebookAnalytics extends HybridObject<{
     android: "kotlin";
 }> {
     initialize(): void;
+    /**
+     * Turn the native SDK's auto-init flag on or off at runtime. Android
+     * persists it, so an app that gates the SDK behind consent should switch it
+     * off again when consent is withdrawn. No-op on iOS, which has no auto-init.
+     */
+    setAutoInitEnabled(enabled: boolean): void;
     setAutoLogAppEventsEnabled(enabled: boolean): void;
     setAdvertiserIDCollectionEnabled(enabled: boolean): void;
     setAppID(appID: string): void;
@@ -13,6 +19,12 @@ export interface FacebookAnalytics extends HybridObject<{
      * developer errors). Logs are printed to the native console.
      */
     setLoggingEnabled(enabled: boolean): void;
+    /**
+     * Log an app activation: publishes the install (with the Play install
+     * referrer on Android) once per device, then the launch event. The only path
+     * that does so when automatic event logging is off.
+     */
+    activateApp(): void;
     logEvent(eventName: string, valueToSum: number, params: Record<string, string>): void;
     logEventWithoutParams(eventName: string, valueToSum: number): void;
     logPurchase(amount: number, currency: string, params: Record<string, string>): void;

package/nitrogen/generated/android/c++/JHybridFacebookAnalyticsSpec.cpp

@@ -52,6 +52,10 @@ namespace margelo::nitro::fbanalytics {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("initialize");
     method(_javaPart);
   }
+  void JHybridFacebookAnalyticsSpec::setAutoInitEnabled(bool enabled) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jboolean /* enabled */)>("setAutoInitEnabled");
+    method(_javaPart, enabled);
+  }
   void JHybridFacebookAnalyticsSpec::setAutoLogAppEventsEnabled(bool enabled) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jboolean /* enabled */)>("setAutoLogAppEventsEnabled");
     method(_javaPart, enabled);
@@ -72,6 +76,10 @@ namespace margelo::nitro::fbanalytics {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jboolean /* enabled */)>("setLoggingEnabled");
     method(_javaPart, enabled);
   }
+  void JHybridFacebookAnalyticsSpec::activateApp() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("activateApp");
+    method(_javaPart);
+  }
   void JHybridFacebookAnalyticsSpec::logEvent(const std::string& eventName, double valueToSum, const std::unordered_map<std::string, std::string>& params) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* eventName */, double /* valueToSum */, jni::alias_ref<jni::JMap<jni::JString, jni::JString>> /* params */)>("logEvent");
     method(_javaPart, jni::make_jstring(eventName), valueToSum, [&]() -> jni::local_ref<jni::JMap<jni::JString, jni::JString>> {

package/nitrogen/generated/android/c++/JHybridFacebookAnalyticsSpec.hpp

@@ -55,11 +55,13 @@ namespace margelo::nitro::fbanalytics {
   public:
     // Methods
     void initialize() override;
+    void setAutoInitEnabled(bool enabled) override;
     void setAutoLogAppEventsEnabled(bool enabled) override;
     void setAdvertiserIDCollectionEnabled(bool enabled) override;
     void setAppID(const std::string& appID) override;
     void setClientToken(const std::string& clientToken) override;
     void setLoggingEnabled(bool enabled) override;
+    void activateApp() override;
     void logEvent(const std::string& eventName, double valueToSum, const std::unordered_map<std::string, std::string>& params) override;
     void logEventWithoutParams(const std::string& eventName, double valueToSum) override;
     void logPurchase(double amount, const std::string& currency, const std::unordered_map<std::string, std::string>& params) override;

package/nitrogen/generated/android/kotlin/com/margelo/nitro/com/nitrofbanalytics/HybridFacebookAnalyticsSpec.kt

@@ -33,6 +33,10 @@ abstract class HybridFacebookAnalyticsSpec: HybridObject() {
   @Keep
   abstract fun initialize(): Unit
   
+  @DoNotStrip
+  @Keep
+  abstract fun setAutoInitEnabled(enabled: Boolean): Unit
+  
   @DoNotStrip
   @Keep
   abstract fun setAutoLogAppEventsEnabled(enabled: Boolean): Unit
@@ -53,6 +57,10 @@ abstract class HybridFacebookAnalyticsSpec: HybridObject() {
   @Keep
   abstract fun setLoggingEnabled(enabled: Boolean): Unit
   
+  @DoNotStrip
+  @Keep
+  abstract fun activateApp(): Unit
+  
   @DoNotStrip
   @Keep
   abstract fun logEvent(eventName: String, valueToSum: Double, params: Map<String, String>): Unit

package/nitrogen/generated/ios/c++/HybridFacebookAnalyticsSpecSwift.hpp

@@ -75,6 +75,12 @@ namespace margelo::nitro::fbanalytics {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void setAutoInitEnabled(bool enabled) override {
+      auto __result = _swiftPart.setAutoInitEnabled(std::forward<decltype(enabled)>(enabled));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline void setAutoLogAppEventsEnabled(bool enabled) override {
       auto __result = _swiftPart.setAutoLogAppEventsEnabled(std::forward<decltype(enabled)>(enabled));
       if (__result.hasError()) [[unlikely]] {
@@ -105,6 +111,12 @@ namespace margelo::nitro::fbanalytics {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void activateApp() override {
+      auto __result = _swiftPart.activateApp();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline void logEvent(const std::string& eventName, double valueToSum, const std::unordered_map<std::string, std::string>& params) override {
       auto __result = _swiftPart.logEvent(eventName, std::forward<decltype(valueToSum)>(valueToSum), params);
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/swift/HybridFacebookAnalyticsSpec.swift

@@ -14,11 +14,13 @@ public protocol HybridFacebookAnalyticsSpec_protocol: HybridObject {
 
   // Methods
   func initialize() throws -> Void
+  func setAutoInitEnabled(enabled: Bool) throws -> Void
   func setAutoLogAppEventsEnabled(enabled: Bool) throws -> Void
   func setAdvertiserIDCollectionEnabled(enabled: Bool) throws -> Void
   func setAppID(appID: String) throws -> Void
   func setClientToken(clientToken: String) throws -> Void
   func setLoggingEnabled(enabled: Bool) throws -> Void
+  func activateApp() throws -> Void
   func logEvent(eventName: String, valueToSum: Double, params: Dictionary<String, String>) throws -> Void
   func logEventWithoutParams(eventName: String, valueToSum: Double) throws -> Void
   func logPurchase(amount: Double, currency: String, params: Dictionary<String, String>) throws -> Void

package/nitrogen/generated/ios/swift/HybridFacebookAnalyticsSpec_cxx.swift

@@ -135,6 +135,17 @@ open class HybridFacebookAnalyticsSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func setAutoInitEnabled(enabled: Bool) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setAutoInitEnabled(enabled: enabled)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func setAutoLogAppEventsEnabled(enabled: Bool) -> bridge.Result_void_ {
     do {
@@ -190,6 +201,17 @@ open class HybridFacebookAnalyticsSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func activateApp() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.activateApp()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func logEvent(eventName: std.string, valueToSum: Double, params: bridge.std__unordered_map_std__string__std__string_) -> bridge.Result_void_ {
     do {

package/nitrogen/generated/shared/c++/HybridFacebookAnalyticsSpec.cpp

@@ -15,11 +15,13 @@ namespace margelo::nitro::fbanalytics {
     // load custom methods/properties
     registerHybrids(this, [](Prototype& prototype) {
       prototype.registerHybridMethod("initialize", &HybridFacebookAnalyticsSpec::initialize);
+      prototype.registerHybridMethod("setAutoInitEnabled", &HybridFacebookAnalyticsSpec::setAutoInitEnabled);
       prototype.registerHybridMethod("setAutoLogAppEventsEnabled", &HybridFacebookAnalyticsSpec::setAutoLogAppEventsEnabled);
       prototype.registerHybridMethod("setAdvertiserIDCollectionEnabled", &HybridFacebookAnalyticsSpec::setAdvertiserIDCollectionEnabled);
       prototype.registerHybridMethod("setAppID", &HybridFacebookAnalyticsSpec::setAppID);
       prototype.registerHybridMethod("setClientToken", &HybridFacebookAnalyticsSpec::setClientToken);
       prototype.registerHybridMethod("setLoggingEnabled", &HybridFacebookAnalyticsSpec::setLoggingEnabled);
+      prototype.registerHybridMethod("activateApp", &HybridFacebookAnalyticsSpec::activateApp);
       prototype.registerHybridMethod("logEvent", &HybridFacebookAnalyticsSpec::logEvent);
       prototype.registerHybridMethod("logEventWithoutParams", &HybridFacebookAnalyticsSpec::logEventWithoutParams);
       prototype.registerHybridMethod("logPurchase", &HybridFacebookAnalyticsSpec::logPurchase);

package/nitrogen/generated/shared/c++/HybridFacebookAnalyticsSpec.hpp

@@ -52,11 +52,13 @@ namespace margelo::nitro::fbanalytics {
     public:
       // Methods
       virtual void initialize() = 0;
+      virtual void setAutoInitEnabled(bool enabled) = 0;
       virtual void setAutoLogAppEventsEnabled(bool enabled) = 0;
       virtual void setAdvertiserIDCollectionEnabled(bool enabled) = 0;
       virtual void setAppID(const std::string& appID) = 0;
       virtual void setClientToken(const std::string& clientToken) = 0;
       virtual void setLoggingEnabled(bool enabled) = 0;
+      virtual void activateApp() = 0;
       virtual void logEvent(const std::string& eventName, double valueToSum, const std::unordered_map<std::string, std::string>& params) = 0;
       virtual void logEventWithoutParams(const std::string& eventName, double valueToSum) = 0;
       virtual void logPurchase(double amount, const std::string& currency, const std::unordered_map<std::string, std::string>& params) = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-facebook-analytics",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "High-performance Facebook Analytics for React Native using Nitro Modules",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/plugin/build/withFacebookAnalyticsIOS.d.ts

@@ -11,6 +11,15 @@ type ResolvedProps = {
 };
 export declare const withFacebookIOS: ConfigPlugin<ResolvedProps>;
 export declare const withUserTrackingPermission: ConfigPlugin<ResolvedProps>;
+/**
+ * Wire the Facebook SDK into the app delegate so it initializes at launch.
+ *
+ * Expo SDK 53 and newer generate `AppDelegate.swift` (an `ExpoAppDelegate`
+ * subclass); older templates are Objective-C. Both are handled, and the patch
+ * is idempotent. Exported without the config-plugin wrapper so it can be
+ * unit-tested against template snippets.
+ */
+export declare function applyFacebookAppDelegate(contents: string, language: string): string;
 export declare const withFacebookAppDelegate: ConfigPlugin<ResolvedProps>;
 export declare const withSKAdNetworkIdentifiers: ConfigPlugin<string[]>;
 export {};

package/plugin/build/withFacebookAnalyticsIOS.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withSKAdNetworkIdentifiers = exports.withFacebookAppDelegate = exports.withUserTrackingPermission = exports.withFacebookIOS = void 0;
+exports.applyFacebookAppDelegate = applyFacebookAppDelegate;
 const config_plugins_1 = require("@expo/config-plugins");
 const withFacebookIOS = (config, props) => {
     return (0, config_plugins_1.withInfoPlist)(config, (mod) => {
@@ -55,26 +56,64 @@ const withUserTrackingPermission = (config, props) => {
     });
 };
 exports.withUserTrackingPermission = withUserTrackingPermission;
-const withFacebookAppDelegate = (config, _props) => {
-    return (0, config_plugins_1.withAppDelegate)(config, (mod) => {
-        const contents = mod.modResults.contents;
-        // Add import
-        if (!contents.includes("#import <FBSDKCoreKit/FBSDKCoreKit.h>")) {
-            mod.modResults.contents = mod.modResults.contents.replace('#import "AppDelegate.h"', '#import "AppDelegate.h"\n#import <FBSDKCoreKit/FBSDKCoreKit.h>');
+const OBJC_IMPORT = "#import <FBSDKCoreKit/FBSDKCoreKit.h>";
+const OBJC_LAUNCH_HOOK = "[[FBSDKApplicationDelegate sharedInstance] application:application didFinishLaunchingWithOptions:launchOptions];";
+const SWIFT_IMPORT = "import FBSDKCoreKit";
+const SWIFT_LAUNCH_HOOK = "ApplicationDelegate.shared.application(application, didFinishLaunchingWithOptions: launchOptions)";
+const SWIFT_LAUNCH_ANCHOR = /^([ \t]*)return super\.application\(application, didFinishLaunchingWithOptions: launchOptions\)/m;
+/**
+ * Wire the Facebook SDK into the app delegate so it initializes at launch.
+ *
+ * Expo SDK 53 and newer generate `AppDelegate.swift` (an `ExpoAppDelegate`
+ * subclass); older templates are Objective-C. Both are handled, and the patch
+ * is idempotent. Exported without the config-plugin wrapper so it can be
+ * unit-tested against template snippets.
+ */
+function applyFacebookAppDelegate(contents, language) {
+    let result = contents;
+    if (language === "swift") {
+        if (!result.includes(SWIFT_IMPORT)) {
+            // Ahead of the first import, whatever access modifier the template uses
+            // (`internal import Expo` on SDK 57, plain `import Expo` before).
+            const withImport = result.replace(/^((?:\w+ )?import [^\n]+\n)/m, `${SWIFT_IMPORT}\n$1`);
+            result =
+                withImport === result ? `${SWIFT_IMPORT}\n${result}` : withImport;
         }
-        // Add didFinishLaunchingWithOptions hook
-        if (!contents.includes("FBSDKApplicationDelegate")) {
-            mod.modResults.contents = mod.modResults.contents.replace("self.initialProps = @{};", "self.initialProps = @{};\n  [[FBSDKApplicationDelegate sharedInstance] application:application didFinishLaunchingWithOptions:launchOptions];");
+        if (!result.includes(SWIFT_LAUNCH_HOOK)) {
+            if (!SWIFT_LAUNCH_ANCHOR.test(result)) {
+                throw new Error("expo-facebook-analytics: could not find `return super.application(application, didFinishLaunchingWithOptions: launchOptions)` in AppDelegate.swift. " +
+                    "Restore Expo's template delegate, or set `isAutoInitEnabled: false` and call `initialize()` from JavaScript.");
+            }
+            result = result.replace(SWIFT_LAUNCH_ANCHOR, `$1${SWIFT_LAUNCH_HOOK}\n$1return super.application(application, didFinishLaunchingWithOptions: launchOptions)`);
         }
-        // Add openURL handler
-        if (!contents.includes("openURL:url options:options")) {
-            const openURLMethod = `
+        return result;
+    }
+    if (!result.includes(OBJC_IMPORT)) {
+        result = result.replace('#import "AppDelegate.h"', `#import "AppDelegate.h"\n${OBJC_IMPORT}`);
+    }
+    if (!result.includes("FBSDKApplicationDelegate")) {
+        result = result.replace("self.initialProps = @{};", `self.initialProps = @{};\n  ${OBJC_LAUNCH_HOOK}`);
+    }
+    if (!result.includes("openURL:url options:options")) {
+        const openURLMethod = `
 
 - (BOOL)application:(UIApplication *)application openURL:(NSURL *)url options:(NSDictionary<UIApplicationOpenURLOptionsKey,id> *)options {
   return [[FBSDKApplicationDelegate sharedInstance] application:application openURL:url options:options];
 }`;
-            mod.modResults.contents = mod.modResults.contents.replace(/@end\s*$/, `${openURLMethod}\n\n@end\n`);
-        }
+        result = result.replace(/@end\s*$/, `${openURLMethod}\n\n@end\n`);
+    }
+    return result;
+}
+const withFacebookAppDelegate = (config, props) => {
+    // With auto-init off the app starts the SDK from JavaScript through
+    // `initialize()`; wiring the delegate anyway would start it at launch and
+    // defeat consent gating. (The iOS SDK has had no auto-init of its own since
+    // v9, so this wiring is the only launch-time path.)
+    if (!props.isAutoInitEnabled) {
+        return config;
+    }
+    return (0, config_plugins_1.withAppDelegate)(config, (mod) => {
+        mod.modResults.contents = applyFacebookAppDelegate(mod.modResults.contents, mod.modResults.language);
         return mod;
     });
 };

package/src/index.ts

@@ -44,6 +44,18 @@ export function initialize(): void {
   NativeFBAnalytics.initialize();
 }
 
+/**
+ * Turn the native SDK's auto-init flag on or off at runtime.
+ *
+ * `initialize()` switches it on, and Android persists the flag, so an app that
+ * gates the SDK behind consent should call `setAutoInitEnabled(false)` when
+ * consent is withdrawn — otherwise the next launch initializes the SDK before
+ * JavaScript runs. No-op on iOS, which has had no auto-init since SDK 9.
+ */
+export function setAutoInitEnabled(enabled: boolean): void {
+  NativeFBAnalytics.setAutoInitEnabled(enabled);
+}
+
 /**
  * Enable or disable automatic logging of app events at runtime.
  */
@@ -113,6 +125,19 @@ export function logEvent(
   }
 }
 
+/**
+ * Log an app activation.
+ *
+ * Publishes the install event (carrying the Google Play install referrer on
+ * Android) the first time it runs on a device, then the launch event. The
+ * Facebook SDK only does this by itself when automatic event logging is on, so
+ * call it once per launch after {@link initialize} whenever
+ * `autoLogAppEventsEnabled` is off — without it Meta cannot attribute installs.
+ */
+export function activateApp(): void {
+  NativeFBAnalytics.activateApp();
+}
+
 /**
  * Log a purchase event.
  */

package/src/specs/FacebookAnalytics.nitro.ts

@@ -4,6 +4,12 @@ export interface FacebookAnalytics
   extends HybridObject<{ ios: "swift"; android: "kotlin" }> {
   // SDK initialization & runtime configuration
   initialize(): void;
+  /**
+   * Turn the native SDK's auto-init flag on or off at runtime. Android
+   * persists it, so an app that gates the SDK behind consent should switch it
+   * off again when consent is withdrawn. No-op on iOS, which has no auto-init.
+   */
+  setAutoInitEnabled(enabled: boolean): void;
   setAutoLogAppEventsEnabled(enabled: boolean): void;
   setAdvertiserIDCollectionEnabled(enabled: boolean): void;
   setAppID(appID: string): void;
@@ -15,6 +21,12 @@ export interface FacebookAnalytics
   setLoggingEnabled(enabled: boolean): void;
 
   // Event logging
+  /**
+   * Log an app activation: publishes the install (with the Play install
+   * referrer on Android) once per device, then the launch event. The only path
+   * that does so when automatic event logging is off.
+   */
+  activateApp(): void;
   logEvent(
     eventName: string,
     valueToSum: number,