react-native-expo-moengage 1.0.0

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "react-native-expo-moengage",
+  "version": "1.0.0",
+  "dependencyVersions": {
+    "firebaseMessaging": "24.1.0"
+  },
+  "description": "MoEngage Expo plugin for integrating MoEngage React-Native SDK",
+  "main": "build/index.js",
+  "files": [
+    "android",
+    "apple",
+    "src",
+    "build",
+    "CHANGELOG.md",
+    "README.md",
+    "package.json",
+    "app.plugin.js",
+    "expo-module.config.json",
+    "!**/__tests__",
+    "!**/__mocks__"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/moengage/React-Native"
+  },
+  "keywords": [
+    "moengage",
+    "push-notification",
+    "react-native",
+    "ios",
+    "tvos",
+    "android",
+    "device",
+    "events",
+    "expo"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "postinstall": "tsc",
+    "prepack": "tsc",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
+  },
+  "author": {
+    "name": "MoEngage",
+    "email": "mobiledevs@moengage.com"
+  },
+  "contributors": [
+    "MoEngage <mobiledevs@moengage.com>"
+  ],
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "devDependencies": {
+    "@expo/config-plugins": "^5.0.0",
+    "@expo/config-types": "^53.0.4",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^22.15.26",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3",
+    "expo": "^48.0.0",
+    "expo-module-scripts": "^3.0.4",
+    "expo-notifications": "^0.31.3"
+  },
+  "peerDependencies": {
+    "react-native-moengage": "^12.1.0"
+  }
+}

package/src/android/constants.ts

@@ -0,0 +1,52 @@
+import { StringBoolean } from "@expo/config-plugins/build/android/Manifest";
+import { ManifestApplicationKey } from "./types";
+
+export const manifestApplicationKeys: ManifestApplicationKey[] = [
+    { "android:fullBackupContent": "@xml/com_moengage_backup_descriptor" },
+    { "android:dataExtractionRules": "@xml/com_moengage_data_extraction_rules" }
+];
+
+/**
+ * Common intent-filter for MoEngage FCM/Expo Notification services
+ */
+export const moEngageMessagingIntentFilter = [
+  {
+    action: [
+      {
+        $: {
+          'android:name': 'com.google.firebase.MESSAGING_EVENT',
+        },
+      },
+    ],
+  },
+];
+
+/**
+ * Service entry for MoEngage Push Notification handling with fcm integration
+ */
+export const moEngageFCMServiceName = 'com.moengage.firebase.MoEFireBaseMessagingService';
+export const moEngageFCMServiceEntry = {
+    $: {
+        'android:name': moEngageFCMServiceName,
+        'android:exported': 'false' as StringBoolean,
+    },
+    'intent-filter': moEngageMessagingIntentFilter,
+};
+
+/**
+ * Service entry for MoEngage Push Notification handling  with expo notification integration
+ */
+export const moEngageExpoNotificationServiceName = 'expo.modules.moengage.MoEExpoFireBaseMessagingService';
+export const moEngageExpoNotificationServiceEntry = {
+    $: {
+        'android:name': moEngageExpoNotificationServiceName,
+        'android:exported': 'false' as StringBoolean,
+    },
+    'intent-filter': moEngageMessagingIntentFilter,
+};
+
+export const drawableResourcePath = './android/app/src/main/res/drawable';
+export const xmlValuesResourcePath = './android/app/src/main/res/values';
+
+export const googleFirebaseMessagingGroup = 'com.google.firebase';
+export const googleFirebaseMessagingModule = 'firebase-messaging';

package/src/android/types.ts

@@ -0,0 +1 @@
+export type ManifestApplicationKey = { [key: string]: string };

package/src/android/utils.ts

