@apirtc/expo-apirtc-options-plugin 0.0.1

package/README.md

@@ -0,0 +1,42 @@
+# expo-apirtc-options-plugin
+
+Plugin to add apiRTC features in React Native application using Expo.
+This plugin simplify the integration of following features :
+- screenSharing for Android and iOS
+
+## Installation
+
+```bash
+npm install @apizee/expo-apirtc-options-plugin-test
+
+```
+
+## Usage in app.json
+
+You need to declare the plugin in app.json file :
+
+```js
+module.exports = {
+  ...
+  plugins: [
+    ['@apizee/expo-apirtc-options-plugin-test', { }]
+  ],
+};
+```
+
+### Possible options :
+
+| Parameter | Description | Default value |
+| --- | --- | --- |
+| enableMediaProjectionService | Can be used to deactivate screenSharing activation on Android | true |
+
+
+```js
+module.exports = {
+  ...
+  plugins: [
+    ['@apizee/expo-apirtc-options-plugin-test', { enableMediaProjectionService: false }]
+  ],
+};
+```
+

package/build/static/java/AppLifecycleModule.java

@@ -0,0 +1,143 @@
+package com.reactnativeapirtc;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.LifecycleEventListener;
+
+import com.oney.WebRTCModule.WebRTCModule;
+
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.Arguments;
+
+import android.util.Log;
+
+import java.util.Map;
+import java.util.HashMap;
+
+public class AppLifecycleModule extends ReactContextBaseJavaModule implements LifecycleEventListener {
+
+    private final ReactApplicationContext reactContext;
+    private String localStreamReactTag = null; // Variable to store the reactTag value
+    private String localStreamTrackId = null; // Variable to store the trackId value
+    // Variables to store the screen sharing reactTag and trackId
+    private String localScreenReactTag = null; // Variable to store the reactTag value
+    private String localScreenTrackId = null; // Variable to store the trackId value
+
+    AppLifecycleModule(ReactApplicationContext context) {
+        super(context);
+        this.reactContext = context;
+
+        // Add the listener for `lifecycleEvents`
+        reactContext.addLifecycleEventListener(this);
+    }
+
+    @Override
+    public String getName() {
+        return "AppLifecycleModule";
+    }
+
+    @Override
+    public void onHostResume() {
+        Log.d("AppLifecycleModule", "Activity onResume");
+    }
+
+    @Override
+    public void onHostPause() {
+        Log.d("AppLifecycleModule", "Activity onPause");
+    }
+
+    @Override
+    public void onHostDestroy() {
+        Log.d("AppLifecycleModule", "Activity onDestroy");
+        WritableMap params = Arguments.createMap();
+        params.putString("eventType", "onDestroy");
+
+        // Send the event to the application level
+        sendEventToApplicationLevel(reactContext, "liveCycleEvent", params);
+
+        //get acces to WebRTCModule
+        WebRTCModule mWebRTCModule = reactContext.getNativeModule(WebRTCModule.class);
+
+        if (mWebRTCModule != null && this.localStreamReactTag != null) {
+            Log.d("AppLifecycleModule", "mWebRTCModule.mediaStreamRelease called with localStreamReactTag: " + this.localStreamReactTag);
+            mWebRTCModule.mediaStreamRelease(this.localStreamReactTag);
+        } else {
+            Log.d("AppLifecycleModule", "WebRTCModule or this.localStreamReactTag is null");
+        }
+
+        if (mWebRTCModule != null && this.localScreenTrackId != null) {
+            Log.d("AppLifecycleModule", "mWebRTCModule.mediaStreamTrackRelease called with localScreenTrackId: " + this.localScreenTrackId);
+            mWebRTCModule.mediaStreamTrackRelease(this.localScreenTrackId);
+            //Using mediaStreamTrackRelease enbale to stop the screen sharing extension
+        } else {
+            Log.d("AppLifecycleModule", "WebRTCModule or this.localScreenTrackId is null");
+        }
+    }
+
+    @ReactMethod
+    public void sendInfoToAppLifecycleModule(ReadableMap params) {
+        Log.d("AppLifecycleModule", "sendInfoToAppLifecycleModule called with params: " + params);
+
+        // Handle the incoming params
+        String localStreamReactTagParam = params.getString("localStreamReactTag");
+        String localStreamTrackIdParam = params.getString("localStreamTrackId");
+        String localScreenReactTagParam = params.getString("localScreenReactTag");
+        String localScreenTrackIdParam = params.getString("localScreenTrackId");
+
+        if (localStreamReactTagParam != null) {
+            Log.d("AppLifecycleModule", "localStreamReactTag is not null: " + localStreamReactTagParam);
+            if (localStreamReactTagParam.equals("STOPPED")) {
+                this.localStreamReactTag = null; // Reset if "STOPPED"
+            } else {
+                this.localStreamReactTag = localStreamReactTagParam;
+            }
+            Log.d("AppLifecycleModule", "localStreamReactTag set to: " + this.localStreamReactTag);
+        } else {
+            Log.d("AppLifecycleModule", "localStreamReactTag is not modified");
+        }
+
+        if (localStreamTrackIdParam != null) {
+            Log.d("AppLifecycleModule", "localStreamTrackId is not null: " + localStreamTrackIdParam);
+            if (localStreamTrackIdParam.equals("STOPPED")) {
+                this.localStreamTrackId = null; // Reset if "STOPPED"
+            } else {
+                this.localStreamTrackId = localStreamTrackIdParam;
+            }
+            Log.d("AppLifecycleModule", "localStreamTrackId set to: " + this.localStreamTrackId);
+        } else {
+            Log.d("AppLifecycleModule", "localStreamTrackId is not modified");
+        }
+
+        if (localScreenReactTagParam != null) {
+            Log.d("AppLifecycleModule", "localScreenReactTag is not null: " + localScreenReactTagParam);
+            if (localScreenReactTagParam.equals("STOPPED")) {
+                this.localScreenReactTag = null; // Reset if "STOPPED"
+            } else {
+                this.localScreenReactTag = localScreenReactTagParam;
+            }
+            Log.d("AppLifecycleModule", "localScreenReactTag set to: " + this.localScreenReactTag);
+        } else {
+            Log.d("AppLifecycleModule", "localScreenReactTag is not modified");
+        }
+
+        if (localScreenTrackIdParam != null) {
+            Log.d("AppLifecycleModule", "localScreenTrackId is not null: " + localScreenTrackIdParam);
+            if (localScreenTrackIdParam.equals("STOPPED")) {
+                this.localScreenTrackId = null; // Reset if "STOPPED"
+            } else {
+                this.localScreenTrackId = localScreenTrackIdParam;
+            }
+            Log.d("AppLifecycleModule", "localScreenTrackId set to: " + this.localScreenTrackId);
+        } else {
+            Log.d("AppLifecycleModule", "localScreenTrackId is not modified");
+        }
+    }
+
+    private void sendEventToApplicationLevel(ReactContext reactContext, String eventName, WritableMap params) {
+        reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class).emit(eventName, params);
+    }
+}

