expo-live-activity 0.1.0 → 0.2.0-alpha

package/plugin/src/lib/getWidgetFiles.ts

@@ -0,0 +1,162 @@
+import * as fs from "fs";
+import * as path from "path";
+
+export type WidgetFiles = {
+  swiftFiles: string[];
+  entitlementFiles: string[];
+  plistFiles: string[];
+  assetDirectories: string[];
+  intentFiles: string[];
+  otherFiles: string[];
+};
+
+export function getWidgetFiles(
+  // widgetsPath: string, // to zmieniamy, bo u nas to będzie "config.modRequest.projectRoot/[tu może coś jeszcze być]/node_modules/nasz-moduł/iosViews"
+  targetPath: string,
+  moduleFileName: string,
+  attributesFileName: string
+) {
+  let packagePath
+  try {
+    packagePath = path.dirname(require.resolve("expo-live-activity/package.json"));
+  } catch {
+    console.log("Building for example app")
+  }
+  const widgetsPath = path.join(packagePath ? packagePath : "..", "/ios-files");
+  console.log(`Widgets path: ${widgetsPath}`);
+  const imageAssetsPath = "./assets/live_activity";
+  const widgetFiles: WidgetFiles = {
+    swiftFiles: [],
+    entitlementFiles: [],
+    plistFiles: [],
+    assetDirectories: [],
+    intentFiles: [],
+    otherFiles: [],
+  };
+  console.log(`Getting widget files`)
+  if (!fs.existsSync(targetPath)) {
+    console.log(`Making directory at: ${targetPath}`)
+    fs.mkdirSync(targetPath, { recursive: true });
+  }
+
+  if (fs.lstatSync(widgetsPath).isDirectory()) {
+    const files = fs.readdirSync(widgetsPath);
+    console.log(`Files: ${files}`)
+
+    files.forEach((file) => {
+      const fileExtension = file.split(".").pop();
+
+      if (fileExtension === "swift") {
+        if (file !== moduleFileName) {
+          widgetFiles.swiftFiles.push(file);
+        }
+      } else if (fileExtension === "entitlements") {
+        widgetFiles.entitlementFiles.push(file);
+      } else if (fileExtension === "plist") {
+        widgetFiles.plistFiles.push(file);
+      } else if (fileExtension === "xcassets") {
+        widgetFiles.assetDirectories.push(file);
+      } else if (fileExtension === "intentdefinition") {
+        widgetFiles.intentFiles.push(file);
+      } else {
+        widgetFiles.otherFiles.push(file);
+      }
+    });
+
+  }
+
+  // Copy files
+  [
+    ...widgetFiles.swiftFiles,
+    ...widgetFiles.entitlementFiles,
+    ...widgetFiles.plistFiles,
+    ...widgetFiles.intentFiles,
+    ...widgetFiles.otherFiles,
+  ].forEach((file) => {
+    const source = path.join(widgetsPath, file);
+    copyFileSync(source, targetPath);
+  });
+
+  // Copy assets directory
+  const imagesXcassetsSource = path.join(widgetsPath, "Assets.xcassets");
+  copyFolderRecursiveSync(imagesXcassetsSource, targetPath);
+
+  // Move images to assets directory
+  console.log(`Images Path: ${imageAssetsPath}`)
+  if (fs.lstatSync(imageAssetsPath).isDirectory()) {
+    const imagesXcassetsTarget = path.join(targetPath, "Assets.xcassets");
+    console.log(`Assets Target: ${imagesXcassetsTarget}`)
+
+    const files = fs.readdirSync(imageAssetsPath);
+    console.log(`Images: ${files}`)
+    files.forEach((file) => {
+      if (path.extname(file).match(/\.(png|jpg|jpeg)$/)) {
+        const source = path.join(imageAssetsPath, file);
+        console.log(`Source: ${source}`)
+        const imageSetDir = path.join(imagesXcassetsTarget, `${path.basename(file, path.extname(file))}.imageset`);
+
+        console.log(`imageSetDir: ${source}`)
+        // Create the .imageset directory if it doesn't exist
+        if (!fs.existsSync(imageSetDir)) {
+          fs.mkdirSync(imageSetDir, { recursive: true });
+        }
+        
+        // Copy image file to the .imageset directory
+        const destPath = path.join(imageSetDir, file);
+        fs.copyFileSync(source, destPath);
+        
+        // Create Contents.json file
+        const contentsJson = {
+          images: [
+            {
+              filename : file,
+              idiom : "universal"
+            }
+          ],
+          info: {
+            author : "xcode",
+            version : 1
+          }
+        };
+        
+        fs.writeFileSync(
+          path.join(imageSetDir, 'Contents.json'),
+          JSON.stringify(contentsJson, null, 2) // beautify the JSON output
+        );
+
+        console.log(`Processed ${file} into ${imageSetDir}`);
+      }
+    })
+  }
+
+  return widgetFiles;
+}
+
+export function copyFileSync(source: string, target: string) {
+  let targetFile = target;
+
+  if (fs.existsSync(target) && fs.lstatSync(target).isDirectory()) {
+    targetFile = path.join(target, path.basename(source));
+  }
+
+  fs.writeFileSync(targetFile, fs.readFileSync(source));
+}
+
+function copyFolderRecursiveSync(source: string, target: string) {
+  const targetPath = path.join(target, path.basename(source));
+  if (!fs.existsSync(targetPath)) {
+    fs.mkdirSync(targetPath, { recursive: true });
+  }
+
+  if (fs.lstatSync(source).isDirectory()) {
+    const files = fs.readdirSync(source);
+    files.forEach((file) => {
+      const currentPath = path.join(source, file);
+      if (fs.lstatSync(currentPath).isDirectory()) {
+        copyFolderRecursiveSync(currentPath, targetPath);
+      } else {
+        copyFileSync(currentPath, targetPath);
+      }
+    });
+  }
+}

