Add extra logs the 'send call notification' flow (#4819)

features/call/api/src/main/kotlin/io/element/android/features/call/api/CallType.kt

@@ -15,11 +15,19 @@ import kotlinx.parcelize.Parcelize
 
 sealed interface CallType : NodeInputs, Parcelable {
     @Parcelize
-    data class ExternalUrl(val url: String) : CallType
+    data class ExternalUrl(val url: String) : CallType {
+        override fun toString(): String {
+            return "ExternalUrl"
+        }
+    }
 
     @Parcelize
     data class RoomCall(
         val sessionId: SessionId,
         val roomId: RoomId,
-    ) : CallType
+    ) : CallType {
+        override fun toString(): String {
+            return "RoomCall(sessionId=$sessionId, roomId=$roomId)"
+        }
+    }
 }

features/call/impl/src/main/kotlin/io/element/android/features/call/impl/ui/CallScreenPresenter.kt

@@ -50,6 +50,7 @@ import kotlinx.coroutines.launch
 import kotlinx.serialization.json.contentOrNull
 import kotlinx.serialization.json.jsonObject
 import kotlinx.serialization.json.jsonPrimitive
+import timber.log.Timber
 import java.util.UUID
 
 class CallScreenPresenter @AssistedInject constructor(
@@ -213,6 +214,7 @@ class CallScreenPresenter @AssistedInject constructor(
                         theme = theme,
                     ).getOrThrow()
                     callWidgetDriver.value = result.driver
+                    Timber.d("Call widget driver initialized for sessionId: ${inputs.sessionId}, roomId: ${inputs.roomId}")
                     result.url
                 }
             }
