Add catchingExceptions method to replace runCatching

appnav/src/main/kotlin/io/element/android/appnav/loggedin/LoggedInPresenter.kt

@@ -21,6 +21,7 @@ import im.vector.app.features.analytics.plan.CryptoSessionStateChange
 import im.vector.app.features.analytics.plan.UserProperties
 import io.element.android.libraries.architecture.AsyncData
 import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.core.extensions.runCatchingExceptions
 import io.element.android.libraries.core.log.logger.LoggerTag
 import io.element.android.libraries.core.meta.BuildMeta
 import io.element.android.libraries.matrix.api.MatrixClient
@@ -125,7 +126,7 @@ class LoggedInPresenter @Inject constructor(
     }
 
     // Force the user to log out if they were using the proxy sliding sync as it's no longer supported by the SDK
-    private suspend fun MatrixClient.needsForcedNativeSlidingSyncMigration(): Result<Boolean> = runCatching {
+    private suspend fun MatrixClient.needsForcedNativeSlidingSyncMigration(): Result<Boolean> = runCatchingExceptions {
         val currentSlidingSyncVersion = currentSlidingSyncVersion().getOrThrow()
         currentSlidingSyncVersion == SlidingSyncVersion.Proxy
     }

build.gradle.kts

@@ -50,6 +50,7 @@ allprojects {
     }
     dependencies {
         detektPlugins("io.nlopez.compose.rules:detekt:0.4.22")
+        detektPlugins(project(":tests:detekt-rules"))
     }
 
     tasks.withType<io.gitlab.arturbosch.detekt.Detekt>().configureEach {

features/cachecleaner/impl/src/main/kotlin/io/element/android/features/cachecleaner/impl/DefaultCacheCleaner.kt

@@ -10,6 +10,7 @@ package io.element.android.features.cachecleaner.impl
 import com.squareup.anvil.annotations.ContributesBinding
 import io.element.android.features.cachecleaner.api.CacheCleaner
 import io.element.android.libraries.core.coroutine.CoroutineDispatchers
+import io.element.android.libraries.core.extensions.runCatchingExceptions
 import io.element.android.libraries.di.AppScope
 import io.element.android.libraries.di.CacheDirectory
 import kotlinx.coroutines.CoroutineScope
@@ -33,7 +34,7 @@ class DefaultCacheCleaner @Inject constructor(
 
     override fun clearCache() {
         scope.launch(dispatchers.io) {
-            runCatching {
+            runCatchingExceptions {
                 SUBDIRS_TO_CLEANUP.forEach {
                     File(cacheDir.path, it).apply {
                         if (exists()) {

features/call/impl/src/main/kotlin/io/element/android/features/call/impl/services/CallForegroundService.kt

@@ -24,6 +24,7 @@
 import androidx.core.graphics.drawable.IconCompat
 import io.element.android.features.call.impl.R
 import io.element.android.features.call.impl.ui.ElementCallActivity
+import io.element.android.libraries.core.extensions.runCatchingExceptions
 import io.element.android.libraries.designsystem.utils.CommonDrawables
 import io.element.android.libraries.push.api.notifications.ForegroundServiceType
 import io.element.android.libraries.push.api.notifications.NotificationIdProvider
@@ -78,7 +79,7 @@
         } else {
             0
         }
-        runCatching {
+        runCatchingExceptions {
             ServiceCompat.startForeground(this, notificationId, notification, serviceType)
         }.onFailure {
             Timber.e(it, "Failed to start ongoing call foreground service")

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

@@ -21,6 +21,7 @@ import io.element.android.features.call.api.CallType
 import io.element.android.features.call.api.CurrentCall
 import io.element.android.features.call.impl.notifications.CallNotificationData
 import io.element.android.features.call.impl.notifications.RingingCallNotificationCreator
+import io.element.android.libraries.core.extensions.runCatchingExceptions
 import io.element.android.libraries.di.AppScope
 import io.element.android.libraries.di.ApplicationContext
 import io.element.android.libraries.di.SingleIn
@@ -218,7 +219,7 @@ class DefaultActiveCallManager @Inject constructor(
             timestamp = notificationData.timestamp,
             textContent = notificationData.textContent,
         ) ?: return
-        runCatching {
+        runCatchingExceptions {
             notificationManagerCompat.notify(
                 NotificationIdProvider.getForegroundServiceNotificationId(ForegroundServiceType.INCOMING_CALL),
                 notification,

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

@@ -8,6 +8,7 @@
 package io.element.android.features.call.impl.utils
 
 import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.libraries.core.extensions.runCatchingExceptions
 import io.element.android.libraries.di.AppScope
 import io.element.android.libraries.matrix.api.MatrixClientProvider
 import io.element.android.libraries.matrix.api.core.RoomId
@@ -33,7 +34,7 @@ class DefaultCallWidgetProvider @Inject constructor(
         clientId: String,
         languageTag: String?,
         theme: String?,
-    ): Result<CallWidgetProvider.GetWidgetResult> = runCatching {
+    ): Result<CallWidgetProvider.GetWidgetResult> = runCatchingExceptions {
         val matrixClient = matrixClientsProvider.getOrRestore(sessionId).getOrThrow()
         val room = activeRoomsHolder.getActiveRoomMatching(sessionId, roomId)
             ?: matrixClient.getJoinedRoom(roomId)

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

@@ -8,13 +8,14 @@
 package io.element.android.features.call.impl.utils
 
 import io.element.android.features.call.impl.data.WidgetMessage
+import io.element.android.libraries.core.extensions.runCatchingExceptions
 import kotlinx.serialization.json.Json
 
 object WidgetMessageSerializer {
     private val coder = Json { ignoreUnknownKeys = true }
 
     fun deserialize(message: String): Result<WidgetMessage> {
-        return runCatching { coder.decodeFromString(WidgetMessage.serializer(), message) }
+        return runCatchingExceptions { coder.decodeFromString(WidgetMessage.serializer(), message) }
     }
 
     fun serialize(message: WidgetMessage): String {

features/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/root/CreateRoomRootStateProvider.kt

@@ -35,7 +35,7 @@ open class CreateRoomRootStateProvider : PreviewParameterProvider<CreateRoomRoot
                 }
             ),
             aCreateRoomRootState(
-                startDmAction = AsyncAction.Failure(Throwable("error")),
+                startDmAction = AsyncAction.Failure(RuntimeException("error")),
                 userListState = aMatrixUser().let {
                     aUserListState().copy(
                         searchQuery = it.userId.value,

features/createroom/impl/src/test/kotlin/io/element/android/features/createroom/impl/DefaultStartDMActionTest.kt

@@ -14,8 +14,8 @@ import io.element.android.features.createroom.api.ConfirmingStartDmWithMatrixUse
 import io.element.android.libraries.architecture.AsyncAction
 import io.element.android.libraries.matrix.api.MatrixClient
 import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.test.AN_EXCEPTION
 import io.element.android.libraries.matrix.test.A_ROOM_ID
-import io.element.android.libraries.matrix.test.A_THROWABLE
 import io.element.android.libraries.matrix.test.FakeMatrixClient
 import io.element.android.libraries.matrix.ui.components.aMatrixUser
 import io.element.android.services.analytics.api.AnalyticsService
@@ -70,13 +70,13 @@ class DefaultStartDMActionTest {
     fun `when dm creation fails, assert state is updated with given error`() = runTest {
         val matrixClient = FakeMatrixClient().apply {
             givenFindDmResult(null)
-            givenCreateDmResult(Result.failure(A_THROWABLE))
+            givenCreateDmResult(Result.failure(AN_EXCEPTION))
         }
         val analyticsService = FakeAnalyticsService()
         val action = createStartDMAction(matrixClient, analyticsService)
         val state = mutableStateOf<AsyncAction<RoomId>>(AsyncAction.Uninitialized)
         action.execute(aMatrixUser(), true, state)
-        assertThat(state.value).isEqualTo(AsyncAction.Failure(A_THROWABLE))
+        assertThat(state.value).isEqualTo(AsyncAction.Failure(AN_EXCEPTION))
         assertThat(analyticsService.capturedEvents).isEmpty()
     }
 

features/createroom/impl/src/test/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureBaseRoomPresenterTest.kt

@@ -22,10 +22,10 @@ import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.room.alias.ResolvedRoomAlias
 import io.element.android.libraries.matrix.api.room.alias.RoomAliasHelper
 import io.element.android.libraries.matrix.test.AN_AVATAR_URL
+import io.element.android.libraries.matrix.test.AN_EXCEPTION
 import io.element.android.libraries.matrix.test.A_MESSAGE
 import io.element.android.libraries.matrix.test.A_ROOM_ID
 import io.element.android.libraries.matrix.test.A_ROOM_NAME
-import io.element.android.libraries.matrix.test.A_THROWABLE
 import io.element.android.libraries.matrix.test.FakeMatrixClient
 import io.element.android.libraries.matrix.test.room.alias.FakeRoomAliasHelper
 import io.element.android.libraries.matrix.ui.components.aMatrixUser
@@ -274,7 +274,7 @@ class ConfigureBaseRoomPresenterTest {
             createRoomDataStore.setAvatarUri(Uri.parse(AN_URI_FROM_GALLERY))
             skipItems(1)
             mediaPreProcessor.givenResult(Result.success(MediaUploadInfo.Image(mockk(), mockk(), mockk())))
-            matrixClient.givenUploadMediaResult(Result.failure(A_THROWABLE))
+            matrixClient.givenUploadMediaResult(Result.failure(AN_EXCEPTION))
 
             initialState.eventSink(ConfigureRoomEvents.CreateRoom)
             assertThat(awaitItem().createRoomAction).isInstanceOf(AsyncAction.Loading::class.java)
@@ -298,7 +298,7 @@ class ConfigureBaseRoomPresenterTest {
         )
         presenter.test {
             val initialState = initialState()
-            val createRoomResult = Result.failure<RoomId>(A_THROWABLE)
+            val createRoomResult = Result.failure<RoomId>(AN_EXCEPTION)
 
             fakeMatrixClient.givenCreateRoomResult(createRoomResult)
 

features/createroom/impl/src/test/kotlin/io/element/android/features/createroom/impl/root/CreateBaseRoomRootPresenterTest.kt

@@ -24,8 +24,8 @@ import io.element.android.libraries.featureflag.test.FakeFeatureFlagService
 import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.matrix.test.AN_EXCEPTION
 import io.element.android.libraries.matrix.test.A_ROOM_ID
-import io.element.android.libraries.matrix.test.A_THROWABLE
 import io.element.android.libraries.matrix.test.core.aBuildMeta
 import io.element.android.libraries.usersearch.test.FakeUserRepository
 import io.element.android.tests.testutils.WarmUpRule
@@ -42,7 +42,7 @@ class CreateBaseRoomRootPresenterTest {
 
     @Test
     fun `present - start DM action failure scenario`() = runTest {
-        val startDMFailureResult = AsyncAction.Failure(A_THROWABLE)
+        val startDMFailureResult = AsyncAction.Failure(AN_EXCEPTION)
         val executeResult = lambdaRecorder<MatrixUser, Boolean, MutableState<AsyncAction<RoomId>>, Unit> { _, _, actionState ->
             actionState.value = startDMFailureResult
         }

features/invite/api/src/main/kotlin/io/element/android/features/invite/api/acceptdecline/AcceptDeclineInviteStateProvider.kt

@@ -29,10 +29,10 @@ open class AcceptDeclineInviteStateProvider : PreviewParameterProvider<AcceptDec
                 ),
             ),
             anAcceptDeclineInviteState(
-                acceptAction = AsyncAction.Failure(Throwable("Error while accepting invite")),
+                acceptAction = AsyncAction.Failure(RuntimeException("Error while accepting invite")),
             ),
             anAcceptDeclineInviteState(
-                declineAction = AsyncAction.Failure(Throwable("Error while declining invite")),
+                declineAction = AsyncAction.Failure(RuntimeException("Error while declining invite")),
             ),
         )
 }

features/invite/impl/src/test/kotlin/io/element/android/features/invite/impl/DefaultAcceptInviteTest.kt

@@ -69,7 +69,7 @@ class DefaultAcceptInviteTest {
     fun `accept invite failure scenario`() = runTest {
         val joinRoomLambda =
             lambdaRecorder<RoomIdOrAlias, List<String>, JoinedRoom.Trigger, Result<Unit>> { _, _, _ ->
-                Result.failure(Throwable("Join room failed"))
+                Result.failure(RuntimeException("Join room failed"))
             }
 
         val acceptInvite = DefaultAcceptInvite(

features/knockrequests/impl/src/main/kotlin/io/element/android/features/knockrequests/impl/list/KnockRequestsListStateProvider.kt

@@ -89,7 +89,7 @@ open class KnockRequestsListStateProvider : PreviewParameterProvider<KnockReques
                     canBan = true,
                 ),
                 currentAction = KnockRequestsAction.AcceptAll,
-                asyncAction = AsyncAction.Failure(Throwable("Failed to accept all")),
+                asyncAction = AsyncAction.Failure(RuntimeException("Failed to accept all")),
             ),
             aKnockRequestsListState(
                 knockRequests = AsyncData.Success(

features/knockrequests/impl/src/test/kotlin/io/element/android/features/knockrequests/impl/list/KnockRequestsListViewTest.kt

@@ -108,7 +108,7 @@ class KnockRequestsListViewTest {
         rule.setKnockRequestsListView(
             aKnockRequestsListState(
                 knockRequests = AsyncData.Success(knockRequests),
-                asyncAction = AsyncAction.Failure(Throwable("Failed to accept all")),
+                asyncAction = AsyncAction.Failure(RuntimeException("Failed to accept all")),
                 currentAction = KnockRequestsAction.AcceptAll,
                 eventSink = eventsRecorder,
             ),
@@ -124,7 +124,7 @@ class KnockRequestsListViewTest {
         rule.setKnockRequestsListView(
             aKnockRequestsListState(
                 knockRequests = AsyncData.Success(knockRequests),
-                asyncAction = AsyncAction.Failure(Throwable("Failed to accept all")),
+                asyncAction = AsyncAction.Failure(RuntimeException("Failed to accept all")),
                 currentAction = KnockRequestsAction.AcceptAll,
                 eventSink = eventsRecorder,
             ),

features/licenses/impl/src/main/kotlin/io/element/android/features/licenses/impl/list/DependencyLicensesListPresenter.kt

@@ -17,6 +17,7 @@ import io.element.android.features.licenses.impl.LicensesProvider
 import io.element.android.features.licenses.impl.model.DependencyLicenseItem
 import io.element.android.libraries.architecture.AsyncData
 import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.core.extensions.runCatchingExceptions
 import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.toPersistentList
 import javax.inject.Inject
@@ -34,7 +35,7 @@ class DependencyLicensesListPresenter @Inject constructor(
         }
         var filter by remember { mutableStateOf("") }
         LaunchedEffect(Unit) {
-            runCatching {
+            runCatchingExceptions {
                 licenses = AsyncData.Success(licensesProvider.provides().toPersistentList())
             }.onFailure {
                 licenses = AsyncData.Failure(it)

features/location/impl/src/main/kotlin/io/element/android/features/location/impl/common/actions/AndroidLocationActions.kt

@@ -15,6 +15,7 @@
 import com.squareup.anvil.annotations.ContributesBinding
 import io.element.android.features.location.api.Location
 import io.element.android.libraries.androidutils.system.openAppSettingsPage
+import io.element.android.libraries.core.extensions.runCatchingExceptions
 import io.element.android.libraries.di.AppScope
 import io.element.android.libraries.di.ApplicationContext
 import timber.log.Timber
@@ -26,7 +27,7 @@
     @ApplicationContext private val context: Context
 ) : LocationActions {
     override fun share(location: Location, label: String?) {
-        runCatching {
+        runCatchingExceptions {
             val uri = buildUrl(location, label).toUri()
             val showMapsIntent = Intent(Intent.ACTION_VIEW).setData(uri)
             val chooserIntent = Intent.createChooser(showMapsIntent, null)

features/lockscreen/impl/src/main/kotlin/io/element/android/features/lockscreen/impl/biometric/BiometricAuthenticator.kt

@@ -13,6 +13,7 @@
 import androidx.biometric.BiometricPrompt.PromptInfo
 import androidx.core.content.ContextCompat
 import androidx.fragment.app.FragmentActivity
+import io.element.android.libraries.core.extensions.runCatchingExceptions
 import io.element.android.libraries.cryptography.api.EncryptionDecryptionService
 import io.element.android.libraries.cryptography.api.SecretKeyRepository
 import kotlinx.coroutines.CancellationException
@@ -119,7 +120,7 @@
 
     private fun Cipher?.isValid(): Boolean {
         if (this == null) return false
-        return runCatching {
+        return runCatchingExceptions {
             doFinal("biometric_challenge".toByteArray())
         }.isSuccess
     }

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/createaccount/CreateAccountPresenter.kt

@@ -21,6 +21,7 @@ import io.element.android.libraries.architecture.AsyncAction
 import io.element.android.libraries.architecture.Presenter
 import io.element.android.libraries.core.data.tryOrNull
 import io.element.android.libraries.core.extensions.flatMap
+import io.element.android.libraries.core.extensions.runCatchingExceptions
 import io.element.android.libraries.core.meta.BuildMeta
 import io.element.android.libraries.matrix.api.MatrixClientProvider
 import io.element.android.libraries.matrix.api.auth.MatrixAuthenticationService
@@ -74,7 +75,7 @@ class CreateAccountPresenter @AssistedInject constructor(
 
     private fun CoroutineScope.importSession(message: String, loggedInState: MutableState<AsyncAction<SessionId>>) = launch {
         loggedInState.value = AsyncAction.Loading
-        runCatching {
+        runCatchingExceptions {
             messageParser.parse(message)
         }.flatMap { externalSession ->
             authenticationService.importCreatedSession(externalSession)

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/createaccount/CreateAccountStateProvider.kt

@@ -17,7 +17,7 @@ open class CreateAccountStateProvider : PreviewParameterProvider<CreateAccountSt
             aCreateAccountState(),
             aCreateAccountState(pageProgress = 33),
             aCreateAccountState(createAction = AsyncAction.Loading),
-            aCreateAccountState(createAction = AsyncAction.Failure(Throwable("Failed to create account"))),
+            aCreateAccountState(createAction = AsyncAction.Failure(RuntimeException("Failed to create account"))),
         )
 }
 

features/login/impl/src/test/kotlin/io/element/android/features/login/impl/error/ErrorFormatterTest.kt

@@ -17,7 +17,7 @@ class ErrorFormatterTest {
     // region loginError
     @Test
     fun `loginError - invalid unknown error returns unknown error message`() {
-        val error = Throwable("Some unknown error")
+        val error = RuntimeException("Some unknown error")
         assertThat(loginError(error)).isEqualTo(CommonStrings.error_unknown)
     }
 

features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderPresenterTest.kt

@@ -17,7 +17,7 @@ import io.element.android.libraries.architecture.AsyncData
 import io.element.android.libraries.core.uri.ensureProtocol
 import io.element.android.libraries.matrix.test.AN_ACCOUNT_PROVIDER_2
 import io.element.android.libraries.matrix.test.AN_ACCOUNT_PROVIDER_3
-import io.element.android.libraries.matrix.test.A_THROWABLE
+import io.element.android.libraries.matrix.test.AN_EXCEPTION
 import io.element.android.libraries.matrix.test.auth.FakeMatrixAuthenticationService
 import io.element.android.tests.testutils.WarmUpRule
 import io.element.android.tests.testutils.test
@@ -113,7 +113,7 @@ class ChooseAccountProviderPresenterTest {
             }
             awaitItem().also {
                 assertThat(it.selectedAccountProvider).isEqualTo(accountProvider1)
-                authenticationService.givenChangeServerError(A_THROWABLE)
+                authenticationService.givenChangeServerError(AN_EXCEPTION)
                 it.eventSink(ChooseAccountProviderEvents.Continue)
                 skipItems(1) // Loading