package/build/static/java/AppLifecyclePackage.java

@@ -0,0 +1,26 @@
+package com.reactnativeapirtc;
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class AppLifecyclePackage implements ReactPackage {
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<NativeModule> createNativeModules(
+            ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+
+        modules.add(new AppLifecycleModule(reactContext));
+        return modules;
+    }
+}

package/build/withAndroidPlugin.d.ts

@@ -0,0 +1,6 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+type PluginProps = {
+    enableMediaProjectionService?: boolean;
+};
+declare const withAndroidPlugin: ConfigPlugin<PluginProps>;
+export default withAndroidPlugin;

package/build/withAndroidPlugin.js

@@ -0,0 +1,172 @@
+"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 });
+const config_plugins_1 = require("@expo/config-plugins");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const REQUIRED_PERMISSIONS = [
+    "android.permission.ACCESS_NETWORK_STATE",
+    "android.permission.CAMERA",
+    "android.permission.INTERNET",
+    "android.permission.MODIFY_AUDIO_SETTINGS",
+    "android.permission.RECORD_AUDIO",
+    "android.permission.SYSTEM_ALERT_WINDOW",
+    "android.permission.WAKE_LOCK",
+    "android.permission.BLUETOOTH",
+    "android.permission.FOREGROUND_SERVICE",
+    "android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION",
+    "android.permission.FOREGROUND_SERVICE_MICROPHONE",
+    "android.permission.FOREGROUND_SERVICE_CAMERA"
+];
+function getAndroidPackagePath(projectRoot) {
+    var _a, _b;
+    const manifestPath = path.join(projectRoot, 'android/app/src/main/AndroidManifest.xml');
+    let packageName;
+    if (fs.existsSync(manifestPath)) {
+        const manifestContent = fs.readFileSync(manifestPath, 'utf8');
+        const match = manifestContent.match(/package="([\w.]+)"/);
+        if (match) {
+            packageName = match[1];
+        }
+    }
+    // Fallback: lire dans app.json
+    if (!packageName) {
+        const appJsonPath = path.join(projectRoot, 'app.json');
+        if (fs.existsSync(appJsonPath)) {
+            const appJson = JSON.parse(fs.readFileSync(appJsonPath, 'utf8'));
+            packageName = (_b = (_a = appJson === null || appJson === void 0 ? void 0 : appJson.expo) === null || _a === void 0 ? void 0 : _a.android) === null || _b === void 0 ? void 0 : _b.package;
+        }
+    }
+    if (!packageName) {
+        throw new Error('Package name not found in AndroidManifest.xml or app.json');
+    }
+    return path.join(projectRoot, 'android/app/src/main/java', ...packageName.split('.'));
+}
+function copyAndPatchJavaFiles(projectRoot) {
+    const srcDir = path.join(__dirname, 'static/java');
+    const destDir = getAndroidPackagePath(projectRoot);
+    // Récupère le packageName sous forme de string (ex: com.reactnativeapirtc)
+    const packageName = destDir
+        .replace(path.join(projectRoot, 'android/app/src/main/java') + path.sep, '')
+        .split(path.sep)
+        .join('.');
+    if (!fs.existsSync(destDir)) {
+        fs.mkdirSync(destDir, { recursive: true });
+    }
+    ['AppLifecycleModule.java', 'AppLifecyclePackage.java'].forEach(file => {
+        const src = path.join(srcDir, file);
+        const dest = path.join(destDir, file);
+        if (fs.existsSync(src)) {
+            let content = fs.readFileSync(src, 'utf8');
+            // Remplace la ligne de package par la bonne valeur
+            content = content.replace(/^package\s+[\w.]+;/m, `package ${packageName};`);
+            fs.writeFileSync(dest, content, 'utf8');
+            console.log(`Copied and patched ${file} to android sources with package: ${packageName}`);
+        }
+    });
+}
+const withAndroidPermissions = (config) => {
+    return (0, config_plugins_1.withAndroidManifest)(config, (config) => {
+        const manifest = config.modResults.manifest;
+        if (!manifest['uses-permission']) {
+            manifest['uses-permission'] = [];
+        }
+        REQUIRED_PERMISSIONS.forEach((permission) => {
+            console.error('check manifest permission:', permission);
+            if (Array.isArray(manifest['uses-permission']) &&
+                !manifest['uses-permission'].some((item) => item.$ && item.$['android:name'] === permission)) {
+                manifest['uses-permission'].push({
+                    $: { 'android:name': permission }
+                });
+                console.error(`Added permission: ${permission}`);
+            }
+        });
+        return config;
+    });
+};
+const withAndroidPlugin = (config, props) => {
+    console.error('withAndroidPlugin called with props:', props);
+    let updatedConfig = (0, config_plugins_1.withMainApplication)(config, (config) => {
+        const mainApplication = config.modResults;
+        if (props.enableMediaProjectionService === false) {
+            // If the feature is disabled, we can return early
+            console.warn('Media Projection Service is disabled, skipping modifications.');
+            return config;
+        }
+        // ✅ Ajouter import après la ligne "package com.xxx"
+        if (!mainApplication.contents.includes('import android.util.Log')) {
+            mainApplication.contents = mainApplication.contents.replace(/(package\s+[\w.]+(?:\r?\n))/, `$1\nimport com.oney.WebRTCModule.WebRTCModuleOptions\n`);
+        }
+        // ✅ Ajouter le code au début de onCreate()
+        const onCreateRegex = /override fun onCreate\(\) \{\n/;
+        const customCode = [
+            '    val options: WebRTCModuleOptions = WebRTCModuleOptions.getInstance()',
+            '    options.enableMediaProjectionService = true\n'
+        ].join('\n');
+        if (!mainApplication.contents.includes('WebRTCModuleOptions.getInstance()')) {
+            mainApplication.contents = mainApplication.contents.replace(onCreateRegex, match => `${match}${customCode}`);
+        }
+        // Ajout du package AppLifecyclePackage dans la liste (compatible Kotlin)
+        // Récupère le packageName automatiquement
+        const packageName = (() => {
+            try {
+                return getAndroidPackagePath(config.modRequest.projectRoot)
+                    .replace(path.join(config.modRequest.projectRoot, 'android/app/src/main/java') + path.sep, '')
+                    .split(path.sep)
+                    .join('.');
+            }
+            catch (_a) {
+                return null;
+            }
+        })();
+        if (packageName) {
+            const importLine = `import ${packageName}.AppLifecyclePackage\n`;
+            if (!mainApplication.contents.includes(importLine.trim())) {
+                mainApplication.contents = mainApplication.contents.replace(/(package\s+[\w.]+(?:\r?\n))/, `$1${importLine}`);
+            }
+        }
+        if (!mainApplication.contents.includes('packages.add(AppLifecyclePackage())')) {
+            mainApplication.contents = mainApplication.contents.replace(/(val packages = PackageList\(this\)\.packages[\s\S]*?)(\n\s*return packages)/, (match, p1, p2) => {
+                return `${p1}\n    packages.add(AppLifecyclePackage())${p2}`;
+            });
+        }
+        // Copie les fichiers Java natifs nécessaires pour AppLifecyclePackage
+        copyAndPatchJavaFiles(config.modRequest.projectRoot);
+        return config;
+    });
+    updatedConfig = withAndroidPermissions(updatedConfig);
+    return updatedConfig;
+};
+exports.default = withAndroidPlugin;

package/build/withPlugin.d.ts

@@ -0,0 +1,6 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+type PluginProps = {
+    enableMediaProjectionService?: boolean;
+};
+export declare const withPlugin: ConfigPlugin<PluginProps>;
+export default withPlugin;

package/build/withPlugin.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withPlugin = void 0;
+const withAndroidPlugin_1 = __importDefault(require("./withAndroidPlugin"));
+const withPlugin = (config, props = { enableMediaProjectionService: true }) => {
+    return (0, withAndroidPlugin_1.default)(config, props);
+};
+exports.withPlugin = withPlugin;
+exports.default = exports.withPlugin;

package/index.js

@@ -0,0 +1,5 @@
+const { withPlugin } = require('./build/withPlugin');
+
+module.exports = function (config, props) {
+  return withPlugin(config, props);
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@apirtc/expo-apirtc-options-plugin",
+  "version": "0.0.1",
+  "description": "Plugin Expo pour ajouter les features apiRTC dans une application React Native",
+  "main": "index.js",
+  "keywords": [
+    "expo",
+    "config-plugin",
+    "react-native",
+    "webrtc",
+    "apiRTC"
+  ],
+  "author": "F.Luart",
+  "license": "MIT",
+  "dependencies": {
+    "@expo/config-plugins": "^10.1.2",
+    "@types/node": "^24.0.12",
+    "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "build": "tsc && npm run copy-static",
+    "copy-static": "mkdir -p ./build/static && cp -R ./plugin/static/* ./build/static"
+  },
+  "files": [
+    "index.js",
+    "build"
+  ],
+  "types": "./build/plugin/withWebRTCOptions.d.ts"
+}