react-native-expo-moengage 1.0.0

package/src/apple/withEntitlements.ts

@@ -0,0 +1,81 @@
+import { ConfigPlugin, withEntitlementsPlist } from "@expo/config-plugins";
+import { MoEngagePluginProps } from "../types";
+import * as fs from 'fs';
+import * as path from 'path';
+
+const plist = require('plist');
+
+/**
+ * MoEngage Expo plugin for iOS - Entitlements modifications
+ *
+ * This plugin configures the app's entitlements file to enable MoEngage features by:
+ * 1. Reading the AppGroupName from the MoEngage configuration file
+ * 2. Adding app groups to entitlements for push notifications and extensions
+ * 3. Setting up keychain sharing if configured
+ * 4. Adding any other required entitlements for MoEngage features
+ *
+ * @param config - The Expo config object
+ * @param props - The MoEngage plugin properties
+ * @returns The updated config with modified entitlements
+ */
+export const withMoEngageEntitlements: ConfigPlugin<MoEngagePluginProps> = (config, props) => {
+  return withEntitlementsPlist(config, (config) => {
+    // Import configuration from plist file if specified
+    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 };
+
+        // Add the app group to the main application target's entitlements if rich push or push templates are enabled
+        const appGroupsKey = 'com.apple.security.application-groups';
+        const appGroupValue = configPlist['AppGroupName'] as string;
+        if (props.apple.pushTemplatesEnabled || props.apple.richPushNotificationEnabled || props.apple.pushNotificationImpressionTrackingEnabled) {
+          if (appGroupValue && appGroupValue.length > 0) {
+            const existingAppGroups = config.modResults[appGroupsKey];
+            if (Array.isArray(existingAppGroups)) {
+              if (!existingAppGroups.includes(appGroupValue)) {
+                config.modResults[appGroupsKey] = existingAppGroups.concat([appGroupValue]);
+              }
+            } else {
+              config.modResults[appGroupsKey] = [appGroupValue];
+            }
+          } else {
+            const message = `Missing AppGroupName key in MoEngage configuration`;
+            console.error(message);
+            throw new Error(message);
+          }
+        }
+
+        // Add the keychain access groups to the main application target's entitlements if specified
+        const keychainGroupsKey = 'keychain-access-groups';
+        const keychainGroupValue = configPlist['KeychainGroupName'] as string;
+        const isStorageEncryptionEnabled = configPlist['IsStorageEncryptionEnabled'] as boolean;
+        if (isStorageEncryptionEnabled && (!keychainGroupValue || keychainGroupValue.length == 0)) {
+          const message = `KeychainGroupName in "${configFilePath}" is required when IsStorageEncryptionEnabled is true`;
+          console.error(message);
+          throw new Error(message);
+        }
+
+        if (keychainGroupValue && keychainGroupValue.length > 0) {
+          const existingKeychainGroups = config.modResults[keychainGroupsKey];
+          if (Array.isArray(existingKeychainGroups)) {
+            if (!existingKeychainGroups.includes(keychainGroupValue)) {
+              config.modResults[keychainGroupsKey] = existingKeychainGroups.concat([keychainGroupValue]);
+            }
+          } else {
+            config.modResults[keychainGroupsKey] = [keychainGroupValue];
+          }
+        }
+      } 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);
+    }
+    return config;
+  });
+};

package/src/apple/withInfoPlist.ts