package/plugin/src/withConfig.ts

@@ -0,0 +1,62 @@
+import { ConfigPlugin } from "@expo/config-plugins";
+
+import { addApplicationGroupsEntitlement, getWidgetExtensionEntitlements } from "./lib/getWidgetExtensionEntitlements";
+
+export const withConfig: ConfigPlugin<{
+  bundleIdentifier: string;
+  targetName: string;
+  groupIdentifier?: string;
+}> = (config, { bundleIdentifier, targetName, groupIdentifier }) => {
+  let configIndex: null | number = null;
+  config.extra?.eas?.build?.experimental?.ios?.appExtensions?.forEach((ext: any, index: number) => {
+    if (ext.targetName === targetName) {
+      configIndex = index;
+    }
+  });
+
+  if (!configIndex) {
+    config.extra = {
+      ...config.extra,
+      eas: {
+        ...config.extra?.eas,
+        build: {
+          ...config.extra?.eas?.build,
+          experimental: {
+            ...config.extra?.eas?.build?.experimental,
+            ios: {
+              ...config.extra?.eas?.build?.experimental?.ios,
+              appExtensions: [
+                ...(config.extra?.eas?.build?.experimental?.ios?.appExtensions ?? []),
+                {
+                  targetName,
+                  bundleIdentifier,
+                },
+              ],
+            },
+          },
+        },
+      },
+    };
+    configIndex = 0;
+  }
+
+  if (configIndex != null && config.extra) {
+    const widgetsExtensionConfig = config.extra.eas.build.experimental.ios.appExtensions[configIndex];
+
+    widgetsExtensionConfig.entitlements = {
+      ...widgetsExtensionConfig.entitlements,
+      ...getWidgetExtensionEntitlements(config.ios, {
+        groupIdentifier,
+      }),
+    };
+
+    config.ios = {
+      ...config.ios,
+      entitlements: {
+        ...addApplicationGroupsEntitlement(config.ios?.entitlements ?? {}, groupIdentifier),
+      },
+    };
+  }
+
+  return config;
+};

package/plugin/src/withPodfile.ts

