expo-turbo-screen-recorder 0.3.0

package/.eslintrc.js

@@ -0,0 +1,2 @@
+// @generated by expo-module-scripts
+module.exports = require('expo-module-scripts/eslintrc.base.js');

package/.prettierrc

@@ -0,0 +1,8 @@
+{
+  "printWidth": 100,
+  "tabWidth": 2,
+  "singleQuote": true,
+  "bracketSameLine": true,
+  "trailingComma": "es5",
+  "jsxSingleQuote": false,
+}

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-present 650 Industries, Inc. (aka Expo)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,35 @@
+# expo-screen-recorder
+
+Expo Module For High Quality Screen Recorder
+
+# API documentation
+
+- [Documentation for the latest stable release](https://docs.expo.dev/versions/latest/sdk/screen-recorder/)
+- [Documentation for the main branch](https://docs.expo.dev/versions/unversioned/sdk/screen-recorder/)
+
+# Installation in managed Expo projects
+
+For [managed](https://docs.expo.dev/archive/managed-vs-bare/) Expo projects, please follow the installation instructions in the [API documentation for the latest stable release](#api-documentation). If you follow the link and there is no documentation available then this library is not yet usable within managed projects — it is likely to be included in an upcoming Expo SDK release.
+
+# Installation in bare React Native projects
+
+For bare React Native projects, you must ensure that you have [installed and configured the `expo` package](https://docs.expo.dev/bare/installing-expo-modules/) before continuing.
+
+### Add the package to your npm dependencies
+
+```
+npm install expo-screen-recorder
+```
+
+### Configure for Android
+
+
+
+
+### Configure for iOS
+
+Run `npx pod-install` after installing the npm package.
+
+# Contributing
+
+Contributions are very welcome! Please refer to guidelines described in the [contributing guide]( https://github.com/expo/expo#contributing).

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -0,0 +1,2 @@
+#Mon Jun 22 15:14:21 ICT 2026
+gradle.version=8.9

package/android/build.gradle

@@ -0,0 +1,50 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+
+group = 'expo.modules.screenrecorder'
+version = '0.3.0'
+
+def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+apply from: expoModulesCorePlugin
+applyKotlinExpoModulesCorePlugin()
+useCoreDependencies()
+useExpoPublishing()
+
+
+android {
+  namespace "expo.modules.screenrecorder"
+  defaultConfig {
+    versionCode 1
+    versionName "0.2.0"
+  }
+  lintOptions {
+    abortOnError false
+  }
+}
+
+
+dependencies {
+    // 2. Kotlin Standard Library (SDK 54 uses Kotlin 1.9+)
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
+
+    // 3. Android KTX for cleaner Kotlin code
+    implementation "androidx.core:core-ktx:1.12.0"
+
+    implementation "androidx.appcompat:appcompat:1.6.1"
+
+    // 4. Coroutines for background processing (Critical for VideoEncoder)
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-play-services:1.10.2"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.2"
+
+
+    // 5. EXIF support for image rotation handling
+    implementation "androidx.exifinterface:exifinterface:1.3.6"
+    
+    // 6. Lifecycle KTX (Useful if you want to scope encoding to the app lifecycle)
+    implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.7.0" 
+     
+    implementation("androidx.exifinterface:exifinterface:1.4.2")
+}
+

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,16 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  package="expo.modules.screenrecorder">
+
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION" />
+  <uses-permission android:name="android.permission.RECORD_AUDIO" />
+  <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+
+  <application>
+    <service
+      android:name=".ScreenCaptureService"
+      android:enabled="true"
+      android:exported="false"
+      android:foregroundServiceType="mediaProjection" />
+  </application>
+</manifest>

package/android/src/main/java/expo/modules/screenrecorder/ExpoScreenRecorderModule.kt

@@ -0,0 +1,198 @@
+package expo.modules.screenrecorder
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import android.media.projection.MediaProjectionManager
+import android.os.Bundle
+import android.util.DisplayMetrics
+import android.view.WindowManager
+import androidx.activity.result.contract.ActivityResultContract
+import expo.modules.kotlin.activityresult.AppContextActivityResultCaller
+import expo.modules.kotlin.activityresult.ActivityResultContractSenderAndroidX
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.kotlin.Promise
+import java.io.File
+import java.util.UUID
+
+// ── Contract ──────────────────────────────────────────────────────────────────
+// Wraps MediaProjectionManager.createScreenCaptureIntent() in the AndroidX
+// Activity Result API that Expo SDK 54 modules are expected to use.
+class ScreenCaptureContract : ActivityResultContract<Unit, Pair<Int, Intent?>>() {
+
+    override fun createIntent(context: Context, input: Unit): Intent {
+        val mgr = context.getSystemService(Context.MEDIA_PROJECTION_SERVICE)
+                as MediaProjectionManager
+        return mgr.createScreenCaptureIntent()
+    }
+
+    override fun parseResult(resultCode: Int, intent: Intent?): Pair<Int, Intent?> =
+        resultCode to intent
+}
+
+// ── Module ────────────────────────────────────────────────────────────────────
+class ExpoScreenRecorderModule : Module() {
+
+    private var pendingPromise: Promise? = null
+    private var currentOutputFile: File? = null
+    private var startTime: Long = 0L
+    private var includeAudioStream: Boolean = false
+    private var qualitySetting: String = "high"
+
+    // Launcher is initialised once inside OnCreate and reused for every recording
+    // request. It is torn down automatically when the module is destroyed because
+    // ActivityResultContractSenderAndroidX is scoped to the module lifecycle.
+    private lateinit var captureLauncher: ActivityResultContractSenderAndroidX<Unit, Pair<Int, Intent?>>
+
+    override fun definition() = ModuleDefinition {
+        Name("ExpoScreenRecorder")
+
+        // ── Lifecycle ─────────────────────────────────────────────────────────
+
+        OnCreate {
+            // Register the contract once. The returned sender is our handle for
+            // launching the system permission dialog on every startRecordingAsync call.
+            captureLauncher = appContext
+                .registerForActivityResult(ScreenCaptureContract()) { (resultCode, data) ->
+                    handleCaptureResult(resultCode, data)
+                }
+        }
+
+        OnDestroy {
+            // Unregister the launcher so no stale callbacks fire after the
+            // module is torn down (e.g. fast-refresh, app backgrounding).
+            captureLauncher.unregister()
+
+            // If the module is destroyed mid-recording, reject the pending
+            // promise rather than leaving the caller hanging forever.
+            pendingPromise?.reject(
+                "ERR_MODULE_DESTROYED",
+                "Screen recorder module was destroyed before the operation completed.",
+                null
+            )
+            pendingPromise = null
+        }
+
+        // ── API ───────────────────────────────────────────────────────────────
+
+        AsyncFunction("isAvailableAsync") {
+            return@AsyncFunction true
+        }
+
+        AsyncFunction("startRecordingAsync") { options: RecordingOptions, promise: Promise ->
+            if (pendingPromise != null) {
+                promise.reject(
+                    "ERR_ALREADY_RECORDING",
+                    "A recording sequence is already initialised.",
+                    null
+                )
+                return@AsyncFunction
+            }
+
+            val cacheDir = appContext.reactContext?.cacheDir
+            if (cacheDir == null) {
+                promise.reject("ERR_NO_CONTEXT", "Cache directory is unavailable.", null)
+                return@AsyncFunction
+            }
+
+            pendingPromise       = promise
+            includeAudioStream   = options.includeAudio ?: false
+            qualitySetting       = options.quality ?: "high"
+            currentOutputFile    = File(cacheDir, "REC_${UUID.randomUUID()}.mp4")
+
+            // Launch the system screen-capture permission dialog.
+            // The result lands in handleCaptureResult() via the contract callback.
+            captureLauncher.launch(
+                input         = Unit,
+                onFailure     = { ex ->
+                    pendingPromise?.reject("ERR_LAUNCH_FAILED", ex.message, ex)
+                    pendingPromise = null
+                }
+            )
+        }
+
+        AsyncFunction("stopRecordingAsync") { promise: Promise ->
+            val context = appContext.reactContext ?: run {
+                promise.reject(
+                    "ERR_NO_CONTEXT",
+                    "Application execution environment dropped.",
+                    null
+                )
+                return@AsyncFunction
+            }
+
+            context.stopService(Intent(context, ScreenCaptureService::class.java))
+
+            val file = currentOutputFile
+            if (file == null || !file.exists()) {
+                promise.reject("ERR_NO_FILE", "Output file missing or recording failed.", null)
+                return@AsyncFunction
+            }
+
+            val durationSec = (System.currentTimeMillis() - startTime) / 1000.0
+            promise.resolve(
+                mapOf(
+                    "uri"      to "file://${file.absolutePath}",
+                    "duration" to durationSec
+                )
+            )
+        }
+    }
+
+    // ── Private helpers ───────────────────────────────────────────────────────
+
+    private fun handleCaptureResult(resultCode: Int, data: Intent?) {
+        val promise = pendingPromise
+
+        if (resultCode != Activity.RESULT_OK || data == null) {
+            promise?.reject(
+                "ERR_PERMISSION_DENIED",
+                "User declined screen recording system permissions.",
+                null
+            )
+            pendingPromise = null
+            return
+        }
+
+        val context = appContext.reactContext ?: run {
+            promise?.reject("ERR_NO_CONTEXT", "React context unavailable.", null)
+            pendingPromise = null
+            return
+        }
+
+        val activity = appContext.currentActivity ?: run {
+            promise?.reject("ERR_NO_ACTIVITY", "Current activity context is missing.", null)
+            pendingPromise = null
+            return
+        }
+
+        // Resolve screen dimensions for the capture service
+        val metrics = DisplayMetrics()
+        @Suppress("DEPRECATION")
+        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.R) {
+            activity.display?.getRealMetrics(metrics)
+        } else {
+            (activity.getSystemService(Context.WINDOW_SERVICE) as WindowManager)
+                .defaultDisplay.getRealMetrics(metrics)
+        }
+
+        val serviceIntent = Intent(context, ScreenCaptureService::class.java).apply {
+            putExtra("RESULT_CODE",   resultCode)
+            putExtra("RESULT_DATA",   data)
+            putExtra("OUTPUT_PATH",   currentOutputFile?.absolutePath)
+            putExtra("WIDTH",         metrics.widthPixels)
+            putExtra("HEIGHT",        metrics.heightPixels)
+            putExtra("DPI",           metrics.densityDpi)
+            putExtra("INCLUDE_AUDIO", includeAudioStream)
+            putExtra("QUALITY",       qualitySetting)
+        }
+
+        startTime = System.currentTimeMillis()
+        context.startForegroundService(serviceIntent)
+
+        // Resolve startRecordingAsync — the caller now awaits stopRecordingAsync.
+        promise?.resolve(null)
+        pendingPromise = null
+    }
+}

package/android/src/main/java/expo/modules/screenrecorder/RecordingOptions.kt

@@ -0,0 +1,15 @@
+package expo.modules.screenrecorder
+
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+
+class RecordingOptions : Record {
+  @Field
+  val durationLimit: Double? = null
+
+  @Field
+  val quality: String? = "high"
+
+  @Field
+  val includeAudio: Boolean? = false
+}

package/android/src/main/java/expo/modules/screenrecorder/ScreenCaptureService.kt

@@ -0,0 +1,160 @@
+package expo.modules.screenrecorder
+
+import android.app.*
+import android.content.Context
+import android.content.Intent
+import android.hardware.display.DisplayManager
+import android.hardware.display.VirtualDisplay
+import android.media.MediaRecorder
+import android.media.projection.MediaProjection
+import android.media.projection.MediaProjectionManager
+import android.os.Build
+import android.os.IBinder
+import androidx.core.app.NotificationCompat
+
+import java.io.File
+
+class ScreenCaptureService : Service() {
+
+    private var mediaProjection: MediaProjection? = null
+    private var virtualDisplay: VirtualDisplay? = null
+    private var mediaRecorder: MediaRecorder? = null
+    private var isRecording = false
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        val resultCode = intent?.getIntExtra("RESULT_CODE", Activity.RESULT_CANCELED)
+            ?: Activity.RESULT_CANCELED
+        val resultData = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            intent?.getParcelableExtra("RESULT_DATA", Intent::class.java)
+        } else {
+            @Suppress("DEPRECATION")
+            intent?.getParcelableExtra("RESULT_DATA")
+        }
+        val outputPath  = intent?.getStringExtra("OUTPUT_PATH") ?: ""
+        val width       = intent?.getIntExtra("WIDTH", 720)     ?: 720
+        val height      = intent?.getIntExtra("HEIGHT", 1280)   ?: 1280
+        val dpi         = intent?.getIntExtra("DPI", 1)         ?: 1
+        val includeAudio = intent?.getBooleanExtra("INCLUDE_AUDIO", false) ?: false
+        val quality     = intent?.getStringExtra("QUALITY")     ?: "high"
+
+        startForegroundNotification()
+
+        if (resultData == null) {
+            stopSelf()
+            return START_NOT_STICKY
+        }
+
+        val mpManager = getSystemService(Context.MEDIA_PROJECTION_SERVICE) as MediaProjectionManager
+        mediaProjection = mpManager.getMediaProjection(resultCode, resultData)
+
+        setupMediaRecorder(outputPath, width, height, includeAudio, quality)
+
+        virtualDisplay = mediaProjection?.createVirtualDisplay(
+            "ExpoScreenCapture",
+            width,
+            height,
+            dpi,
+            DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR,
+            mediaRecorder?.surface,
+            null,
+            null
+        )
+
+        try {
+            mediaRecorder?.start()
+            isRecording = true
+        } catch (e: Exception) {
+            e.printStackTrace()
+            stopSelf()
+        }
+
+        return START_NOT_STICKY
+    }
+
+    private fun setupMediaRecorder(
+        path: String,
+        width: Int,
+        height: Int,
+        includeAudio: Boolean,
+        quality: String
+    ) {
+        mediaRecorder = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            MediaRecorder(this)
+        } else {
+            @Suppress("DEPRECATION")
+            MediaRecorder()
+        }.apply {
+            if (includeAudio) {
+                setAudioSource(MediaRecorder.AudioSource.MIC)
+            }
+            setVideoSource(MediaRecorder.VideoSource.SURFACE)
+            setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)
+            setOutputFile(File(path).absolutePath)
+            setVideoEncoder(MediaRecorder.VideoEncoder.H264)
+            if (includeAudio) {
+                setAudioEncoder(MediaRecorder.AudioEncoder.AAC)
+            }
+            setVideoSize(width, height)
+            setVideoEncodingBitRate(
+                when (quality) {
+                    "low"    -> 2 * 1024 * 1024
+                    "medium" -> 4 * 1024 * 1024
+                    else     -> 8 * 1024 * 1024
+                }
+            )
+            setVideoFrameRate(30)
+            prepare()
+        }
+    }
+
+    private fun startForegroundNotification() {
+        val channelId = "screen_record_channel"
+        val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                channelId,
+                "Screen Recording",
+                NotificationManager.IMPORTANCE_LOW
+            )
+            notificationManager.createNotificationChannel(channel)
+        }
+
+        val notification = NotificationCompat.Builder(this, channelId)
+            .setContentTitle("Screen Recording Active")
+            .setContentText("Capturing screen...")
+            .setSmallIcon(android.R.drawable.presence_video_online)
+            .setOngoing(true)
+            .build()
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            startForeground(
+                101,
+                notification,
+                android.content.pm.ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION
+            )
+        } else {
+            startForeground(101, notification)
+        }
+    }
+
+    override fun onDestroy() {
+        if (isRecording) {
+            try { mediaRecorder?.stop() } catch (_: Exception) {}
+            isRecording = false
+        }
+
+        mediaRecorder?.release()
+        mediaRecorder = null
+
+        virtualDisplay?.release()   // release display before stopping projection
+        virtualDisplay = null
+
+        mediaProjection?.stop()
+        mediaProjection = null
+
+        super.onDestroy()
+    }
+}