@@ -0,0 +1,63 @@
+import { ConfigPlugin, withInfoPlist } from "@expo/config-plugins";
+import { MoEngagePluginProps } from "../types";
+import * as fs from 'fs';
+import * as path from 'path';
+
+const plist = require('plist');
+
+/**
+ * MoEngage Expo plugin for iOS - Info.plist modifications
+ *
+ * This plugin configures the Info.plist file with MoEngage settings, including:
+ * 1. Importing configuration from the MoEngage plist file
+ * 2. Setting up notification service extensions
+ * 3. Configuring required app settings for MoEngage SDK
+ *
+ * @param config - The Expo config object
+ * @param props - The MoEngage plugin properties
+ * @returns The updated config with Info.plist modifications
+ */
+export const withMoEngageInfoPlist: ConfigPlugin<MoEngagePluginProps> = (config, props) => {
+  return withInfoPlist(config, (config) => {
+    const { apple } = props;
+
+    // Initialize MoEngage configuration in Info.plist
+    config.modResults['MoEngage'] = config.modResults['MoEngage'] || {};
+
+    // Import configuration from plist file if specified
+    try {
+      const configFilePath = path.join(config.modRequest.projectRoot, apple.configFilePath);
+      if (fs.existsSync(configFilePath)) {
+        const configPlist = plist.parse(fs.readFileSync(configFilePath, 'utf8'));
+
+        // Merge the configuration from the plist file with existing MoEngage settings
+        config.modResults['MoEngage'] = {
+          ...config.modResults['MoEngage'] as { [key: string]: any },
+          ...configPlist
+        };
+      } 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 Live Activities support in the Info.plist if enabled
+     *
+     * This adds the NSSupportsLiveActivities key to Info.plist, which is required
+     * for the app to support Live Activities on iOS. We only enable this if:
+     * 1. The app is not a tvOS app (Live Activities aren't supported on tvOS)
+     * 2. A Live Activity target path has been specified in the plugin configuration
+     */
+    if (!process.env['EXPO_TV'] && apple.liveActivityTargetPath && apple.liveActivityTargetPath.length) {
+        config.modResults['NSSupportsLiveActivities'] = true;
+    }
+
+    return config;
+  });
+};

package/src/apple/withXcodeProject.ts

@@ -0,0 +1,418 @@
+import { ConfigPlugin, ExportedConfigWithProps, XcodeProject, withXcodeProject } 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
+} from './constants';
+
+const plist = require('plist');
+
+/**
+ * MoEngage Expo plugin for iOS - Xcode project modifications
+ *
+ * This plugin configures the Xcode project to include MoEngage extensions for rich notifications,
+ * push templates, and LiveActivity. It reads configuration from the MoEngage plist file and sets up
+ * the necessary targets, PBX groups, and build phases.
+ *
+ * @param config - The Expo config object
+ * @param props - The MoEngage plugin properties
+ * @returns The updated config object with Xcode project modifications
+ */
+export const withMoEngageXcodeProject: ConfigPlugin<MoEngagePluginProps> = (config, props) => {
+  return withXcodeProject(config, (config) => {
+    if (process.env['EXPO_TV']) {
+      // Skip modifications for tvOS
+      console.log(`Skipping extension targets setup for tvOS`);
+      return config;
+    }
+
+    const { apple } = props;
+    const shouldAddRichPushExtension = apple.richPushNotificationEnabled || apple.pushNotificationImpressionTrackingEnabled || apple.pushTemplatesEnabled;
+
+    // Get app group from plist file if specified
+    let appGroupValue = ''
+    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 };
+        appGroupValue = configPlist['AppGroupName'] as string;
+
+        if (!appGroupValue) {
+          const message = `Missing AppGroupName key in MoEngage configuration`;
+          console.error(message);
+          throw new Error(message);
+        }
+      } 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);
+    }
+
+    // Initialize with an empty object if these top-level objects are non-existent.
+    // This guarantees that the extension targets will have a destination.
+    const objects = config.modResults.hash.project.objects;
+    objects['PBXTargetDependency'] = objects['PBXTargetDependency'] || {};
+    objects['PBXContainerItemProxy'] = objects['PBXContainerItemProxy'] || {};
+
+    const groups = objects['PBXGroup'];
+    const xcconfigs = objects['XCBuildConfiguration'];
+
+    // Retrieve Swift version and code signing settings from main target to apply to dependency targets.
+    let swiftVersion;
+    let codeSignStyle;
+    let codeSignIdentity;
+    let otherCodeSigningFlags;
+    let developmentTeam;
+    let provisioningProfile;
+    for (const configUUID of Object.keys(xcconfigs)) {
+      const buildSettings = xcconfigs[configUUID].buildSettings;
+      if (!swiftVersion && buildSettings && buildSettings.SWIFT_VERSION) {
+        swiftVersion = buildSettings.SWIFT_VERSION;
+        codeSignStyle = buildSettings.CODE_SIGN_STYLE;
+        codeSignIdentity = buildSettings.CODE_SIGN_IDENTITY;
+        otherCodeSigningFlags = buildSettings.OTHER_CODE_SIGN_FLAGS;
+        developmentTeam = buildSettings.DEVELOPMENT_TEAM;
+        provisioningProfile = buildSettings.PROVISIONING_PROFILE_SPECIFIER;
+        break;
+      }
+    }
+
+    // Rich Push Notification Service Extension
+    if (shouldAddRichPushExtension && !config.modResults.pbxGroupByName(MOENGAGE_IOS_RICH_PUSH_TARGET)) {
+      // Add the Notification Service Extension target.
+      const richPushTarget = config.modResults.addTarget(
+        MOENGAGE_IOS_RICH_PUSH_TARGET,
+        'app_extension',
+        MOENGAGE_IOS_RICH_PUSH_TARGET,
+        `${config.ios?.bundleIdentifier}.${MOENGAGE_IOS_RICH_PUSH_TARGET}`,
+      );
+
+      // Add the relevant files to the PBX group.
+      const moengageNotificationServiceGroup = config.modResults.addPbxGroup(
+        MOENGAGE_IOS_RICH_PUSH_FILES,
+        MOENGAGE_IOS_RICH_PUSH_TARGET,
+        MOENGAGE_IOS_RICH_PUSH_TARGET,
+      );
+
+      for (const groupUUID of Object.keys(groups)) {
+        if (typeof groups[groupUUID] === 'object'
+          && groups[groupUUID].name === undefined
+          && groups[groupUUID].path === undefined) {
+          config.modResults.addToPbxGroup(moengageNotificationServiceGroup.uuid, groupUUID);
+        }
+      };
+
+      for (const configUUID of Object.keys(xcconfigs)) {
+        const buildSettings = xcconfigs[configUUID].buildSettings;
+        if (buildSettings && buildSettings.PRODUCT_NAME === `"${MOENGAGE_IOS_RICH_PUSH_TARGET}"`) {
+          buildSettings.MOENGAGE_APP_GROUP = appGroupValue;
+          buildSettings.SWIFT_VERSION = swiftVersion;
+          buildSettings.CODE_SIGN_ENTITLEMENTS = `${MOENGAGE_IOS_RICH_PUSH_TARGET}/${MOENGAGE_IOS_RICH_PUSH_TARGET}.entitlements`;
+          if (codeSignStyle) { buildSettings.CODE_SIGN_STYLE = codeSignStyle; }
+          if (codeSignIdentity) { buildSettings.CODE_SIGN_IDENTITY = codeSignIdentity; }
+          if (otherCodeSigningFlags) { buildSettings.OTHER_CODE_SIGN_FLAGS = otherCodeSigningFlags; }
+          if (developmentTeam) { buildSettings.DEVELOPMENT_TEAM = developmentTeam; }
+          if (provisioningProfile) { buildSettings.PROVISIONING_PROFILE_SPECIFIER = provisioningProfile; }
+        }
+      }
+
+      // Set up target build phase scripts.
+      config.modResults.addBuildPhase(
+        [
+          'NotificationService.swift',
+        ],
+        'PBXSourcesBuildPhase',
+        'Sources',
+        richPushTarget.uuid
+      );
+
+      config.modResults.addBuildPhase(
+        ['UserNotifications.framework'],
+        'PBXFrameworksBuildPhase',
+        'Frameworks',
+        richPushTarget.uuid
+      );
+    }
+
+    // Push Templates Notification Content Extension
+    if (apple.pushTemplatesEnabled && !config.modResults.pbxGroupByName(MOENGAGE_IOS_PUSH_TEMPLATE_TARGET)) {
+      // Add the Notification Content Extension target.
+      const pushTemplateTarget = config.modResults.addTarget(
+        MOENGAGE_IOS_PUSH_TEMPLATE_TARGET,
+        'app_extension',
+        MOENGAGE_IOS_PUSH_TEMPLATE_TARGET,
+        `${config.ios?.bundleIdentifier}.${MOENGAGE_IOS_PUSH_TEMPLATE_TARGET}`,
+      );
+
+      // Add the relevant files to the PBX group.
+      const moengageNotificationContentGroup = config.modResults.addPbxGroup(
+        MOENGAGE_IOS_PUSH_TEMPLATE_FILES,
+        MOENGAGE_IOS_PUSH_TEMPLATE_TARGET,
+        MOENGAGE_IOS_PUSH_TEMPLATE_TARGET,
+      );
+
+      for (const groupUUID of Object.keys(groups)) {
+        if (typeof groups[groupUUID] === 'object'
+          && groups[groupUUID].name === undefined
+          && groups[groupUUID].path === undefined) {
+          config.modResults.addToPbxGroup(moengageNotificationContentGroup.uuid, groupUUID);
+        }
+      };
+
+      for (const configUUID of Object.keys(xcconfigs)) {
+        const buildSettings = xcconfigs[configUUID].buildSettings;
+        if (buildSettings && buildSettings.PRODUCT_NAME === `"${MOENGAGE_IOS_PUSH_TEMPLATE_TARGET}"`) {
+          buildSettings.MOENGAGE_APP_GROUP = appGroupValue;
+          buildSettings.SWIFT_VERSION = swiftVersion;
+          buildSettings.CODE_SIGN_ENTITLEMENTS = `${MOENGAGE_IOS_PUSH_TEMPLATE_TARGET}/${MOENGAGE_IOS_PUSH_TEMPLATE_TARGET}.entitlements`;
+          if (codeSignStyle) { buildSettings.CODE_SIGN_STYLE = codeSignStyle; }
+          if (codeSignIdentity) { buildSettings.CODE_SIGN_IDENTITY = codeSignIdentity; }
+          if (otherCodeSigningFlags) { buildSettings.OTHER_CODE_SIGN_FLAGS = otherCodeSigningFlags; }
+          if (developmentTeam) { buildSettings.DEVELOPMENT_TEAM = developmentTeam; }
+          if (provisioningProfile) { buildSettings.PROVISIONING_PROFILE_SPECIFIER = provisioningProfile; }
+        }
+      }
+
+      // Set up target build phase scripts.
+      config.modResults.addBuildPhase(
+        [
+          'NotificationViewController.swift',
+        ],
+        'PBXSourcesBuildPhase',
+        'Sources',
+        pushTemplateTarget.uuid
+      );
+
+      config.modResults.addBuildPhase(
+        [
+          'MainInterface.storyboard',
+        ],
+        'PBXResourcesBuildPhase',
+        'Resources',
+        pushTemplateTarget.uuid
+      );
+
+      config.modResults.addBuildPhase(
+        [
+          'UserNotifications.framework',
+          'UserNotificationsUI.framework'
+        ],
+        'PBXFrameworksBuildPhase',
+        'Frameworks',
+        pushTemplateTarget.uuid
+      );
+    }
+
+    // Handle Live Activity configuration if targetPath is provided
+    if (apple.liveActivityTargetPath && apple.liveActivityTargetPath.length && !config.modResults.pbxGroupByName(MOENGAGE_IOS_LIVE_ACTIVITY_TARGET)) {
+      config = withLiveActivity(config, apple.liveActivityTargetPath, {
+        swiftVersion,
+        codeSignStyle,
+        codeSignIdentity,
+        otherCodeSigningFlags,
+        developmentTeam,
+        provisioningProfile
+      });
+    }
+
+    return config;
+  });
+};
+
+/**
+ * Interface for code signing settings
+ * These settings are extracted from the main target and applied to extension targets
+ * to ensure consistent code signing across all targets in the project
+ */
+interface CodeSignSettings {
+  /** Swift version used in the project (e.g. '5.0') */
+  swiftVersion?: string;
+  /** Code signing style ('Automatic' or 'Manual') */
+  codeSignStyle?: string;
+  /** Code signing identity (e.g. 'Apple Developer') */
+  codeSignIdentity?: string;
+  /** Additional code signing flags */
+  otherCodeSigningFlags?: string;
+  /** Development team identifier */
+  developmentTeam?: string;
+  /** Provisioning profile specifier */
+  provisioningProfile?: string;
+}
+
+/**
+ * Adds Live Activity extension target to the Xcode project
+ *
+ * This function configures a LiveActivity extension by:
+ * 1. Creating the target and PBX groups
+ * 2. Scanning the provided directory for source files, resources, and configuration files
+ * 3. Adding all files to appropriate build phases
+ * 4. Setting up build settings including code signing and entitlements
+ *
+ * @param config - Expo config with Xcode project
+ * @param liveActivityTargetPath - Path to the LiveActivity source files
+ * @param codeSignSettings - Code signing settings to apply to the target
+ * @returns The updated config object
+ */
+export function withLiveActivity(config: ExportedConfigWithProps<XcodeProject>, liveActivityTargetPath: string, codeSignSettings: CodeSignSettings) {
+  const liveActivityPath = path.join(config.modRequest.projectRoot, liveActivityTargetPath);
+  const objects = config.modResults.hash.project.objects;
+  const xcconfigs = objects['XCBuildConfiguration'];
+  const groups = objects['PBXGroup'];
+
+  // Add the Live Activity target
+  const liveActivityTarget = config.modResults.addTarget(
+    MOENGAGE_IOS_LIVE_ACTIVITY_TARGET,
+    'app_extension',
+    MOENGAGE_IOS_LIVE_ACTIVITY_TARGET,
+    `${config.ios?.bundleIdentifier}.${MOENGAGE_IOS_LIVE_ACTIVITY_TARGET}`,
+  );
+
+  // Add the relevant files to the PBX group.
+  const moengageLiveActivityPathContentGroup = config.modResults.addPbxGroup(
+    [], MOENGAGE_IOS_LIVE_ACTIVITY_TARGET, liveActivityPath,
+  );
+
+  for (const groupUUID of Object.keys(groups)) {
+    if (typeof groups[groupUUID] === 'object'
+      && groups[groupUUID].name === undefined
+      && groups[groupUUID].path === undefined) {
+      config.modResults.addToPbxGroup(moengageLiveActivityPathContentGroup.uuid, groupUUID);
+    }
+  };
+
+  // Find  all .xcassets files, source files, header files,
+  // info plist file and entitlements file in liveActivityTargetPath
+  let entitlementsFile = '';
+  let infoPlistFile = '';
+  let resourcesFiles: string[] = [];
+  let sourceFiles: string[] = [];
+  let headerFiles: string[] = [];
+
+  try {
+    const findFilesRecursively = (directory: string, group: any) => {
+      let items = fs.readdirSync(directory, { withFileTypes: true });
+      for (const item of items) {
+        const itemPath = path.join(directory, item.name);
+        const ext = path.extname(item.name).toLowerCase();
+        if (item.isDirectory()) {
+          if (['.xcassets'].includes(ext)) {
+            resourcesFiles.push(itemPath);
+            console.log(`Found ${itemPath} as resource for LiveActivity`);
+          } else {
+            // Recursively read directories
+            const group = config.modResults.addPbxGroup([], item.name, itemPath);
+            config.modResults.addToPbxGroup(group.uuid, moengageLiveActivityPathContentGroup.uuid);
+            findFilesRecursively(itemPath, group);
+            continue;
+          }
+        } else if (['.swift', '.m', '.c', '.cpp'].includes(ext)) {
+          sourceFiles.push(itemPath);
+          console.log(`Found ${itemPath} as source file for LiveActivity`);
+        } else if (['.h'].includes(ext)) {
+          headerFiles.push(itemPath);
+          console.log(`Found ${itemPath} as header file for LiveActivity`);
+        } else if (['.entitlements'].includes(ext)) {
+          entitlementsFile = itemPath;
+          console.log(`Found ${itemPath} as entitlements file for LiveActivity`);
+        } else if (item.name === 'Info.plist' ||
+          item.name === `${MOENGAGE_IOS_LIVE_ACTIVITY_TARGET}-Info.plist` ||
+          item.name === `${path.basename(path.dirname(liveActivityTargetPath ?? ''))}-Info.plist`) {
+          infoPlistFile = itemPath;
+          console.log(`Found ${itemPath} as Info.plist file for LiveActivity`);
+        } else {
+          resourcesFiles.push(itemPath);
+          console.log(`Found ${itemPath} as resource for LiveActivity`);
+        }
+        // Add file to project
+        config.modResults.addFile(itemPath, group.uuid);
+      }
+    };
+
+    // Find all files
+    findFilesRecursively(liveActivityPath, moengageLiveActivityPathContentGroup);
+  } catch (e) {
+    const message = `Error finding files in Live Activity path: ${e}`;
+    console.error(message);
+    throw new Error(message);
+  }
+
+  // Set up build settings for the Live Activity target
+  for (const configUUID of Object.keys(xcconfigs)) {
+    const buildSettings = xcconfigs[configUUID].buildSettings;
+    if (buildSettings && buildSettings.PRODUCT_NAME === `"${MOENGAGE_IOS_LIVE_ACTIVITY_TARGET}"`) {
+      buildSettings.SWIFT_VERSION = codeSignSettings.swiftVersion;
+      buildSettings.IPHONEOS_DEPLOYMENT_TARGET = '18.0'; // Set minimum iOS version for Live Activity
+
+      // Add entitlements file if found
+      if (entitlementsFile && entitlementsFile.length) {
+        buildSettings.CODE_SIGN_ENTITLEMENTS = `${entitlementsFile}`;
+      }
+
+      // Add Info.plist file if found
+      if (infoPlistFile && infoPlistFile.length) {
+        buildSettings.INFOPLIST_FILE = `${infoPlistFile}`;
+      }
+
+      // Copy code signing settings from main target
+      if (codeSignSettings.codeSignStyle) { buildSettings.CODE_SIGN_STYLE = codeSignSettings.codeSignStyle; }
+      if (codeSignSettings.codeSignIdentity) { buildSettings.CODE_SIGN_IDENTITY = codeSignSettings.codeSignIdentity; }
+      if (codeSignSettings.otherCodeSigningFlags) { buildSettings.OTHER_CODE_SIGN_FLAGS = codeSignSettings.otherCodeSigningFlags; }
+      if (codeSignSettings.developmentTeam) { buildSettings.DEVELOPMENT_TEAM = codeSignSettings.developmentTeam; }
+      if (codeSignSettings.provisioningProfile) { buildSettings.PROVISIONING_PROFILE_SPECIFIER = codeSignSettings.provisioningProfile; }
+    }
+  }
+
+  // Add resources (xcassets) to the target
+  if (resourcesFiles.length) {
+    config.modResults.addBuildPhase(
+      resourcesFiles,
+      'PBXResourcesBuildPhase',
+      'Resources',
+      liveActivityTarget.uuid
+    );
+  }
+
+  // Add source files to the target
+  if (sourceFiles.length) {
+    config.modResults.addBuildPhase(
+      sourceFiles,
+      'PBXSourcesBuildPhase',
+      'Sources',
+      liveActivityTarget.uuid
+    );
+  }
+
+  // Add header files to the target
+  if (headerFiles.length) {
+    config.modResults.addBuildPhase(
+      headerFiles,
+      'PBXHeadersBuildPhase',
+      'Headers',
+      liveActivityTarget.uuid
+    );
+  }
+
+  // Add required frameworks for Live Activity
+  config.modResults.addBuildPhase(
+    [
+      'SwiftUI.framework',
+      'WidgetKit.framework',
+      'ActivityKit.framework'
+    ],
+    'PBXFrameworksBuildPhase',
+    'Frameworks',
+    liveActivityTarget.uuid
+  );
+
+  return config;
+}

