react-native-notify-kit 10.3.3 → 10.4.0

package/plugin/build/android/withNotifyKitAndroidManifest.js

@@ -0,0 +1,236 @@
+'use strict';
+
+const NOTIFY_KIT_FOREGROUND_SERVICE_NAME = 'app.notifee.core.ForegroundService';
+const ANDROID_SPECIAL_USE_FGS_SUBTYPE_PROPERTY =
+  'android.app.PROPERTY_SPECIAL_USE_FGS_SUBTYPE';
+
+const ANDROID_FOREGROUND_SERVICE_PERMISSION = 'android.permission.FOREGROUND_SERVICE';
+
+const ANDROID_FOREGROUND_SERVICE_TYPE_PERMISSIONS = {
+  camera: 'android.permission.FOREGROUND_SERVICE_CAMERA',
+  connectedDevice: 'android.permission.FOREGROUND_SERVICE_CONNECTED_DEVICE',
+  dataSync: 'android.permission.FOREGROUND_SERVICE_DATA_SYNC',
+  health: 'android.permission.FOREGROUND_SERVICE_HEALTH',
+  location: 'android.permission.FOREGROUND_SERVICE_LOCATION',
+  mediaPlayback: 'android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK',
+  mediaProjection: 'android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION',
+  microphone: 'android.permission.FOREGROUND_SERVICE_MICROPHONE',
+  phoneCall: 'android.permission.FOREGROUND_SERVICE_PHONE_CALL',
+  remoteMessaging: 'android.permission.FOREGROUND_SERVICE_REMOTE_MESSAGING',
+  specialUse: 'android.permission.FOREGROUND_SERVICE_SPECIAL_USE',
+  systemExempted: 'android.permission.FOREGROUND_SERVICE_SYSTEM_EXEMPTED',
+};
+
+function withNotifyKitAndroidManifest(config, foregroundServiceOptions) {
+  if (!foregroundServiceOptions.enabled) {
+    return config;
+  }
+
+  const { withAndroidManifest } = requireExpoConfigPlugins();
+
+  return withAndroidManifest(config, modConfig => {
+    applyNotifyKitAndroidForegroundServiceManifest(
+      modConfig.modResults,
+      foregroundServiceOptions,
+    );
+
+    return modConfig;
+  });
+}
+
+function applyNotifyKitAndroidForegroundServiceManifest(
+  androidManifest,
+  foregroundServiceOptions,
+) {
+  ensurePermission(androidManifest, ANDROID_FOREGROUND_SERVICE_PERMISSION);
+
+  for (const permission of resolveTypeSpecificPermissions(foregroundServiceOptions.types)) {
+    ensurePermission(androidManifest, permission);
+  }
+
+  const application = ensureMainApplication(androidManifest);
+  const service = ensureNotifyKitForegroundService(application);
+  service.$ = {
+    ...service.$,
+    'android:name': NOTIFY_KIT_FOREGROUND_SERVICE_NAME,
+    'android:exported': 'false',
+    'android:foregroundServiceType': foregroundServiceOptions.types.join('|'),
+  };
+
+  if (foregroundServiceOptions.types.includes('specialUse')) {
+    if (foregroundServiceOptions.specialUseSubtype === undefined) {
+      throw new Error(
+        '[react-native-notify-kit] android.foregroundService.specialUseSubtype is required when types includes specialUse.',
+      );
+    }
+
+    upsertSpecialUseProperty(service, foregroundServiceOptions.specialUseSubtype);
+  } else {
+    removeSpecialUseProperty(service);
+  }
+
+  return androidManifest;
+}
+
+function resolveTypeSpecificPermissions(types) {
+  const permissions = [];
+
+  for (const type of types) {
+    const permission = ANDROID_FOREGROUND_SERVICE_TYPE_PERMISSIONS[type];
+    if (permission !== undefined && !permissions.includes(permission)) {
+      permissions.push(permission);
+    }
+  }
+
+  return permissions;
+}
+
+function ensurePermission(androidManifest, permissionName) {
+  const manifest = ensureManifestRoot(androidManifest);
+  const permissions = ensureArrayProperty(
+    manifest,
+    'uses-permission',
+    '[react-native-notify-kit] AndroidManifest.xml uses-permission must be an array.',
+  );
+
+  const hasPermission = permissions.some(
+    permission => permission.$ && permission.$['android:name'] === permissionName,
+  );
+
+  if (!hasPermission) {
+    permissions.push({
+      $: {
+        'android:name': permissionName,
+      },
+    });
+  }
+}
+
+function ensureMainApplication(androidManifest) {
+  const manifest = ensureManifestRoot(androidManifest);
+  const applications = ensureArrayProperty(
+    manifest,
+    'application',
+    '[react-native-notify-kit] AndroidManifest.xml application must be an array.',
+  );
+
+  if (applications.length === 0) {
+    applications.push({});
+  }
+
+  return applications[0];
+}
+
+function ensureNotifyKitForegroundService(application) {
+  const services = ensureArrayProperty(
+    application,
+    'service',
+    '[react-native-notify-kit] AndroidManifest.xml application.service must be an array.',
+  );
+  const existingService = services.find(
+    service =>
+      service.$ && service.$['android:name'] === NOTIFY_KIT_FOREGROUND_SERVICE_NAME,
+  );
+
+  if (existingService !== undefined) {
+    return existingService;
+  }
+
+  const service = {
+    $: {
+      'android:name': NOTIFY_KIT_FOREGROUND_SERVICE_NAME,
+    },
+  };
+  services.push(service);
+
+  return service;
+}
+
+function upsertSpecialUseProperty(service, subtype) {
+  const properties = ensureArrayProperty(
+    service,
+    'property',
+    '[react-native-notify-kit] AndroidManifest.xml service.property must be an array.',
+  );
+  const existingProperty = properties.find(
+    property =>
+      property.$ &&
+      property.$['android:name'] === ANDROID_SPECIAL_USE_FGS_SUBTYPE_PROPERTY,
+  );
+
+  if (existingProperty !== undefined) {
+    existingProperty.$ = {
+      ...existingProperty.$,
+      'android:name': ANDROID_SPECIAL_USE_FGS_SUBTYPE_PROPERTY,
+      'android:value': subtype,
+    };
+    return;
+  }
+
+  properties.push({
+    $: {
+      'android:name': ANDROID_SPECIAL_USE_FGS_SUBTYPE_PROPERTY,
+      'android:value': subtype,
+    },
+  });
+}
+
+function removeSpecialUseProperty(service) {
+  if (service.property === undefined) {
+    return;
+  }
+
+  service.property = service.property.filter(
+    property =>
+      property.$ &&
+      property.$['android:name'] !== ANDROID_SPECIAL_USE_FGS_SUBTYPE_PROPERTY,
+  );
+
+  if (service.property.length === 0) {
+    delete service.property;
+  }
+}
+
+function ensureManifestRoot(androidManifest) {
+  if (androidManifest.manifest === undefined) {
+    androidManifest.manifest = {};
+  }
+
+  return androidManifest.manifest;
+}
+
+function ensureArrayProperty(object, key, errorMessage) {
+  const value = object[key];
+
+  if (value === undefined) {
+    const nextValue = [];
+    object[key] = nextValue;
+    return nextValue;
+  }
+
+  if (!Array.isArray(value)) {
+    throw new Error(errorMessage);
+  }
+
+  return value;
+}
+
+function requireExpoConfigPlugins() {
+  try {
+    return require('expo/config-plugins');
+  } catch (error) {
+    try {
+      return require(require.resolve('expo/config-plugins', { paths: [process.cwd()] }));
+    } catch {
+      throw error;
+    }
+  }
+}
+
+module.exports = {
+  NOTIFY_KIT_FOREGROUND_SERVICE_NAME,
+  ANDROID_SPECIAL_USE_FGS_SUBTYPE_PROPERTY,
+  withNotifyKitAndroidManifest,
+  applyNotifyKitAndroidForegroundServiceManifest,
+  resolveTypeSpecificPermissions,
+};

