@fishjam-cloud/react-native-client 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fishjam-cloud/react-native-client",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "A React Native client for Fishjam Cloud",
   "author": "Fishjam Cloud Team",
   "license": "Apache-2.0",
@@ -31,7 +31,7 @@
   "bugs": {
     "url": "https://github.com/fishjam-cloud/mobile-client-sdk/issues"
   },
-  "homepage": "https://github.com/fishjam-cloud/mobile-client-sdk#readme",
+  "homepage": "https://fishjam.io",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
@@ -78,12 +78,15 @@
     "testEnvironment": "jsdom"
   },
   "files": [
-    "build/",
-    "ios/*.swift",
-    "android/src",
+    "build/**",
     "android/build.gradle",
-    "plugin/build",
+    "android/src/**",
+    "ios/*.swift",
+    "ios/RNFishjamClient.podspec",
+    "plugin/build/**",
     "app.plugin.js",
-    "README.md"
+    "expo-module.config.json",
+    "README.md",
+    "!**/node_modules"
   ]
 }

package/plugin/build/types.d.ts

@@ -0,0 +1,9 @@
+export type FishjamPluginOptions = {
+    android: {
+        enableForegroundService: boolean;
+    };
+    ios: {
+        iphoneDeploymentTarget?: string;
+        enableScreensharing: boolean;
+    };
+};

package/plugin/build/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/plugin/build/withFishjam.d.ts

@@ -0,0 +1,4 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+import { FishjamPluginOptions } from './types';
+declare const withFishjam: ConfigPlugin<FishjamPluginOptions>;
+export default withFishjam;

package/plugin/build/withFishjam.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const withFishjamAndroid_1 = require("./withFishjamAndroid");
+const withFishjamIos_1 = __importDefault(require("./withFishjamIos"));
+const withFishjam = (config, options) => {
+    (0, withFishjamAndroid_1.withFishjamAndroid)(config, options);
+    (0, withFishjamIos_1.default)(config, options);
+    return config;
+};
+exports.default = withFishjam;

package/plugin/build/withFishjamAndroid.d.ts

@@ -0,0 +1,3 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+import { FishjamPluginOptions } from './types';
+export declare const withFishjamAndroid: ConfigPlugin<FishjamPluginOptions>;

package/plugin/build/withFishjamAndroid.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withFishjamAndroid = void 0;
+const config_plugins_1 = require("@expo/config-plugins");
+const Manifest_1 = require("@expo/config-plugins/build/android/Manifest");
+const withFishjamForegroundService = (config) => {
+    return (0, config_plugins_1.withAndroidManifest)(config, async (config) => {
+        const mainApplication = (0, Manifest_1.getMainApplicationOrThrow)(config.modResults);
+        mainApplication.service = mainApplication.service || [];
+        const newService = {
+            $: {
+                'android:name': 'io.fishjam.reactnative.FishjamForegroundService',
+                'android:foregroundServiceType': 'camera|microphone|mediaProjection',
+            },
+        };
+        const existingServiceIndex = mainApplication.service.findIndex((service) => service.$['android:name'] === newService.$['android:name']);
+        if (existingServiceIndex !== -1) {
+            mainApplication.service[existingServiceIndex] = newService;
+        }
+        else {
+            mainApplication.service.push(newService);
+        }
+        return config;
+    });
+};
+const withFishjamAndroid = (config, { android: { enableForegroundService } }) => {
+    if (enableForegroundService) {
+        config = withFishjamForegroundService(config);
+    }
+    return config;
+};
+exports.withFishjamAndroid = withFishjamAndroid;

package/plugin/build/withFishjamIos.d.ts

@@ -0,0 +1,9 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+import { FishjamPluginOptions } from './types';
+export declare const SBE_PODFILE_SNIPPET = "\ntarget 'FishjamScreenBroadcastExtension' do\n  pod 'FishjamCloudClient/Broadcast'\nend";
+/**
+ * Applies screen sharing plugin if enabled. In order for screensharing to work, we need to copy extension files to your iOS project.
+ * Allows for dynamically changing deploymentTarget.
+ */
+declare const withFishjamIos: ConfigPlugin<FishjamPluginOptions>;
+export default withFishjamIos;

package/plugin/build/withFishjamIos.js