package/src/index.ts

@@ -0,0 +1,52 @@
+import { ConfigPlugin, createRunOncePlugin } from '@expo/config-plugins';
+import withMoEngageAndroid from './android/withMoEngageAndroid';
+import { withMoEngageIos } from './apple';
+import { MoEngagePluginProps } from './types';
+
+const defaultProps: MoEngagePluginProps = {
+  android: {
+    disableMoEngageDefaultBackupFile: false,
+    isExpoNotificationIntegration: false,
+    shouldIncludeMoEngageFirebaseMessagingService: false,
+    includeFirebaseMessagingDependencies: false,
+    configFilePath: 'assets/moengage/android_initilisation_config.xml',
+  },
+  apple: {
+    configFilePath: 'assets/moengage/MoEngage-Config.plist',
+    pushNotificationImpressionTrackingEnabled: true,
+    richPushNotificationEnabled: false,
+    pushTemplatesEnabled: false,
+    deviceTriggerEnabled: false,
+    liveActivityTargetPath: '',
+  },
+};
+
+/**
+ * Configure MoEngage SDK in your Expo app
+ */
+const withMoEngage: ConfigPlugin<MoEngagePluginProps | undefined> = (config, props) => {
+  // Apply default values or handle undefined props
+  const pluginProps: MoEngagePluginProps = props ? {
+    ...defaultProps,
+    ...props,
+    android: {
+      ...defaultProps.android,
+      ...props.android,
+    },
+    apple: {
+      ...defaultProps.apple,
+      ...props.apple,
+    },
+  } : defaultProps
+  config = withMoEngageAndroid(config, pluginProps);
+  config = withMoEngageIos(config, pluginProps);
+  return config;
+};
+
+const pkg = require('../package.json');
+
+export default createRunOncePlugin(
+  withMoEngage,
+  pkg.name,
+  pkg.version
+);