package/plugin/build/index.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const { createRunOncePlugin } = requireExpoConfigPlugins();
+const { normalizeNotifyKitPluginOptions } = require('./options');
+const {
+  withNotifyKitAndroidManifest,
+} = require('./android/withNotifyKitAndroidManifest');
+const {
+  withNotifyKitIosNseAppExtension,
+} = require('./ios/withNotifyKitIosNseAppExtension');
+const {
+  withNotifyKitIosNseFiles,
+} = require('./ios/withNotifyKitIosNseFiles');
+const {
+  withNotifyKitIosNsePodfile,
+} = require('./ios/withNotifyKitIosNsePodfile');
+const {
+  withNotifyKitIosNseXcodeProject,
+} = require('./ios/withNotifyKitIosNseXcodeProject');
+const pkg = require('../../package.json');
+
+function withNotifyKit(config, props = {}) {
+  const options = normalizeNotifyKitPluginOptions(props);
+  const foregroundServiceOptions = options.android.foregroundService;
+  const nseOptions = options.ios.notificationServiceExtension;
+  const configWithAndroidManifest = withNotifyKitAndroidManifest(
+    config,
+    foregroundServiceOptions,
+  );
+  const configWithAppExtension = withNotifyKitIosNseAppExtension(
+    configWithAndroidManifest,
+    nseOptions,
+  );
+  const configWithFiles = withNotifyKitIosNseFiles(configWithAppExtension, nseOptions);
+  const configWithXcodeProject = withNotifyKitIosNseXcodeProject(configWithFiles, nseOptions);
+
+  return withNotifyKitIosNsePodfile(configWithXcodeProject, nseOptions);
+}
+
+const plugin = createRunOncePlugin(withNotifyKit, pkg.name, pkg.version);
+
+module.exports = plugin;
+module.exports.default = plugin;
+module.exports.withNotifyKit = withNotifyKit;
+module.exports.normalizeNotifyKitPluginOptions = normalizeNotifyKitPluginOptions;
+module.exports.withNotifyKitAndroidManifest = withNotifyKitAndroidManifest;
+module.exports.withNotifyKitIosNseAppExtension = withNotifyKitIosNseAppExtension;
+module.exports.withNotifyKitIosNseFiles = withNotifyKitIosNseFiles;
+module.exports.withNotifyKitIosNseXcodeProject = withNotifyKitIosNseXcodeProject;
+module.exports.withNotifyKitIosNsePodfile = withNotifyKitIosNsePodfile;
+
+function requireExpoConfigPlugins() {
+  try {
+    return require('expo/config-plugins');
+  } catch (error) {
+    try {
+      return require(require.resolve('expo/config-plugins', { paths: [process.cwd()] }));
+    } catch {
+      throw error;
+    }
+  }
+}

