@capgo/capacitor-screen-recorder 8.2.37 → 8.3.0

package/README.md

@@ -104,6 +104,8 @@ No configuration required for this plugin.
 * [`start(...)`](#start)
 * [`stop()`](#stop)
 * [`getPluginVersion()`](#getpluginversion)
+* [Interfaces](#interfaces)
+* [Type Aliases](#type-aliases)
 
 </docgen-index>
 
@@ -116,7 +118,7 @@ Allows you to capture video recordings of the screen with optional audio.
 ### start(...)
 
 ```typescript
-start(options?: { recordAudio?: boolean | undefined; } | undefined) => Promise<void>
+start(options?: StartRecordingOptions | undefined) => Promise<void>
 ```
 
 Start recording the device screen.
@@ -126,9 +128,9 @@ prompted to grant screen recording permissions if not already granted.
 On iOS, the system recording UI will be displayed. On Android, the recording
 starts immediately after permission is granted.
 
-| Param         | Type                                    | Description                       |
-| ------------- | --------------------------------------- | --------------------------------- |
-| **`options`** | <code>{ recordAudio?: boolean; }</code> | - Recording configuration options |
+| Param         | Type                                                                    | Description                       |
+| ------------- | ----------------------------------------------------------------------- | --------------------------------- |
+| **`options`** | <code><a href="#startrecordingoptions">StartRecordingOptions</a></code> | - Recording configuration options |
 
 **Since:** 1.0.0
 
@@ -166,4 +168,27 @@ Get the native Capacitor plugin version.
 
 --------------------
 
+
+### Interfaces
+
+
+#### StartRecordingOptions
+
+Options for {@link ScreenRecorderPlugin.start}.
+
+| Prop              | Type                                                                                                                | Description                                                                                                                                                                                                         | Default            | Since |
+| ----------------- | ------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ | ----- |
+| **`recordAudio`** | <code>boolean</code>                                                                                                | Whether to record audio along with the screen video.                                                                                                                                                                | <code>false</code> | 1.0.0 |
+| **`format`**      | <code><a href="#screenrecordervideoformat">ScreenRecorderVideoFormat</a> \| 'video/mp4' \| 'video/quicktime'</code> | Video container format for the saved recording. Accepts `mp4`, `mov`, or MIME types `video/mp4` and `video/quicktime`. iOS supports both `mp4` and `mov`. Android records MPEG-4 (`.mp4`) regardless of this value. | <code>'mp4'</code> | 8.3.0 |
+
+
+### Type Aliases
+
+
+#### ScreenRecorderVideoFormat
+
+Supported video container formats for screen recordings.
+
+<code>'mp4' | 'mov'</code>
+
 </docgen-api>

package/android/build.gradle

@@ -68,4 +68,6 @@ dependencies {
     implementation "androidx.core:core-ktx:$androidxCoreVersion"
     implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
     implementation ("dev.bmcreations:scrcast:0.3.0")
+    implementation "com.karumi:dexter:6.2.3"
+    implementation "androidx.localbroadcastmanager:localbroadcastmanager:1.1.0"
 }

package/android/src/main/AndroidManifest.xml

@@ -1,2 +1,12 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+    <application
+        android:fullBackupContent="@xml/screen_recorder_backup_rules"
+        android:usesCleartextTraffic="false"
+        tools:node="merge">
+        <service
+            android:name="ee.forgr.plugin.screenrecorder.service.CapgoRecorderService"
+            android:exported="false"
+            android:foregroundServiceType="mediaProjection|microphone" />
+    </application>
 </manifest>

package/android/src/main/java/ee/forgr/plugin/screenrecorder/CapgoRecordScreen.kt

@@ -0,0 +1,19 @@
+package ee.forgr.plugin.screenrecorder
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import android.media.projection.MediaProjectionManager
+import androidx.activity.result.ActivityResult
+import androidx.activity.result.contract.ActivityResultContract
+
+class CapgoRecordScreen : ActivityResultContract<Unit, ActivityResult>() {
+    override fun createIntent(context: Context, input: Unit): Intent {
+        val pm = context.getSystemService(MediaProjectionManager::class.java)
+        return pm.createScreenCaptureIntent()
+    }
+
+    override fun parseResult(resultCode: Int, intent: Intent?): ActivityResult {
+        return ActivityResult(resultCode, intent)
+    }
+}

package/android/src/main/java/ee/forgr/plugin/screenrecorder/CapgoScrCastWithAudio.kt

@@ -0,0 +1,192 @@
+package ee.forgr.plugin.screenrecorder
+
+import android.Manifest
+import android.app.Activity
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.ServiceConnection
+import android.media.MediaScannerConnection
+import android.os.IBinder
+import android.util.DisplayMetrics
+import android.util.Log
+import androidx.activity.ComponentActivity
+import androidx.activity.result.ActivityResult
+import androidx.localbroadcastmanager.content.LocalBroadcastManager
+import com.karumi.dexter.Dexter
+import com.karumi.dexter.MultiplePermissionsReport
+import com.karumi.dexter.PermissionToken
+import com.karumi.dexter.listener.PermissionRequest
+import com.karumi.dexter.listener.multi.MultiplePermissionsListener
+import dev.bmcreations.scrcast.config.Options
+import dev.bmcreations.scrcast.internal.recorder.Action
+import dev.bmcreations.scrcast.internal.recorder.EXTRA_ERROR
+import dev.bmcreations.scrcast.internal.recorder.STATE_IDLE
+import dev.bmcreations.scrcast.internal.recorder.STATE_RECORDING
+import dev.bmcreations.scrcast.internal.recorder.notification.RecorderNotificationProvider
+import dev.bmcreations.scrcast.recorder.RecordingState
+import ee.forgr.plugin.screenrecorder.service.CapgoRecorderService
+import java.io.File
+
+class CapgoScrCastWithAudio private constructor(private val activity: ComponentActivity) {
+    var options: Options = Options()
+        private set
+
+    private var fileExtension: String = "mp4"
+
+    private var recordingSession: Intent? = null
+    private var serviceBinder: CapgoRecorderService? = null
+    private var outputFile: File? = null
+
+    private val metrics by lazy {
+        DisplayMetrics().apply { activity.windowManager.defaultDisplay.getMetrics(this) }
+    }
+
+    private val dpi by lazy { metrics.density }
+
+    private val notificationProvider by lazy {
+        RecorderNotificationProvider(activity, options.notification)
+    }
+
+    private val broadcaster by lazy { LocalBroadcastManager.getInstance(activity) }
+
+    private val connection = object : ServiceConnection {
+        override fun onServiceConnected(className: ComponentName, service: IBinder) {
+            val binder = service as CapgoRecorderService.LocalBinder
+            serviceBinder = binder.service
+            serviceBinder?.setNotificationProvider(notificationProvider)
+        }
+
+        override fun onServiceDisconnected(arg0: ComponentName) {
+            serviceBinder = null
+        }
+    }
+
+    private val recordingStateHandler = object : android.content.BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            if (intent?.action == STATE_IDLE) {
+                cleanupSession()
+            }
+        }
+    }
+
+    private val permissionListener = object : MultiplePermissionsListener {
+        override fun onPermissionsChecked(report: MultiplePermissionsReport?) {
+            startProjection.launch(Unit)
+        }
+
+        override fun onPermissionRationaleShouldBeShown(
+            permissions: MutableList<PermissionRequest>?,
+            token: PermissionToken?,
+        ) {
+            token?.continuePermissionRequest()
+        }
+    }
+
+    private val startProjection = activity.registerForActivityResult(CapgoRecordScreen()) { result ->
+        if (result.resultCode != Activity.RESULT_OK) {
+            return@registerForActivityResult
+        }
+        val file = resolveOutputFile() ?: return@registerForActivityResult
+        startService(result, file)
+    }
+
+    fun updateOptions(options: Options) {
+        this.options = handleDynamicVideoSize(options)
+    }
+
+    fun updateVideoFormat(format: String?) {
+        val resolved = VideoFormatResolver.resolve(format)
+        fileExtension = resolved.extension
+        options = handleDynamicVideoSize(
+            options.copy(storage = options.storage.copy(outputFormat = resolved.outputFormat)),
+        )
+    }
+
+    fun record() {
+        Dexter.withContext(activity)
+            .withPermissions(
+                Manifest.permission.WRITE_EXTERNAL_STORAGE,
+                Manifest.permission.READ_EXTERNAL_STORAGE,
+                Manifest.permission.RECORD_AUDIO,
+            )
+            .withListener(permissionListener)
+            .check()
+    }
+
+    fun stopRecording() {
+        broadcaster.sendBroadcast(Intent(Action.Stop.name))
+    }
+
+    private fun resolveOutputFile(): File? {
+        val dir = options.storage.mediaStorageLocation ?: return null
+        return File("${dir.path}${File.separator}${options.storage.fileNameFormatter()}.$fileExtension")
+    }
+
+    private fun startService(result: ActivityResult, file: File) {
+        outputFile = file
+        val session = Intent(activity, CapgoRecorderService::class.java).apply {
+            putExtra("code", result.resultCode)
+            putExtra("data", result.data)
+            putExtra("options", options)
+            putExtra("outputFile", file.absolutePath)
+            putExtra("dpi", dpi)
+            putExtra("rotation", activity.windowManager.defaultDisplay.rotation)
+        }
+        recordingSession = session
+
+        broadcaster.registerReceiver(
+            recordingStateHandler,
+            IntentFilter().apply {
+                addAction(STATE_IDLE)
+                addAction(STATE_RECORDING)
+            },
+        )
+
+        activity.bindService(session, connection, Context.BIND_AUTO_CREATE)
+        activity.startService(session)
+    }
+
+    private fun cleanupSession() {
+        try {
+            broadcaster.unregisterReceiver(recordingStateHandler)
+        } catch (ignored: Exception) {
+            Log.d("CapgoScreenRecorder", "Receiver already unregistered", ignored)
+        }
+
+        try {
+            activity.unbindService(connection)
+        } catch (ignored: Exception) {
+            Log.d("CapgoScreenRecorder", "Service already unbound", ignored)
+        }
+
+        recordingSession?.let { activity.stopService(it) }
+        recordingSession = null
+
+        outputFile?.let { file ->
+            MediaScannerConnection.scanFile(activity, arrayOf(file.absolutePath), null) { path, uri ->
+                Log.i("CapgoScreenRecorder", "Saved recording: $path uri=$uri")
+            }
+        }
+        outputFile = null
+    }
+
+    private fun handleDynamicVideoSize(options: Options): Options {
+        var reconfig = options
+        if (options.video.width == -1) {
+            reconfig = reconfig.copy(video = reconfig.video.copy(width = metrics.widthPixels))
+        }
+        if (options.video.height == -1) {
+            reconfig = reconfig.copy(video = reconfig.video.copy(height = metrics.heightPixels))
+        }
+        return reconfig
+    }
+
+    companion object {
+        @JvmStatic
+        fun use(activity: ComponentActivity): CapgoScrCastWithAudio {
+            return CapgoScrCastWithAudio(activity)
+        }
+    }
+}

package/android/src/main/java/ee/forgr/plugin/screenrecorder/ScreenRecorderPlugin.java

@@ -11,27 +11,56 @@ import dev.bmcreations.scrcast.config.Options;
 @CapacitorPlugin(name = "ScreenRecorder")
 public class ScreenRecorderPlugin extends Plugin {
 
-    private final String pluginVersion = "8.2.37";
+    private final String pluginVersion = "8.3.0";
 
     private ScrCast recorder;
+    private CapgoScrCastWithAudio audioRecorder;
+    private boolean recordingWithAudio = false;
 
     @Override
     public void load() {
         recorder = ScrCast.use(this.bridge.getActivity());
+        audioRecorder = CapgoScrCastWithAudio.use(this.bridge.getActivity());
         Options options = new Options();
         recorder.updateOptions(options);
+        audioRecorder.updateOptions(options);
     }
 
     @PluginMethod
     public void start(PluginCall call) {
-        recorder.record();
-        call.resolve();
+        try {
+            final boolean recordAudio = call.getBoolean("recordAudio", false);
+            final String format = call.getString("format");
+            recordingWithAudio = recordAudio;
+
+            final Options configuredOptions = VideoFormatResolver.INSTANCE.applyTo(recorder.getOptions(), format);
+            recorder.updateOptions(configuredOptions);
+            audioRecorder.updateVideoFormat(format);
+
+            if (recordAudio) {
+                audioRecorder.record();
+            } else {
+                recorder.record();
+            }
+            call.resolve();
+        } catch (final Exception e) {
+            call.reject("Could not start screen recording", e);
+        }
     }
 
     @PluginMethod
     public void stop(PluginCall call) {
-        recorder.stopRecording();
-        call.resolve();
+        try {
+            if (recordingWithAudio) {
+                audioRecorder.stopRecording();
+            } else {
+                recorder.stopRecording();
+            }
+            recordingWithAudio = false;
+            call.resolve();
+        } catch (final Exception e) {
+            call.reject("Could not stop screen recording", e);
+        }
     }
 
     @PluginMethod

package/android/src/main/java/ee/forgr/plugin/screenrecorder/VideoFormatResolver.kt

@@ -0,0 +1,21 @@
+package ee.forgr.plugin.screenrecorder
+
+import android.media.MediaRecorder
+import dev.bmcreations.scrcast.config.Options
+
+object VideoFormatResolver {
+    data class Resolved(
+        val extension: String = "mp4",
+        val outputFormat: Int = MediaRecorder.OutputFormat.MPEG_4,
+    )
+
+    fun resolve(@Suppress("UNUSED_PARAMETER") format: String?): Resolved {
+        // Android MediaRecorder only supports MPEG-4 output.
+        return Resolved()
+    }
+
+    fun applyTo(options: Options, format: String?): Options {
+        val resolved = resolve(format)
+        return options.copy(storage = options.storage.copy(outputFormat = resolved.outputFormat))
+    }
+}

package/android/src/main/java/ee/forgr/plugin/screenrecorder/service/CapgoRecorderService.kt

@@ -0,0 +1,317 @@
+package ee.forgr.plugin.screenrecorder.service
+
+import android.app.Service
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.hardware.display.DisplayManager
+import android.hardware.display.VirtualDisplay
+import android.media.MediaRecorder
+import android.media.MediaRecorder.*
+import android.media.projection.MediaProjection
+import android.media.projection.MediaProjectionManager
+import android.os.Binder
+import android.os.Build
+import android.os.Handler
+import android.os.IBinder
+import android.util.Log
+import androidx.localbroadcastmanager.content.LocalBroadcastManager
+import dev.bmcreations.scrcast.config.Options
+import dev.bmcreations.scrcast.internal.extensions.countdown
+import dev.bmcreations.scrcast.internal.recorder.*
+import dev.bmcreations.scrcast.internal.recorder.service.orientations
+import dev.bmcreations.scrcast.recorder.*
+import dev.bmcreations.scrcast.recorder.notification.NotificationProvider
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+import java.io.File
+
+class CapgoRecorderService : Service() {
+
+    private val projectionManager: MediaProjectionManager by lazy {
+        getSystemService(MediaProjectionManager::class.java)
+    }
+
+    private val broadcaster by lazy {
+        LocalBroadcastManager.getInstance(this)
+    }
+
+    private val binder = LocalBinder()
+
+    private lateinit var notificationProvider: NotificationProvider
+
+    private val pauseResumeHandler = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            when (intent?.action) {
+                ACTION_PAUSE -> pause()
+                ACTION_RESUME -> resume()
+                ACTION_STOP -> stopRecording()
+            }
+        }
+    }
+    private val screenHandler = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            when (intent?.action) {
+                Intent.ACTION_SCREEN_OFF -> {
+                    Log.d("scrcast", "stopping recording with screen off per request")
+                    if (state == RecordingState.Recording) {
+                        stopRecording()
+                    }
+                }
+            }
+        }
+    }
+
+    private var state: RecordingState = RecordingState.Idle()
+        set(value) {
+            field = value
+            broadcaster.sendBroadcast(Intent(value.stateString()).apply {
+                if (value is RecordingState.Delay) {
+                    putExtra(EXTRA_DELAY_REMAINING, value.remainingSeconds)
+                } else if (value is RecordingState.Idle) {
+                    putExtra(EXTRA_ERROR, value.error)
+                }
+            })
+        }
+
+    private var options: Options = Options()
+    private lateinit var outputFile: String
+    private var rotation = 0
+    private val orientation by lazy {
+        orientations.get(rotation + 90)
+    }
+    private var dpi: Float = 0f
+
+    private var requestCode: Int = -1
+    private var requestData: Intent = Intent()
+
+    private var mediaProjection: MediaProjection? = null
+    private var mediaProjectionCallback = MediaProjectionCallback()
+
+    private var _virtualDisplay: VirtualDisplay? = null
+    private val virtualDisplay: VirtualDisplay?
+        get() {
+            if (_virtualDisplay == null) {
+                _virtualDisplay = mediaProjection?.createVirtualDisplay(
+                    "SrcCast",
+                    options.video.width,
+                    options.video.height,
+                    dpi.toInt(),
+                    DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR,
+                    mediaRecorder?.surface,
+                    null,
+                    null
+                )
+            }
+            return _virtualDisplay
+        }
+
+    private var mediaRecorder: MediaRecorder? = null
+
+
+    private fun createMediaRecorder(): MediaRecorder {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            MediaRecorder(this)
+        } else {
+            @Suppress("DEPRECATION")
+            MediaRecorder()
+        }
+    }
+
+    private fun createRecorder() {
+        Log.d("scrcast", "createRecorder()")
+        mediaRecorder = createMediaRecorder().apply {
+            setAudioSource(AudioSource.MIC)
+            setVideoSource(VideoSource.SURFACE)
+            setOutputFormat(options.storage.outputFormat)
+            setAudioEncoder(AudioEncoder.AAC)
+            setOutputFile(outputFile)
+            with(options.video) {
+                setVideoSize(width, height)
+                setVideoEncoder(videoEncoder)
+                setVideoEncodingBitRate(bitrate)
+                setVideoFrameRate(frameRate)
+                if (maxLengthSecs > 0) {
+                    setMaxDuration(maxLengthSecs * 1000)
+                }
+            }
+            with(options.storage) {
+                if (maxSizeMB > 0) {
+                    setMaxFileSize((maxSizeMB * (1024 * 1024)).toLong())
+                }
+            }
+            setOnInfoListener { _, what, _ ->
+                when (what) {
+                    MEDIA_RECORDER_INFO_MAX_DURATION_REACHED -> {
+                        Log.d(
+                            "scrcast",
+                            "max duration of ${options.video.maxLengthSecs} seconds reached. Stopping reconrding..."
+                        )
+                        stopRecording()
+                    }
+                    MEDIA_RECORDER_INFO_MAX_FILESIZE_APPROACHING -> Log.d(
+                        "scrcast",
+                        "Approaching max file size of ${options.storage.maxSizeMB}MB"
+                    )
+                    MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED -> {
+                        Log.d(
+                            "scrcast",
+                            "max file size of ${options.storage.maxSizeMB}MB reached. Stopping reconrding..."
+                        )
+                        stopRecording()
+                    }
+
+                }
+            }
+            setOrientationHint(orientation)
+        }
+        mediaRecorder?.prepare()
+    }
+
+    fun setNotificationProvider(provider: NotificationProvider) {
+        notificationProvider = provider
+    }
+
+    private fun pause() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            if (state.isRecording) {
+                mediaRecorder?.pause()
+            }
+            state = RecordingState.Paused
+
+            notificationProvider.update(state)
+        }
+    }
+
+    private fun resume() {
+        when (state) {
+            is RecordingState.Idle -> startRecording()
+            RecordingState.Paused -> {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                    mediaRecorder?.resume()
+                    state = RecordingState.Recording
+                    notificationProvider.update(state)
+                }
+            }
+            else -> Unit
+        }
+    }
+
+    private fun startRecording(code: Int = requestCode, data: Intent = requestData) {
+        requestCode = code
+        requestData = data
+
+        if (options.startDelayMs > 0) {
+            options.startDelayMs.countdown(
+                repeatMillis = 1_000,
+                onTick = { state = RecordingState.Delay((it / 1000).toInt() + 1) },
+                after = { recordInternal(code, data) }
+            )
+        } else {
+            recordInternal(code, data)
+        }
+    }
+
+    private fun recordInternal(code: Int, data: Intent) {
+        GlobalScope.launch(Dispatchers.Main) {
+            startForeground(
+                notificationProvider.getNotificationId(),
+                notificationProvider.get(state)
+            )
+            mediaProjection = projectionManager.getMediaProjection(code, data)
+
+            if (options.stopOnScreenOff) {
+                with(IntentFilter(Intent.ACTION_SCREEN_OFF)) {
+                    registerReceiver(screenHandler, this)
+                }
+            }
+
+            with(IntentFilter(ACTION_PAUSE).apply {
+                addAction(ACTION_RESUME)
+                addAction(ACTION_STOP)
+            }) {
+                broadcaster.registerReceiver(pauseResumeHandler, this)
+            }
+
+            mediaProjection?.registerCallback(mediaProjectionCallback, Handler())
+            createRecorder()
+            virtualDisplay // touch
+            try {
+                mediaRecorder?.start()
+                state = RecordingState.Recording
+                notificationProvider.update(state)
+            } catch (e: Exception) {
+                stopRecording(e)
+            }
+        }
+    }
+
+    private fun stopRecording(error: Throwable? = null) {
+        mediaProjection?.stop()
+
+        state = RecordingState.Idle(error)
+        stopForeground(true)
+    }
+
+    private fun cleanupProjection() {
+        mediaProjection?.unregisterCallback(mediaProjectionCallback)
+        mediaProjection = null
+
+        _virtualDisplay?.release()
+
+        runCatching {
+            mediaRecorder?.stop()
+            mediaRecorder?.reset()
+            mediaRecorder?.release()
+        }
+    }
+
+    private inner class MediaProjectionCallback : MediaProjection.Callback() {
+        override fun onStop() {
+            Log.d("scrcast", "projection on stop")
+            cleanupProjection()
+        }
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        intent?.let {
+            options = it.getParcelableExtra("options") ?: Options()
+            rotation = it.getIntExtra("rotation", 0)
+            dpi = it.getFloatExtra("dpi", 0f)
+            outputFile = it.getStringExtra("outputFile") ?: ""
+
+            startRecording(
+                code = it.getIntExtra("code", -1),
+                data = it.getParcelableExtra("data") ?: Intent()
+            )
+        }
+
+        return START_STICKY
+    }
+
+    override fun onDestroy() {
+        Log.d("scrcast", "onDestroy: service")
+        stopRecording()
+        if (options.stopOnScreenOff) {
+            unregisterReceiver(screenHandler)
+        }
+        try {
+            broadcaster.unregisterReceiver(pauseResumeHandler)
+        } catch (swallow: Exception) {
+            Log.d("CapgoScreenRecorder", "Receiver already unregistered", swallow)
+        }
+
+        super.onDestroy()
+    }
+
+    override fun onBind(p0: Intent?): IBinder? = binder
+
+    // Class used for the client Binder.
+    inner class LocalBinder : Binder() {
+        // Return this instance of MyService so clients can call public methods
+        val service: CapgoRecorderService
+            get() = this@CapgoRecorderService
+    }
+}