package/build/ExpoScreenRecorder.types.js

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

package/build/ExpoScreenRecorderModule.js

@@ -0,0 +1,11 @@
+"use strict";
+// import { NativeModule, requireNativeModule } from 'expo';
+Object.defineProperty(exports, "__esModule", { value: true });
+// import { ExpoScreenRecorderModuleEvents } from './ExpoScreenRecorder.types';
+// declare class ExpoScreenRecorderModule extends NativeModule<ExpoScreenRecorderModuleEvents> {
+//   hello(): string;
+//   setValueAsync(value: string): Promise<void>;
+// }
+// export default requireNativeModule<ExpoScreenRecorderModule>('ExpoScreenRecorder');
+var expo_1 = require("expo");
+exports.default = (0, expo_1.requireNativeModule)('ExpoScreenRecorder');

package/build/ExpoScreenRecorderModule.web.js

@@ -0,0 +1,73 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var expo_1 = require("expo");
+var ExpoScreenRecorderModule = /** @class */ (function (_super) {
+    __extends(ExpoScreenRecorderModule, _super);
+    function ExpoScreenRecorderModule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ExpoScreenRecorderModule.prototype.hello = function () {
+        return 'Hello world! 👋';
+    };
+    ExpoScreenRecorderModule.prototype.setValueAsync = function (value) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.emit('onChange', { value: value });
+                return [2 /*return*/];
+            });
+        });
+    };
+    return ExpoScreenRecorderModule;
+}(expo_1.NativeModule));
+exports.default = (0, expo_1.registerWebModule)(ExpoScreenRecorderModule, 'ExpoScreenRecorderModule');

