fix(demos): camera: fix creation of new streamer when enabling/disabling audio

Author: ThibaultBee

demos/camera/src/main/java/io/github/thibaultbee/streampack/app/ui/main/PreviewFragment.kt

@@ -43,6 +43,7 @@ import kotlinx.coroutines.launch
 
 class PreviewFragment : Fragment(R.layout.main_fragment) {
     private lateinit var binding: MainFragmentBinding
+    private var previousStreamerLifecycleObserver: StreamerViewModelLifeCycleObserver? = null
 
     private val previewViewModel: PreviewViewModel by viewModels {
         PreviewViewModelFactory(requireActivity().application)
@@ -107,8 +108,14 @@ class PreviewFragment : Fragment(R.layout.main_fragment) {
 
         previewViewModel.streamerLiveData.observe(viewLifecycleOwner) { streamer ->
             if (streamer is IStreamer) {
-                // TODO: Remove this observer when streamer is released
-                lifecycle.addObserver(StreamerViewModelLifeCycleObserver(streamer))
+                if (previousStreamerLifecycleObserver != null) {
+                    lifecycle.removeObserver(previousStreamerLifecycleObserver!!)
+                }
+                val newObserver = StreamerViewModelLifeCycleObserver(streamer).apply {
+                    previousStreamerLifecycleObserver = this
+                }
+                lifecycle.addObserver(newObserver)
+
             } else {
                 Log.e(TAG, "Streamer is not a ICoroutineStreamer")
             }

demos/camera/src/main/java/io/github/thibaultbee/streampack/app/ui/main/PreviewViewModel.kt

@@ -65,6 +65,7 @@ import kotlinx.coroutines.flow.filterNotNull
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 
@@ -74,7 +75,12 @@ class PreviewViewModel(private val application: Application) : ObservableViewMod
 
     private val buildStreamerUseCase = BuildStreamerUseCase(application, storageRepository)
 
-    private val streamerFlow = MutableStateFlow(buildStreamerUseCase())
+    private val streamerFlow =
+        MutableStateFlow(
+            SingleStreamer(
+                application,
+                runBlocking { storageRepository.isAudioEnableFlow.first() }) // TODO avoid runBlocking
+        )
     private val streamer: SingleStreamer
         get() = streamerFlow.value
     val streamerLiveData = streamerFlow.asLiveData()
@@ -119,8 +125,9 @@ class PreviewViewModel(private val application: Application) : ObservableViewMod
     val endpointErrorLiveData: LiveData<String> = _endpointErrorLiveData
 
     // Streamer states
+    private val _isStreamingFlow = MutableStateFlow(false)
     val isStreamingLiveData: LiveData<Boolean>
-        get() = streamer.isStreamingFlow.asLiveData()
+        get() = _isStreamingFlow.asLiveData()
     private val _isTryingConnectionLiveData = MutableLiveData<Boolean>()
     val isTryingConnectionLiveData: LiveData<Boolean> = _isTryingConnectionLiveData
 
@@ -148,6 +155,7 @@ class PreviewViewModel(private val application: Application) : ObservableViewMod
                     Log.i(TAG, "Video source is disabled")
                 }
 
+                // TODO: cancel jobs linked to previous streamer
                 viewModelScope.launch {
                     streamer.videoInput?.sourceFlow?.collect {
                         notifySourceChanged()
@@ -174,8 +182,9 @@ class PreviewViewModel(private val application: Application) : ObservableViewMod
                 }
                 viewModelScope.launch {
                     streamer.isStreamingFlow
-                        .collect {
-                            Log.i(TAG, "Streamer is streaming: $it")
+                        .collect { isStreaming ->
+                            _isStreamingFlow.emit(isStreaming)
+                            Log.i(TAG, "Streamer is streaming: $isStreaming")
                         }
                 }
             }
@@ -190,34 +199,30 @@ class PreviewViewModel(private val application: Application) : ObservableViewMod
         viewModelScope.launch {
             storageRepository.isAudioEnableFlow.combine(storageRepository.isVideoEnableFlow) { isAudioEnable, isVideoEnable ->
                 Pair(isAudioEnable, isVideoEnable)
-            }.drop(1).collect { (_, _) ->
-                val previousStreamer = streamer
-                streamerFlow.emit(buildStreamerUseCase(previousStreamer))
-                if (previousStreamer != streamer) {
-                    previousStreamer.release()
-                }
+            }.drop(1).collect { (isAudioEnable, _) ->
+                streamerFlow.emit(buildStreamerUseCase(streamer, isAudioEnable))
             }
         }
         viewModelScope.launch {
-            storageRepository.audioConfigFlow
+            storageRepository.audioConfigFlow.filterNotNull()
                 .collect { config ->
+                    if (!streamer.withAudio) {
+                        Log.i(TAG, "Audio is disabled. Skip setting audio config")
+                        return@collect
+                    }
                     if (ActivityCompat.checkSelfPermission(
                             application,
                             Manifest.permission.RECORD_AUDIO
                         ) == PackageManager.PERMISSION_GRANTED
                     ) {
-                        config?.let {
-                            streamer.setAudioConfig(it)
-                        } ?: Log.i(TAG, "Audio is disabled")
+                        streamer.setAudioConfig(config)
                     }
                 }
         }
         viewModelScope.launch {
-            storageRepository.videoConfigFlow
+            storageRepository.videoConfigFlow.filterNotNull()
                 .collect { config ->
-                    config?.let {
-                        streamer.setVideoConfig(it)
-                    } ?: Log.i(TAG, "Video is disabled")
+                    streamer.setVideoConfig(config)
                 }
         }
     }

demos/camera/src/main/java/io/github/thibaultbee/streampack/app/ui/main/usecases/BuildStreamerUseCase.kt

@@ -1,10 +1,11 @@
 package io.github.thibaultbee.streampack.app.ui.main.usecases
 
+import android.Manifest
 import android.content.Context
+import android.content.pm.PackageManager
+import androidx.core.app.ActivityCompat
 import io.github.thibaultbee.streampack.app.data.storage.DataStoreRepository
 import io.github.thibaultbee.streampack.core.streamers.single.SingleStreamer
-import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.runBlocking
 
 class BuildStreamerUseCase(
     private val context: Context,
@@ -15,17 +16,33 @@ class BuildStreamerUseCase(
      *
      * Only create a new streamer if the previous one is not the same type.
      *
+     * It releases the previous streamer if a new one is created.
+     *
      * @param previousStreamer Previous streamer to check if we need to create a new one.
      */
-    operator fun invoke(previousStreamer: SingleStreamer? = null): SingleStreamer {
-        val isAudioEnable = runBlocking {
-            dataStoreRepository.isAudioEnableFlow.first()
-        }
-
-        if (previousStreamer == null) {
-            return SingleStreamer(context, isAudioEnable)
-        } else if ((previousStreamer.audioInput?.sourceFlow?.value == null) != !isAudioEnable) {
-            return SingleStreamer(context, isAudioEnable)
+    suspend operator fun invoke(
+        previousStreamer: SingleStreamer,
+        isAudioEnable: Boolean
+    ): SingleStreamer {
+        if (previousStreamer.withAudio != isAudioEnable) {
+            return SingleStreamer(context, isAudioEnable).apply {
+                // Get previous streamer config if any
+                val audioConfig = previousStreamer.audioConfigFlow.value
+                val videoConfig = previousStreamer.videoConfigFlow.value
+                if ((audioConfig != null && isAudioEnable)) {
+                    if (ActivityCompat.checkSelfPermission(
+                            context,
+                            Manifest.permission.RECORD_AUDIO
+                        ) == PackageManager.PERMISSION_GRANTED
+                    ) {
+                        setAudioConfig(audioConfig)
+                    }
+                }
+                if (videoConfig != null) {
+                    setVideoConfig(videoConfig)
+                }
+                previousStreamer.release()
+            }
         }
         return previousStreamer
     }