package/android/src/main/res/xml/screen_recorder_backup_rules.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<full-backup-content />

package/dist/docs.json

@@ -12,12 +12,12 @@
     "methods": [
       {
         "name": "start",
-        "signature": "(options?: { recordAudio?: boolean | undefined; } | undefined) => Promise<void>",
+        "signature": "(options?: StartRecordingOptions | undefined) => Promise<void>",
         "parameters": [
           {
             "name": "options",
             "docs": "- Recording configuration options",
-            "type": "{ recordAudio?: boolean | undefined; } | undefined"
+            "type": "StartRecordingOptions | undefined"
           }
         ],
         "returns": "Promise<void>",
@@ -30,6 +30,10 @@
             "name": "param",
             "text": "options.recordAudio - Whether to record audio along with the screen video. Defaults to false."
           },
+          {
+            "name": "param",
+            "text": "options.format - Video container format for the saved recording. Defaults to `mp4`."
+          },
           {
             "name": "returns",
             "text": "Promise that resolves when recording starts"
@@ -44,11 +48,13 @@
           },
           {
             "name": "example",
-            "text": "```typescript\n// Start recording without audio\nawait ScreenRecorder.start();\n\n// Start recording with audio\nawait ScreenRecorder.start({ recordAudio: true });\n```"
+            "text": "```typescript\n// Start recording without audio\nawait ScreenRecorder.start();\n\n// Start recording with audio\nawait ScreenRecorder.start({ recordAudio: true });\n\n// Start recording as MOV on iOS\nawait ScreenRecorder.start({ format: 'mov' });\n```"
           }
         ],
         "docs": "Start recording the device screen.\n\nInitiates screen recording with optional audio capture. The user will be\nprompted to grant screen recording permissions if not already granted.\nOn iOS, the system recording UI will be displayed. On Android, the recording\nstarts immediately after permission is granted.",
