@capgo/capacitor-screen-recorder 8.2.36 → 8.2.38

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,182 @@
+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 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 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()}.mp4")
+    }
+
+    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,51 @@ import dev.bmcreations.scrcast.config.Options;
 @CapacitorPlugin(name = "ScreenRecorder")
 public class ScreenRecorderPlugin extends Plugin {
 
-    private final String pluginVersion = "8.2.36";
+    private final String pluginVersion = "8.2.38";
 
     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);
+            recordingWithAudio = recordAudio;
+
+            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/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/ios/Sources/ScreenRecorderPlugin/ScreenRecorderPlugin.swift

@@ -7,7 +7,7 @@ import Capacitor
  */
 @objc(ScreenRecorderPlugin)
 public class ScreenRecorderPlugin: CAPPlugin, CAPBridgedPlugin {
-    private let pluginVersion: String = "8.2.36"
+    private let pluginVersion: String = "8.2.38"
     public let identifier = "ScreenRecorderPlugin"
     public let jsName = "ScreenRecorder"
     public let pluginMethods: [CAPPluginMethod] = [
@@ -18,7 +18,8 @@ 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
+        implementation.startRecording(saveToCameraRoll: true, recordAudio: recordAudio, handler: { error in
             if let error = error {
                 debugPrint("Error when start recording \(error)")
                 call.reject("Cannot start recording")

package/ios/Sources/ScreenRecorderPlugin/Wyler.swift

@@ -6,9 +6,11 @@
 //  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
@@ -22,37 +24,47 @@ public final class ScreenRecorder {
     private var micAudioWriterInput: AVAssetWriterInput?
     private var appAudioWriterInput: AVAssetWriterInput?
     private var saveToCameraRoll = false
+    private var recordAudio = false
     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,
                                handler: @escaping (Error?) -> Void) {
-        recorder.isMicrophoneEnabled = true
+        self.saveToCameraRoll = saveToCameraRoll
+        self.recordAudio = recordAudio
+        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 {
@@ -93,18 +105,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 +122,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 +157,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.36",
+  "version": "8.2.38",
   "description": "Record device's screen",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -55,8 +55,7 @@
     "prepublishOnly": "bun run build",
     "check:wiring": "node scripts/check-capacitor-plugin-wiring.mjs",
     "example:install": "cd example-app && bun install --frozen-lockfile",
-    "example:build": "bun run build && cd example-app && bun install --frozen-lockfile && bun run build",
-    "example:capgo:deploy": "bun run example:build && bun scripts/deploy-example-capgo.mjs"
+    "example:build": "bun run build && cd example-app && bun install --frozen-lockfile && bun run build"
   },
   "devDependencies": {
     "@capacitor/android": "^8.0.0",