package/build/index.js

@@ -0,0 +1,77 @@
+"use strict";
+// Reexport the native module. On web, it will be resolved to ExpoScreenRecorderModule.web.ts
+// and on native platforms to ExpoScreenRecorderModule.ts
+// export { default } from './ExpoScreenRecorderModule';
+// export * from './ExpoScreenRecorder.types';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAvailableAsync = isAvailableAsync;
+exports.startRecordingAsync = startRecordingAsync;
+exports.stopRecordingAsync = stopRecordingAsync;
+var ExpoScreenRecorderModule_1 = require("./ExpoScreenRecorderModule");
+function isAvailableAsync() {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, ExpoScreenRecorderModule_1.default.isAvailableAsync()];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+}
+function startRecordingAsync() {
+    return __awaiter(this, arguments, void 0, function (options) {
+        if (options === void 0) { options = {}; }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, ExpoScreenRecorderModule_1.default.startRecordingAsync(options)];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+}
+function stopRecordingAsync() {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, ExpoScreenRecorderModule_1.default.stopRecordingAsync()];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+}

package/eslint.config.cjs

@@ -0,0 +1,5 @@
+const { defineConfig } = require('eslint/config');
+const universe = require('eslint-config-universe/flat/native');
+const universeWeb = require('eslint-config-universe/flat/web');
+
+module.exports = defineConfig([{ ignores: ['build'] }, ...universe, ...universeWeb]);