-        "complexTypes": [],
+        "complexTypes": [
+          "StartRecordingOptions"
+        ],
         "slug": "start"
       },
       {
@@ -108,8 +114,77 @@
     ],
     "properties": []
   },
-  "interfaces": [],
+  "interfaces": [
+    {
+      "name": "StartRecordingOptions",
+      "slug": "startrecordingoptions",
+      "docs": "Options for {@link ScreenRecorderPlugin.start}.",
+      "tags": [
+        {
+          "text": "8.3.0",
+          "name": "since"
+        }
+      ],
+      "methods": [],
+      "properties": [
+        {
+          "name": "recordAudio",
+          "tags": [
+            {
+              "text": "false",
+              "name": "default"
+            },
+            {
+              "text": "1.0.0",
+              "name": "since"
+            }
+          ],
+          "docs": "Whether to record audio along with the screen video.",
+          "complexTypes": [],
+          "type": "boolean | undefined"
+        },
+        {
+          "name": "format",
+          "tags": [
+            {
+              "text": "'mp4'",
+              "name": "default"
+            },
+            {
+              "text": "8.3.0",
+              "name": "since"
+            },
+            {
+              "text": "'mov'",
+              "name": "example"
+            }
+          ],
+          "docs": "Video container format for the saved recording.\n\nAccepts `mp4`, `mov`, or MIME types `video/mp4` and `video/quicktime`.\niOS supports both `mp4` and `mov`. Android records MPEG-4 (`.mp4`) regardless of this value.",
+          "complexTypes": [
+            "ScreenRecorderVideoFormat"
+          ],
+          "type": "ScreenRecorderVideoFormat | 'video/mp4' | 'video/quicktime' | undefined"
+        }
+      ]
+    }
+  ],
   "enums": [],