@@ -0,0 +1,222 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SBE_PODFILE_SNIPPET = void 0;
+// ios-related code was mostly copied from OneSignal expo plugin: https://github.com/OneSignal/onesignal-expo-plugin/blob/main/onesignal/withOneSignalIos.ts
+const config_plugins_1 = require("@expo/config-plugins");
+const fs = __importStar(require("promise-fs"));
+const path = __importStar(require("path"));
+const SBE_TARGET_NAME = 'FishjamScreenBroadcastExtension';
+exports.SBE_PODFILE_SNIPPET = `
+target '${SBE_TARGET_NAME}' do
+  pod 'FishjamCloudClient/Broadcast'
+end`;
+const TARGETED_DEVICE_FAMILY = `"1,2"`;
+const IPHONEOS_DEPLOYMENT_TARGET = '13.4';
+const GROUP_IDENTIFIER_TEMPLATE_REGEX = /{{GROUP_IDENTIFIER}}/gm;
+const BUNDLE_IDENTIFIER_TEMPLATE_REGEX = /{{BUNDLE_IDENTIFIER}}/gm;
+/**
+ * A helper function for updating a value in a file for given regex
+ */
+async function updateFileWithRegex(iosPath, fileName, regex, value) {
+    const filePath = `${iosPath}/${SBE_TARGET_NAME}/${fileName}`;
+    let file = await fs.readFile(filePath, { encoding: 'utf-8' });
+    file = file.replace(regex, value);
+    await fs.writeFile(filePath, file);
+}
+/**
+ * Inserts a required target to Podfile.
+ * This is needed to provide the dependency of FishjamCloudClient/Broadcast to the extension.
+ */
+async function updatePodfile(iosPath) {
+    let matches;
+    try {
+        const podfile = await fs.readFile(`${iosPath}/Podfile`, {
+            encoding: 'utf-8',
+        });
+        matches = podfile.match(exports.SBE_PODFILE_SNIPPET);
+    }
+    catch (e) {
+        console.error('Error reading from Podfile: ', e);
+    }
+    if (matches) {
+        console.log(`${SBE_TARGET_NAME} target already added to Podfile. Skipping...`);
+        return;
+    }
+    try {
+        fs.appendFile(`${iosPath}/Podfile`, exports.SBE_PODFILE_SNIPPET);
+    }
+    catch (e) {
+        console.error('Error writing to Podfile: ', e);
+    }
+}
+/**
+ * Adds "App Group" permission
+ * App Group allow your app and the FishjamScreenBroadcastExtension to communicate with each other.
+ */
+const withAppGroupPermissions = (config) => {
+    const APP_GROUP_KEY = 'com.apple.security.application-groups';
+    return (0, config_plugins_1.withEntitlementsPlist)(config, (newConfig) => {
+        if (!Array.isArray(newConfig.modResults[APP_GROUP_KEY])) {
+            newConfig.modResults[APP_GROUP_KEY] = [];
+        }
+        const modResultsArray = newConfig.modResults[APP_GROUP_KEY];
+        const entitlement = `group.${newConfig?.ios?.bundleIdentifier || ''}`;
+        if (modResultsArray.indexOf(entitlement) !== -1) {
+            return newConfig;
+        }
+        modResultsArray.push(entitlement);
+        return newConfig;
+    });
+};
+/**
+ * Adds constants to Info.plist
+ * In other to dynamically retreive extension's bundleId and group name we need to store it in Info.plist.
+ */
+const withInfoPlistConstants = (config) => {
+    return (0, config_plugins_1.withInfoPlist)(config, (config) => {
+        const bundleIdentifier = config.ios?.bundleIdentifier || '';
+        config.modResults['AppGroupName'] = `group.${bundleIdentifier}`;
+        config.modResults['ScreencastExtensionBundleId'] =
+            `${bundleIdentifier}.${SBE_TARGET_NAME}`;
+        return config;
+    });
+};
+/**
+ * Updates and copies required extension files.
+ * Our extension needs to be properly setup inside the XCode project. In order to do that we need to copy the files and update the pbxproj.
+ */
+const withFishjamSBE = (config, options) => {
+    return (0, config_plugins_1.withXcodeProject)(config, async (props) => {
+        const appName = props.modRequest.projectName || '';
+        const iosPath = props.modRequest.platformProjectRoot;
+        const bundleIdentifier = props.ios?.bundleIdentifier;
+        const xcodeProject = props.modResults;
+        const pluginDir = require.resolve('@fishjam-cloud/react-native-client/package.json');
+        const extensionSourceDir = path.join(pluginDir, '../plugin/broadcastExtensionFiles/');
+        await updatePodfile(iosPath);
+        const projPath = `${iosPath}/${appName}.xcodeproj/project.pbxproj`;
+        const extFiles = [
+            'FishjamBroadcastSampleHandler.swift',
+            `${SBE_TARGET_NAME}.entitlements`,
+            `Info.plist`,
+        ];
+        await xcodeProject.parse(async function (err) {
+            if (err) {
+                console.error(`Error parsing iOS project: ${JSON.stringify(err)}`);
+                return;
+            }
+            if (xcodeProject.pbxTargetByName(`"${SBE_TARGET_NAME}"`)) {
+                console.log(`${SBE_TARGET_NAME} already exists in project. Skipping...`);
+                return;
+            }
+            try {
+                // copy extension files
+                await fs.mkdir(`${iosPath}/${SBE_TARGET_NAME}`, { recursive: true });
+                for (let i = 0; i < extFiles.length; i++) {
+                    const extFile = extFiles[i];
+                    const targetFile = `${iosPath}/${SBE_TARGET_NAME}/${extFile}`;
+                    await fs.copyFile(`${extensionSourceDir}${extFile}`, targetFile);
+                }
+            }
+            catch (e) {
+                console.error('Error copying extension files: ', e);
+            }
+            // update extension files
+            await updateFileWithRegex(iosPath, `${SBE_TARGET_NAME}.entitlements`, GROUP_IDENTIFIER_TEMPLATE_REGEX, `group.${bundleIdentifier}`);
+            await updateFileWithRegex(iosPath, 'FishjamBroadcastSampleHandler.swift', GROUP_IDENTIFIER_TEMPLATE_REGEX, `group.${bundleIdentifier}`);
+            await updateFileWithRegex(iosPath, 'FishjamBroadcastSampleHandler.swift', BUNDLE_IDENTIFIER_TEMPLATE_REGEX, bundleIdentifier || '');
+            // Create new PBXGroup for the extension
+            const extGroup = xcodeProject.addPbxGroup(extFiles, SBE_TARGET_NAME, SBE_TARGET_NAME);
+            // Add the new PBXGroup to the top level group. This makes the
+            // files / folder appear in the file explorer in Xcode.
+            const groups = xcodeProject.hash.project.objects['PBXGroup'];
+            Object.keys(groups).forEach(function (key) {
+                if (groups[key].name === undefined) {
+                    xcodeProject.addToPbxGroup(extGroup.uuid, key);
+                }
+            });
+            // WORK AROUND for codeProject.addTarget BUG
+            // Xcode projects don't contain these if there is only one target
+            // An upstream fix should be made to the code referenced in this link:
+            //   - https://github.com/apache/cordova-node-xcode/blob/8b98cabc5978359db88dc9ff2d4c015cba40f150/lib/pbxProject.js#L860
+            const projObjects = xcodeProject.hash.project.objects;
+            projObjects['PBXTargetDependency'] =
+                projObjects['PBXTargetDependency'] || {};
+            projObjects['PBXContainerItemProxy'] =
+                projObjects['PBXTargetDependency'] || {};
+            // Add the SBE target
+            // This adds PBXTargetDependency and PBXContainerItemProxy for you
+            const sbeTarget = xcodeProject.addTarget(SBE_TARGET_NAME, 'app_extension', SBE_TARGET_NAME, `${bundleIdentifier}.${SBE_TARGET_NAME}`);
+            // Add build phases to the new target
+            xcodeProject.addBuildPhase(['FishjamBroadcastSampleHandler.swift'], 'PBXSourcesBuildPhase', 'Sources', sbeTarget.uuid);
+            xcodeProject.addBuildPhase([], 'PBXResourcesBuildPhase', 'Resources', sbeTarget.uuid);
+            xcodeProject.addBuildPhase([], 'PBXFrameworksBuildPhase', 'Frameworks', sbeTarget.uuid);
+            xcodeProject.addFramework('ReplayKit.framework', {
+                target: sbeTarget.uuid,
+            });
+            // Edit the Deployment info of the new Target, only IphoneOS and Targeted Device Family
+            // However, can be more
+            const configurations = xcodeProject.pbxXCBuildConfigurationSection();
+            for (const key in configurations) {
+                if (typeof configurations[key].buildSettings !== 'undefined' &&
+                    configurations[key].buildSettings.PRODUCT_NAME ===
+                        `"${SBE_TARGET_NAME}"`) {
+                    const buildSettingsObj = configurations[key].buildSettings;
+                    buildSettingsObj.IPHONEOS_DEPLOYMENT_TARGET =
+                        options.ios.iphoneDeploymentTarget ?? IPHONEOS_DEPLOYMENT_TARGET;
+                    buildSettingsObj.TARGETED_DEVICE_FAMILY = TARGETED_DEVICE_FAMILY;
+                    buildSettingsObj.CODE_SIGN_ENTITLEMENTS = `${SBE_TARGET_NAME}/${SBE_TARGET_NAME}.entitlements`;
+                    buildSettingsObj.CODE_SIGN_STYLE = 'Automatic';
+                    buildSettingsObj.INFOPLIST_FILE = `${SBE_TARGET_NAME}/Info.plist`;
+                    buildSettingsObj.SWIFT_VERSION = '5.0';
+                    buildSettingsObj.MARKETING_VERSION = '1.0.0';
+                    buildSettingsObj.CURRENT_PROJECT_VERSION = '1';
+                    buildSettingsObj.ENABLE_BITCODE = 'NO';
+                }
+            }
+            await fs.writeFile(projPath, xcodeProject.writeSync());
+        });
+        return props;
+    });
+};
+/**
+ * Applies screen sharing plugin if enabled. In order for screensharing to work, we need to copy extension files to your iOS project.
+ * Allows for dynamically changing deploymentTarget.
+ */
+const withFishjamIos = (config, props) => {
+    if (props.ios.enableScreensharing) {
+        withAppGroupPermissions(config);
+        withInfoPlistConstants(config);
+        withFishjamSBE(config, props);
+    }
+    (0, config_plugins_1.withPodfileProperties)(config, (config) => {
+        config.modResults['ios.deploymentTarget'] =
+            props.ios.iphoneDeploymentTarget ?? IPHONEOS_DEPLOYMENT_TARGET;
+        return config;
+    });
+    return config;
+};
+exports.default = withFishjamIos;