package/plugin/build/ios/withNotifyKitIosNseAppExtension.js

@@ -0,0 +1,142 @@
+'use strict';
+
+function withNotifyKitIosNseAppExtension(config, nseOptions) {
+  if (!nseOptions.enabled) {
+    return config;
+  }
+
+  const bundleIdentifier = resolveNotifyKitIosNseBundleIdentifier(config, nseOptions);
+  const currentAppExtensions = getCurrentAppExtensions(config);
+  const nextAppExtensions = upsertNotifyKitIosNseAppExtension(currentAppExtensions, {
+    targetName: nseOptions.targetName,
+    bundleIdentifier,
+  });
+
+  return {
+    ...config,
+    extra: setNestedAppExtensions(config.extra, nextAppExtensions),
+  };
+}
+
+function resolveNotifyKitIosNseBundleIdentifier(config, nseOptions) {
+  const hostBundleIdentifier = config.ios && config.ios.bundleIdentifier;
+  if (!hostBundleIdentifier) {
+    throw new Error(
+      '[react-native-notify-kit] ios.bundleIdentifier is required when ios.notificationServiceExtension.enabled is true.',
+    );
+  }
+
+  return `${hostBundleIdentifier}${nseOptions.bundleSuffix}`;
+}
+
+function upsertNotifyKitIosNseAppExtension(appExtensions, nextExtension) {
+  const nextAppExtensions = [];
+  let didUpsert = false;
+
+  for (const appExtension of appExtensions) {
+    if (!isPlainObject(appExtension)) {
+      throw new Error(
+        '[react-native-notify-kit] extra.eas.build.experimental.ios.appExtensions must contain objects.',
+      );
+    }
+
+    if (appExtension.targetName === nextExtension.targetName) {
+      if (
+        appExtension.bundleIdentifier !== undefined &&
+        appExtension.bundleIdentifier !== nextExtension.bundleIdentifier
+      ) {
+        throw new Error(
+          `[react-native-notify-kit] EAS app extension targetName '${nextExtension.targetName}' already uses bundleIdentifier '${appExtension.bundleIdentifier}'. ` +
+            `Expected '${nextExtension.bundleIdentifier}'.`,
+        );
+      }
+
+      if (!didUpsert) {
+        nextAppExtensions.push({
+          ...appExtension,
+          targetName: nextExtension.targetName,
+          bundleIdentifier: nextExtension.bundleIdentifier,
+        });
+        didUpsert = true;
+      }
+      continue;
+    }
+
+    if (appExtension.bundleIdentifier === nextExtension.bundleIdentifier) {
+      throw new Error(
+        `[react-native-notify-kit] EAS app extension bundleIdentifier '${nextExtension.bundleIdentifier}' already belongs to targetName '${appExtension.targetName}'. ` +
+          `Expected '${nextExtension.targetName}'.`,
+      );
+    }
+
+    nextAppExtensions.push(appExtension);
+  }
+
+  if (!didUpsert) {
+    nextAppExtensions.push({
+      targetName: nextExtension.targetName,
+      bundleIdentifier: nextExtension.bundleIdentifier,
+    });
+  }
+
+  return nextAppExtensions;
+}
+
+function getCurrentAppExtensions(config) {
+  const appExtensions = getObject(config.extra)?.eas;
+  const build = getObject(appExtensions)?.build;
+  const experimental = getObject(build)?.experimental;
+  const ios = getObject(experimental)?.ios;
+  const currentAppExtensions = getObject(ios)?.appExtensions;
+
+  if (currentAppExtensions === undefined) {
+    return [];
+  }
+
+  if (!Array.isArray(currentAppExtensions)) {
+    throw new Error(
+      '[react-native-notify-kit] extra.eas.build.experimental.ios.appExtensions must be an array.',
+    );
+  }
+
+  return currentAppExtensions;
+}
+
+function setNestedAppExtensions(currentExtra, appExtensions) {
+  const extra = getObject(currentExtra) ?? {};
+  const eas = getObject(extra.eas) ?? {};
+  const build = getObject(eas.build) ?? {};
+  const experimental = getObject(build.experimental) ?? {};
+  const ios = getObject(experimental.ios) ?? {};
+
+  return {
+    ...extra,
+    eas: {
+      ...eas,
+      build: {
+        ...build,
+        experimental: {
+          ...experimental,
+          ios: {
+            ...ios,
+            appExtensions,
+          },
+        },
+      },
+    },
+  };
+}
+
+function getObject(value) {
+  return isPlainObject(value) ? value : null;
+}
+
+function isPlainObject(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+module.exports = {
+  withNotifyKitIosNseAppExtension,
+  resolveNotifyKitIosNseBundleIdentifier,
+  upsertNotifyKitIosNseAppExtension,
+};

package/plugin/build/ios/withNotifyKitIosNseFiles.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const {
+  renderNotificationServiceSwift,
+  renderNseEntitlementsPlist,
+  renderNseInfoPlist,
+} = require('../shared/nse/initNseCore');
+
+function withNotifyKitIosNseFiles(config, nseOptions) {
+  if (!nseOptions.enabled) {
+    return config;
+  }
+
+  const { withDangerousMod } = requireExpoConfigPlugins();
+
+  return withDangerousMod(config, [
+    'ios',
+    modConfig => {
+      writeNotifyKitIosNseFiles(
+        modConfig.modRequest.platformProjectRoot,
+        nseOptions.targetName,
+      );
+      return modConfig;
+    },
+  ]);
+}
+
+function writeNotifyKitIosNseFiles(platformProjectRoot, targetName) {
+  const targetDir = path.join(platformProjectRoot, targetName);
+  fs.mkdirSync(targetDir, { recursive: true });
+
+  writeFileIfMissingOrIdentical(
+    path.join(targetDir, 'NotificationService.swift'),
+    renderNotificationServiceSwift(),
+  );
+  writeFileIfMissingOrIdentical(
+    path.join(targetDir, 'Info.plist'),
+    renderNseInfoPlist({ targetName }),
+  );
+  writeFileIfMissingOrIdentical(
+    path.join(targetDir, `${targetName}.entitlements`),
+    renderNseEntitlementsPlist(),
+  );
+}
+
+function writeFileIfMissingOrIdentical(filePath, contents) {
+  if (fs.existsSync(filePath)) {
+    const currentContents = fs.readFileSync(filePath, 'utf8');
+    if (currentContents !== contents) {
+      throw new Error(
+        `[react-native-notify-kit] Refusing to overwrite existing ${filePath}. ` +
+          'Delete it or make it match the generated NotifyKit NSE template.',
+      );
+    }
+    return;
+  }
+
+  fs.writeFileSync(filePath, contents, 'utf8');
+}
+
+function requireExpoConfigPlugins() {
+  try {
+    return require('expo/config-plugins');
+  } catch (error) {
+    try {
+      return require(require.resolve('expo/config-plugins', { paths: [process.cwd()] }));
+    } catch {
+      throw error;
+    }
+  }
+}
+
+module.exports = {
+  withNotifyKitIosNseFiles,
+  writeNotifyKitIosNseFiles,
+};

package/plugin/build/ios/withNotifyKitIosNsePodfile.js

@@ -0,0 +1,130 @@
+'use strict';
+
+const path = require('path');
+
+const { patchPodfileForNotifyKitNse } = require('../shared/nse/patchPodfile');
+
+function withNotifyKitIosNsePodfile(config, nseOptions) {
+  if (!nseOptions.enabled) {
+    return config;
+  }
+
+  const { withPodfile } = requireExpoConfigPlugins();
+  const configuredUseFrameworks = detectConfiguredExpoBuildPropertiesUseFrameworks(config);
+
+  return withPodfile(config, modConfig => {
+    const { projectRoot, platformProjectRoot } = modConfig.modRequest;
+    const packagePathFromIos = resolveNotifyKitPackagePathFromIos(
+      projectRoot,
+      platformProjectRoot,
+    );
+    const hostUseFrameworks = detectPodfileUseFrameworks(modConfig.modResults.contents);
+    const useFrameworks = resolveNseUseFrameworks(hostUseFrameworks, configuredUseFrameworks);
+    const result = patchPodfileForNotifyKitNse(modConfig.modResults.contents, {
+      targetName: nseOptions.targetName,
+      packagePathFromIos,
+      placement: 'topLevel',
+      useFrameworks,
+    });
+
+    modConfig.modResults.contents = result.contents;
+    return modConfig;
+  });
+}
+
+function resolveNotifyKitPackagePathFromIos(projectRoot, platformProjectRoot) {
+  const packageJsonPath = require.resolve('react-native-notify-kit/package.json', {
+    paths: [projectRoot],
+  });
+  const packageDir = path.dirname(packageJsonPath);
+
+  return normalizePodfilePath(path.relative(platformProjectRoot, packageDir));
+}
+
+function normalizePodfilePath(filePath) {
+  return filePath.replace(/\\/g, '/');
+}
+
+function detectPodfileUseFrameworks(contents) {
+  let detected = false;
+
+  for (const line of contents.split('\n')) {
+    const stripped = line.replace(/#.*$/, '').trim();
+    if (!/^use_frameworks!(?:\s|$)/.test(stripped)) {
+      continue;
+    }
+
+    if (/:linkage\s*=>\s*:static\b/.test(stripped) || /\blinkage:\s*:static\b/.test(stripped)) {
+      return 'static';
+    }
+
+    if (
+      /:linkage\s*=>\s*:dynamic\b/.test(stripped) ||
+      /\blinkage:\s*:dynamic\b/.test(stripped)
+    ) {
+      return 'dynamic';
+    }
+
+    detected = true;
+  }
+
+  return detected;
+}
+
+function resolveNseUseFrameworks(hostUseFrameworks, configuredUseFrameworks) {
+  if (hostUseFrameworks === false) {
+    return false;
+  }
+
+  if (hostUseFrameworks === true && configuredUseFrameworks !== false) {
+    return configuredUseFrameworks;
+  }
+
+  return hostUseFrameworks;
+}
+
+function detectConfiguredExpoBuildPropertiesUseFrameworks(config) {
+  const plugins = Array.isArray(config.plugins) ? config.plugins : [];
+  let detected = false;
+
+  for (const plugin of plugins) {
+    if (!Array.isArray(plugin) || plugin[0] !== 'expo-build-properties') {
+      continue;
+    }
+
+    const options = isPlainObject(plugin[1]) ? plugin[1] : null;
+    const ios = isPlainObject(options?.ios) ? options.ios : null;
+    const useFrameworks = ios?.useFrameworks;
+
+    if (useFrameworks === 'static' || useFrameworks === 'dynamic') {
+      detected = useFrameworks;
+    } else if (useFrameworks === true || useFrameworks === false) {
+      detected = useFrameworks;
+    }
+  }
+
+  return detected;
+}
+
+function isPlainObject(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function requireExpoConfigPlugins() {
+  try {
+    return require('expo/config-plugins');
+  } catch (error) {
+    try {
+      return require(require.resolve('expo/config-plugins', { paths: [process.cwd()] }));
+    } catch {
+      throw error;
+    }
+  }
+}
+
+module.exports = {
+  withNotifyKitIosNsePodfile,
+  resolveNotifyKitPackagePathFromIos,
+  normalizePodfilePath,
+  detectPodfileUseFrameworks,
+};

package/plugin/build/ios/withNotifyKitIosNseXcodeProject.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const {
+  patchXcodeProjectForNotifyKitNse,
+} = require('../shared/nse/patchXcodeProject');
+const {
+  resolveNotifyKitIosNseBundleIdentifier,
+} = require('./withNotifyKitIosNseAppExtension');
+
+function withNotifyKitIosNseXcodeProject(config, nseOptions) {
+  if (!nseOptions.enabled) {
+    return config;
+  }
+
+  const { withXcodeProject } = requireExpoConfigPlugins();
+  const bundleIdentifier = resolveNotifyKitIosNseBundleIdentifier(config, nseOptions);
+
+  return withXcodeProject(config, modConfig => {
+    const result = patchXcodeProjectForNotifyKitNse(modConfig.modResults, {
+      targetName: nseOptions.targetName,
+      bundleIdentifier,
+      parentTargetName: modConfig.modRequest.projectName,
+    });
+
+    if (result.didChange && !result.hostTargetUuid) {
+      throw new Error(
+        '[react-native-notify-kit] Failed to link NotifyKit NSE target to the host app target.',
+      );
+    }
+
+    return modConfig;
+  });
+}
+
+function requireExpoConfigPlugins() {
+  try {
+    return require('expo/config-plugins');
+  } catch (error) {
+    try {
+      return require(require.resolve('expo/config-plugins', { paths: [process.cwd()] }));
+    } catch {
+      throw error;
+    }
+  }
+}
+
+module.exports = {
+  withNotifyKitIosNseXcodeProject,
+};