-  "typeAliases": [],
+  "typeAliases": [
+    {
+      "name": "ScreenRecorderVideoFormat",
+      "slug": "screenrecordervideoformat",
+      "docs": "Supported video container formats for screen recordings.",
+      "types": [
+        {
+          "text": "'mp4'",
+          "complexTypes": []
+        },
+        {
+          "text": "'mov'",
+          "complexTypes": []
+        }
+      ]
+    }
+  ],
   "pluginConfigs": []
 }

package/dist/esm/definitions.d.ts

@@ -1,3 +1,34 @@
+/**
+ * Supported video container formats for screen recordings.
+ *
+ * @since 8.3.0
+ */
+export type ScreenRecorderVideoFormat = 'mp4' | 'mov';
+/**
+ * Options for {@link ScreenRecorderPlugin.start}.
+ *
+ * @since 8.3.0
+ */
+export interface StartRecordingOptions {
+    /**
+     * Whether to record audio along with the screen video.
+     *
+     * @default false
+     * @since 1.0.0
+     */
+    recordAudio?: boolean;
+    /**
+     * Video container format for the saved recording.
+     *
+     * Accepts `mp4`, `mov`, or MIME types `video/mp4` and `video/quicktime`.
+     * iOS supports both `mp4` and `mov`. Android records MPEG-4 (`.mp4`) regardless of this value.
+     *
+     * @default 'mp4'
+     * @since 8.3.0
+     * @example 'mov'
+     */
+    format?: ScreenRecorderVideoFormat | 'video/mp4' | 'video/quicktime';
+}
 /**
  * Capacitor Screen Recorder Plugin for recording the device screen.
  * Allows you to capture video recordings of the screen with optional audio.
@@ -15,6 +46,7 @@ export interface ScreenRecorderPlugin {
      *
      * @param options - Recording configuration options
      * @param options.recordAudio - Whether to record audio along with the screen video. Defaults to false.
+     * @param options.format - Video container format for the saved recording. Defaults to `mp4`.
      * @returns Promise that resolves when recording starts
      * @throws Error if recording fails to start or permissions are denied
      * @since 1.0.0
@@ -25,11 +57,12 @@ export interface ScreenRecorderPlugin {
      *
      * // Start recording with audio
      * await ScreenRecorder.start({ recordAudio: true });
+     *
+     * // Start recording as MOV on iOS
+     * await ScreenRecorder.start({ format: 'mov' });
      * ```
      */