@@ -0,0 +1,74 @@
+import { ManifestApplication } from "@expo/config-plugins/build/android/Manifest";
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Add serviceEntry to the main application manifest if does not already exist.
+ */
+export function addServiceToManifestIfNotExist(
+    mainApplication: ManifestApplication,
+    serviceEntry: any,
+    serviceName: string
+): ManifestApplication {
+    console.log('Checking if service exists:', serviceName);
+    if (!isServiceExistInManifest(mainApplication, serviceName)) {
+        console.log('Adding service to manifest:', serviceName);
+        addServiceToManifest(mainApplication, serviceEntry);
+    }
+    return mainApplication;
+}
+
+/**
+ * Return true if given serviceName already exists in the main application manifest, else false.
+ */
+export function isServiceExistInManifest(mainApplication: ManifestApplication, serviceName: string): boolean {
+    const isServiceExist = (mainApplication.service || []).find(
+        (service: any) => service.$ && service.$['android:name'] === serviceName
+    );
+    console.log('Service exists:', serviceName, isServiceExist !== undefined);
+    return isServiceExist !== undefined;
+}
+
+/**
+ * Add serviceEntry to the main application manifest.
+ */
+export function addServiceToManifest(mainApplication: ManifestApplication, serviceEntry: any) {
+    console.log('Adding service entry:', serviceEntry);
+    if (!mainApplication.service) {
+        mainApplication.service = [];
+    }
+    mainApplication.service.push(serviceEntry);
+}
+
+/**
+ * Copy file from src to dest after creating dest directory if not exist
+ */
+export async function copyFile(src: string, dest: string) {
+  let destPath = dest;
+  if (fs.existsSync(dest) && fs.statSync(dest).isDirectory()) {
+    destPath = path.join(dest, path.basename(src));
+  }
+  const destDir = path.dirname(destPath);
+  if (!fs.existsSync(destDir)) {
+    fs.mkdirSync(destDir, { recursive: true });
+  }
+  console.log('Copying file from', src, 'to', destPath);
+  fs.copyFileSync(src, destPath);
+}
+
+/**
+ * Add a dependency to the dependencies block in app/build.gradle if not already present.
+ */
+export function addDependencyToGradle(contents: string, group: string, module: string, version: string): string {
+  const dependency = `implementation("${group}:${module}:${version}")`;
+  console.log('Checking for dependency:', group, module, version);
+  if (!contents.includes(`${group}:${module}`)) {
+    console.log('Adding dependency:', dependency);
+    return contents.replace(
+      /dependencies\s*\{/,
+      match => `${match}\n    ${dependency}`
+    );
+  }
+  console.log('Dependency already present:', dependency);
+  return contents;
+}

package/src/android/withMoEngageAndroid.ts

@@ -0,0 +1,127 @@
+import { withAndroidManifest, ConfigPlugin, AndroidConfig, withDangerousMod, withAppBuildGradle } from '@expo/config-plugins';
+import {
+  drawableResourcePath,
+  manifestApplicationKeys,
+  xmlValuesResourcePath,
+  moEngageFCMServiceEntry,
+  moEngageFCMServiceName,
+  moEngageExpoNotificationServiceEntry,
+  moEngageExpoNotificationServiceName,
+  googleFirebaseMessagingGroup,
+  googleFirebaseMessagingModule
+} from './constants';
+import { MoEngagePluginProps } from '../types';
+import { addServiceToManifestIfNotExist, copyFile, addDependencyToGradle } from './utils';
+
+const packageJsonFile = require('../../package.json');
+
+const withMoEngageAndroid: ConfigPlugin<MoEngagePluginProps> = (config, props) => {
+  console.log('Running withMoEngageAndroid');
+  config = withMoEngageAndroidManifest(config, props);
+  config = withMoEngageInitialisationConfigResource(config, props);
+  config = withMoEngageDependencies(config, props);
+  return config;
+};
+
+
+/**
+ * Update the AndroidManifest.xml file with MoEngage specific configurations.
+ */
+const withMoEngageAndroidManifest: ConfigPlugin<MoEngagePluginProps> = (config, props) => {
+  console.log('Running withMoEngageAndroidManifest');
+  if (!props.android.disableMoEngageDefaultBackupFile) {
+    withAndroidManifest(config, config => {
+      const mainApplication = AndroidConfig.Manifest.getMainApplicationOrThrow(config.modResults);
+      console.log('Adding manifest application keys');
+      manifestApplicationKeys.forEach(item => {
+        const key = Object.keys(item)[0];
+        if (key !== undefined) {
+          const value = (item as any)[key];
+          if (!mainApplication.$) {
+            const androidName = (mainApplication as any)["android:name"] || "";
+            mainApplication.$ = { "android:name": androidName };
+          }
+          
+          if (!(key in mainApplication.$)) {
+            mainApplication.$[key] = value;
+          }
+        }
+      });
+
+      return config;
+    });
+  }
+
+  if (props.android.shouldIncludeMoEngageFirebaseMessagingService) {
+    withAndroidManifest(config, config => {
+      const mainApplication = AndroidConfig.Manifest.getMainApplicationOrThrow(config.modResults);
+      if (props.android.isExpoNotificationIntegration) {
+        console.log('Adding Expo Notification Service to manifest');
+        addServiceToManifestIfNotExist(
+          mainApplication, 
+          moEngageExpoNotificationServiceEntry, 
+          moEngageExpoNotificationServiceName
+        );
+      } else {
+        console.log('Adding MoEngage FCM Service to manifest');
+        addServiceToManifestIfNotExist(
+          mainApplication,
+          moEngageFCMServiceEntry,
+          moEngageFCMServiceName
+        );
+      }
+
+      return config;
+    });
+  }
+
+  return config;
+};
+
+
+/**
+ * Copy all the required resources for MoEngage initialisation to native Android module.
+ */
+const withMoEngageInitialisationConfigResource: ConfigPlugin<MoEngagePluginProps> = (config, props) => {
+  console.log('Running withMoEngageInitialisationConfigResource');
+  return withDangerousMod(config, [
+    'android',
+    async (config) => {
+      if (props.android.smallIconPath !== undefined) {
+        console.log('Copying small icon:', props.android.smallIconPath);
+        await copyFile(props.android.smallIconPath, drawableResourcePath);
+      }
+      if (props.android.largeIconPath !== undefined) {
+        console.log('Copying large icon:', props.android.largeIconPath);
+        await copyFile(props.android.largeIconPath, drawableResourcePath);
+      }
+      
+      console.log('Copying config file:', props.android.configFilePath);
+      await copyFile(props.android.configFilePath, xmlValuesResourcePath);
+      return config;
+    },
+  ]);
+};
+
+/**
+ * Add required dependencies to app/build.gradle
+ */
+const withMoEngageDependencies: ConfigPlugin<MoEngagePluginProps> = (config, props) => {
+  if (props.android.includeFirebaseMessagingDependencies) {
+    const firebaseMessagingVersion = packageJsonFile.dependencyVersions.firebaseMessaging;
+    console.log('Adding Firebase Messaging dependency:', firebaseMessagingVersion);
+    return withAppBuildGradle(config, gradleConfig => {
+      gradleConfig.modResults.contents = addDependencyToGradle(
+        gradleConfig.modResults.contents,
+        googleFirebaseMessagingGroup,
+        googleFirebaseMessagingModule,
+        firebaseMessagingVersion
+      );
+      return gradleConfig;
+    });
+  }
+
+  return config;
+};
+
+export default withMoEngageAndroid;

package/src/apple/constants.ts

@@ -0,0 +1,48 @@
+/**
+ * Constants used in the MoEngage iOS implementation
+ *
+ * This file contains all the constants needed for configuring the MoEngage SDK for iOS,
+ * including target names, file lists, and pod dependencies.
+ */
+
+/**
+ * Target names for the extension targets in Xcode
+ * These names are used when creating extension targets in the Xcode project
+ * and must match the names used in entitlements and Info.plist files
+ */
+export const MOENGAGE_IOS_RICH_PUSH_TARGET = 'MoEngageExpoRichPush';
+export const MOENGAGE_IOS_PUSH_TEMPLATE_TARGET = 'MoEngageExpoPushTemplates';
+export const MOENGAGE_IOS_LIVE_ACTIVITY_TARGET = 'MoEngageExpoLiveActivity';
+
+/**
+ * Files required for the Rich Push Notification Service Extension
+ * These files are copied from the plugin's resources to the Xcode project
+ * and added to the Rich Push target
+ */
+export const MOENGAGE_IOS_RICH_PUSH_FILES = [
+  'NotificationService.swift',
+  `${MOENGAGE_IOS_RICH_PUSH_TARGET}-Info.plist`,
+  `${MOENGAGE_IOS_RICH_PUSH_TARGET}.entitlements`
+];
+
+/**
+ * Files required for the Push Templates Notification Content Extension
+ * These files are copied from the plugin's resources to the Xcode project
+ * and added to the Push Templates target
+ */
+export const MOENGAGE_IOS_PUSH_TEMPLATE_FILES = [
+  'MainInterface.storyboard',
+  'NotificationViewController.swift',
+  `${MOENGAGE_IOS_PUSH_TEMPLATE_TARGET}-Info.plist`,
+  `${MOENGAGE_IOS_PUSH_TEMPLATE_TARGET}.entitlements`
+];
+
+/**
+ * CocoaPods dependencies for each feature
+ * These pod specifications are added to the Podfile for each target
+ * that requires the functionality
+ */
+export const MOENGAGE_IOS_NOTIFICATION_SERVICE_POD = 'MoEngage-iOS-SDK/RichNotification';  // For Rich Push Notification Service Extension
+export const MOENGAGE_IOS_PUSH_TEMPLATE_POD = 'MoEngage-iOS-SDK/RichNotification';  // For Push Templates Notification Content Extension
+export const MOENGAGE_IOS_DEVICE_TRIGGER_POD = 'MoEngage-iOS-SDK/RealTimeTrigger';  // For Device-based campaign triggers
+export const MOENGAGE_IOS_LIVE_ACTIVITY_POD = 'MoEngage-iOS-SDK/LiveActivity';  // For LiveActivity support

package/src/apple/index.ts

@@ -0,0 +1,38 @@
+import { ConfigPlugin } from "@expo/config-plugins";
+import { MoEngagePluginProps } from "../types";
+import { withMoEngageInfoPlist } from "./withInfoPlist";
+import { withMoEngageEntitlements } from "./withEntitlements";
+import { withMoEngageXcodeProject } from "./withXcodeProject";
+import { withMoEngageDangerousMod } from "./withDangerousMod";
+import * as constants from './constants';
+
+/**
+ * The main iOS plugin that applies all modifiers to set up MoEngage iOS integration
+ *
+ * This is the primary entry point for the MoEngage Expo plugin for iOS.
+ * It orchestrates the entire configuration process by applying each of the
+ * specialized modifiers in the correct order:
+ *
+ * 1. withMoEngageInfoPlist - Updates Info.plist with MoEngage configuration
+ * 2. withMoEngageEntitlements - Sets up app groups and other entitlements
+ * 3. withMoEngageXcodeProject - Configures the Xcode project with extension targets
+ * 4. withMoEngageDangerousMod - Performs file operations and updates Podfile
+ *
+ * @param config - The Expo config object
+ * @param props - The MoEngage plugin properties
+ * @returns The fully configured Expo config
+ */
+export const withMoEngageIos: ConfigPlugin<MoEngagePluginProps> = (config, props) => {
+  config = withMoEngageInfoPlist(config, props);
+  config = withMoEngageEntitlements(config, props);
+  config = withMoEngageXcodeProject(config, props);
+  config = withMoEngageDangerousMod(config, props);
+  return config;
+};
+
+// Export all constants and individual modifiers for advanced usage
+export { constants };
+export { withMoEngageInfoPlist, withMoEngageEntitlements, withMoEngageXcodeProject, withMoEngageDangerousMod };
+
+// Default export
+export default withMoEngageIos;

package/src/apple/withDangerousMod.ts

@@ -0,0 +1,265 @@
+import { ConfigPlugin, withDangerousMod } from "@expo/config-plugins";
+import { MoEngagePluginProps } from "../types";
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  MOENGAGE_IOS_RICH_PUSH_TARGET,
+  MOENGAGE_IOS_PUSH_TEMPLATE_TARGET,
+  MOENGAGE_IOS_LIVE_ACTIVITY_TARGET,
+  MOENGAGE_IOS_RICH_PUSH_FILES,
+  MOENGAGE_IOS_PUSH_TEMPLATE_FILES,
+  MOENGAGE_IOS_NOTIFICATION_SERVICE_POD,
+  MOENGAGE_IOS_PUSH_TEMPLATE_POD,
+  MOENGAGE_IOS_DEVICE_TRIGGER_POD,
+  MOENGAGE_IOS_LIVE_ACTIVITY_POD
+} from './constants';
+
+const plist = require('plist');
+
+/**
+ * MoEngage Expo plugin for iOS - Dangerous modifications
+ *
+ * This plugin handles file operations that are not directly exposed by the Expo Config Plugin API,
+ * including copying Rich Push, Push Templates, and LiveActivity files, and updating the Podfile
+ * to include the necessary MoEngage pods for each target.
+ *
+ * @param config - The Expo config object
+ * @param props - The MoEngage plugin properties
+ * @returns The updated config object
+ */
+export const withMoEngageDangerousMod: ConfigPlugin<MoEngagePluginProps> = (config, props) => {
+  return withDangerousMod(config, [
+    'ios',
+    (config) => {
+      if (process.env['EXPO_TV']) {
+        // Skip modifications for tvOS
+        console.log(`Skipping extension targets copy for tvOS`);
+        return config;
+      }
+
+      const applicationPods: string[] = []
+      const projectRoot = config.modRequest.projectRoot;
+      const { apple } = props;
+      const shouldAddRichPushExtension = apple.richPushNotificationEnabled || apple.pushNotificationImpressionTrackingEnabled || apple.pushTemplatesEnabled;
+
+      /**
+       * Extract the KeychainGroupName from the MoEngage configuration file
+       *
+       * The keychain group is needed for secure data sharing between the main app
+       * and extension targets. If present, it's added to the entitlements files
+       * for the extension targets.
+       */
+      let keychainGroupValue = ''
+      try {
+        const configFilePath = path.join(config.modRequest.projectRoot, props.apple.configFilePath);
+        if (fs.existsSync(configFilePath)) {
+          const configPlist = plist.parse(fs.readFileSync(configFilePath, 'utf8')) as { [key: string]: any };
+          keychainGroupValue = configPlist['KeychainGroupName'] as string;
+        } else {
+          const message = `MoEngage configuration does not exist`;
+          console.error(message);
+          throw new Error(message);
+        }
+      } catch (e) {
+        const message = `Could not import MoEngage configuration: ${e}`;
+        console.error(message);
+        throw new Error(message);
+      }
+
+      /**
+       * Set up the Rich Push Notification Service Extension
+       *
+       * This extension handles rich push notifications with media attachments and
+       * custom notification UI. We:
+       * 1. Create the extension directory if it doesn't exist
+       * 2. Copy template files from the plugin's resources
+       * 3. Update entitlements with keychain access if configured
+       * 4. Modify the Podfile to include the MoEngage rich notification dependency
+       */
+      if (shouldAddRichPushExtension) {
+        // Copy Rich Push files to project path.
+        const absoluteSource = require.resolve('react-native-expo-moengage/apple/RichPush/NotificationService.swift');
+        const sourcePath = path.dirname(absoluteSource);
+        const destinationPath = `${projectRoot}/ios/${MOENGAGE_IOS_RICH_PUSH_TARGET}`;
+        if (!fs.existsSync(`${destinationPath}`)) {
+          fs.mkdirSync(`${destinationPath}`, { recursive: true });
+        }
+        for (const file of MOENGAGE_IOS_RICH_PUSH_FILES) {
+          // Copy keychain group to extension entitlements
+          if (keychainGroupValue && keychainGroupValue.length > 0 && file.endsWith('.entitlements')) {
+            const entitlements = plist.parse(fs.readFileSync(`${sourcePath}/${file}`, 'utf8'));
+            entitlements['keychain-access-groups'] = [keychainGroupValue]
+            fs.writeFileSync(`${destinationPath}/${file}`, plist.build(entitlements))
+            continue
+          }
+          fs.copyFileSync(`${sourcePath}/${file}`, `${destinationPath}/${file}`);
+        }
+
+        // Modify Podfile to include `MoEngageRichNotification`.
+        const podfilePath = `${projectRoot}/ios/Podfile`;
+        if (fs.existsSync(podfilePath)) {
+          const podfile = fs.readFileSync(podfilePath, 'utf8');
+          if (!podfile.includes(MOENGAGE_IOS_RICH_PUSH_TARGET) || !podfile.includes(MOENGAGE_IOS_NOTIFICATION_SERVICE_POD)) {
+            const notificationServiceTarget =
+              [
+                ``,
+                `target '${MOENGAGE_IOS_RICH_PUSH_TARGET}' do`,
+                `  use_frameworks! :linkage => podfile_properties['ios.useFrameworks'].to_sym if podfile_properties['ios.useFrameworks']`,
+                `  use_frameworks! :linkage => ENV['USE_FRAMEWORKS'].to_sym if ENV['USE_FRAMEWORKS']`,
+                `  pod '${MOENGAGE_IOS_NOTIFICATION_SERVICE_POD}'`,
+                `end`
+              ].join('\n');
+            fs.appendFileSync(podfilePath, notificationServiceTarget);
+          }
+        }
+      }
+
+      /**
+       * Set up the Push Templates Notification Content Extension
+       *
+       * This extension enables custom notification UI templates for push notifications.
+       * The setup process includes:
+       * 1. Creating the extension directory if it doesn't exist
+       * 2. Copying template files from the plugin's resources
+       * 3. Updating entitlements with keychain access if configured
+       * 4. Modifying the Podfile to include the MoEngage push template dependency
+       */
+      if (apple.pushTemplatesEnabled) {
+        // Copy Push Template files to project path.
+        const absoluteSource = require.resolve('react-native-expo-moengage/apple/PushTemplates/NotificationViewController.swift');
+        const sourcePath = path.dirname(absoluteSource);
+        const destinationPath = `${projectRoot}/ios/${MOENGAGE_IOS_PUSH_TEMPLATE_TARGET}`;
+        if (!fs.existsSync(`${destinationPath}`)) {
+          fs.mkdirSync(`${destinationPath}`, { recursive: true });
+        }
+        for (const file of MOENGAGE_IOS_PUSH_TEMPLATE_FILES) {
+          // Copy keychain group to extension entitlements
+          if (keychainGroupValue && keychainGroupValue.length > 0 && file.endsWith('.entitlements')) {
+            const entitlements = plist.parse(fs.readFileSync(`${sourcePath}/${file}`, 'utf8'));
+            entitlements['keychain-access-groups'] = [keychainGroupValue]
+            fs.writeFileSync(`${destinationPath}/${file}`, plist.build(entitlements))
+            continue
+          }
+          fs.copyFileSync(`${sourcePath}/${file}`, `${destinationPath}/${file}`);
+        }
+
+        // Modify Podfile to include `MoEngageRichNotification`.
+        const podfilePath = `${projectRoot}/ios/Podfile`;
+        if (fs.existsSync(podfilePath)) {
+          const podfile = fs.readFileSync(podfilePath, 'utf8');
+          if (!podfile.includes(MOENGAGE_IOS_PUSH_TEMPLATE_TARGET) || !podfile.includes(MOENGAGE_IOS_PUSH_TEMPLATE_POD)) {
+            const pushTemplateTarget =
+              [
+                ``,
+                `target '${MOENGAGE_IOS_PUSH_TEMPLATE_TARGET}' do`,
+                `  use_frameworks! :linkage => podfile_properties['ios.useFrameworks'].to_sym if podfile_properties['ios.useFrameworks']`,
+                `  use_frameworks! :linkage => ENV['USE_FRAMEWORKS'].to_sym if ENV['USE_FRAMEWORKS']`,
+                `  pod '${MOENGAGE_IOS_PUSH_TEMPLATE_POD}'`,
+                `end`
+              ].join('\n');
+            fs.appendFileSync(podfilePath, pushTemplateTarget);
+          }
+        }
+      }
+
+      /**
+       * Set up Live Activity support
+       *
+       * Live Activities allow apps to display persistent, interactive notifications
+       * on the lock screen and in the Dynamic Island on supported devices.
+       *
+       * This section:
+       * 1. Adds the MoEngageLiveActivity pod to the main app target
+       * 2. Creates a LiveActivity extension target in the Podfile if needed
+       * 3. Configures the pod dependencies for the LiveActivity extension
+       */
+      if (apple.liveActivityTargetPath && apple.liveActivityTargetPath.length) {
+        // Add MoEngageLiveActivity pod to the Podfile
+        applicationPods.push(`  pod '${MOENGAGE_IOS_LIVE_ACTIVITY_POD}'`)
+        const podfilePath = path.join(projectRoot, 'ios', 'Podfile');
+        if (fs.existsSync(podfilePath)) {
+          const podfile = fs.readFileSync(podfilePath, 'utf8');
+
+          if (!podfile.includes(MOENGAGE_IOS_LIVE_ACTIVITY_TARGET)) {
+            const liveActivityTarget = [
+              ``,
+              `target '${MOENGAGE_IOS_LIVE_ACTIVITY_TARGET}' do`,
+              `  use_frameworks! :linkage => podfile_properties['ios.useFrameworks'].to_sym if podfile_properties['ios.useFrameworks']`,
+              `  use_frameworks! :linkage => ENV['USE_FRAMEWORKS'].to_sym if ENV['USE_FRAMEWORKS']`,
+              `  pod '${MOENGAGE_IOS_LIVE_ACTIVITY_POD}'`,
+              `end`
+            ].join('\n');
+
+            fs.appendFileSync(podfilePath, liveActivityTarget);
+            console.log(`Added MoEngageLiveActivity pod to Podfile for ${MOENGAGE_IOS_LIVE_ACTIVITY_TARGET} target`);
+          }
+        }
+      }
+
+      /**
+       * Set up Device Trigger support
+       *
+       * Device Triggers allow campaigns to be triggered based on device events,
+       * without requiring server communication. This is useful for real-time
+       * engagement based on user actions within the app.
+       *
+       * If enabled, we add the MoEngage RealTimeTrigger pod to the main application.
+       */
+      if (apple.deviceTriggerEnabled) {
+        applicationPods.push(`  pod '${MOENGAGE_IOS_DEVICE_TRIGGER_POD}'`)
+      }
+
+      /**
+       * Update the main application's Podfile with MoEngage dependencies
+       *
+       * This section adds any accumulated MoEngage pods to the main application target
+       * in the Podfile. It:
+       * 1. Finds the main application target section in the Podfile
+       * 2. Locates a suitable insertion point before existing dependencies
+       * 3. Inserts the MoEngage pod declarations
+       */
+      if (applicationPods && applicationPods.length) {
+        const podfilePath = `${projectRoot}/ios/Podfile`;
+        if (fs.existsSync(podfilePath)) {
+          const podfile = fs.readFileSync(podfilePath, 'utf8');
+          if (!podfile.includes(MOENGAGE_IOS_DEVICE_TRIGGER_POD)) {
+            // Find the main target and add the pod there
+            const lines = podfile.split('\n');
+            let mainTargetIndex = -1;
+
+            // Find the main application target
+            for (let i = 0; i < lines.length; i++) {
+              if (lines[i]?.includes('target') && lines[i]?.includes('do') &&
+                !lines[i]?.includes(MOENGAGE_IOS_RICH_PUSH_TARGET) &&
+                !lines[i]?.includes(MOENGAGE_IOS_PUSH_TEMPLATE_TARGET)) {
+                mainTargetIndex = i;
+                break;
+              }
+            }
+
+            if (mainTargetIndex !== -1) {
+              // Find the end of the dependency section
+              let dependenciesEndIndex = -1;
+              for (let i = mainTargetIndex; i < lines.length; i++) {
+                if (lines[i]?.includes('use_native_modules') ||
+                  lines[i]?.includes('use_react_native') ||
+                  lines[i]?.includes('post_install')) {
+                  dependenciesEndIndex = i;
+                  break;
+                }
+              }
+
+              if (dependenciesEndIndex !== -1) {
+                // Insert the application pods before the end of the target
+                lines.splice(dependenciesEndIndex, 0, ...applicationPods);
+                fs.writeFileSync(podfilePath, lines.join('\n'));
+              }
+            }
+          }
+        }
+      }
+
+      return config;
+    },
+  ]);
+};