package/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["apple", "android", "web"],
+  "apple": {
+    "modules": ["ExpoScreenRecorderModule"]
+  },
+  "android": {
+    "modules": ["expo.modules.screenrecorder.ExpoScreenRecorderModule"]
+  }
+}

package/ios/ExpoScreenRecorder.podspec

@@ -0,0 +1,23 @@
+Pod::Spec.new do |s|
+  s.name           = 'ExpoScreenRecorder'
+  s.version        = '1.0.0'
+  s.summary        = 'High performance Expo module Screen Recorder'
+  s.description    = 'Screen Recorder for Expo'
+  s.author         = ''
+  s.homepage       = 'https://docs.expo.dev/modules/'
+  s.platforms      = {
+    :ios => '16.4',
+    :tvos => '16.4'
+  }
+  s.source         = { git: '' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+  }
+
+  s.source_files = "**/*.{h,m,mm,swift,hpp,cpp}"
+end

package/ios/ExpoScreenRecorderModule.swift

@@ -0,0 +1,147 @@
+import ExpoModulesCore
+import ReplayKit
+
+public class ExpoScreenRecorderModule: Module {
+    private let recorder = RPScreenRecorder.shared()
+    private var startTime: Date?
+    private var durationTimer: Timer?
+    private var pendingPromise: Promise?
+    private var currentOutputURL: URL?
+
+    deinit {
+        durationTimer?.invalidate()
+        durationTimer = nil
+        pendingPromise?.reject("ERR_MODULE_DESTROYED", "Screen recorder module was deallocated before the operation completed.")
+        pendingPromise = nil
+    }
+
+    public func definition() -> ModuleDefinition {
+        Name("ExpoScreenRecorder")
+
+        AsyncFunction("isAvailableAsync") { () -> Bool in
+            return self.recorder.isAvailable
+        }
+
+        AsyncFunction("startRecordingAsync") { (options: RecordingOptions, promise: Promise) in
+            guard self.recorder.isAvailable else {
+                promise.reject("ERR_NOT_AVAILABLE", "Screen recorder is not available on this device.")
+                return
+            }
+
+            guard !self.recorder.isRecording else {
+                promise.reject("ERR_ALREADY_RECORDING", "A recording is already in progress.")
+                return
+            }
+
+            self.recorder.isMicrophoneEnabled = options.includeAudio ?? false
+
+            let cacheDirectory = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first!
+            let uniqueFilename = "REC_\(UUID().uuidString).mp4"
+            self.currentOutputURL = cacheDirectory.appendingPathComponent(uniqueFilename)
+            self.pendingPromise = promise
+
+            self.recorder.startRecording { [weak self] error in
+                guard let self = self else { return }
+
+                if let error = error {
+                    self.pendingPromise?.reject("ERR_START_FAILED", error.localizedDescription)
+                    self.pendingPromise = nil
+                    return
+                }
+
+                self.startTime = Date()
+                self.pendingPromise?.resolve(nil)
+                self.pendingPromise = nil
+
+                if let limit = options.durationLimit, limit > 0 {
+                    DispatchQueue.main.async {
+                        self.durationTimer = Timer.scheduledTimer(
+                            withTimeInterval: limit,
+                            repeats: false
+                        ) { [weak self] _ in
+                            self?.stopRecordingInternal()
+                        }
+                    }
+                }
+            }
+        }
+
+        AsyncFunction("stopRecordingAsync") { (promise: Promise) in
+            self.stopRecordingWithPromise(promise: promise)
+        }
+    }
+
+    private func stopRecordingWithPromise(promise: Promise) {
+        durationTimer?.invalidate()
+        durationTimer = nil
+
+        guard recorder.isRecording else {
+            promise.reject("ERR_NOT_RECORDING", "No active recording to stop.")
+            return
+        }
+
+        guard let outputURL = currentOutputURL else {
+            promise.reject("ERR_NO_FILE", "Output file URL was not set.")
+            return
+        }
+
+        if #available(iOS 17.0, *) {
+            // stopRecording(withOutput:) is deprecated in iOS 17.
+            // Full migration to startCapture(handler:) for buffer-level control
+            // is recommended for a future release. For now, suppress the warning.
+        }
+
+        #if swift(>=5.9)
+        // Suppress deprecation for the withOutput variant — still functional through iOS 17+
+        // and is the only single-call file-output API ReplayKit exposes publicly.
+        #endif
+
+        self.recorder.stopRecording(withOutput: outputURL) { [weak self] error in
+            guard let self = self else { return }
+
+            if let error = error {
+                promise.reject("ERR_STOP_FAILED", error.localizedDescription)
+                self.cleanup()
+                return
+            }
+
+            let durationSec = Date().timeIntervalSince(self.startTime ?? Date())
+
+            // Use "file://" prefix to match Android's uri format consistently
+            let uri = "file://\(outputURL.path)"
+
+            promise.resolve([
+                "uri": uri,
+                "duration": durationSec
+            ] as [String: Any])
+
+            self.cleanup()
+        }
+    }
+
+    private func stopRecordingInternal() {
+        durationTimer?.invalidate()
+        durationTimer = nil
+
+        guard let outputURL = currentOutputURL, recorder.isRecording else { return }
+
+        recorder.stopRecording(withOutput: outputURL) { [weak self] _ in
+            self?.cleanup()
+        }
+    }
+
+    private func cleanup() {
+        durationTimer?.invalidate()
+        durationTimer = nil
+        startTime = nil
+        currentOutputURL = nil
+    }
+}
+
+struct RecordingOptions: Record {
+    @Field var durationLimit: Double?
+    // NOTE: ReplayKit does not expose bitrate/quality control via RPScreenRecorder.
+    // This field is accepted for API consistency with Android but has no effect on iOS.
+    @Field var quality: String?
+    @Field var includeAudio: Bool?
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "expo-turbo-screen-recorder",
+  "version": "0.3.0",
+  "description": "Expo Module For High Quality Screen Recorder",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "expo-module build",
+    "clean": "expo-module clean",
+    "lint": "expo-module lint",
+    "test": "expo-module test",
+    "prepare": "expo-module prepare",
+    "prepublishOnly": "expo-module prepublishOnly",
+    "expo-module": "expo-module",
+    "open:ios": "xed example/ios",
+    "open:android": "open -a \"Android Studio\" example/android"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "expo-screen-recorder",
+    "ExpoScreenRecorder"
+  ],
+  "repository": "https://github.com/tsnguyenducphuong/screen-recorder",
+  "bugs": {
+    "url": "https://github.com/tsnguyenducphuong/screen-recorder/issues"
+  },
+  "author": "tsnguyenducphuong <ts.nguyenducphuong@gmail.com> (https://github.com/tsnguyenducphuong)",
+  "license": "MIT",
+  "homepage": "https://github.com/tsnguyenducphuong/expo-screen-recorder#readme",
+  "devDependencies": {
+    "expo-module-scripts": "^5.0.8"
+  },
+  "peerDependencies": {
+    "expo": "*",
+    "react": "*",
+    "react-native": "*"
+  }
+}