-    start(options?: {
-        recordAudio?: boolean;
-    }): Promise<void>;
+    start(options?: StartRecordingOptions): Promise<void>;
     /**
      * Stop the current screen recording.
      *

package/dist/esm/definitions.js.map

@@ -1 +1 @@
-{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Capacitor Screen Recorder Plugin for recording the device screen.\n * Allows you to capture video recordings of the screen with optional audio.\n *\n * @since 1.0.0\n */\nexport interface ScreenRecorderPlugin {\n  /**\n   * Start recording the device screen.\n   *\n   * Initiates screen recording with optional audio capture. The user will be\n   * prompted to grant screen recording permissions if not already granted.\n   * On iOS, the system recording UI will be displayed. On Android, the recording\n   * starts immediately after permission is granted.\n   *\n   * @param options - Recording configuration options\n   * @param options.recordAudio - Whether to record audio along with the screen video. Defaults to false.\n   * @returns Promise that resolves when recording starts\n   * @throws Error if recording fails to start or permissions are denied\n   * @since 1.0.0\n   * @example\n   * ```typescript\n   * // Start recording without audio\n   * await ScreenRecorder.start();\n   *\n   * // Start recording with audio\n   * await ScreenRecorder.start({ recordAudio: true });\n   * ```\n   */\n  start(options?: { recordAudio?: boolean }): Promise<void>;\n\n  /**\n   * Stop the current screen recording.\n   *\n   * Stops the active screen recording and saves the video to the device's\n   * camera roll or gallery. On iOS, the system will show a preview of the\n   * recording. On Android, the video is saved directly to the gallery.\n   *\n   * @returns Promise that resolves when recording stops and the video is saved\n   * @throws Error if stopping the recording fails or no recording is active\n   * @since 1.0.0\n   * @example\n   * ```typescript\n   * await ScreenRecorder.stop();\n   * console.log('Recording saved to gallery');\n   * ```\n   */\n  stop(): Promise<void>;\n\n  /**\n   * Get the native Capacitor plugin version.\n   *\n   * @returns Promise that resolves with the plugin version\n   * @throws Error if getting the version fails\n   * @since 1.0.0\n   * @example\n   * ```typescript\n   * const { version } = await ScreenRecorder.getPluginVersion();\n   * console.log('Plugin version:', version);\n   * ```\n   */\n  getPluginVersion(): Promise<{ version: string }>;\n}\n"]}
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Supported video container formats for screen recordings.\n *\n * @since 8.3.0\n */\nexport type ScreenRecorderVideoFormat = 'mp4' | 'mov';\n\n/**\n * Options for {@link ScreenRecorderPlugin.start}.\n *\n * @since 8.3.0\n */\nexport interface StartRecordingOptions {\n  /**\n   * Whether to record audio along with the screen video.\n   *\n   * @default false\n   * @since 1.0.0\n   */\n  recordAudio?: boolean;\n\n  /**\n   * Video container format for the saved recording.\n   *\n   * Accepts `mp4`, `mov`, or MIME types `video/mp4` and `video/quicktime`.\n   * iOS supports both `mp4` and `mov`. Android records MPEG-4 (`.mp4`) regardless of this value.\n   *\n   * @default 'mp4'\n   * @since 8.3.0\n   * @example 'mov'\n   */\n  format?: ScreenRecorderVideoFormat | 'video/mp4' | 'video/quicktime';\n}\n\n/**\n * Capacitor Screen Recorder Plugin for recording the device screen.\n * Allows you to capture video recordings of the screen with optional audio.\n *\n * @since 1.0.0\n */\nexport interface ScreenRecorderPlugin {\n  /**\n   * Start recording the device screen.\n   *\n   * Initiates screen recording with optional audio capture. The user will be\n   * prompted to grant screen recording permissions if not already granted.\n   * On iOS, the system recording UI will be displayed. On Android, the recording\n   * starts immediately after permission is granted.\n   *\n   * @param options - Recording configuration options\n   * @param options.recordAudio - Whether to record audio along with the screen video. Defaults to false.\n   * @param options.format - Video container format for the saved recording. Defaults to `mp4`.\n   * @returns Promise that resolves when recording starts\n   * @throws Error if recording fails to start or permissions are denied\n   * @since 1.0.0\n   * @example\n   * ```typescript\n   * // Start recording without audio\n   * await ScreenRecorder.start();\n   *\n   * // Start recording with audio\n   * await ScreenRecorder.start({ recordAudio: true });\n   *\n   * // Start recording as MOV on iOS\n   * await ScreenRecorder.start({ format: 'mov' });\n   * ```\n   */\n  start(options?: StartRecordingOptions): Promise<void>;\n\n  /**\n   * Stop the current screen recording.\n   *\n   * Stops the active screen recording and saves the video to the device's\n   * camera roll or gallery. On iOS, the system will show a preview of the\n   * recording. On Android, the video is saved directly to the gallery.\n   *\n   * @returns Promise that resolves when recording stops and the video is saved\n   * @throws Error if stopping the recording fails or no recording is active\n   * @since 1.0.0\n   * @example\n   * ```typescript\n   * await ScreenRecorder.stop();\n   * console.log('Recording saved to gallery');\n   * ```\n   */\n  stop(): Promise<void>;\n\n  /**\n   * Get the native Capacitor plugin version.\n   *\n   * @returns Promise that resolves with the plugin version\n   * @throws Error if getting the version fails\n   * @since 1.0.0\n   * @example\n   * ```typescript\n   * const { version } = await ScreenRecorder.getPluginVersion();\n   * console.log('Plugin version:', version);\n   * ```\n   */\n  getPluginVersion(): Promise<{ version: string }>;\n}\n"]}