@@ -0,0 +1,72 @@
+import { mergeContents } from "@expo/config-plugins/build/utils/generateCode";
+import { ConfigPlugin, withDangerousMod } from "@expo/config-plugins";
+import * as fs from "fs";
+import * as path from "path";
+
+export const withPodfile: ConfigPlugin<{ targetName: string }> = (
+  config,
+  { targetName }
+) => {
+  return withDangerousMod(config, [
+    "ios",
+    (config) => {
+      const podFilePath = path.join(
+        config.modRequest.platformProjectRoot,
+        "Podfile"
+      );
+      let podFileContent = fs.readFileSync(podFilePath).toString();
+
+      /* podFileContent = mergeContents({
+        tag: "withWidgetExtensionPodfile1999999999",
+        src: podFileContent,
+        newSrc: `  target '${targetName}' do\n    \n  end`,
+        anchor: /post_install/,
+        offset: 0,
+        comment: "#",
+      }).contents; */
+
+      /* podFileContent = podFileContent.replace(
+        /use_expo_modules!/,
+        `use_expo_modules!(searchPaths: ["./node_modules", "../../node_modules", "../../../WidgetExtension"])`
+      ); */
+
+      podFileContent = mergeContents({
+        tag: "react-native-widget-extension-1",
+        src: podFileContent,
+        newSrc: `installer.pods_project.targets.each do |target|
+          target.build_configurations.each do |config|
+            # Sentry has build errors unless configured as 'YES' for the Sentry target: https://github.com/bndkt/react-native-widget-extension/issues/24
+            config.build_settings['APPLICATION_EXTENSION_API_ONLY'] = target.name == 'Sentry' ? 'YES' : 'No'
+          end
+        end`,
+        anchor:
+          /installer.target_installation_results.pod_target_installation_results/,
+        offset: 0,
+        comment: "#",
+      }).contents;
+
+      /* podFileContent = mergeContents({
+        tag: "react-native-widget-extension-2",
+        src: podFileContent,
+        newSrc: `pod 'WidgetExtension', :path => '../WidgetExtension/ios'`,
+        anchor: /use_react_native/,
+        offset: -1,
+        comment: "#",
+      }).contents; */
+
+      podFileContent = podFileContent
+        .concat(`\n\n# >>> Inserted by react-native-widget-extension\n`)
+        .concat(
+          `target '${targetName}' 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']
+          end`
+        )
+        .concat(`\n# >>> Inserted by react-native-widget-extension`);
+
+      fs.writeFileSync(podFilePath, podFileContent);
+
+      return config;
+    },
+  ]);
+};

package/plugin/src/withWidgetExtensionEntitlements.ts

@@ -0,0 +1,26 @@
+import plist from "@expo/plist";
+import { ConfigPlugin, withInfoPlist } from "@expo/config-plugins";
+import * as fs from "fs";
+import * as path from "path";
+
+// import { getWidgetExtensionEntitlements } from "./lib/getWidgetExtensionEntitlements";
+
+export const withWidgetExtensionEntitlements: ConfigPlugin<{
+  targetName: string;
+  targetPath: string;
+  // groupIdentifier: string;
+  appleSignin: boolean;
+}> = (config, { targetName }) => {
+  return withInfoPlist(config, (config) => {
+    const targetPath = path.join(config.modRequest.platformProjectRoot, targetName);
+    const filePath = path.join(targetPath, `${targetName}.entitlements`);
+
+    // const appClipEntitlements = getWidgetExtensionEntitlements(config.ios, {
+    // });
+
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, plist.build({}));
+    console.log("Finishing running withWidgetExtensionEntitlements")
+    return config;
+  });
+};

package/plugin/src/withXcode.ts

@@ -0,0 +1,93 @@
+import { ConfigPlugin, withXcodeProject } from "@expo/config-plugins";
+import * as path from "path";
+
+import { addXCConfigurationList } from "./xcode/addXCConfigurationList";
+import { addProductFile } from "./xcode/addProductFile";
+import { addToPbxNativeTargetSection } from "./xcode/addToPbxNativeTargetSection";
+import { addToPbxProjectSection } from "./xcode/addToPbxProjectSection";
+import { addTargetDependency } from "./xcode/addTargetDependency";
+import { addPbxGroup } from "./xcode/addPbxGroup";
+import { addBuildPhases } from "./xcode/addBuildPhases";
+import { getWidgetFiles } from "./lib/getWidgetFiles";
+
+export const withXcode: ConfigPlugin<{
+  targetName: string;
+  bundleIdentifier: string;
+  deploymentTarget: string;
+  // widgetsFolder: string;
+  moduleFileName: string;
+  attributesFileName: string;
+}> = (
+  config,
+  {
+    targetName,
+    bundleIdentifier,
+    deploymentTarget,
+    // widgetsFolder,
+    moduleFileName,
+    attributesFileName,
+  }
+) => {
+  return withXcodeProject(config, (config) => {
+    console.log("Running withXcode")
+    const xcodeProject = config.modResults;
+    // const widgetsPath = path.join(config.modRequest.projectRoot, widgetsFolder);
+
+    const targetUuid = xcodeProject.generateUuid();
+    const groupName = "Embed Foundation Extensions";
+    const { platformProjectRoot } = config.modRequest;
+    const marketingVersion = config.version;
+
+    const targetPath = path.join(platformProjectRoot, targetName);
+
+    const widgetFiles = getWidgetFiles(
+      // widgetsPath,
+      targetPath,
+      moduleFileName,
+      attributesFileName
+    );
+
+    console.log("Finished running withFiles")
+    const xCConfigurationList = addXCConfigurationList(xcodeProject, {
+      targetName,
+      currentProjectVersion: config.ios!.buildNumber || "1",
+      bundleIdentifier,
+      deploymentTarget,
+      marketingVersion,
+    });
+    console.log("Finished running addXCConfigurationList")
+
+    const productFile = addProductFile(xcodeProject, {
+      targetName,
+      groupName,
+    });
+    console.log("Finished running addProductFile")
+
+    const target = addToPbxNativeTargetSection(xcodeProject, {
+      targetName,
+      targetUuid,
+      productFile,
+      xCConfigurationList,
+    });
+    console.log("Finished running addToPbxNativeTargetSection")
+
+    addToPbxProjectSection(xcodeProject, target);
+
+    addTargetDependency(xcodeProject, target);
+
+    addBuildPhases(xcodeProject, {
+      targetUuid,
+      groupName,
+      productFile,
+      widgetFiles,
+    });
+
+    addPbxGroup(xcodeProject, {
+      targetName,
+      widgetFiles,
+    });
+
+    console.log("Finished running withXcode")
+    return config;
+  });
+};