@@ -223,10 +225,12 @@ class CallScreenPresenter @AssistedInject constructor(
     private fun HandleMatrixClientSyncState() {
         val coroutineScope = rememberCoroutineScope()
         DisposableEffect(Unit) {
-            val client = (callType as? CallType.RoomCall)?.sessionId?.let {
+            val roomCallType = callType as? CallType.RoomCall ?: return@DisposableEffect onDispose {}
-                matrixClientsProvider.getOrNull(it)
+            val client = matrixClientsProvider.getOrNull(roomCallType.sessionId) ?: return@DisposableEffect onDispose {
-            } ?: return@DisposableEffect onDispose { }
+                Timber.w("No MatrixClient found for sessionId, can't send call notification: ${roomCallType.sessionId}")
+            }
             coroutineScope.launch {
+                Timber.d("Observing sync state in-call for sessionId: ${roomCallType.sessionId}")
                 client.syncService().syncState
                     .collect { state ->
                         if (state == SyncState.Running) {
@@ -237,6 +241,7 @@ class CallScreenPresenter @AssistedInject constructor(
                     }
             }
             onDispose {
+                Timber.d("Stopped observing sync state in-call for sessionId: ${roomCallType.sessionId}")
                 // Make sure we mark the call as ended in the app state
                 appForegroundStateService.updateIsInCallState(false)
             }
@@ -244,12 +249,29 @@ class CallScreenPresenter @AssistedInject constructor(
     }
 
     private suspend fun MatrixClient.notifyCallStartIfNeeded(roomId: RoomId) {
-        if (!notifiedCallStart) {
+        if (notifiedCallStart) return
-            val activeRoomForSession = activeRoomsHolder.getActiveRoomMatching(sessionId, roomId)
+
-            val sendCallNotificationResult = activeRoomForSession?.sendCallNotificationIfNeeded()
+        val activeRoomForSession = activeRoomsHolder.getActiveRoomMatching(sessionId, roomId)
-                ?: getJoinedRoom(roomId)?.use { it.sendCallNotificationIfNeeded() }
+        val sendCallNotificationResult = if (activeRoomForSession != null) {
-            sendCallNotificationResult?.onSuccess { notifiedCallStart = true }
+            Timber.d("Notifying call start for room $roomId. Has room call: ${activeRoomForSession.info().hasRoomCall}")
+            activeRoomForSession.sendCallNotificationIfNeeded()
+        } else {
+            // Instantiate the room from the session and roomId and send the notification
+            getJoinedRoom(roomId)?.use { room ->
+                Timber.d("Notifying call start for room $roomId. Has room call: ${room.info().hasRoomCall}")
+                room.sendCallNotificationIfNeeded()
+            } ?: run {
+                Timber.w("No room found for session $sessionId and room $roomId, skipping call notification.")
+                return
+            }
         }
+
+        sendCallNotificationResult.fold(
+            onSuccess = { notifiedCallStart = true },
+            onFailure = { error ->
+                Timber.e(error, "Failed to send call notification for room $roomId.")
+            }
+        )
     }
 
     private fun parseMessage(message: String): WidgetMessage? {

features/call/impl/src/main/kotlin/io/element/android/features/call/impl/ui/CallScreenView.kt

@@ -134,11 +134,13 @@ internal fun CallScreenView(
                 AsyncData.Uninitialized,
                 is AsyncData.Loading ->
                     ProgressDialog(text = stringResource(id = CommonStrings.common_please_wait))
-                is AsyncData.Failure ->
+                is AsyncData.Failure -> {
+                    Timber.e(state.urlState.error, "WebView failed to load URL: ${state.urlState.error.message}")
                     ErrorDialog(
                         content = state.urlState.error.message.orEmpty(),
                         onSubmit = { state.eventSink(CallScreenEvents.Hangup) },
                     )
+                }
                 is AsyncData.Success -> Unit
             }
         }
@@ -242,6 +244,20 @@ private fun WebView.setup(
                 ConsoleMessage.MessageLevel.WARNING -> Log.WARN
                 else -> Log.DEBUG
             }
+
+            val message = buildString {
+                append(consoleMessage.sourceId())
+                append(":")
+                append(consoleMessage.lineNumber())
+                append(" ")
+                append(consoleMessage.message())
+            }
+
+            if (message.contains("password=")) {
+                // Avoid logging any messages that contain "password" to prevent leaking sensitive information
+                return true
+            }
+
             Timber.tag("WebView").log(
                 priority = priority,
                 message = buildString {

features/call/impl/src/main/kotlin/io/element/android/features/call/impl/ui/ElementCallActivity.kt

@@ -97,6 +97,8 @@ class ElementCallActivity :
 
         pictureInPicturePresenter.setPipView(this)
 
+        Timber.d("Created ElementCallActivity with call type: ${webViewTarget.value}")
+
         setContent {
             val pipState = pictureInPicturePresenter.present()
             ListenToAndroidEvents(pipState)

features/call/impl/src/main/kotlin/io/element/android/features/call/impl/utils/ActiveCallManager.kt

@@ -183,6 +183,9 @@ class DefaultActiveCallManager @Inject constructor(
             Timber.tag(tag).w("Call type $callType does not match the active call type, ignoring")
             return
         }
+
+        Timber.tag(tag).d("Hung up call: $callType")
+
         cancelIncomingCallNotification()
         if (activeWakeLock?.isHeld == true) {
             Timber.tag(tag).d("Releasing partial wakelock after hang up")
@@ -193,6 +196,8 @@ class DefaultActiveCallManager @Inject constructor(
     }
 
     override suspend fun joinedCall(callType: CallType) = mutex.withLock {
+        Timber.tag(tag).d("Joined call: $callType")
+
         cancelIncomingCallNotification()
         if (activeWakeLock?.isHeld == true) {
             Timber.tag(tag).d("Releasing partial wakelock after joining call")

features/roomcall/impl/src/main/kotlin/io/element/android/features/roomcall/impl/RoomCallStatePresenter.kt

@@ -46,14 +46,18 @@ class RoomCallStatePresenter @Inject constructor(
                 (currentCall as? CurrentCall.RoomCall)?.roomId == room.roomId
             }
         }
-        val callState = when {
+        val callState by remember {
-            isAvailable.not() -> RoomCallState.Unavailable
+            derivedStateOf {
-            roomInfo.hasRoomCall -> RoomCallState.OnGoing(
+                when {
-                canJoinCall = canJoinCall,
+                    isAvailable.not() -> RoomCallState.Unavailable
-                isUserInTheCall = isUserInTheCall,
+                    roomInfo.hasRoomCall -> RoomCallState.OnGoing(
-                isUserLocallyInTheCall = isUserLocallyInTheCall,
+                        canJoinCall = canJoinCall,
-            )
+                        isUserInTheCall = isUserInTheCall,
-            else -> RoomCallState.StandBy(canStartCall = canJoinCall)
+                        isUserLocallyInTheCall = isUserLocallyInTheCall,
+                    )
+                    else -> RoomCallState.StandBy(canStartCall = canJoinCall)
+                }
+            }
         }
         return callState
     }