Change callbacks to suspended

auth/src/main/java/org/futo/circles/auth/feature/active_sessions/ActiveSessionsDataSource.kt

@@ -20,7 +20,6 @@ import org.futo.circles.core.extensions.createResult
 import org.futo.circles.core.provider.MatrixSessionProvider
 import org.matrix.android.sdk.api.session.crypto.model.CryptoDeviceInfo
 import org.matrix.android.sdk.api.session.crypto.model.DeviceInfo
-import org.matrix.android.sdk.api.util.awaitCallback
 import java.util.concurrent.TimeUnit
 import javax.inject.Inject
 
@@ -94,16 +93,12 @@ class ActiveSessionsDataSource @Inject constructor(
     }
 
     suspend fun removeSession(deviceId: String): Response<Unit> = createResult {
-        awaitCallback {
-            session.cryptoService().deleteDevice(deviceId, authConfirmationProvider, it)
-        }
+        session.cryptoService().deleteDevice(deviceId, authConfirmationProvider)
     }
 
     suspend fun resetKeysToEnableCrossSigning(): Response<Unit> = createResult {
-        awaitCallback {
-            session.cryptoService().crossSigningService()
-                .initializeCrossSigning(authConfirmationProvider, it)
-        }
+        session.cryptoService().crossSigningService()
+            .initializeCrossSigning(authConfirmationProvider)
     }
 
     private fun isSessionInactive(lastSeenTsMillis: Long?): Boolean =

auth/src/main/java/org/futo/circles/auth/feature/cross_signing/CrossSigningDataSource.kt

 package org.futo.circles.auth.feature.cross_signing
 
 import org.futo.circles.core.provider.MatrixSessionProvider
+import org.matrix.android.sdk.api.extensions.tryOrNull
 import org.matrix.android.sdk.api.session.Session
 import org.matrix.android.sdk.api.session.crypto.crosssigning.MASTER_KEY_SSSS_NAME
 import org.matrix.android.sdk.api.session.crypto.crosssigning.SELF_SIGNING_KEY_SSSS_NAME
@@ -9,7 +10,6 @@ import org.matrix.android.sdk.api.session.crypto.crosssigning.isVerified
 import org.matrix.android.sdk.api.session.securestorage.KeyInfoResult
 import org.matrix.android.sdk.api.session.securestorage.KeyRef
 import org.matrix.android.sdk.api.session.securestorage.SsssKeySpec