package/plugin/src/xcode/addBuildPhases.ts

@@ -0,0 +1,83 @@
+import { XcodeProject } from "@expo/config-plugins";
+import * as util from "util";
+
+import { WidgetFiles } from "../lib/getWidgetFiles";
+
+export function addBuildPhases(
+  xcodeProject: XcodeProject,
+  {
+    targetUuid,
+    groupName,
+    productFile,
+    widgetFiles,
+  }: {
+    targetUuid: string;
+    groupName: string;
+    productFile: {
+      uuid: string;
+      target: string;
+      basename: string;
+      group: string;
+    };
+    widgetFiles: WidgetFiles;
+  }
+) {
+  const buildPath = `""`;
+  const folderType = "app_extension";
+
+  const {
+    swiftFiles,
+    intentFiles,
+    assetDirectories,
+    entitlementFiles,
+    plistFiles,
+  } = widgetFiles;
+
+  // Sources build phase
+  xcodeProject.addBuildPhase(
+    [...swiftFiles, ...intentFiles],
+    "PBXSourcesBuildPhase",
+    groupName,
+    targetUuid,
+    folderType,
+    buildPath
+  );
+
+  // Copy files build phase
+  xcodeProject.addBuildPhase(
+    [],
+    "PBXCopyFilesBuildPhase",
+    groupName,
+    xcodeProject.getFirstTarget().uuid,
+    folderType,
+    buildPath
+  );
+
+  xcodeProject
+    .buildPhaseObject("PBXCopyFilesBuildPhase", groupName, productFile.target)
+    .files.push({
+      value: productFile.uuid,
+      comment: util.format("%s in %s", productFile.basename, productFile.group), // longComment(file);
+    });
+  xcodeProject.addToPbxBuildFileSection(productFile);
+
+  // Frameworks build phase
+  xcodeProject.addBuildPhase(
+    [],
+    "PBXFrameworksBuildPhase",
+    groupName,
+    targetUuid,
+    folderType,
+    buildPath
+  );
+
+  // Resources build phase
+  xcodeProject.addBuildPhase(
+    [...assetDirectories],
+    "PBXResourcesBuildPhase",
+    groupName,
+    targetUuid,
+    folderType,
+    buildPath
+  );
+}

package/plugin/src/xcode/addPbxGroup.ts

@@ -0,0 +1,48 @@
+import { XcodeProject } from "@expo/config-plugins";
+
+import { WidgetFiles } from "../lib/getWidgetFiles";
+
+export function addPbxGroup(
+  xcodeProject: XcodeProject,
+  {
+    targetName,
+    widgetFiles,
+  }: {
+    targetName: string;
+    widgetFiles: WidgetFiles;
+  }
+) {
+  const {
+    swiftFiles,
+    intentFiles,
+    otherFiles,
+    assetDirectories,
+    entitlementFiles,
+    plistFiles,
+  } = widgetFiles;
+
+  // Add PBX group
+  const { uuid: pbxGroupUuid } = xcodeProject.addPbxGroup(
+    [
+      ...swiftFiles,
+      ...intentFiles,
+      ...otherFiles,
+      ...entitlementFiles,
+      ...plistFiles,
+      ...assetDirectories,
+      `${targetName}.entitlements`,
+    ],
+    targetName,
+    targetName
+  );
+
+  // Add PBXGroup to top level group
+  const groups = xcodeProject.hash.project.objects["PBXGroup"];
+  if (pbxGroupUuid) {
+    Object.keys(groups).forEach(function (key) {
+      if (groups[key].name === undefined && groups[key].path === undefined) {
+        xcodeProject.addToPbxGroup(pbxGroupUuid, key);
+      }
+    });
+  }
+}