package/dist/esm/web.d.ts

@@ -1,7 +1,7 @@
 import { WebPlugin } from '@capacitor/core';
-import type { ScreenRecorderPlugin } from './definitions';
+import type { ScreenRecorderPlugin, StartRecordingOptions } from './definitions';
 export declare class ScreenRecorderWeb extends WebPlugin implements ScreenRecorderPlugin {
-    start(): Promise<void>;
+    start(_options?: StartRecordingOptions): Promise<void>;
     stop(): Promise<void>;
     getPluginVersion(): Promise<{
         version: string;

package/dist/esm/web.js

@@ -1,6 +1,6 @@
 import { WebPlugin } from '@capacitor/core';
 export class ScreenRecorderWeb extends WebPlugin {
-    async start() {
+    async start(_options) {
         throw new Error('Method not implemented.');
     }
     async stop() {

package/dist/esm/web.js.map

@@ -1 +1 @@
-{"version":3,"file":"web.js","sourceRoot":"","sources":["../../src/web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAI5C,MAAM,OAAO,iBAAkB,SAAQ,SAAS;IAC9C,KAAK,CAAC,KAAK;QACT,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC7C,CAAC;IACD,KAAK,CAAC,IAAI;QACR,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC7C,CAAC;IAED,KAAK,CAAC,gBAAgB;QACpB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAC5B,CAAC;CACF","sourcesContent":["import { WebPlugin } from '@capacitor/core';\n\nimport type { ScreenRecorderPlugin } from './definitions';\n\nexport class ScreenRecorderWeb extends WebPlugin implements ScreenRecorderPlugin {\n  async start(): Promise<void> {\n    throw new Error('Method not implemented.');\n  }\n  async stop(): Promise<void> {\n    throw new Error('Method not implemented.');\n  }\n\n  async getPluginVersion(): Promise<{ version: string }> {\n    return { version: 'web' };\n  }\n}\n"]}
+{"version":3,"file":"web.js","sourceRoot":"","sources":["../../src/web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAI5C,MAAM,OAAO,iBAAkB,SAAQ,SAAS;IAC9C,KAAK,CAAC,KAAK,CAAC,QAAgC;QAC1C,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC7C,CAAC;IACD,KAAK,CAAC,IAAI;QACR,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC7C,CAAC;IAED,KAAK,CAAC,gBAAgB;QACpB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAC5B,CAAC;CACF","sourcesContent":["import { WebPlugin } from '@capacitor/core';\n\nimport type { ScreenRecorderPlugin, StartRecordingOptions } from './definitions';\n\nexport class ScreenRecorderWeb extends WebPlugin implements ScreenRecorderPlugin {\n  async start(_options?: StartRecordingOptions): Promise<void> {\n    throw new Error('Method not implemented.');\n  }\n  async stop(): Promise<void> {\n    throw new Error('Method not implemented.');\n  }\n\n  async getPluginVersion(): Promise<{ version: string }> {\n    return { version: 'web' };\n  }\n}\n"]}

package/dist/plugin.cjs.js

@@ -7,7 +7,7 @@ const ScreenRecorder = core.registerPlugin('ScreenRecorder', {
 });
 
 class ScreenRecorderWeb extends core.WebPlugin {
-    async start() {
+    async start(_options) {
         throw new Error('Method not implemented.');
     }
     async stop() {

package/dist/plugin.cjs.js.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.cjs.js","sources":["esm/index.js","esm/web.js"],"sourcesContent":["import { registerPlugin } from '@capacitor/core';\nconst ScreenRecorder = registerPlugin('ScreenRecorder', {\n    web: () => import('./web').then((m) => new m.ScreenRecorderWeb()),\n});\nexport * from './definitions';\nexport { ScreenRecorder };\n//# sourceMappingURL=index.js.map","import { WebPlugin } from '@capacitor/core';\nexport class ScreenRecorderWeb extends WebPlugin {\n    async start() {\n        throw new Error('Method not implemented.');\n    }\n    async stop() {\n        throw new Error('Method not implemented.');\n    }\n    async getPluginVersion() {\n        return { version: 'web' };\n    }\n}\n//# sourceMappingURL=web.js.map"],"names":["registerPlugin","WebPlugin"],"mappings":";;;;AACK,MAAC,cAAc,GAAGA,mBAAc,CAAC,gBAAgB,EAAE;AACxD,IAAI,GAAG,EAAE,MAAM,mDAAe,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,iBAAiB,EAAE,CAAC;AACrE,CAAC;;ACFM,MAAM,iBAAiB,SAASC,cAAS,CAAC;AACjD,IAAI,MAAM,KAAK,GAAG;AAClB,QAAQ,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC;AAClD,IAAI;AACJ,IAAI,MAAM,IAAI,GAAG;AACjB,QAAQ,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC;AAClD,IAAI;AACJ,IAAI,MAAM,gBAAgB,GAAG;AAC7B,QAAQ,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE;AACjC,IAAI;AACJ;;;;;;;;;"}
+{"version":3,"file":"plugin.cjs.js","sources":["esm/index.js","esm/web.js"],"sourcesContent":["import { registerPlugin } from '@capacitor/core';\nconst ScreenRecorder = registerPlugin('ScreenRecorder', {\n    web: () => import('./web').then((m) => new m.ScreenRecorderWeb()),\n});\nexport * from './definitions';\nexport { ScreenRecorder };\n//# sourceMappingURL=index.js.map","import { WebPlugin } from '@capacitor/core';\nexport class ScreenRecorderWeb extends WebPlugin {\n    async start(_options) {\n        throw new Error('Method not implemented.');\n    }\n    async stop() {\n        throw new Error('Method not implemented.');\n    }\n    async getPluginVersion() {\n        return { version: 'web' };\n    }\n}\n//# sourceMappingURL=web.js.map"],"names":["registerPlugin","WebPlugin"],"mappings":";;;;AACK,MAAC,cAAc,GAAGA,mBAAc,CAAC,gBAAgB,EAAE;AACxD,IAAI,GAAG,EAAE,MAAM,mDAAe,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,iBAAiB,EAAE,CAAC;AACrE,CAAC;;ACFM,MAAM,iBAAiB,SAASC,cAAS,CAAC;AACjD,IAAI,MAAM,KAAK,CAAC,QAAQ,EAAE;AAC1B,QAAQ,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC;AAClD,IAAI;AACJ,IAAI,MAAM,IAAI,GAAG;AACjB,QAAQ,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC;AAClD,IAAI;AACJ,IAAI,MAAM,gBAAgB,GAAG;AAC7B,QAAQ,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE;AACjC,IAAI;AACJ;;;;;;;;;"}

package/dist/plugin.js

@@ -6,7 +6,7 @@ var capacitorScreenRecorder = (function (exports, core) {
     });
 
     class ScreenRecorderWeb extends core.WebPlugin {
-        async start() {
+        async start(_options) {
             throw new Error('Method not implemented.');
         }
         async stop() {

package/dist/plugin.js.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.js","sources":["esm/index.js","esm/web.js"],"sourcesContent":["import { registerPlugin } from '@capacitor/core';\nconst ScreenRecorder = registerPlugin('ScreenRecorder', {\n    web: () => import('./web').then((m) => new m.ScreenRecorderWeb()),\n});\nexport * from './definitions';\nexport { ScreenRecorder };\n//# sourceMappingURL=index.js.map","import { WebPlugin } from '@capacitor/core';\nexport class ScreenRecorderWeb extends WebPlugin {\n    async start() {\n        throw new Error('Method not implemented.');\n    }\n    async stop() {\n        throw new Error('Method not implemented.');\n    }\n    async getPluginVersion() {\n        return { version: 'web' };\n    }\n}\n//# sourceMappingURL=web.js.map"],"names":["registerPlugin","WebPlugin"],"mappings":";;;AACK,UAAC,cAAc,GAAGA,mBAAc,CAAC,gBAAgB,EAAE;IACxD,IAAI,GAAG,EAAE,MAAM,mDAAe,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,iBAAiB,EAAE,CAAC;IACrE,CAAC;;ICFM,MAAM,iBAAiB,SAASC,cAAS,CAAC;IACjD,IAAI,MAAM,KAAK,GAAG;IAClB,QAAQ,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC;IAClD,IAAI;IACJ,IAAI,MAAM,IAAI,GAAG;IACjB,QAAQ,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC;IAClD,IAAI;IACJ,IAAI,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE;IACjC,IAAI;IACJ;;;;;;;;;;;;;;;"}
+{"version":3,"file":"plugin.js","sources":["esm/index.js","esm/web.js"],"sourcesContent":["import { registerPlugin } from '@capacitor/core';\nconst ScreenRecorder = registerPlugin('ScreenRecorder', {\n    web: () => import('./web').then((m) => new m.ScreenRecorderWeb()),\n});\nexport * from './definitions';\nexport { ScreenRecorder };\n//# sourceMappingURL=index.js.map","import { WebPlugin } from '@capacitor/core';\nexport class ScreenRecorderWeb extends WebPlugin {\n    async start(_options) {\n        throw new Error('Method not implemented.');\n    }\n    async stop() {\n        throw new Error('Method not implemented.');\n    }\n    async getPluginVersion() {\n        return { version: 'web' };\n    }\n}\n//# sourceMappingURL=web.js.map"],"names":["registerPlugin","WebPlugin"],"mappings":";;;AACK,UAAC,cAAc,GAAGA,mBAAc,CAAC,gBAAgB,EAAE;IACxD,IAAI,GAAG,EAAE,MAAM,mDAAe,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,iBAAiB,EAAE,CAAC;IACrE,CAAC;;ICFM,MAAM,iBAAiB,SAASC,cAAS,CAAC;IACjD,IAAI,MAAM,KAAK,CAAC,QAAQ,EAAE;IAC1B,QAAQ,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC;IAClD,IAAI;IACJ,IAAI,MAAM,IAAI,GAAG;IACjB,QAAQ,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC;IAClD,IAAI;IACJ,IAAI,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE;IACjC,IAAI;IACJ;;;;;;;;;;;;;;;"}

package/ios/Sources/ScreenRecorderPlugin/ScreenRecorderPlugin.swift

@@ -7,7 +7,7 @@ import Capacitor
  */
 @objc(ScreenRecorderPlugin)
 public class ScreenRecorderPlugin: CAPPlugin, CAPBridgedPlugin {
-    private let pluginVersion: String = "8.2.37"
+    private let pluginVersion: String = "8.3.0"
     public let identifier = "ScreenRecorderPlugin"
     public let jsName = "ScreenRecorder"
     public let pluginMethods: [CAPPluginMethod] = [
@@ -18,7 +18,9 @@ public class ScreenRecorderPlugin: CAPPlugin, CAPBridgedPlugin {
     private let implementation = ScreenRecorder()
 
     @objc func start(_ call: CAPPluginCall) {
-        implementation.startRecording(saveToCameraRoll: true, handler: { error in
+        let recordAudio = call.getBool("recordAudio") ?? false
+        let videoFormat = VideoContainerFormat.from(call.getString("format"))
+        implementation.startRecording(saveToCameraRoll: true, recordAudio: recordAudio, videoFormat: videoFormat, handler: { error in
             if let error = error {
                 debugPrint("Error when start recording \(error)")
                 call.reject("Cannot start recording")
@@ -27,6 +29,7 @@ public class ScreenRecorderPlugin: CAPPlugin, CAPBridgedPlugin {
             }
         })
     }
+
     @objc func stop(_ call: CAPPluginCall) {
         implementation.stoprecording(handler: { error in
             if let error = error {
@@ -41,5 +44,4 @@ public class ScreenRecorderPlugin: CAPPlugin, CAPBridgedPlugin {
     @objc func getPluginVersion(_ call: CAPPluginCall) {
         call.resolve(["version": self.pluginVersion])
     }
-
 }

package/ios/Sources/ScreenRecorderPlugin/Wyler.swift

@@ -6,15 +6,49 @@
 //  Copyright © 2020 Cesar Vargas. All rights reserved.
 //
 
+import AVFoundation
 import Foundation
-import ReplayKit
 import Photos
+import ReplayKit
+import UIKit
 
 public enum ScreenRecorderError: Error {
     case notAvailable
     case photoLibraryAccessNotGranted
 }
 
+public enum VideoContainerFormat {
+    case mp4
+    case mov
+
+    var fileType: AVFileType {
+        switch self {
+        case .mp4:
+            return .mp4
+        case .mov:
+            return .mov
+        }
+    }
+
+    var fileExtension: String {
+        switch self {
+        case .mp4:
+            return "mp4"
+        case .mov:
+            return "mov"
+        }
+    }
+
+    static func from(_ value: String?) -> VideoContainerFormat {
+        switch value?.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() {
+        case "mov", "video/quicktime", "quicktime":
+            return .mov
+        default:
+            return .mp4
+        }
+    }
+}
+
 public final class ScreenRecorder {
     private var videoOutputURL: URL?
     private var videoWriter: AVAssetWriter?
@@ -22,37 +56,50 @@ public final class ScreenRecorder {
     private var micAudioWriterInput: AVAssetWriterInput?
     private var appAudioWriterInput: AVAssetWriterInput?
     private var saveToCameraRoll = false
+    private var recordAudio = false
+    private var videoFormat: VideoContainerFormat = .mp4
     let recorder = RPScreenRecorder.shared()
 
-    /**
-     Starts recording the content of the application screen. It works together with stopRecording
-
-     - Parameter outputURL: The output where the video will be saved. If nil, it saves it in the documents directory.
-     - Parameter size: The size of the video. If nil, it will use the app screen size.
-     - Parameter saveToCameraRoll: Whether to save it to camera roll. False by default.
-     - Parameter errorHandler: Called when an error is found
-     */
     public func startRecording(to outputURL: URL? = nil,
                                size: CGSize? = nil,
                                saveToCameraRoll: Bool = false,
+                               recordAudio: Bool = false,
+                               videoFormat: VideoContainerFormat = .mp4,
                                handler: @escaping (Error?) -> Void) {
-        recorder.isMicrophoneEnabled = true
+        self.saveToCameraRoll = saveToCameraRoll
+        self.recordAudio = recordAudio
+        self.videoFormat = videoFormat
+        resetWriterState()
+
+        recorder.isMicrophoneEnabled = recordAudio
+
         do {
+            if recordAudio {
+                try configureAudioSession()
+            }
             try createVideoWriter(in: outputURL)
             addVideoWriterInput(size: size)
-            self.micAudioWriterInput = createAndAddAudioInput()
-            self.appAudioWriterInput = createAndAddAudioInput()
+            if recordAudio {
+                self.micAudioWriterInput = createAndAddAudioInput()
+                self.appAudioWriterInput = createAndAddAudioInput()
+            }
             startCapture(handler: handler)
         } catch let err {
             handler(err)
         }
     }
 
-    private func checkPhotoLibraryAuthorizationStatus() {
-        let status = PHPhotoLibrary.authorizationStatus()
-        if status == .notDetermined {
-            PHPhotoLibrary.requestAuthorization({ _ in })
-        }
+    private func resetWriterState() {
+        videoWriter = nil
+        videoWriterInput = nil
+        micAudioWriterInput = nil
+        appAudioWriterInput = nil
+    }
+
+    private func configureAudioSession() throws {
+        let session = AVAudioSession.sharedInstance()
+        try session.setCategory(.playAndRecord, mode: .videoRecording, options: [.defaultToSpeaker, .mixWithOthers])
+        try session.setActive(true)
     }
 
     private func createVideoWriter(in outputURL: URL? = nil) throws {
@@ -63,7 +110,8 @@ public final class ScreenRecorder {
             newVideoOutputURL = passedVideoOutput
         } else {
             let documentsPath = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true)[0] as NSString
-            newVideoOutputURL = URL(fileURLWithPath: documentsPath.appendingPathComponent("WylerNewVideo.mp4"))
+            let fileName = "WylerNewVideo.\(videoFormat.fileExtension)"
+            newVideoOutputURL = URL(fileURLWithPath: documentsPath.appendingPathComponent(fileName))
             self.videoOutputURL = newVideoOutputURL
         }
 
@@ -72,7 +120,7 @@ public final class ScreenRecorder {
         } catch {}
 
         do {
-            try videoWriter = AVAssetWriter(outputURL: newVideoOutputURL, fileType: AVFileType.mp4)
+            try videoWriter = AVAssetWriter(outputURL: newVideoOutputURL, fileType: videoFormat.fileType)
         } catch let writerError as NSError {
             videoWriter = nil
             throw writerError
@@ -93,18 +141,9 @@ public final class ScreenRecorder {
     }
 
     private func createAndAddAudioInput() -> AVAssetWriterInput {
-        let settings = [
-            AVFormatIDKey: Int(kAudioFormatMPEG4AAC),
-            AVSampleRateKey: 12000,
-            AVNumberOfChannelsKey: 1,
-            AVEncoderAudioQualityKey: AVAudioQuality.high.rawValue
-        ]
-
-        let audioInput = AVAssetWriterInput(mediaType: .audio, outputSettings: settings)
-
+        let audioInput = AVAssetWriterInput(mediaType: .audio, outputSettings: nil)
         audioInput.expectsMediaDataInRealTime = true
         videoWriter?.add(audioInput)
-
         return audioInput
     }
 
@@ -119,15 +158,20 @@ public final class ScreenRecorder {
                     handler(passedError)
                     sent = true
                 }
+                return
             }
 
             switch sampleType {
             case .video:
                 self.handleSampleBuffer(sampleBuffer: sampleBuffer)
             case .audioApp:
-                self.add(sample: sampleBuffer, to: self.appAudioWriterInput)
+                if self.recordAudio {
+                    self.add(sample: sampleBuffer, to: self.appAudioWriterInput)
+                }
             case .audioMic:
-                self.add(sample: sampleBuffer, to: self.micAudioWriterInput)
+                if self.recordAudio {
+                    self.add(sample: sampleBuffer, to: self.micAudioWriterInput)
+                }
             default:
                 break
             }
@@ -149,26 +193,48 @@ public final class ScreenRecorder {
     }
 
     private func add(sample: CMSampleBuffer, to writerInput: AVAssetWriterInput?) {
-        if writerInput?.isReadyForMoreMediaData ?? false {
-            writerInput?.append(sample)
+        guard let writerInput = writerInput else { return }
+        guard self.videoWriter?.status == .writing else { return }
+        if writerInput.isReadyForMoreMediaData {
+            writerInput.append(sample)
         }
     }
 
-    /**
-     Stops recording the content of the application screen, after calling startRecording
-
-     - Parameter errorHandler: Called when an error is found
-     */
     public func stoprecording(handler: @escaping (Error?) -> Void) {
-        recorder.stopCapture( handler: { error in
+        recorder.stopCapture(handler: { error in
             if let error = error {
                 handler(error)
+                return
+            }
+
+            self.videoWriterInput?.markAsFinished()
+            self.micAudioWriterInput?.markAsFinished()
+            self.appAudioWriterInput?.markAsFinished()
+
+            guard let writer = self.videoWriter else {
+                handler(nil)
+                return
+            }
+
+            if writer.status == .writing {
+                writer.finishWriting {
+                    if let finishError = writer.error {
+                        handler(finishError)
+                        return
+                    }
+                    if self.saveToCameraRoll {
+                        self.saveVideoToCameraRollAfterAuthorized(handler: handler)
+                    } else {
+                        handler(nil)
+                    }
+                }
+            } else if writer.status == .failed {
+                handler(writer.error)
             } else {
-                self.videoWriterInput?.markAsFinished()
-                self.micAudioWriterInput?.markAsFinished()
-                self.appAudioWriterInput?.markAsFinished()
-                self.videoWriter?.finishWriting {
+                if self.saveToCameraRoll {
                     self.saveVideoToCameraRollAfterAuthorized(handler: handler)
+                } else {
+                    handler(nil)
                 }
             }
         })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/capacitor-screen-recorder",
-  "version": "8.2.37",
+  "version": "8.3.0",
   "description": "Record device's screen",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",