Merge pull request #5811 from vector-im/feature/ons/voip_screen_sharing_permission

onurays · web-flow · commit 8eaa2f8dfb67 · 2022-04-21T16:03:35.000+03:00
VoIP Screen Sharing Permission
diff --git a/changelog.d/5811.feature b/changelog.d/5811.feature
@@ -0,0 +1 @@
+VoIP Screen Sharing Permission
diff --git a/vector/src/debug/java/im/vector/app/features/debug/features/DebugVectorFeatures.kt b/vector/src/debug/java/im/vector/app/features/debug/features/DebugVectorFeatures.kt
@@ -60,6 +60,9 @@ class DebugVectorFeatures(
     override fun isLiveLocationEnabled(): Boolean = read(DebugFeatureKeys.liveLocationSharing)
             ?: vectorFeatures.isLiveLocationEnabled()
 
+    override fun isScreenSharingEnabled(): Boolean = read(DebugFeatureKeys.screenSharing)
+            ?: vectorFeatures.isScreenSharingEnabled()
+
     fun <T> override(value: T?, key: Preferences.Key<T>) = updatePreferences {
         if (value == null) {
             it.remove(key)
@@ -114,4 +117,5 @@ object DebugFeatureKeys {
     val onboardingPersonalize = booleanPreferencesKey("onboarding-personalize")
     val onboardingCombinedRegister = booleanPreferencesKey("onboarding-combined-register")
     val liveLocationSharing = booleanPreferencesKey("live-location-sharing")
+    val screenSharing = booleanPreferencesKey("screen-sharing")
 }
diff --git a/vector/src/main/AndroidManifest.xml b/vector/src/main/AndroidManifest.xml
@@ -375,6 +375,12 @@
             android:exported="false"
             android:foregroundServiceType="location" />
 
+        <service
+            android:name=".features.call.webrtc.ScreenCaptureService"
+            android:exported="false"
+            android:foregroundServiceType="mediaProjection"
+            tools:targetApi="Q" />
+
         <!-- Receivers -->
 
         <receiver
diff --git a/vector/src/main/java/im/vector/app/features/VectorFeatures.kt b/vector/src/main/java/im/vector/app/features/VectorFeatures.kt
@@ -27,6 +27,7 @@ interface VectorFeatures {
     fun isOnboardingPersonalizeEnabled(): Boolean
     fun isOnboardingCombinedRegisterEnabled(): Boolean
     fun isLiveLocationEnabled(): Boolean
+    fun isScreenSharingEnabled(): Boolean
 
     enum class OnboardingVariant {
         LEGACY,
@@ -43,4 +44,5 @@ class DefaultVectorFeatures : VectorFeatures {
     override fun isOnboardingPersonalizeEnabled() = false
     override fun isOnboardingCombinedRegisterEnabled() = false
     override fun isLiveLocationEnabled(): Boolean = false
+    override fun isScreenSharingEnabled(): Boolean = false
 }
diff --git a/vector/src/main/java/im/vector/app/features/call/CallControlsBottomSheet.kt b/vector/src/main/java/im/vector/app/features/call/CallControlsBottomSheet.kt
@@ -27,13 +27,17 @@ import dagger.hilt.android.AndroidEntryPoint
 import im.vector.app.R
 import im.vector.app.core.platform.VectorBaseBottomSheetDialogFragment
 import im.vector.app.databinding.BottomSheetCallControlsBinding
+import im.vector.app.features.VectorFeatures
+import javax.inject.Inject
 
 @AndroidEntryPoint
 class CallControlsBottomSheet : VectorBaseBottomSheetDialogFragment<BottomSheetCallControlsBinding>() {
     override fun getBinding(inflater: LayoutInflater, container: ViewGroup?): BottomSheetCallControlsBinding {
         return BottomSheetCallControlsBinding.inflate(inflater, container, false)
     }
 
+    @Inject lateinit var vectorFeatures: VectorFeatures
+
     private val callViewModel: VectorCallViewModel by activityViewModel()
 
     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
@@ -66,6 +70,12 @@ class CallControlsBottomSheet : VectorBaseBottomSheetDialogFragment<BottomSheetC
             callViewModel.handle(VectorCallViewActions.InitiateCallTransfer)
             dismiss()
         }
+
+        views.callControlsShareScreen.isVisible = vectorFeatures.isScreenSharingEnabled()
+        views.callControlsShareScreen.views.bottomSheetActionClickableZone.debouncedClicks {
+            callViewModel.handle(VectorCallViewActions.ToggleScreenSharing)
+            dismiss()
+        }
     }
 
     private fun renderState(state: VectorCallViewState) {
@@ -95,5 +105,6 @@ class CallControlsBottomSheet : VectorBaseBottomSheetDialogFragment<BottomSheetC
             views.callControlsToggleHoldResume.leftIcon = ContextCompat.getDrawable(requireContext(), R.drawable.ic_call_hold_action)
         }
         views.callControlsTransfer.isVisible = state.canOpponentBeTransferred
+        views.callControlsShareScreen.title = getString(if (state.isSharingScreen) R.string.call_stop_screen_sharing else R.string.call_start_screen_sharing)
     }
 }
diff --git a/vector/src/main/java/im/vector/app/features/call/VectorCallActivity.kt b/vector/src/main/java/im/vector/app/features/call/VectorCallActivity.kt
@@ -24,6 +24,7 @@ import android.content.Intent
 import android.content.Intent.FLAG_ACTIVITY_CLEAR_TOP
 import android.content.res.Configuration
 import android.graphics.Color
+import android.media.projection.MediaProjectionManager
 import android.os.Build
 import android.os.Bundle
 import android.os.Parcelable
@@ -56,6 +57,8 @@ import im.vector.app.features.call.dialpad.CallDialPadBottomSheet
 import im.vector.app.features.call.dialpad.DialPadFragment
 import im.vector.app.features.call.transfer.CallTransferActivity
 import im.vector.app.features.call.utils.EglUtils
+import im.vector.app.features.call.webrtc.ScreenCaptureService
+import im.vector.app.features.call.webrtc.ScreenCaptureServiceConnection
 import im.vector.app.features.call.webrtc.WebRtcCall
 import im.vector.app.features.call.webrtc.WebRtcCallManager
 import im.vector.app.features.displayname.getBestName
@@ -94,6 +97,7 @@ class VectorCallActivity : VectorBaseActivity<ActivityCallBinding>(), CallContro
 
     @Inject lateinit var callManager: WebRtcCallManager
     @Inject lateinit var avatarRenderer: AvatarRenderer
+    @Inject lateinit var screenCaptureServiceConnection: ScreenCaptureServiceConnection
 
     private val callViewModel: VectorCallViewModel by viewModel()
 
@@ -512,20 +516,22 @@ class VectorCallActivity : VectorBaseActivity<ActivityCallBinding>(), CallContro
     private fun handleViewEvents(event: VectorCallViewEvents?) {
         Timber.tag(loggerTag.value).v("handleViewEvents $event")
         when (event) {
-            is VectorCallViewEvents.ConnectionTimeout      -> {
+            is VectorCallViewEvents.ConnectionTimeout                 -> {
                 onErrorTimoutConnect(event.turn)
             }
-            is VectorCallViewEvents.ShowDialPad            -> {
+            is VectorCallViewEvents.ShowDialPad                       -> {
                 CallDialPadBottomSheet.newInstance(false).apply {
                     callback = dialPadCallback
                 }.show(supportFragmentManager, FRAGMENT_DIAL_PAD_TAG)
             }
-            is VectorCallViewEvents.ShowCallTransferScreen -> {
+            is VectorCallViewEvents.ShowCallTransferScreen            -> {
                 val callId = withState(callViewModel) { it.callId }
                 navigator.openCallTransfer(this, callTransferActivityResultLauncher, callId)
             }
-            is VectorCallViewEvents.FailToTransfer         -> showSnackbar(getString(R.string.call_transfer_failure))
-            else                                           -> Unit
+            is VectorCallViewEvents.FailToTransfer                    -> showSnackbar(getString(R.string.call_transfer_failure))
+            is VectorCallViewEvents.ShowScreenSharingPermissionDialog -> handleShowScreenSharingPermissionDialog()
+            is VectorCallViewEvents.StopScreenSharingService          -> handleStopScreenSharingService()
+            else                                                      -> Unit
         }
     }
 
@@ -628,6 +634,32 @@ class VectorCallActivity : VectorBaseActivity<ActivityCallBinding>(), CallContro
         }
     }
 
+    private val screenSharingPermissionActivityResultLauncher = registerStartForActivityResult { activityResult ->
+        if (activityResult.resultCode == Activity.RESULT_OK) {
+            callViewModel.handle(VectorCallViewActions.StartScreenSharing)
+            // We need to start a foreground service with a sticky notification during screen sharing
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                ContextCompat.startForegroundService(
+                        this,
+                        Intent(this, ScreenCaptureService::class.java)
+                )
+                screenCaptureServiceConnection.bind()
+            }
+        }
+    }
+
+    private fun handleShowScreenSharingPermissionDialog() {
+        getSystemService<MediaProjectionManager>()?.let {
+            navigator.openScreenSharingPermissionDialog(it.createScreenCaptureIntent(), screenSharingPermissionActivityResultLauncher)
+        }
+    }
+
+    private fun handleStopScreenSharingService() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            screenCaptureServiceConnection.stopScreenCapturing()
+        }
+    }
+
     companion object {
         private const val EXTRA_MODE = "EXTRA_MODE"
         private const val FRAGMENT_DIAL_PAD_TAG = "FRAGMENT_DIAL_PAD_TAG"
diff --git a/vector/src/main/java/im/vector/app/features/call/VectorCallViewActions.kt b/vector/src/main/java/im/vector/app/features/call/VectorCallViewActions.kt
@@ -40,4 +40,6 @@ sealed class VectorCallViewActions : VectorViewModelAction {
     object CallTransferSelectionCancelled : VectorCallViewActions()
     data class CallTransferSelectionResult(val callTransferResult: CallTransferResult) : VectorCallViewActions()
     object TransferCall : VectorCallViewActions()
+    object ToggleScreenSharing : VectorCallViewActions()
+    object StartScreenSharing : VectorCallViewActions()
 }
diff --git a/vector/src/main/java/im/vector/app/features/call/VectorCallViewEvents.kt b/vector/src/main/java/im/vector/app/features/call/VectorCallViewEvents.kt
@@ -31,7 +31,6 @@ sealed class VectorCallViewEvents : VectorViewEvents {
     object ShowDialPad : VectorCallViewEvents()
     object ShowCallTransferScreen : VectorCallViewEvents()
     object FailToTransfer : VectorCallViewEvents()
-//    data class CallAnswered(val content: CallAnswerContent) : VectorCallViewEvents()
-//    data class CallHangup(val content: CallHangupContent) : VectorCallViewEvents()
-//    object CallAccepted : VectorCallViewEvents()
+    object ShowScreenSharingPermissionDialog : VectorCallViewEvents()
+    object StopScreenSharingService : VectorCallViewEvents()
 }
diff --git a/vector/src/main/java/im/vector/app/features/call/VectorCallViewModel.kt b/vector/src/main/java/im/vector/app/features/call/VectorCallViewModel.kt
@@ -256,7 +256,10 @@ class VectorCallViewModel @AssistedInject constructor(
 
     override fun handle(action: VectorCallViewActions) = withState { state ->
         when (action) {
-            VectorCallViewActions.EndCall                        -> call?.endCall()
+            VectorCallViewActions.EndCall                        -> {
+                call?.endCall()
+                _viewEvents.post(VectorCallViewEvents.StopScreenSharingService)
+            }
             VectorCallViewActions.AcceptCall                     -> {
                 setState {
                     copy(callState = Loading())
@@ -341,6 +344,31 @@ class VectorCallViewModel @AssistedInject constructor(
                 setState { VectorCallViewState(action.callArgs) }
                 setupCallWithCurrentState()
             }
+            is VectorCallViewActions.ToggleScreenSharing         -> {
+                handleToggleScreenSharing(state.isSharingScreen)
+            }
+            is VectorCallViewActions.StartScreenSharing          -> {
+                call?.startSharingScreen()
+                setState {
+                    copy(isSharingScreen = true)
+                }
+            }
+        }
+    }
+
+    private fun handleToggleScreenSharing(isSharingScreen: Boolean) {
+        if (isSharingScreen) {
+            call?.stopSharingScreen()
+            setState {
+                copy(isSharingScreen = false)
+            }
+            _viewEvents.post(
+                    VectorCallViewEvents.StopScreenSharingService
+            )
+        } else {
+            _viewEvents.post(
+                    VectorCallViewEvents.ShowScreenSharingPermissionDialog
+            )
         }
     }
 
diff --git a/vector/src/main/java/im/vector/app/features/call/VectorCallViewState.kt b/vector/src/main/java/im/vector/app/features/call/VectorCallViewState.kt
@@ -42,7 +42,8 @@ data class VectorCallViewState(
         val callInfo: CallInfo? = null,
         val formattedDuration: String = "",
         val canOpponentBeTransferred: Boolean = false,
-        val transferee: TransfereeState = TransfereeState.NoTransferee
+        val transferee: TransfereeState = TransfereeState.NoTransferee,
+        val isSharingScreen: Boolean = false
 ) : MavericksState {
 
     sealed class TransfereeState {
diff --git a/vector/src/main/java/im/vector/app/features/call/webrtc/ScreenCaptureService.kt b/vector/src/main/java/im/vector/app/features/call/webrtc/ScreenCaptureService.kt
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2022 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.app.features.call.webrtc
+
+import android.content.Intent
+import android.os.Binder
+import android.os.IBinder
+import dagger.hilt.android.AndroidEntryPoint
+import im.vector.app.core.services.VectorService
+import im.vector.app.features.notifications.NotificationUtils
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class ScreenCaptureService : VectorService() {
+
+    @Inject lateinit var notificationUtils: NotificationUtils
+    private val binder = LocalBinder()
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        showStickyNotification()
+
+        return START_STICKY
+    }
+
+    private fun showStickyNotification() {
+        val notificationId = System.currentTimeMillis().toInt()
+        val notification = notificationUtils.buildScreenSharingNotification()
+        startForeground(notificationId, notification)
+    }
+
+    override fun onBind(intent: Intent?): IBinder {
+        return binder
+    }
+
+    fun stopService() {
+        stopSelf()
+    }
+
+    inner class LocalBinder : Binder() {
+        fun getService(): ScreenCaptureService = this@ScreenCaptureService
+    }
+}
diff --git a/vector/src/main/java/im/vector/app/features/call/webrtc/ScreenCaptureServiceConnection.kt b/vector/src/main/java/im/vector/app/features/call/webrtc/ScreenCaptureServiceConnection.kt
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2022 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.app.features.call.webrtc
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.ServiceConnection
+import android.os.IBinder
+import javax.inject.Inject
+
+class ScreenCaptureServiceConnection @Inject constructor(
+        private val context: Context
+) : ServiceConnection {
+
+    private var isBound = false
+    private var screenCaptureService: ScreenCaptureService? = null
+
+    fun bind() {
+        if (!isBound) {
+            Intent(context, ScreenCaptureService::class.java).also { intent ->
+                context.bindService(intent, this, 0)
+            }
+        }
+    }
+
+    fun stopScreenCapturing() {
+        screenCaptureService?.stopService()
+    }
+
+    override fun onServiceConnected(className: ComponentName, binder: IBinder) {
+        screenCaptureService = (binder as ScreenCaptureService.LocalBinder).getService()
+        isBound = true
+    }
+
+    override fun onServiceDisconnected(className: ComponentName) {
+        isBound = false
+        screenCaptureService = null
+    }
+}
diff --git a/vector/src/main/java/im/vector/app/features/call/webrtc/WebRtcCall.kt b/vector/src/main/java/im/vector/app/features/call/webrtc/WebRtcCall.kt
@@ -770,6 +770,14 @@ class WebRtcCall(
         return currentCaptureFormat
     }
 
+    fun startSharingScreen() {
+        // TODO. Will be handled within the next PR.
+    }
+
+    fun stopSharingScreen() {
+        // TODO. Will be handled within the next PR.
+    }
+
     private suspend fun release() {
         listeners.clear()
         mxCall.removeListener(this)
diff --git a/vector/src/main/java/im/vector/app/features/navigation/DefaultNavigator.kt b/vector/src/main/java/im/vector/app/features/navigation/DefaultNavigator.kt
@@ -600,4 +600,9 @@ class DefaultNavigator @Inject constructor(
                         roomEncryptionTrustLevel = threadTimelineArgs.roomEncryptionTrustLevel
                 )))
     }
+
+    override fun openScreenSharingPermissionDialog(screenCaptureIntent: Intent,
+                                                   activityResultLauncher: ActivityResultLauncher<Intent>) {
+        activityResultLauncher.launch(screenCaptureIntent)
+    }
 }
diff --git a/vector/src/main/java/im/vector/app/features/navigation/Navigator.kt b/vector/src/main/java/im/vector/app/features/navigation/Navigator.kt
@@ -168,4 +168,9 @@ interface Navigator {
     fun openThread(context: Context, threadTimelineArgs: ThreadTimelineArgs, eventIdToNavigate: String? = null)
 
     fun openThreadList(context: Context, threadTimelineArgs: ThreadTimelineArgs)
+
+    fun openScreenSharingPermissionDialog(
+            screenCaptureIntent: Intent,
+            activityResultLauncher: ActivityResultLauncher<Intent>
+    )
 }
diff --git a/vector/src/main/java/im/vector/app/features/notifications/NotificationUtils.kt b/vector/src/main/java/im/vector/app/features/notifications/NotificationUtils.kt
diff --git a/vector/src/main/res/drawable/ic_share_screen.xml b/vector/src/main/res/drawable/ic_share_screen.xml
diff --git a/vector/src/main/res/layout/bottom_sheet_call_controls.xml b/vector/src/main/res/layout/bottom_sheet_call_controls.xml
diff --git a/vector/src/main/res/values/strings.xml b/vector/src/main/res/values/strings.xml

Original file line number	Diff line number	Diff line change
`@@ -27,13 +27,17 @@ import dagger.hilt.android.AndroidEntryPoint`
`27`	`27`	`import im.vector.app.R`
`28`	`28`	`import im.vector.app.core.platform.VectorBaseBottomSheetDialogFragment`
`29`	`29`	`import im.vector.app.databinding.BottomSheetCallControlsBinding`
	`30`	`+import im.vector.app.features.VectorFeatures`
	`31`	`+import javax.inject.Inject`
`30`	`32`
`31`	`33`	`@AndroidEntryPoint`
`32`	`34`	`class CallControlsBottomSheet : VectorBaseBottomSheetDialogFragment<BottomSheetCallControlsBinding>() {`
`33`	`35`	`override fun getBinding(inflater: LayoutInflater, container: ViewGroup?): BottomSheetCallControlsBinding {`
`34`	`36`	`return BottomSheetCallControlsBinding.inflate(inflater, container, false)`
`35`	`37`	`}`
`36`	`38`
	`39`	`+ @Inject lateinit var vectorFeatures: VectorFeatures`
	`40`	`+`
`37`	`41`	`private val callViewModel: VectorCallViewModel by activityViewModel()`
`38`	`42`
`39`	`43`	`override fun onViewCreated(view: View, savedInstanceState: Bundle?) {`
`@@ -66,6 +70,12 @@ class CallControlsBottomSheet : VectorBaseBottomSheetDialogFragment<BottomSheetC`
`66`	`70`	`callViewModel.handle(VectorCallViewActions.InitiateCallTransfer)`
`67`	`71`	`dismiss()`
`68`	`72`	`}`
	`73`	`+`
	`74`	`+ views.callControlsShareScreen.isVisible = vectorFeatures.isScreenSharingEnabled()`
	`75`	`+ views.callControlsShareScreen.views.bottomSheetActionClickableZone.debouncedClicks {`
	`76`	`+ callViewModel.handle(VectorCallViewActions.ToggleScreenSharing)`
	`77`	`+ dismiss()`
	`78`	`+ }`
`69`	`79`	`}`
`70`	`80`
`71`	`81`	`private fun renderState(state: VectorCallViewState) {`
`@@ -95,5 +105,6 @@ class CallControlsBottomSheet : VectorBaseBottomSheetDialogFragment<BottomSheetC`
`95`	`105`	`views.callControlsToggleHoldResume.leftIcon = ContextCompat.getDrawable(requireContext(), R.drawable.ic_call_hold_action)`
`96`	`106`	`}`
`97`	`107`	`views.callControlsTransfer.isVisible = state.canOpponentBeTransferred`
	`108`	`+ views.callControlsShareScreen.title = getString(if (state.isSharingScreen) R.string.call_stop_screen_sharing else R.string.call_start_screen_sharing)`
`98`	`109`	`}`
`99`	`110`	`}`
Original file line number	Diff line number	Diff line change
`@@ -40,4 +40,6 @@ sealed class VectorCallViewActions : VectorViewModelAction {`
`40`	`40`	`object CallTransferSelectionCancelled : VectorCallViewActions()`
`41`	`41`	`data class CallTransferSelectionResult(val callTransferResult: CallTransferResult) : VectorCallViewActions()`
`42`	`42`	`object TransferCall : VectorCallViewActions()`
	`43`	`+ object ToggleScreenSharing : VectorCallViewActions()`
	`44`	`+ object StartScreenSharing : VectorCallViewActions()`
`43`	`45`	`}`