package/plugin/src/xcode/addProductFile.ts

@@ -0,0 +1,25 @@
+import { XcodeProject } from "@expo/config-plugins";
+
+export function addProductFile(
+  xcodeProject: XcodeProject,
+  { targetName, groupName }: { targetName: string; groupName: string }
+) {
+  const options = {
+    basename: `${targetName}.appex`,
+    // fileRef: xcodeProject.generateUuid(),
+    // uuid: xcodeProject.generateUuid(),
+    group: groupName,
+    explicitFileType: "wrapper.app-extension",
+    /* fileEncoding: 4, */
+    settings: {
+      ATTRIBUTES: ["RemoveHeadersOnCopy"],
+    },
+    includeInIndex: 0,
+    path: `${targetName}.appex`,
+    sourceTree: "BUILT_PRODUCTS_DIR",
+  };
+
+  const productFile = xcodeProject.addProductFile(targetName, options);
+
+  return productFile;
+}

package/plugin/src/xcode/addTargetDependency.ts

@@ -0,0 +1,17 @@
+import { XcodeProject } from "@expo/config-plugins";
+
+export function addTargetDependency(
+  xcodeProject: XcodeProject,
+  target: { uuid: string }
+) {
+  if (!xcodeProject.hash.project.objects["PBXTargetDependency"]) {
+    xcodeProject.hash.project.objects["PBXTargetDependency"] = {};
+  }
+  if (!xcodeProject.hash.project.objects["PBXContainerItemProxy"]) {
+    xcodeProject.hash.project.objects["PBXContainerItemProxy"] = {};
+  }
+
+  xcodeProject.addTargetDependency(xcodeProject.getFirstTarget().uuid, [
+    target.uuid,
+  ]);
+}

package/plugin/src/xcode/addToPbxNativeTargetSection.ts

@@ -0,0 +1,46 @@
+import { XcodeProject } from "@expo/config-plugins";
+
+export function addToPbxNativeTargetSection(
+  xcodeProject: XcodeProject,
+  {
+    targetName,
+    targetUuid,
+    productFile,
+    xCConfigurationList,
+  }: {
+    targetName: string;
+    targetUuid: string;
+    productFile: { fileRef: string };
+    xCConfigurationList: { uuid: string };
+  }
+) {
+  const target = {
+    uuid: targetUuid,
+    pbxNativeTarget: {
+      isa: "PBXNativeTarget",
+      name: targetName,
+      productName: targetName,
+      productReference: productFile.fileRef,
+      productType: `"com.apple.product-type.app-extension"`,
+      buildConfigurationList: xCConfigurationList.uuid,
+      buildPhases: [],
+      buildRules: [],
+      dependencies: [],
+    },
+  };
+
+  xcodeProject.addToPbxNativeTargetSection(target);
+
+  const frameworksGroup = xcodeProject.findPBXGroupKey({ name: "Frameworks" });
+  const file1 = xcodeProject.addFile("WidgetKit.framework", frameworksGroup);
+  const file2 = xcodeProject.addFile("SwiftUI.framework", frameworksGroup);
+  const frameworksBuildPhaseObj = xcodeProject.pbxFrameworksBuildPhaseObj(
+    target.uuid
+  );
+  /* console.log(
+    { file1, file2, frameworksBuildPhaseObj },
+    frameworksBuildPhaseObj.files
+  ); */
+
+  return target;
+}

package/plugin/src/xcode/addToPbxProjectSection.ts

@@ -0,0 +1,23 @@
+import { XcodeProject } from "@expo/config-plugins";
+
+export function addToPbxProjectSection(
+  xcodeProject: XcodeProject,
+  target: { uuid: string }
+) {
+  xcodeProject.addToPbxProjectSection(target);
+
+  // Add target attributes to project section
+  if (
+    !xcodeProject.pbxProjectSection()[xcodeProject.getFirstProject().uuid]
+      .attributes.TargetAttributes
+  ) {
+    xcodeProject.pbxProjectSection()[
+      xcodeProject.getFirstProject().uuid
+    ].attributes.TargetAttributes = {};
+  }
+  xcodeProject.pbxProjectSection()[
+    xcodeProject.getFirstProject().uuid
+  ].attributes.TargetAttributes[target.uuid] = {
+    LastSwiftMigration: 1250,
+  };
+}