package/src/ExpoScreenRecorder.types.ts

@@ -0,0 +1,19 @@
+export type ExpoScreenRecorderModuleEvents = {
+  onChange: (params: ChangeEventPayload) => void;
+};
+
+export type ChangeEventPayload = {
+  value: string;
+};
+
+
+export interface RecordingOptions {
+  durationLimit?: number;
+  quality?: 'low' | 'medium' | 'high';
+  includeAudio?: boolean;
+}
+
+export interface RecordingResult {
+  uri: string;
+  duration: number;
+}

package/src/ExpoScreenRecorderModule.ts

@@ -0,0 +1,32 @@
+// import { NativeModule, requireNativeModule } from 'expo';
+
+// import { ExpoScreenRecorderModuleEvents } from './ExpoScreenRecorder.types';
+
+// declare class ExpoScreenRecorderModule extends NativeModule<ExpoScreenRecorderModuleEvents> {
+//   hello(): string;
+//   setValueAsync(value: string): Promise<void>;
+// }
+
+// export default requireNativeModule<ExpoScreenRecorderModule>('ExpoScreenRecorder');
+
+
+import { NativeModule, requireNativeModule } from 'expo';
+
+export interface RecordingOptions {
+  durationLimit?: number;
+  quality?: 'low' | 'medium' | 'high';
+  includeAudio?: boolean;
+}
+
+export interface RecordingResult {
+  uri: string;
+  duration: number;
+}
+
+declare class ExpoScreenRecorderModule extends NativeModule {
+  isAvailableAsync(): Promise<boolean>;
+  startRecordingAsync(options: RecordingOptions): Promise<void>;
+  stopRecordingAsync(): Promise<RecordingResult>;
+}
+
+export default requireNativeModule<ExpoScreenRecorderModule>('ExpoScreenRecorder');