-import org.matrix.android.sdk.api.util.awaitCallback
 import javax.inject.Inject
 
 class CrossSigningDataSource @Inject constructor() {
@@ -20,7 +20,7 @@ class CrossSigningDataSource @Inject constructor() {
         try {
             session.sharedSecretStorageService().getSecret(MASTER_KEY_SSSS_NAME, null, keySpec)
         } catch (ignore: Throwable) {
-            awaitCallback { crossSigningService.initializeCrossSigning(null, it) }
+            tryOrNull { crossSigningService.initializeCrossSigning(null) }
             storeKeys(session, keySpec)
         }
     }
@@ -45,10 +45,9 @@ class CrossSigningDataSource @Inject constructor() {
                 mskPrivateKey, uskPrivateKey, sskPrivateKey
             )
         if (trustResult.isVerified()) {
-            awaitCallback {
-                session.sessionParams.deviceId?.let { deviceId ->
-                    session.cryptoService().crossSigningService().trustDevice(deviceId, it)
-                }
+            tryOrNull {
+                session.cryptoService().crossSigningService()
+                    .trustDevice(session.sessionParams.deviceId)
             }
         }
     }

auth/src/main/java/org/futo/circles/auth/feature/pass_phrase/EncryptionAlgorithmHelper.kt

@@ -3,6 +3,7 @@ package org.futo.circles.auth.feature.pass_phrase
 import org.futo.circles.core.provider.MatrixSessionProvider
 import org.matrix.android.sdk.api.crypto.BCRYPT_ALGORITHM_BACKUP
 import org.matrix.android.sdk.api.crypto.BSSPEKE_ALGORITHM_BACKUP
+import org.matrix.android.sdk.api.extensions.tryOrNull
 import org.matrix.android.sdk.api.session.crypto.keysbackup.toKeysVersionResult
 import org.matrix.android.sdk.api.session.securestorage.KeyInfoResult
 import org.matrix.android.sdk.api.util.awaitCallback
@@ -21,10 +22,10 @@ class EncryptionAlgorithmHelper @Inject constructor() {
     }
 
     private suspend fun getEncryptionAlgorithm(): String? {
-        val keyVersion = awaitCallback {
+        val keyVersion = tryOrNull {
             MatrixSessionProvider.currentSession?.cryptoService()?.keysBackupService()
-                ?.getCurrentVersion(it)
-        }.toKeysVersionResult()
+                ?.getCurrentVersion()
+        }?.toKeysVersionResult()
 
         return keyVersion?.algorithm
     }

auth/src/main/java/org/futo/circles/auth/feature/pass_phrase/create/CreatePassPhraseDataSource.kt

@@ -8,10 +8,9 @@ import org.futo.circles.auth.feature.cross_signing.CrossSigningDataSource
 import org.futo.circles.auth.feature.pass_phrase.restore.SSSSDataSource
 import org.futo.circles.core.model.LoadingData
 import org.futo.circles.core.provider.MatrixSessionProvider
-import org.matrix.android.sdk.api.session.crypto.keysbackup.KeysVersion
+import org.matrix.android.sdk.api.extensions.tryOrNull
 import org.matrix.android.sdk.api.session.crypto.keysbackup.MegolmBackupCreationInfo
 import org.matrix.android.sdk.api.session.crypto.keysbackup.toKeysVersionResult
-import org.matrix.android.sdk.api.util.awaitCallback
 import java.security.SecureRandom
 import javax.inject.Inject
 
@@ -29,9 +28,8 @@ class CreatePassPhraseDataSource @Inject constructor(
     suspend fun createPassPhraseBackup() {
         loadingLiveData.postValue(LoadingData(messageId = R.string.generating_recovery_key))
         val keyBackupPrivateKey = generateRandomPrivateKey()
-        val backupCreationInfo = awaitCallback {
-            keysBackupService.prepareKeysBackupVersion(keyBackupPrivateKey, it)
-        }
+        val backupCreationInfo =
+            keysBackupService.prepareKeysBackupVersion(keyBackupPrivateKey, null)
         createKeyBackup(backupCreationInfo)
         val keyData = ssssDataSource.storeBsSpekeKeyIntoSSSS(keyBackupPrivateKey)
         crossSigningDataSource.initCrossSigningIfNeed(keyData.keySpec)
@@ -61,21 +59,19 @@ class CreatePassPhraseDataSource @Inject constructor(
         loadingLiveData.postValue(LoadingData(messageId = R.string.creating_backup))
         val versionData = getCurrentBackupVersion()
 
-        if (versionData?.version.isNullOrBlank()) {
-            awaitCallback<KeysVersion> {
-                keysBackupService.createKeysBackupVersion(backupCreationInfo, it)
-            }
-        } else throw Exception(context.getString(R.string.backup_already_exist))
+        if (versionData?.version.isNullOrBlank())
+            keysBackupService.createKeysBackupVersion(backupCreationInfo)
+        else throw Exception(context.getString(R.string.backup_already_exist))
     }
 
     private suspend fun removeCurrentBackupIfExist() {
         loadingLiveData.postValue(LoadingData(messageId = R.string.removing_backup))
         getCurrentBackupVersion()?.version?.let { version ->
-            awaitCallback { keysBackupService.deleteBackup(version, it) }
+            keysBackupService.deleteBackup(version)
         }
     }
 
     private suspend fun getCurrentBackupVersion() =
-        awaitCallback { keysBackupService.getCurrentVersion(it) }.toKeysVersionResult()
+        tryOrNull { keysBackupService.getCurrentVersion() }?.toKeysVersionResult()
 }