@stream-io/video-react-native-sdk 1.41.0 → 1.43.0

package/expo-config-plugin/dist/withAndroidMessagingService.js

@@ -0,0 +1,313 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIREBASE_DEP_MARKER = exports.FIREBASE_BOM_FALLBACK_VERSION = exports.FIREBASE_MESSAGING_ARTIFACT = exports.STREAM_DEFAULT_SERVICE = exports.GENERATED_SERVICE_CLASS_NAME = exports.EXPO_NOTIFICATIONS_SERVICE = void 0;
+exports.updateManifest = updateManifest;
+exports.buildServiceSource = buildServiceSource;
+exports.validateBaseClass = validateBaseClass;
+exports.resolveBaseClass = resolveBaseClass;
+exports.isExpoNotificationsInstalled = isExpoNotificationsInstalled;
+exports.getGeneratedServiceFqcn = getGeneratedServiceFqcn;
+exports.addFirebaseMessagingDependency = addFirebaseMessagingDependency;
+exports.resolveFirebaseBomVersion = resolveFirebaseBomVersion;
+const config_plugins_1 = require("@expo/config-plugins");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const GENERATED_SERVICE_CLASS_NAME = 'StreamVideoMessagingService';
+exports.GENERATED_SERVICE_CLASS_NAME = GENERATED_SERVICE_CLASS_NAME;
+const STREAM_DEFAULT_SERVICE = 'io.getstream.rn.callingx.StreamMessagingService';
+exports.STREAM_DEFAULT_SERVICE = STREAM_DEFAULT_SERVICE;
+/** React Native Firebase's own FCM service. */
+const RN_FIREBASE_SERVICE = 'io.invertase.firebase.messaging.ReactNativeFirebaseMessagingService';
+/** expo-notifications' FCM service — the default base auto-detected when installed. */
+const EXPO_NOTIFICATIONS_SERVICE = 'expo.modules.notifications.service.ExpoFirebaseMessagingService';
+exports.EXPO_NOTIFICATIONS_SERVICE = EXPO_NOTIFICATIONS_SERVICE;
+const EXPO_NOTIFICATIONS_PACKAGE = 'expo-notifications';
+const MESSAGING_EVENT_ACTION = 'com.google.firebase.MESSAGING_EVENT';
+/**
+ * The generated service lives in the `:app` module, which only has
+ * firebase-messaging on its *runtime* classpath (via callingx / RNFB /
+ * expo-notifications `implementation` deps). We add it as `compileOnly` so the
+ * app can compile a `FirebaseMessagingService` subclass. The runtime artifact is
+ * still supplied by those modules, so this avoids a version conflict.
+ */
+const FIREBASE_MESSAGING_ARTIFACT = 'com.google.firebase:firebase-messaging';
+exports.FIREBASE_MESSAGING_ARTIFACT = FIREBASE_MESSAGING_ARTIFACT;
+/**
+ * Fallback Firebase BOM version, used only when the live BOM cannot be resolved
+ * from @react-native-firebase/app. This is the BOM shipped by the minimum RNFB
+ * version we support: @stream-io/react-native-callingx declares a
+ * `@react-native-firebase/* >= 23.0.0` peer dependency, and RNFB `23.0.0` pins
+ * firebase-bom `34.0.0`. Keep in sync with that peer floor.
+ */
+const FIREBASE_BOM_FALLBACK_VERSION = '34.0.0';
+exports.FIREBASE_BOM_FALLBACK_VERSION = FIREBASE_BOM_FALLBACK_VERSION;
+/** Stable comment used to detect (and avoid duplicating) our gradle injection. */
+const FIREBASE_DEP_MARKER = '// Added by @stream-io/video-react-native-sdk for the generated FCM messaging service';
+exports.FIREBASE_DEP_MARKER = FIREBASE_DEP_MARKER;
+function getAndroidPackage(config) {
+    const modResults = config.modResults;
+    const pkg = config.android?.package ?? modResults?.manifest?.$?.package;
+    if (!pkg) {
+        throw new Error('[StreamVideo] Unable to resolve the Android package name required to generate ' +
+            'the FCM messaging service. Set "android.package" in your app config.');
+    }
+    return pkg;
+}
+function getGeneratedServiceFqcn(androidPackage) {
+    return `${androidPackage}.${GENERATED_SERVICE_CLASS_NAME}`;
+}
+function validateBaseClass(baseClass) {
+    if (typeof baseClass !== 'string' || baseClass.trim().length === 0) {
+        throw new Error('[StreamVideo] "androidMessagingServiceBaseClass" must be a non-empty string.');
+    }
+    if (!baseClass.includes('.')) {
+        throw new Error(`[StreamVideo] "androidMessagingServiceBaseClass" must be a fully-qualified class name ` +
+            `including its package (e.g. "expo.modules.notifications.service.ExpoFirebaseMessagingService"), ` +
+            `received "${baseClass}".`);
+    }
+}
+function isExpoNotificationsInstalled(projectRoot) {
+    return isPackageUsedByApp(EXPO_NOTIFICATIONS_PACKAGE, projectRoot);
+}
+/**
+ * Whether `packageName` belongs to this app's own dependency graph.
+ *
+ * Deliberately avoids `require.resolve`, which walks up the directory tree: in a
+ * workspace that also finds packages hoisted to the repo root by a *sibling*
+ * app. Those are not linked into this app's Android build, so extending their
+ * service generates Kotlin that cannot compile.
+ */
+function isPackageUsedByApp(packageName, projectRoot) {
+    if (!projectRoot) {
+        // No project context to scope the lookup to; plain resolution is all we have.
+        try {
+            require.resolve(`${packageName}/package.json`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    try {
+        const appPackageJson = JSON.parse(fs.readFileSync(path.join(projectRoot, 'package.json'), 'utf8'));
+        // Only runtime dependencies: a devDependency is not linked into the build.
+        if (packageName in { ...appPackageJson?.dependencies }) {
+            return true;
+        }
+    }
+    catch {
+        // Unreadable app package.json: fall through to the filesystem check.
+    }
+    return fs.existsSync(path.join(projectRoot, 'node_modules', packageName, 'package.json'));
+}
+function resolveBaseClass(value, projectRoot) {
+    if (value === null) {
+        return undefined;
+    }
+    if (typeof value === 'string') {
+        validateBaseClass(value);
+        return value;
+    }
+    return isExpoNotificationsInstalled(projectRoot)
+        ? EXPO_NOTIFICATIONS_SERVICE
+        : undefined;
+}
+/** Kotlin source for the generated messaging service. */
+function buildServiceSource(androidPackage, baseClassFqcn) {
+    const simpleName = baseClassFqcn.split('.').pop();
+    const shouldForwardNewToken = baseClassFqcn !== RN_FIREBASE_SERVICE;
+    const onNewToken = shouldForwardNewToken
+        ? `
+  override fun onNewToken(token: String) {
+    super.onNewToken(token)
+    // Keep Stream's device registration working under a non-RNFirebase base.
+    StreamMessagingHelper.forwardNewToken(token)
+  }
+`
+        : '';
+    return `package ${androidPackage}
+
+import android.annotation.SuppressLint
+import com.google.firebase.messaging.RemoteMessage
+import io.getstream.rn.callingx.StreamMessagingHelper
+import ${baseClassFqcn}
+
+/**
+ * AUTO-GENERATED by the @stream-io/video-react-native-sdk Expo config plugin.
+ * Do not edit — this file is regenerated on every \`expo prebuild\`.
+ *
+ * Extends the app-declared FCM service (${baseClassFqcn}) and injects Stream
+ * Video incoming-call (\`call.ring\`) handling. Stream's default
+ * ${STREAM_DEFAULT_SERVICE} is removed from the merged manifest so this class is
+ * the single FirebaseMessagingService for the app.
+ */
+@SuppressLint("MissingFirebaseInstanceTokenRefresh")
+class ${GENERATED_SERVICE_CLASS_NAME} : ${simpleName}() {
+  override fun onMessageReceived(remoteMessage: RemoteMessage) {
+    if (StreamMessagingHelper.isStreamCallRing(remoteMessage)) {
+      StreamMessagingHelper.handleMessage(applicationContext, remoteMessage)
+      return
+    }
+    super.onMessageReceived(remoteMessage)
+  }
+${onNewToken}}
+`;
+}
+function updateManifest(androidManifest, generatedFqcn, baseClassFqcn) {
+    const manifest = androidManifest.manifest;
+    if (!manifest ||
+        !Array.isArray(manifest.application) ||
+        !manifest.application[0]) {
+        throw new Error('[StreamVideo] Malformed AndroidManifest.xml: missing <application> element.');
+    }
+    manifest.$ = manifest.$ ?? {};
+    manifest.$['xmlns:tools'] =
+        manifest.$['xmlns:tools'] ?? 'http://schemas.android.com/tools';
+    // Services whose registration we strip so the generated service is the only
+    // MESSAGING_EVENT handler: Stream's default (from react-native-callingx) and
+    // the base class (its logic still runs — the generated service subclasses it).
+    const servicesToRemove = [
+        ...new Set([STREAM_DEFAULT_SERVICE, baseClassFqcn]),
+    ];
+    const application = manifest.application[0];
+    const existing = application.service ?? [];
+    // Drop our own previously-added entries so re-runs don't duplicate them.
+    const services = existing.filter((service) => {
+        const name = service?.$?.['android:name'];
+        return name !== generatedFqcn && !servicesToRemove.includes(name ?? '');
+    });
+    // The generated service becomes the single com.google.firebase.MESSAGING_EVENT handler.
+    services.push({
+        $: {
+            'android:name': generatedFqcn,
+            'android:exported': 'false',
+        },
+        'intent-filter': [
+            {
+                action: [{ $: { 'android:name': MESSAGING_EVENT_ACTION } }],
+            },
+        ],
+    });
+    // Remove the competing services so they don't win FCM delivery. `tools:node`
+    // is not part of the strict typing but is valid manifest merger syntax.
+    for (const name of servicesToRemove) {
+        services.push({
+            $: {
+                'android:name': name,
+                'tools:node': 'remove',
+            },
+        });
+    }
+    application.service = services;
+    return androidManifest;
+}
+const withGeneratedMessagingServiceFile = (config, value) => {
+    return (0, config_plugins_1.withDangerousMod)(config, [
+        'android',
+        (dangerousConfig) => {
+            const baseClassFqcn = resolveBaseClass(value, dangerousConfig.modRequest.projectRoot);
+            if (!baseClassFqcn) {
+                return dangerousConfig;
+            }
+            const androidPackage = getAndroidPackage(dangerousConfig);
+            const packagePath = androidPackage.replace(/\./g, path.sep);
+            const javaDir = path.join(dangerousConfig.modRequest.platformProjectRoot, 'app', 'src', 'main', 'java', packagePath);
+            fs.mkdirSync(javaDir, { recursive: true });
+            const destPath = path.join(javaDir, `${GENERATED_SERVICE_CLASS_NAME}.kt`);
+            fs.writeFileSync(destPath, buildServiceSource(androidPackage, baseClassFqcn), 'utf8');
+            return dangerousConfig;
+        },
+    ]);
+};
+const withMessagingServiceManifest = (config, value) => {
+    return (0, config_plugins_1.withAndroidManifest)(config, (androidConfig) => {
+        const baseClassFqcn = resolveBaseClass(value, androidConfig.modRequest.projectRoot);
+        if (!baseClassFqcn) {
+            return androidConfig;
+        }
+        const androidPackage = getAndroidPackage(androidConfig);
+        androidConfig.modResults = updateManifest(androidConfig.modResults, getGeneratedServiceFqcn(androidPackage), baseClassFqcn);
+        return androidConfig;
+    });
+};
+function resolveFirebaseBomVersion(projectRoot) {
+    try {
+        const pkgPath = require.resolve('@react-native-firebase/app/package.json', projectRoot ? { paths: [projectRoot] } : undefined);
+        const pkg = require(pkgPath);
+        const bom = pkg?.sdkVersions?.android?.firebase;
+        return typeof bom === 'string' && bom.length > 0 ? bom : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const DEPENDENCIES_BLOCK = /dependencies\s*\{/;
+function addFirebaseMessagingDependency(contents, bomVersion) {
+    if (contents.includes(FIREBASE_DEP_MARKER)) {
+        return contents;
+    }
+    if (!DEPENDENCIES_BLOCK.test(contents)) {
+        throw new Error('[StreamVideo] Could not find a "dependencies { }" block in the app build.gradle ' +
+            'to add the firebase-messaging compile dependency for the generated FCM service.');
+    }
+    const lines = `    ${FIREBASE_DEP_MARKER}\n` +
+        `    compileOnly(platform("com.google.firebase:firebase-bom:${bomVersion ?? FIREBASE_BOM_FALLBACK_VERSION}"))\n` +
+        `    compileOnly("${FIREBASE_MESSAGING_ARTIFACT}")`;
+    return contents.replace(DEPENDENCIES_BLOCK, (match) => `${match}\n${lines}`);
+}
+const withMessagingServiceGradle = (config, value) => {
+    return (0, config_plugins_1.withAppBuildGradle)(config, (gradleConfig) => {
+        const baseClassFqcn = resolveBaseClass(value, gradleConfig.modRequest.projectRoot);
+        if (!baseClassFqcn) {
+            return gradleConfig;
+        }
+        const bomVersion = resolveFirebaseBomVersion(gradleConfig.modRequest.projectRoot);
+        gradleConfig.modResults.contents = addFirebaseMessagingDependency(gradleConfig.modResults.contents, bomVersion);
+        return gradleConfig;
+    });
+};
+const withAndroidMessagingService = (config, props) => {
+    // The messaging-service override only matters for the ringing flow, skip it otherwise.
+    if (!props?.ringing) {
+        return config;
+    }
+    const value = props?.androidMessagingServiceBaseClass;
+    let updated = withGeneratedMessagingServiceFile(config, value);
+    updated = withMessagingServiceManifest(updated, value);
+    updated = withMessagingServiceGradle(updated, value);
+    return updated;
+};
+exports.default = withAndroidMessagingService;

package/expo-config-plugin/dist/withIosScreenCapture/addBroadcastExtensionXcodeTarget.js

@@ -33,8 +33,88 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDeploymentTarget = exports.MIN_DEPLOYMENT_TARGET = void 0;
 exports.default = addBroadcastExtensionXcodeTarget;
 const util = __importStar(require("util"));
+/**
+ * The lowest iOS version the broadcast extension is built for.
+ */
+exports.MIN_DEPLOYMENT_TARGET = '15.0';
+/**
+ * A plain dotted version number, for example `15` or `16.4`. Anything else
+ * (`$(inherited)`, `16.4beta`) is not comparable and must not be adopted:
+ * `Number.parseInt` would silently accept a trailing suffix.
+ */
+const VERSION_PATTERN = /^\d+(?:\.\d+)*$/;
+/**
+ * Returns true when `candidate` is a higher iOS version than `current`.
+ * Values that are not plain version numbers are treated as not higher.
+ */
+const isHigherVersion = (candidate, current) => {
+    if (!VERSION_PATTERN.test(candidate)) {
+        return false;
+    }
+    const parse = (value) => value.split('.').map((part) => Number.parseInt(part, 10));
+    const parsedCandidate = parse(candidate);
+    const parsedCurrent = parse(current);
+    const length = Math.max(parsedCandidate.length, parsedCurrent.length);
+    for (let index = 0; index < length; index++) {
+        const left = parsedCandidate[index] ?? 0;
+        const right = parsedCurrent[index] ?? 0;
+        if (left !== right) {
+            return left > right;
+        }
+    }
+    return false;
+};
+/**
+ * Deployment targets declared by the host app target and by the project itself.
+ *
+ * Scoped to those two on purpose. `pbxXCBuildConfigurationSection()` also
+ * returns configurations belonging to unrelated targets (widgets, share or
+ * notification-service extensions), and adopting the highest of those could make
+ * the broadcast extension require a newer iOS than the app it ships inside,
+ * which would silently drop screen share on devices in between.
+ */
+const collectHostDeploymentTargets = (proj) => {
+    const configurations = (proj.pbxXCBuildConfigurationSection?.() ??
+        {});
+    const configurationLists = (proj.pbxXCConfigurationList?.() ?? {});
+    const listUuids = [
+        proj.getFirstTarget?.()?.firstTarget?.buildConfigurationList,
+        proj.getFirstProject?.()?.firstProject?.buildConfigurationList,
+    ].filter((uuid) => typeof uuid === 'string');
+    const values = [];
+    for (const listUuid of listUuids) {
+        const entries = configurationLists[listUuid]?.buildConfigurations ?? [];
+        for (const entry of entries) {
+            const value = configurations[entry?.value]?.buildSettings?.IPHONEOS_DEPLOYMENT_TARGET;
+            if (value === undefined || value === null) {
+                continue;
+            }
+            values.push(String(value).replace(/"/g, '').trim());
+        }
+    }
+    return values;
+};
+/**
+ * Resolves the deployment target to use for the broadcast extension.
+ *
+ * The extension mirrors the highest deployment target of its host app, so it
+ * never requires a newer iOS than the app itself and it satisfies the minimum
+ * the toolchain accepts (Xcode 27 rejects anything below 15.0). The value only
+ * ever moves up from {@link MIN_DEPLOYMENT_TARGET}.
+ */
+const resolveDeploymentTarget = (proj) => {
+    let resolved = exports.MIN_DEPLOYMENT_TARGET;
+    for (const candidate of collectHostDeploymentTargets(proj)) {
+        if (isHigherVersion(candidate, resolved)) {
+            resolved = candidate;
+        }
+    }
+    return resolved;
+};
+exports.resolveDeploymentTarget = resolveDeploymentTarget;
 function addBroadcastExtensionXcodeTarget(proj, { appName, extensionName, extensionBundleIdentifier, currentProjectVersion, marketingVersion, developmentTeamId, }) {
     const targets = proj.getFirstProject().firstProject.targets ?? [];
     if (targets.length > 0 &&
@@ -50,6 +130,7 @@ function addBroadcastExtensionXcodeTarget(proj, { appName, extensionName, extens
         marketingVersion,
         extensionName,
         appName,
+        developmentTeamId,
     });
     const productFile = addProductFile(proj, extensionName, groupName);
     const target = addToPbxNativeTargetSection(proj, {
@@ -74,7 +155,7 @@ function addBroadcastExtensionXcodeTarget(proj, { appName, extensionName, extens
     });
     addPbxGroup(proj, productFile);
 }
-const addXCConfigurationList = (proj, { extensionBundleIdentifier, currentProjectVersion, marketingVersion, extensionName, }) => {
+const addXCConfigurationList = (proj, { extensionBundleIdentifier, currentProjectVersion, marketingVersion, extensionName, developmentTeamId, }) => {
     const commonBuildSettings = {
         CLANG_ANALYZER_NONNULL: 'YES',
         CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION: 'YES_AGGRESSIVE',
@@ -86,12 +167,13 @@ const addXCConfigurationList = (proj, { extensionBundleIdentifier, currentProjec
         CODE_SIGN_ENTITLEMENTS: `${extensionName}/${extensionName}.entitlements`,
         CODE_SIGN_STYLE: 'Automatic',
         CURRENT_PROJECT_VERSION: currentProjectVersion,
+        DEVELOPMENT_TEAM: developmentTeamId,
         GCC_C_LANGUAGE_STANDARD: 'gnu11',
         GENERATE_INFOPLIST_FILE: 'YES',
         INFOPLIST_FILE: `${extensionName}/Info.plist`,
         INFOPLIST_KEY_CFBundleDisplayName: `${extensionName}`,
         INFOPLIST_KEY_NSHumanReadableCopyright: quoted(''),
-        IPHONEOS_DEPLOYMENT_TARGET: '14.0',
+        IPHONEOS_DEPLOYMENT_TARGET: (0, exports.resolveDeploymentTarget)(proj),
         LD_RUNPATH_SEARCH_PATHS: quoted('$(inherited) @executable_path/Frameworks @executable_path/../../Frameworks'),
         MARKETING_VERSION: marketingVersion,
         MTL_FAST_MATH: 'YES',

package/expo-config-plugin/dist/withIosScreenCapture/withPlistUpdates.js

@@ -6,8 +6,7 @@ exports.default = withPlistUpdates;
 // adds the app group identifier to the app's entitlements file
 const withAppEntitlements = (configuration) => {
     return (0, config_plugins_1.withEntitlementsPlist)(configuration, (config) => {
-        const appGroupIdentifier = `group.${config.ios
-            .bundleIdentifier}.appgroup`;
+        const appGroupIdentifier = `group.${config.ios.bundleIdentifier}.appgroup`;
         config.modResults['com.apple.security.application-groups'] = [
             appGroupIdentifier,
         ];
@@ -16,10 +15,8 @@ const withAppEntitlements = (configuration) => {
 };
 const withInfoPlistRTC = (configuration) => {
     return (0, config_plugins_1.withInfoPlist)(configuration, (config) => {
-        const appGroupIdentifier = `group.${config.ios
-            .bundleIdentifier}.appgroup`;
-        const extensionBundleIdentifier = `${config.ios
-            .bundleIdentifier}.broadcast`;
+        const appGroupIdentifier = `group.${config.ios.bundleIdentifier}.appgroup`;
+        const extensionBundleIdentifier = `${config.ios.bundleIdentifier}.broadcast`;
         config.modResults.RTCAppGroupIdentifier = appGroupIdentifier;
         config.modResults.RTCScreenSharingExtension = extensionBundleIdentifier;
         if (!config.modResults.UIBackgroundModes) {

package/expo-config-plugin/dist/withIosScreenCapture/withTarget.js

@@ -46,8 +46,7 @@ const withTarget = (configuration, props) => {
     return (0, config_plugins_1.withXcodeProject)(configuration, (config) => {
         const appName = config.modRequest.projectName;
         const extensionName = 'broadcast';
-        const extensionBundleIdentifier = `${config.ios
-            .bundleIdentifier}.broadcast`;
+        const extensionBundleIdentifier = `${config.ios.bundleIdentifier}.broadcast`;
         const currentProjectVersion = config.ios.buildNumber || '1';
         const marketingVersion = config.version;
         const proj = config.modResults;
@@ -63,8 +62,7 @@ const withTarget = (configuration, props) => {
             marketingVersion,
             developmentTeamId,
         });
-        const appGroupIdentifier = `group.${config.ios
-            .bundleIdentifier}.appgroup`;
+        const appGroupIdentifier = `group.${config.ios.bundleIdentifier}.appgroup`;
         const extensionRootPath = path.join(config.modRequest.platformProjectRoot, 'broadcast');
         addBroadcastEntitlementsFile({
             proj,
@@ -103,6 +101,7 @@ const addBroadcastSourceFiles = ({ proj, extensionRootPath, appGroupIdentifier,
     fs.copyFileSync(path.join(__dirname, '..', '..', 'static', 'Atomic.swift'), path.join(extensionRootPath, 'Atomic.swift'));
     fs.copyFileSync(path.join(__dirname, '..', '..', 'static', 'DarwinNotificationCenter.swift'), path.join(extensionRootPath, 'DarwinNotificationCenter.swift'));
     fs.copyFileSync(path.join(__dirname, '..', '..', 'static', 'SampleUploader.swift'), path.join(extensionRootPath, 'SampleUploader.swift'));
+    fs.copyFileSync(path.join(__dirname, '..', '..', 'static', 'AudioUploader.swift'), path.join(extensionRootPath, 'AudioUploader.swift'));
     fs.copyFileSync(path.join(__dirname, '..', '..', 'static', 'SocketConnection.swift'), path.join(extensionRootPath, 'SocketConnection.swift'));
     // Update app group bundle id in SampleHandler code
     const code = fs.readFileSync(path.join(extensionRootPath, 'SampleHandler.swift'), { encoding: 'utf-8' });
@@ -126,6 +125,9 @@ const addBroadcastSourceFiles = ({ proj, extensionRootPath, appGroupIdentifier,
     proj.addSourceFile('SampleUploader.swift', {
         target: targetUuid,
     }, groupUuid);
+    proj.addSourceFile('AudioUploader.swift', {
+        target: targetUuid,
+    }, groupUuid);
     proj.addSourceFile('SocketConnection.swift', {
         target: targetUuid,
     }, groupUuid);