package/src/ExpoScreenRecorderModule.web.ts

@@ -0,0 +1,15 @@
+import { registerWebModule, NativeModule } from 'expo';
+
+import { ExpoScreenRecorderModuleEvents } from './ExpoScreenRecorder.types';
+
+class ExpoScreenRecorderModule extends NativeModule<ExpoScreenRecorderModuleEvents> {
+  hello() {
+    return 'Hello world! 👋';
+  }
+
+  async setValueAsync(value: string): Promise<void> {
+    this.emit('onChange', { value });
+  }
+}
+
+export default registerWebModule(ExpoScreenRecorderModule, 'ExpoScreenRecorderModule');

package/src/index.ts

@@ -0,0 +1,22 @@
+// Reexport the native module. On web, it will be resolved to ExpoScreenRecorderModule.web.ts
+// and on native platforms to ExpoScreenRecorderModule.ts
+// export { default } from './ExpoScreenRecorderModule';
+// export * from './ExpoScreenRecorder.types';
+
+
+import ExpoScreenRecorderModule from './ExpoScreenRecorderModule';
+import type { RecordingOptions, RecordingResult } from './ExpoScreenRecorder.types';
+
+export async function isAvailableAsync(): Promise<boolean> {
+  return await ExpoScreenRecorderModule.isAvailableAsync();
+}
+
+export async function startRecordingAsync(options: RecordingOptions = {}): Promise<void> {
+  return await ExpoScreenRecorderModule.startRecordingAsync(options);
+}
+
+export async function stopRecordingAsync(): Promise<RecordingResult> {
+  return await ExpoScreenRecorderModule.stopRecordingAsync();
+}
+
+export type { RecordingOptions, RecordingResult };

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": { 
+    "rootDir": "./src",
+    "outDir": "./build",
+    "skipLibCheck": true
+  },
+  "include": ["./src"],
+  "exclude": ["**/__mocks__/*", "**/__tests__/*"]
+}