Merge pull request #549 from vector-im/feature/third_party_invite

Fix rendering issue of accepted third party invitation event

CHANGES.md

@@ -1,11 +1,106 @@
+Changes in RiotX 0.5.0 (2019-XX-XX)
+===================================================
+
+Features:
+ -
+
+Improvements:
+ - Reduce default release build log level, and lab option to enable more logs.
+
+Other changes:
+ -
+
+Bugfix:
+ - Fix crash due to missing informationData (#535)
+ - Progress in initial sync dialog is decreasing for a step and should not (#532)
+
+Translations:
+ -
+
+Build:
+ - Fix issue with version name (#533)
+ - Fix rendering issue of accepted third party invitation event
+
+Changes in RiotX 0.4.0 (2019-XX-XX)
+===================================================
+
+Features:
+ - Display read receipts in timeline (#81)
+
+Improvements:
+ - Reactions: Reinstate the ability to react with non-unicode keys (#307)
+
+Bugfix:
+ - Fix text diff linebreak display (#441)
+ - Date change message repeats for each redaction until a normal message (#358)
+ - Slide-in reply icon is distorted (#423)
+ - Regression / e2e replies not encrypted
+ - Some video won't play
+ - Privacy: remove log of notifiable event (#519)
+ - Fix crash with EmojiCompat (#530)
+
+Changes in RiotX 0.3.0 (2019-08-08)
+===================================================
+
+Features:
+ - Create Direct Room flow
+ - Handle `/markdown` command
+
+Improvements:
+ - UI for pending edits (#193)
+ - UX image preview screen transition (#393)
+ - Basic support for resending failed messages (retry/remove)
+ - Enable proper cancellation of suspending functions (including db transaction)
+ - Enhances network connectivity checks in SDK
+ - Add "View Edit History" item in the message bottom sheet (#401)
+ - Cancel sync request on pause and timeout to 0 after pause (#404)
+
+Other changes:
+ - Show sync progress also in room detail screen (#403)
+
+Bugfix:
+ - Edited message: link confusion when (edited) appears in body (#398)
+ - Close detail room screen when the room is left with another client (#256)
+ - Clear notification for a room left on another client
+ - Fix messages with empty `in_reply_to` not rendering (#447)
+ - Fix clear cache (#408) and Logout (#205)
+ - Fix `(edited)` link can be copied to clipboard (#402)
+
+Build:
+ - Split APK: generate one APK per arch, to reduce APK size of about 30%
+
+
+Changes in RiotX 0.2.0 (2019-07-18)
+===================================================
+
+Features:
+ - Message Editing: View edit history (#121)
+ - Rooms filtering (#304)
+ - Edit in encrypted room
+
+Improvements:
+ - Handle click on redacted events: view source and create permalink
+ - Improve long tap menu: reply on top, more compact (#368)
+ - Quick reply in timeline with swipe gesture (#167)
+ - Improve edit of replies
+ - Improve performance on Room Members and Users management (#381)
+
+Other changes:
+ - migrate from rxbinding 2 to rxbinding 3
+
+Bugfix:
+ - Fix regression on permalink click
+ - Fix crash reported by the PlayStore (#341)
+ - Fix Chat composer separator color in dark/black theme
+ - Fix bad layout for room directory filter (#349)
+ - Fix Copying link from a message shouldn't open context menu (#364)
+
 Changes in RiotX 0.1.0 (2019-07-11)
 ===================================================
 
 First release!
 
-
+Mode details here: https://medium.com/@RiotChat/introducing-the-riotx-beta-for-android-b17952e8f771
-
-
 
 
 =======================================================
@@ -13,7 +108,7 @@ First release!
 =======================================================
 
 
-Changes in RiotX 0.XX (2019-XX-XX)
+Changes in RiotX 0.0.0 (2019-XX-XX)
 ===================================================
 
 Features:

README.md

@@ -1,4 +1,4 @@
-[![Buildkite](https://badge.buildkite.com/657d3db27364448d69d54f66c690f7788bc6aa80a7628e37f3.svg?branch=develop)](https://buildkite.com/matrix-dot-org/riotx-android)
+[![Buildkite](https://badge.buildkite.com/657d3db27364448d69d54f66c690f7788bc6aa80a7628e37f3.svg?branch=develop)](https://buildkite.com/matrix-dot-org/riotx-android/builds?branch=develop)
 [![Weblate](https://translate.riot.im/widgets/riot-android/-/svg-badge.svg)](https://translate.riot.im/engage/riot-android/?utm_source=widget)
 [![RiotX Android Matrix room #riot-android:matrix.org](https://img.shields.io/matrix/riotx:matrix.org.svg?label=%23RiotX:matrix.org&logo=matrix&server_fqdn=matrix.org)](https://matrix.to/#/#riotx:matrix.org)
 [![Quality Gate](https://sonarcloud.io/api/project_badges/measure?project=vector.android.riotx&metric=alert_status)](https://sonarcloud.io/dashboard?id=vector.android.riotx)
@@ -7,14 +7,31 @@
 
 # RiotX Android
 
-RiotX is an Android Matrix Client currently in development. The application is not yet available on the PlayStore. 
+RiotX is an Android Matrix Client currently in beta but in active development.
 
-It's based on a new Matrix SDK, written in Kotlin.
+It is a total rewrite of [Riot-Android](https://github.com/vector-im/riot-android) with a new user experience. RiotX will become the official replacement as soon as all features are implemented.
 
-Download nightly build here: [![Buildkite](https://badge.buildkite.com/657d3db27364448d69d54f66c690f7788bc6aa80a7628e37f3.svg?branch=develop)](https://buildkite.com/matrix-dot-org/riotx-android/builds?branch=develop)
+[<img src="https://play.google.com/intl/en_us/badges/images/generic/en_badge_web_generic.png" alt="Get it on Google Play" height="60">](https://play.google.com/store/apps/details?id=im.vector.riotx)
+
+Nightly build: [![Buildkite](https://badge.buildkite.com/657d3db27364448d69d54f66c690f7788bc6aa80a7628e37f3.svg?branch=develop)](https://buildkite.com/matrix-dot-org/riotx-android/builds?branch=develop)
+
+# New Android SDK
+
+RiotX is based on a new Android SDK fully written in Kotlin (like RiotX). In order to make the early development as fast as possible, RiotX and the new SDK currently share the same git repository. We will make separate repos once the API is stable enough.
+
+
+# Roadmap
+
+The current target is to release an application out of beta with the same level of features (and even more) as Riot.
+The roadmap has 3 phases:
+
+- [phase 0](https://github.com/vector-im/riotX-android/labels/phase0): Prototyping / Project setup
+- [phase 1](https://github.com/vector-im/riotX-android/labels/phase1): Beta release to the Play Store
+- [phase 2](https://github.com/vector-im/riotX-android/labels/phase2): Out of beta
 
-Matrix Room: [![RiotX Android Matrix room #riot-android:matrix.org](https://img.shields.io/matrix/riotx:matrix.org.svg?label=%23RiotX:matrix.org&logo=matrix&server_fqdn=matrix.org)](https://matrix.to/#/#riotx:matrix.org)
 
 ## Contributing
 
-Please refer to [CONTRIBUTING.md](https://github.com/vector-im/riotX-android/blob/develop/CONTRIBUTING.md) if you want to contribute the Matrix on Android projects!
+Please refer to [CONTRIBUTING.md](https://github.com/vector-im/riotX-android/blob/develop/CONTRIBUTING.md) if you want to contribute on Matrix Android projects!
+
+Come chat with the community in the dedicated Matrix [room](https://matrix.to/#/#riotx:matrix.org).

build.gradle

@@ -1,3 +1,5 @@
+import javax.tools.JavaCompiler
+
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 
 buildscript {
@@ -45,7 +47,26 @@ allprojects {
         maven { url 'https://oss.sonatype.org/content/repositories/snapshots/' }
         google()
         jcenter()
+        maven {
+            url 'https://repo.adobe.com/nexus/content/repositories/public/'
+            content {
+                includeGroupByRegex "diff_match_patch"
+            }
+        }
     }
+
+    tasks.withType(JavaCompile).all {
+        options.compilerArgs += [
+                '-Adagger.gradle.incremental=enabled'
+        ]
+    }
+
+    afterEvaluate {
+        extensions.findByName("kapt")?.arguments {
+            arg("dagger.gradle.incremental", "enabled")
+        }
+    }
+
 }
 
 task clean(type: Delete) {

docs/notifications.md

@@ -1,4 +1,4 @@
-This document aims to describe how Riot X android displays notifications to the end user. It also clarifies notifications and background settings in the app.
+This document aims to describe how RiotX android displays notifications to the end user. It also clarifies notifications and background settings in the app.
 
 # Table of Contents
 1. [Prerequisites Knowledge](#prerequisites-knowledge)
@@ -50,7 +50,7 @@ By default, this is 0, so the server will return immediately even if the respons
 
 **delay** is a client preference. When the server responds to a sync request, the client waits for `delay`before calling a new sync.
 
-When the Riot X Android app is open (i.e in foreground state), the default timeout is 30 seconds, and delay is 0.
+When the RiotX Android app is open (i.e in foreground state), the default timeout is 30 seconds, and delay is 0.
 
 ## How does a mobile app receives push notification
 
@@ -86,7 +86,7 @@ This need some disambiguation, because it is the source of common confusion:
 In order to send a push to a mobile, App developers need to have a server that will use the FCM APIs, and these APIs requires authentication!
 This server is called a **Push Gateway** in the matrix world
 
-That means that Riot X Android, a matrix client created by New Vector, is using a **Push Gateway** with the needed credentials (FCM API secret Key) in order to send push to the New Vector client.
+That means that RiotX Android, a matrix client created by New Vector, is using a **Push Gateway** with the needed credentials (FCM API secret Key) in order to send push to the New Vector client.
 
 If you create your own matrix client, you will also need to deploy an instance of a **Push Gateway** with the credentials needed to use FCM for your app.
 
@@ -223,7 +223,7 @@ Upon reception of the FCM push, RiotX will perform a sync call to the Home Serve
   * The sync generates additional notifications (e.g an encrypted message where the user is mentioned detected locally)
   * The sync takes too long and the process is killed before completion, or network is not reliable and the sync fails.
 
-Riot X implements several strategies in these cases (TODO document)
+RiotX implements several strategies in these cases (TODO document)
 
 ## FCM Fallback mode
 

matrix-sdk-android-rx/build.gradle

@@ -33,11 +33,12 @@ android {
 }
 
 dependencies {
-    implementation fileTree(dir: 'libs', include: ['*.jar'])
     implementation project(":matrix-sdk-android")
     implementation 'androidx.appcompat:appcompat:1.1.0-beta01'
     implementation 'io.reactivex.rxjava2:rxkotlin:2.3.0'
     implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
+    // Paging
+    implementation "androidx.paging:paging-runtime-ktx:2.1.0"
 
     testImplementation 'junit:junit:4.12'
     androidTestImplementation 'androidx.test:runner:1.2.0'

matrix-sdk-android-rx/src/main/java/im/vector/matrix/rx/LiveDataObservable.kt

@@ -20,6 +20,8 @@ import androidx.lifecycle.LiveData
 import androidx.lifecycle.Observer
 import io.reactivex.Observable
 import io.reactivex.android.MainThreadDisposable
+import io.reactivex.android.schedulers.AndroidSchedulers
+import io.reactivex.schedulers.Schedulers
 
 private class LiveDataObservable<T>(
         private val liveData: LiveData<T>,
@@ -57,5 +59,5 @@ private class LiveDataObservable<T>(
 }
 
 fun <T> LiveData<T>.asObservable(): Observable<T> {
-    return LiveDataObservable(this)
+    return LiveDataObservable(this).observeOn(Schedulers.computation())
 }

matrix-sdk-android-rx/src/main/java/im/vector/matrix/rx/MatrixCallbackCompletable.kt

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2019 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.matrix.rx
+
+import im.vector.matrix.android.api.MatrixCallback
+import im.vector.matrix.android.api.util.Cancelable
+import io.reactivex.CompletableEmitter
+import io.reactivex.SingleEmitter
+
+internal class MatrixCallbackCompletable<T>(private val completableEmitter: CompletableEmitter) : MatrixCallback<T> {
+
+    override fun onSuccess(data: T) {
+        completableEmitter.onComplete()
+    }
+
+    override fun onFailure(failure: Throwable) {
+        completableEmitter.tryOnError(failure)
+    }
+}
+
+fun Cancelable.toCompletable(completableEmitter: CompletableEmitter) {
+    completableEmitter.setCancellable {
+        this.cancel()
+    }
+}

matrix-sdk-android-rx/src/main/java/im/vector/matrix/rx/MatrixCallbackSingle.kt

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2019 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.matrix.rx
+
+import im.vector.matrix.android.api.MatrixCallback
+import im.vector.matrix.android.api.util.Cancelable
+import io.reactivex.SingleEmitter
+
+internal class MatrixCallbackSingle<T>(private val singleEmitter: SingleEmitter<T>) : MatrixCallback<T> {
+
+    override fun onSuccess(data: T) {
+        singleEmitter.onSuccess(data)
+    }
+
+    override fun onFailure(failure: Throwable) {
+        singleEmitter.tryOnError(failure)
+    }
+}
+
+fun <T> Cancelable.toSingle(singleEmitter: SingleEmitter<T>) {
+    singleEmitter.setCancellable {
+        this.cancel()
+    }
+}

matrix-sdk-android-rx/src/main/java/im/vector/matrix/rx/RxRoom.kt

@@ -18,27 +18,40 @@ package im.vector.matrix.rx
 
 import im.vector.matrix.android.api.session.room.Room
 import im.vector.matrix.android.api.session.room.model.EventAnnotationsSummary
+import im.vector.matrix.android.api.session.room.model.ReadReceipt
 import im.vector.matrix.android.api.session.room.model.RoomSummary
 import im.vector.matrix.android.api.session.room.timeline.TimelineEvent
 import io.reactivex.Observable
-import io.reactivex.schedulers.Schedulers
+import io.reactivex.Single
 
 class RxRoom(private val room: Room) {
 
     fun liveRoomSummary(): Observable<RoomSummary> {
-        return room.liveRoomSummary().asObservable().observeOn(Schedulers.computation())
+        return room.liveRoomSummary().asObservable()
     }
 
     fun liveRoomMemberIds(): Observable<List<String>> {
-        return room.getRoomMemberIdsLive().asObservable().observeOn(Schedulers.computation())
+        return room.getRoomMemberIdsLive().asObservable()
     }
 
     fun liveAnnotationSummary(eventId: String): Observable<EventAnnotationsSummary> {
-        return room.getEventSummaryLive(eventId).asObservable().observeOn(Schedulers.computation())
+        return room.getEventSummaryLive(eventId).asObservable()
     }
 
     fun liveTimelineEvent(eventId: String): Observable<TimelineEvent> {
-        return room.liveTimeLineEvent(eventId).asObservable().observeOn(Schedulers.computation())
+        return room.liveTimeLineEvent(eventId).asObservable()
+    }
+
+    fun loadRoomMembersIfNeeded(): Single<Unit> = Single.create {
+        room.loadRoomMembersIfNeeded(MatrixCallbackSingle(it)).toSingle(it)
+    }
+
+    fun joinRoom(viaServers: List<String> = emptyList()): Single<Unit> = Single.create {
+        room.join(viaServers, MatrixCallbackSingle(it)).toSingle(it)
+    }
+
+    fun liveEventReadReceipts(eventId: String): Observable<List<ReadReceipt>> {
+        return room.getEventReadReceiptsLive(eventId).asObservable()
     }
 
 }

matrix-sdk-android-rx/src/main/java/im/vector/matrix/rx/RxSession.kt

@@ -16,30 +16,55 @@
 
 package im.vector.matrix.rx
 
+import androidx.paging.PagedList
 import im.vector.matrix.android.api.session.Session
 import im.vector.matrix.android.api.session.group.model.GroupSummary
 import im.vector.matrix.android.api.session.pushers.Pusher
 import im.vector.matrix.android.api.session.room.model.RoomSummary
+import im.vector.matrix.android.api.session.room.model.create.CreateRoomParams
 import im.vector.matrix.android.api.session.sync.SyncState
+import im.vector.matrix.android.api.session.user.model.User
 import io.reactivex.Observable
-import io.reactivex.schedulers.Schedulers
+import io.reactivex.Single
 
 class RxSession(private val session: Session) {
 
     fun liveRoomSummaries(): Observable<List<RoomSummary>> {
-        return session.liveRoomSummaries().asObservable().observeOn(Schedulers.computation())
+        return session.liveRoomSummaries().asObservable()
     }
 
     fun liveGroupSummaries(): Observable<List<GroupSummary>> {
-        return session.liveGroupSummaries().asObservable().observeOn(Schedulers.computation())
+        return session.liveGroupSummaries().asObservable()
     }
 
     fun liveSyncState(): Observable<SyncState> {
-        return session.syncState().asObservable().observeOn(Schedulers.computation())
+        return session.syncState().asObservable()
     }
 
     fun livePushers(): Observable<List<Pusher>> {
-        return session.livePushers().asObservable().observeOn(Schedulers.computation())
+        return session.livePushers().asObservable()
+    }
+
+    fun liveUsers(): Observable<List<User>> {
+        return session.liveUsers().asObservable()
+    }
+
+    fun livePagedUsers(filter: String? = null): Observable<PagedList<User>> {
+        return session.livePagedUsers(filter).asObservable()
+    }
+
+    fun createRoom(roomParams: CreateRoomParams): Single<String> = Single.create {
+        session.createRoom(roomParams, MatrixCallbackSingle(it)).toSingle(it)
+    }
+
+    fun searchUsersDirectory(search: String,
+                             limit: Int,
+                             excludedUserIds: Set<String>): Single<List<User>> = Single.create {
+        session.searchUsersDirectory(search, limit, excludedUserIds, MatrixCallbackSingle(it)).toSingle(it)
+    }
+
+    fun joinRoom(roomId: String, viaServers: List<String> = emptyList()): Single<Unit> = Single.create {
+        session.joinRoom(roomId, viaServers, MatrixCallbackSingle(it)).toSingle(it)
     }
 
 }

matrix-sdk-android/build.gradle

@@ -94,7 +94,6 @@ dependencies {
     def markwon_version = '3.0.0'
     def daggerVersion = '2.23.1'
 
-    implementation fileTree(dir: 'libs', include: ['*.aar'])
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutines_version"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$coroutines_version"
@@ -110,7 +109,7 @@ dependencies {
     implementation 'com.squareup.retrofit2:converter-moshi:2.4.0'
     implementation 'com.squareup.okhttp3:okhttp:3.14.1'
     implementation 'com.squareup.okhttp3:logging-interceptor:3.10.0'
-    implementation 'com.novoda:merlin:1.1.6'
+    implementation 'com.novoda:merlin:1.2.0'
     implementation "com.squareup.moshi:moshi-adapters:$moshi_version"
     kapt "com.squareup.moshi:moshi-kotlin-codegen:$moshi_version"
 
@@ -126,9 +125,6 @@ dependencies {
     // FP
     implementation "io.arrow-kt:arrow-core:$arrow_version"
     implementation "io.arrow-kt:arrow-instances-core:$arrow_version"
-    implementation "io.arrow-kt:arrow-effects:$arrow_version"
-    implementation "io.arrow-kt:arrow-effects-instances:$arrow_version"
-    implementation "io.arrow-kt:arrow-integration-retrofit-adapter:$arrow_version"
 
     // olm lib is now hosted by jitpack: https://jitpack.io/#org.matrix.gitlab.matrix-org/olm
     implementation 'org.matrix.gitlab.matrix-org:olm:3.1.2'

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/LiveDataTestObserver.java

@@ -16,10 +16,10 @@
 
 package im.vector.matrix.android;
 
+import androidx.annotation.Nullable;
 import androidx.lifecycle.LiveData;
 import androidx.lifecycle.MutableLiveData;
 import androidx.lifecycle.Observer;
-import androidx.annotation.Nullable;
 
 import java.util.ArrayList;
 import java.util.Collections;

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/CryptoStoreHelper.kt

@@ -21,7 +21,7 @@ import im.vector.matrix.android.internal.crypto.store.IMXCryptoStore
 import im.vector.matrix.android.internal.crypto.store.db.RealmCryptoStore
 import im.vector.matrix.android.internal.crypto.store.db.RealmCryptoStoreModule
 import io.realm.RealmConfiguration
-import java.util.*
+import kotlin.random.Random
 
 internal class CryptoStoreHelper {
 
@@ -35,7 +35,7 @@ internal class CryptoStoreHelper {
     }
 
     fun createCredential() = Credentials(
-            userId = "userId_" + Random().nextInt(),
+            userId = "userId_" + Random.nextInt(),
             homeServer = "http://matrix.org",
             accessToken = "access_token",
             refreshToken = null,

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/session/room/timeline/ChunkEntityTest.kt

@@ -19,11 +19,7 @@ package im.vector.matrix.android.session.room.timeline
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.zhuinden.monarchy.Monarchy
 import im.vector.matrix.android.InstrumentedTest
-import im.vector.matrix.android.internal.database.helper.add
+import im.vector.matrix.android.internal.database.helper.*
-import im.vector.matrix.android.internal.database.helper.addAll
-import im.vector.matrix.android.internal.database.helper.isUnlinked
-import im.vector.matrix.android.internal.database.helper.lastStateIndex
-import im.vector.matrix.android.internal.database.helper.merge
 import im.vector.matrix.android.internal.database.model.ChunkEntity
 import im.vector.matrix.android.internal.session.room.timeline.PaginationDirection
 import im.vector.matrix.android.session.room.timeline.RoomDataHelper.createFakeListOfEvents

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/session/room/timeline/FakeGetContextOfEventTask.kt

@@ -16,7 +16,6 @@
 
 package im.vector.matrix.android.session.room.timeline
 
-import arrow.core.Try
 import im.vector.matrix.android.internal.session.room.timeline.GetContextOfEventTask
 import im.vector.matrix.android.internal.session.room.timeline.PaginationDirection
 import im.vector.matrix.android.internal.session.room.timeline.TokenChunkEventPersistor
@@ -24,7 +23,7 @@ import kotlin.random.Random
 
 internal class FakeGetContextOfEventTask constructor(private val tokenChunkEventPersistor: TokenChunkEventPersistor) : GetContextOfEventTask {
 
-    override suspend fun execute(params: GetContextOfEventTask.Params): Try<TokenChunkEventPersistor.Result> {
+    override suspend fun execute(params: GetContextOfEventTask.Params): TokenChunkEventPersistor.Result {
         val fakeEvents = RoomDataHelper.createFakeListOfEvents(30)
         val tokenChunkEvent = FakeTokenChunkEvent(
                 Random.nextLong(System.currentTimeMillis()).toString(),

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/session/room/timeline/FakePaginationTask.kt

@@ -16,7 +16,6 @@
 
 package im.vector.matrix.android.session.room.timeline
 
-import arrow.core.Try
 import im.vector.matrix.android.internal.session.room.timeline.PaginationTask
 import im.vector.matrix.android.internal.session.room.timeline.TokenChunkEventPersistor
 import javax.inject.Inject
@@ -24,7 +23,7 @@ import kotlin.random.Random
 
 internal class FakePaginationTask @Inject constructor(private val tokenChunkEventPersistor: TokenChunkEventPersistor) : PaginationTask {
 
-    override suspend fun execute(params: PaginationTask.Params): Try<TokenChunkEventPersistor.Result> {
+    override suspend fun execute(params: PaginationTask.Params): TokenChunkEventPersistor.Result {
         val fakeEvents = RoomDataHelper.createFakeListOfEvents(30)
         val tokenChunkEvent = FakeTokenChunkEvent(params.from, Random.nextLong(System.currentTimeMillis()).toString(), fakeEvents)
         return tokenChunkEventPersistor.insertInDb(tokenChunkEvent, params.roomId, params.direction)

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/MatrixPatterns.kt

@@ -28,7 +28,7 @@ object MatrixPatterns {
     // regex pattern to find matrix user ids in a string.
     // See https://matrix.org/speculator/spec/HEAD/appendices.html#historical-user-ids
     private const val MATRIX_USER_IDENTIFIER_REGEX = "@[A-Z0-9\\x21-\\x39\\x3B-\\x7F]+$DOMAIN_REGEX"
-    private val PATTERN_CONTAIN_MATRIX_USER_IDENTIFIER = MATRIX_USER_IDENTIFIER_REGEX.toRegex(RegexOption.IGNORE_CASE)
+    val PATTERN_CONTAIN_MATRIX_USER_IDENTIFIER = MATRIX_USER_IDENTIFIER_REGEX.toRegex(RegexOption.IGNORE_CASE)
 
     // regex pattern to find room ids in a string.
     private const val MATRIX_ROOM_IDENTIFIER_REGEX = "![A-Z0-9]+$DOMAIN_REGEX"
@@ -123,9 +123,9 @@ object MatrixPatterns {
      */
     fun isEventId(str: String?): Boolean {
         return str != null
-                && (str matches PATTERN_CONTAIN_MATRIX_EVENT_IDENTIFIER
+               && (str matches PATTERN_CONTAIN_MATRIX_EVENT_IDENTIFIER
-                || str matches PATTERN_CONTAIN_MATRIX_EVENT_IDENTIFIER_V3
+                   || str matches PATTERN_CONTAIN_MATRIX_EVENT_IDENTIFIER_V3
-                || str matches PATTERN_CONTAIN_MATRIX_EVENT_IDENTIFIER_V4)
+                   || str matches PATTERN_CONTAIN_MATRIX_EVENT_IDENTIFIER_V4)
     }
 
     /**
@@ -137,4 +137,23 @@ object MatrixPatterns {
     fun isGroupId(str: String?): Boolean {
         return str != null && str matches PATTERN_CONTAIN_MATRIX_GROUP_IDENTIFIER
     }
+
+    /**
+     * Extract server name from a matrix id
+     *
+     * @param matrixId
+     * @return null if not found or if matrixId is null
+     */
+    fun extractServerNameFromId(matrixId: String?): String? {
+        if (matrixId == null) {
+            return null
+        }
+
+        val index = matrixId.indexOf(":")
+
+        return if (index == -1) {
+            null
+        } else matrixId.substring(index + 1)
+
+    }
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/auth/data/HomeServerConnectionConfig.kt

@@ -31,7 +31,7 @@ import okhttp3.TlsVersion
 @JsonClass(generateAdapter = true)
 data class HomeServerConnectionConfig(
         val homeServerUri: Uri,
-        val identityServerUri: Uri,
+        val identityServerUri: Uri? = null,
         val antiVirusServerUri: Uri? = null,
         val allowedFingerprints: MutableList<Fingerprint> = ArrayList(),
         val shouldPin: Boolean = false,
@@ -48,7 +48,7 @@ data class HomeServerConnectionConfig(
     class Builder {
 
         private lateinit var homeServerUri: Uri
-        private lateinit var identityServerUri: Uri
+        private var identityServerUri: Uri? = null
         private var antiVirusServerUri: Uri? = null
         private val allowedFingerprints: MutableList<Fingerprint> = ArrayList()
         private var shouldPin: Boolean = false

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/comparators/DatedObjectComparators.kt

@@ -17,7 +17,6 @@
 package im.vector.matrix.android.api.comparators
 
 import im.vector.matrix.android.api.interfaces.DatedObject
-import java.util.*
 
 object DatedObjectComparators {
 

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/extensions/MatrixSdkExtensions.kt

@@ -19,7 +19,7 @@ package im.vector.matrix.android.api.extensions
 import im.vector.matrix.android.api.comparators.DatedObjectComparators
 import im.vector.matrix.android.internal.crypto.model.MXDeviceInfo
 import im.vector.matrix.android.internal.crypto.model.rest.DeviceInfo
-import java.util.*
+import java.util.Collections
 
 /* ==========================================================================================
  * MXDeviceInfo

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/failure/MatrixError.kt

@@ -26,8 +26,13 @@ import com.squareup.moshi.JsonClass
 @JsonClass(generateAdapter = true)
 data class MatrixError(
         @Json(name = "errcode") val code: String,
-        @Json(name = "error") val message: String
+        @Json(name = "error") val message: String,
-) {
+
+        @Json(name = "consent_uri") val consentUri: String? = null,
+        // RESOURCE_LIMIT_EXCEEDED data
+        @Json(name = "limit_type") val limitType: String? = null,
+        @Json(name = "admin_contact") val adminUri: String? = null) {
+
 
     companion object {
         const val FORBIDDEN = "M_FORBIDDEN"
@@ -55,5 +60,8 @@ data class MatrixError(
         const val M_CONSENT_NOT_GIVEN = "M_CONSENT_NOT_GIVEN"
         const val RESOURCE_LIMIT_EXCEEDED = "M_RESOURCE_LIMIT_EXCEEDED"
         const val WRONG_ROOM_KEYS_VERSION = "M_WRONG_ROOM_KEYS_VERSION"
+
+        // Possible value for "limit_type"
+        const val LIMIT_TYPE_MAU = "monthly_active_user"
     }
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/permalinks/MatrixLinkify.kt

@@ -42,7 +42,7 @@ object MatrixLinkify {
                 hasMatch = true
                 val startPos = match.range.first
                 if (startPos == 0 || text[startPos - 1] != '/') {
-                    val endPos = match.range.last
+                    val endPos = match.range.last + 1
                     val url = text.substring(match.range)
                     val span = MatrixPermalinkSpan(url, callback)
                     spannable.setSpan(span, startPos, endPos, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
@@ -51,5 +51,5 @@ object MatrixLinkify {
         }
         return hasMatch
     }
-    
+
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/permalinks/MatrixPermalinkSpan.kt

@@ -18,6 +18,7 @@ package im.vector.matrix.android.api.permalinks
 
 import android.text.style.ClickableSpan
 import android.view.View
+import im.vector.matrix.android.api.permalinks.MatrixPermalinkSpan.Callback
 
 /**
  * This MatrixPermalinkSpan is a clickable span which use a [Callback] to communicate back.

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/pushrules/PushRuleService.kt

@@ -18,6 +18,7 @@ package im.vector.matrix.android.api.pushrules
 import im.vector.matrix.android.api.MatrixCallback
 import im.vector.matrix.android.api.pushrules.rest.PushRule
 import im.vector.matrix.android.api.session.events.model.Event
+import im.vector.matrix.android.api.util.Cancelable
 
 interface PushRuleService {
 
@@ -31,7 +32,7 @@ interface PushRuleService {
 
     //TODO update rule
 
-    fun updatePushRuleEnableStatus(kind: String, pushRule: PushRule, enabled: Boolean, callback: MatrixCallback<Unit>)
+    fun updatePushRuleEnableStatus(kind: String, pushRule: PushRule, enabled: Boolean, callback: MatrixCallback<Unit>): Cancelable
 
     fun addPushRuleListener(listener: PushRuleListener)
 
@@ -41,6 +42,7 @@ interface PushRuleService {
 
     interface PushRuleListener {
         fun onMatchRule(event: Event, actions: List<Action>)
+        fun onRoomLeft(roomId: String)
         fun batchFinish()
     }
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/pushrules/RoomMemberCountCondition.kt

@@ -18,18 +18,17 @@ package im.vector.matrix.android.api.pushrules
 import im.vector.matrix.android.api.session.events.model.Event
 import im.vector.matrix.android.api.session.room.RoomService
 import timber.log.Timber
-import java.util.regex.Pattern
 
-private val regex = Pattern.compile("^(==|<=|>=|<|>)?(\\d*)$")
+private val regex = Regex("^(==|<=|>=|<|>)?(\\d*)$")
 
-class RoomMemberCountCondition(val `is`: String) : Condition(Kind.room_member_count) {
+class RoomMemberCountCondition(val iz: String) : Condition(Kind.room_member_count) {
 
     override fun isSatisfied(conditionResolver: ConditionResolver): Boolean {
         return conditionResolver.resolveRoomMemberCountCondition(this)
     }
 
     override fun technicalDescription(): String {
-        return "Room member count is $`is`"
+        return "Room member count is $iz"
     }
 
     fun isSatisfied(event: Event, session: RoomService?): Boolean {
@@ -56,12 +55,9 @@ class RoomMemberCountCondition(val `is`: String) : Condition(Kind.room_member_co
      */
     private fun parseIsField(): Pair<String?, Int>? {
         try {
-            val match = regex.matcher(`is`)
+            val match = regex.find(iz) ?: return null
-            if (match.find()) {
+            val (prefix, count) = match.destructured
-                val prefix = match.group(1)
+            return prefix to count.toInt()
-                val count = match.group(2).toInt()
-                return prefix to count
-            }
         } catch (t: Throwable) {
             Timber.d(t)
         }

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/InitialSyncProgressService.kt

@@ -20,10 +20,10 @@ import androidx.lifecycle.LiveData
 
 interface InitialSyncProgressService {
 
-    fun getLiveStatus() : LiveData<Status?>
+    fun getInitialSyncProgressStatus() : LiveData<Status?>
 
     data class Status(
-            @StringRes val statusText: Int?,
+            @StringRes val statusText: Int,
             val percentProgress: Int = 0
     )
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/Session.kt

@@ -57,6 +57,9 @@ interface Session :
      */
     val sessionParams: SessionParams
 
+    /**
+     * Useful shortcut to get access to the userId
+     */
     val myUserId: String
         get() = sessionParams.credentials.userId
 
@@ -84,7 +87,7 @@ interface Session :
     /**
      * This method start the sync thread.
      */
-    fun startSync()
+    fun startSync(fromForeground : Boolean)
 
     /**
      * This method stop the sync thread.

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/crypto/CryptoService.kt

@@ -26,14 +26,12 @@ import im.vector.matrix.android.api.session.events.model.Content
 import im.vector.matrix.android.api.session.events.model.Event
 import im.vector.matrix.android.internal.crypto.MXEventDecryptionResult
 import im.vector.matrix.android.internal.crypto.NewSessionListener
-import im.vector.matrix.android.internal.crypto.attachments.ElementToDecrypt
 import im.vector.matrix.android.internal.crypto.model.ImportRoomKeysResult
 import im.vector.matrix.android.internal.crypto.model.MXDeviceInfo
 import im.vector.matrix.android.internal.crypto.model.MXEncryptEventContentResult
 import im.vector.matrix.android.internal.crypto.model.MXUsersDevicesMap
 import im.vector.matrix.android.internal.crypto.model.rest.DevicesListResponse
 import im.vector.matrix.android.internal.crypto.model.rest.RoomKeyRequestBody
-import java.io.File
 
 interface CryptoService {
 

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/events/model/Event.kt

@@ -20,6 +20,9 @@ import android.text.TextUtils
 import com.squareup.moshi.Json
 import com.squareup.moshi.JsonClass
 import im.vector.matrix.android.api.session.crypto.MXCryptoError
+import im.vector.matrix.android.api.session.room.model.message.MessageContent
+import im.vector.matrix.android.api.session.room.model.message.MessageType
+import im.vector.matrix.android.api.session.room.send.SendState
 import im.vector.matrix.android.api.util.JsonDict
 import im.vector.matrix.android.internal.crypto.algorithms.olm.OlmDecryptionResult
 import im.vector.matrix.android.internal.di.MoshiProvider
@@ -79,9 +82,15 @@ data class Event(
 ) {
 
 
+    @Transient
     var mxDecryptionResult: OlmDecryptionResult? = null
+
+    @Transient
     var mCryptoError: MXCryptoError.ErrorType? = null
 
+    @Transient
+    var sendState: SendState = SendState.UNKNOWN
+
 
     /**
      * Check if event is a state event.
@@ -95,42 +104,6 @@ data class Event(
     // Crypto
     //==============================================================================================================
 
-//    /**
-//     * For encrypted events, the plaintext payload for the event.
-//     * This is a small MXEvent instance with typically value for `type` and 'content' fields.
-//     */
-//    @Transient
-//    var mClearEvent: Event? = null
-//        private set
-//
-//    /**
-//     * Curve25519 key which we believe belongs to the sender of the event.
-//     * See `senderKey` property.
-//     */
-//    @Transient
-//    private var mSenderCurve25519Key: String? = null
-//
-//    /**
-//     * Ed25519 key which the sender of this event (for olm) or the creator of the megolm session (for megolm) claims to own.
-//     * See `claimedEd25519Key` property.
-//     */
-//    @Transient
-//    private var mClaimedEd25519Key: String? = null
-//
-//    /**
-//     * Curve25519 keys of devices involved in telling us about the senderCurve25519Key and claimedEd25519Key.
-//     * See `forwardingCurve25519KeyChain` property.
-//     */
-//    @Transient
-//    private var mForwardingCurve25519KeyChain: List<String> = ArrayList()
-//
-//    /**
-//     * Decryption error
-//     */
-//    @Transient
-//    var mCryptoError: MXCryptoError? = null
-//        private set
-
     /**
      * @return true if this event is encrypted.
      */
@@ -138,51 +111,11 @@ data class Event(
         return TextUtils.equals(type, EventType.ENCRYPTED)
     }
 
-    /**
-     * Update the clear data on this event.
-     * This is used after decrypting an event; it should not be used by applications.
-     *
-     * @param decryptionResult the decryption result, including the plaintext and some key info.
-     */
-//    internal fun setClearData(decryptionResult: MXEventDecryptionResult?) {
-//        mClearEvent = null
-//        if (decryptionResult != null) {
-//            if (decryptionResult.clearEvent != null) {
-//                val adapter = MoshiProvider.providesMoshi().adapter(Event::class.java)
-//                mClearEvent = adapter.fromJsonValue(decryptionResult.clearEvent)
-//
-//                if (mClearEvent != null) {
-//                    mSenderCurve25519Key = decryptionResult.senderCurve25519Key
-//                    mClaimedEd25519Key = decryptionResult.claimedEd25519Key
-//                    mForwardingCurve25519KeyChain = decryptionResult.forwardingCurve25519KeyChain
-//
-//                    // For encrypted events with relation, the m.relates_to is kept in clear, so we need to put it back
-//                    // in the clear event
-//                    try {
-//                        content?.get("m.relates_to")?.let { clearRelates ->
-//                            mClearEvent = mClearEvent?.copy(
-//                                    content = HashMap(mClearEvent!!.content).apply {
-//                                        this["m.relates_to"] = clearRelates
-//                                    }
-//                            )
-//                        }
-//                    } catch (e: Exception) {
-//                        Timber.e(e, "Unable to restore 'm.relates_to' the clear event")
-//                    }
-//                }
-//
-//
-//            }
-//        }
-//        mCryptoError = null
-//    }
-
     /**
      * @return The curve25519 key that sent this event.
      */
     fun getSenderKey(): String? {
         return mxDecryptionResult?.senderKey
-        // return mClearEvent?.mSenderCurve25519Key ?: mSenderCurve25519Key
     }
 
     /**
@@ -190,23 +123,13 @@ data class Event(
      */
     fun getKeysClaimed(): Map<String, String> {
         return mxDecryptionResult?.keysClaimed ?: HashMap()
-//        val res = HashMap<String, String>()
-//
-//        val claimedEd25519Key = if (null != mClearEvent) mClearEvent!!.mClaimedEd25519Key else mClaimedEd25519Key
-//
-//        if (null != claimedEd25519Key) {
-//            res["ed25519"] = claimedEd25519Key
-//        }
-//
-//        return res
     }
-//
+
     /**
      * @return the event type
      */
     fun getClearType(): String {
-        return mxDecryptionResult?.payload?.get("type")?.toString()
+        return mxDecryptionResult?.payload?.get("type")?.toString() ?: type
-                ?: type//get("type")?.toString() ?: type
     }
 
     /**
@@ -216,30 +139,8 @@ data class Event(
         return mxDecryptionResult?.payload?.get("content") as? Content ?: content
     }
 
-//    /**
-//     * @return the linked crypto error
-//     */
-//    fun getCryptoError(): MXCryptoError? {
-//        return mCryptoError
-//    }
-//
-//    /**
-//     * Update the linked crypto error
-//     *
-//     * @param error the new crypto error.
-//     */
-//    fun setCryptoError(error: MXCryptoError?) {
-//        mCryptoError = error
-//        if (null != error) {
-//            mClearEvent = null
-//        }
-//    }
-
-
     fun toContentStringWithIndent(): String {
-        val contentMap = this.toContent()?.toMutableMap() ?: HashMap()
+        val contentMap = toContent()?.toMutableMap() ?: HashMap()
-        contentMap.remove("mxDecryptionResult")
-        contentMap.remove("mCryptoError")
         return JSONObject(contentMap).toString(4)
     }
 
@@ -272,6 +173,7 @@ data class Event(
         if (redacts != other.redacts) return false
         if (mxDecryptionResult != other.mxDecryptionResult) return false
         if (mCryptoError != other.mCryptoError) return false
+        if (sendState != other.sendState) return false
 
         return true
     }
@@ -289,6 +191,27 @@ data class Event(
         result = 31 * result + (redacts?.hashCode() ?: 0)
         result = 31 * result + (mxDecryptionResult?.hashCode() ?: 0)
         result = 31 * result + (mCryptoError?.hashCode() ?: 0)
+        result = 31 * result + sendState.hashCode()
         return result
     }
+
+}
+
+
+fun Event.isTextMessage(): Boolean {
+    return getClearType() == EventType.MESSAGE
+            && when (getClearContent()?.toModel<MessageContent>()?.type) {
+        MessageType.MSGTYPE_TEXT,
+        MessageType.MSGTYPE_EMOTE,
+        MessageType.MSGTYPE_NOTICE -> true
+        else                       -> false
+    }
+}
+
+fun Event.isImageMessage(): Boolean {
+    return getClearType() == EventType.MESSAGE
+            && when (getClearContent()?.toModel<MessageContent>()?.type) {
+        MessageType.MSGTYPE_IMAGE -> true
+        else                      -> false
+    }
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/events/model/RelationType.kt

@@ -17,7 +17,7 @@ package im.vector.matrix.android.api.session.events.model
 
 
 /**
- * Constants defining known event relation types from Matrix specifications.
+ * Constants defining known event relation types from Matrix specifications
  */
 object RelationType {
 
@@ -25,7 +25,7 @@ object RelationType {
     const val ANNOTATION = "m.annotation"
     /** Lets you define an event which replaces an existing event.*/
     const val REPLACE = "m.replace"
-    /** ets you define an event which references an existing event.*/
+    /** Lets you define an event which references an existing event.*/
     const val REFERENCE = "m.reference"
 
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/pushers/PushersService.kt

@@ -17,7 +17,7 @@ package im.vector.matrix.android.api.session.pushers
 
 import androidx.lifecycle.LiveData
 import im.vector.matrix.android.api.MatrixCallback
-import java.util.*
+import java.util.UUID
 
 
 interface PushersService {

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/RoomDirectoryService.kt

@@ -30,20 +30,17 @@ interface RoomDirectoryService {
     /**
      * Get rooms from directory
      */
-    fun getPublicRooms(server: String?,
+    fun getPublicRooms(server: String?, publicRoomsParams: PublicRoomsParams, callback: MatrixCallback<PublicRoomsResponse>): Cancelable
-                       publicRoomsParams: PublicRoomsParams,
-                       callback: MatrixCallback<PublicRoomsResponse>): Cancelable
 
     /**
      * Join a room by id
      */
-    fun joinRoom(roomId: String,
+    fun joinRoom(roomId: String, callback: MatrixCallback<Unit>): Cancelable
-                 callback: MatrixCallback<Unit>)
 
     /**
      * Fetches the overall metadata about protocols supported by the homeserver.
      * Includes both the available protocols and all fields required for queries against each protocol.
      */
-    fun getThirdPartyProtocol(callback: MatrixCallback<Map<String, ThirdPartyProtocol>>)
+    fun getThirdPartyProtocol(callback: MatrixCallback<Map<String, ThirdPartyProtocol>>): Cancelable
 
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/RoomService.kt

@@ -20,6 +20,7 @@ import androidx.lifecycle.LiveData
 import im.vector.matrix.android.api.MatrixCallback
 import im.vector.matrix.android.api.session.room.model.RoomSummary
 import im.vector.matrix.android.api.session.room.model.create.CreateRoomParams
+import im.vector.matrix.android.api.util.Cancelable
 
 /**
  * This interface defines methods to get rooms. It's implemented at the session level.
@@ -27,10 +28,18 @@ import im.vector.matrix.android.api.session.room.model.create.CreateRoomParams
 interface RoomService {
 
     /**
-     * Create a room
+     * Create a room asynchronously
      */
-    fun createRoom(createRoomParams: CreateRoomParams,
+    fun createRoom(createRoomParams: CreateRoomParams, callback: MatrixCallback<String>): Cancelable
-                   callback: MatrixCallback<String>)
+
+    /**
+     * Join a room by id
+     * @param roomId the roomId of the room to join
+     * @param viaServers the servers to attempt to join the room through. One of the servers must be participating in the room.
+     */
+    fun joinRoom(roomId: String,
+                 viaServers: List<String> = emptyList(),
+                 callback: MatrixCallback<Unit>): Cancelable
 
     /**
      * Get a room from a roomId

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/failure/CreateRoomFailure.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2019 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.matrix.android.api.session.room.failure
+
+import im.vector.matrix.android.api.failure.Failure
+
+sealed class CreateRoomFailure : Failure.FeatureFailure() {
+
+    object CreatedWithTimeout: CreateRoomFailure()
+
+}

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/failure/JoinRoomFailure.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2019 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.matrix.android.api.session.room.failure
+
+import im.vector.matrix.android.api.failure.Failure
+
+sealed class JoinRoomFailure : Failure.FeatureFailure() {
+
+    object JoinedWithTimeout : JoinRoomFailure()
+
+}

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/members/MembershipService.kt

@@ -30,7 +30,7 @@ interface MembershipService {
      * This methods load all room members if it was done yet.
      * @return a [Cancelable]
      */
-    fun loadRoomMembersIfNeeded(): Cancelable
+    fun loadRoomMembersIfNeeded(matrixCallback: MatrixCallback<Unit>): Cancelable
 
     /**
      * Return the roomMember with userId or null.
@@ -52,16 +52,17 @@ interface MembershipService {
     /**
      * Invite a user in the room
      */
-    fun invite(userId: String, callback: MatrixCallback<Unit>)
+    fun invite(userId: String, callback: MatrixCallback<Unit>): Cancelable
 
     /**
      * Join the room, or accept an invitation.
      */
-    fun join(callback: MatrixCallback<Unit>)
+
+    fun join(viaServers: List<String> = emptyList(), callback: MatrixCallback<Unit>): Cancelable
 
     /**
      * Leave the room, or reject an invitation.
      */
-    fun leave(callback: MatrixCallback<Unit>)
+    fun leave(callback: MatrixCallback<Unit>): Cancelable
 
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/model/ReadReceipt.kt

@@ -16,8 +16,9 @@
 
 package im.vector.matrix.android.api.session.room.model
 
+import im.vector.matrix.android.api.session.user.model.User
+
 data class ReadReceipt(
-        val userId: String,
+        val user: User,
-        val eventId: String,
         val originServerTs: Long
 )

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/model/RoomSummary.kt

@@ -34,5 +34,10 @@ data class RoomSummary(
         val notificationCount: Int = 0,
         val highlightCount: Int = 0,
         val tags: List<RoomTag> = emptyList(),
-        val membership: Membership = Membership.NONE
+        val membership: Membership = Membership.NONE,
-)
+        val versioningState: VersioningState = VersioningState.NONE
+) {
+
+    val isVersioned: Boolean
+        get() = versioningState != VersioningState.NONE
+}

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/model/VersioningState.kt

@@ -14,8 +14,10 @@
  * limitations under the License.
  */
 
-package im.vector.riotx.features.home.room
+package im.vector.matrix.android.api.session.room.model
 
-import im.vector.riotx.core.utils.RxStore
+enum class VersioningState {
-
+    NONE,
-class VisibleRoomStore : RxStore<String>()
+    UPGRADED_ROOM_NOT_JOINED,
+    UPGRADED_ROOM_JOINED
+}

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/model/create/CreateRoomParams.kt

@@ -29,7 +29,6 @@ import im.vector.matrix.android.api.session.room.model.PowerLevels
 import im.vector.matrix.android.api.session.room.model.RoomDirectoryVisibility
 import im.vector.matrix.android.api.session.room.model.RoomHistoryVisibility
 import im.vector.matrix.android.internal.auth.data.ThreePidMedium
-import java.util.*
 
 /**
  * Parameter to create a room, with facilities functions to configure it
@@ -128,12 +127,12 @@ class CreateRoomParams {
             contentMap["algorithm"] = algorithm
 
             val algoEvent = Event(type = EventType.ENCRYPTION,
-                    stateKey = "",
+                                  stateKey = "",
-                    content = contentMap.toContent()
+                                  content = contentMap.toContent()
             )
 
             if (null == initialStates) {
-                initialStates = Arrays.asList<Event>(algoEvent)
+                initialStates = mutableListOf(algoEvent)
             } else {
                 initialStates!!.add(algoEvent)
             }
@@ -162,11 +161,11 @@ class CreateRoomParams {
             contentMap["history_visibility"] = historyVisibility
 
             val historyVisibilityEvent = Event(type = EventType.STATE_HISTORY_VISIBILITY,
-                    stateKey = "",
+                                               stateKey = "",
-                    content = contentMap.toContent())
+                                               content = contentMap.toContent())
 
             if (null == initialStates) {
-                initialStates = Arrays.asList<Event>(historyVisibilityEvent)
+                initialStates = mutableListOf(historyVisibilityEvent)
             } else {
                 initialStates!!.add(historyVisibilityEvent)
             }
@@ -202,8 +201,8 @@ class CreateRoomParams {
      */
     fun isDirect(): Boolean {
         return preset == CreateRoomPreset.PRESET_TRUSTED_PRIVATE_CHAT
-                && isDirect == true
+               && isDirect == true
-                && (1 == getInviteCount() || 1 == getInvite3PidCount())
+               && (1 == getInviteCount() || 1 == getInvite3PidCount())
     }
 
     /**
@@ -223,14 +222,13 @@ class CreateRoomParams {
                           credentials: Credentials,
                           ids: List<String>) {
         for (id in ids) {
-            if (Patterns.EMAIL_ADDRESS.matcher(id).matches()) {
+            if (Patterns.EMAIL_ADDRESS.matcher(id).matches() && hsConfig.identityServerUri != null) {
                 if (null == invite3pids) {
                     invite3pids = ArrayList()
                 }
-
                 val pid = Invite3Pid(idServer = hsConfig.identityServerUri.host!!,
-                        medium = ThreePidMedium.EMAIL,
+                                     medium = ThreePidMedium.EMAIL,
-                        address = id)
+                                     address = id)
 
                 invite3pids!!.add(pid)
             } else if (isUserId(id)) {

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/model/create/Predecessor.kt

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2019 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.matrix.android.api.session.room.model.create
+
+import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
+
+/**
+ * A link to an old room in case of room versioning
+ */
+@JsonClass(generateAdapter = true)
+data class Predecessor(
+        @Json(name = "room_id") val roomId: String? = null,
+        @Json(name = "event_id") val eventId: String? = null
+)

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/model/create/RoomCreateContent.kt

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2019 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.matrix.android.api.session.room.model.create
+
+import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
+
+/**
+ * Content of a m.room.create type event
+ */
+@JsonClass(generateAdapter = true)
+data class RoomCreateContent(
+        @Json(name = "creator") val creator: String? = null,
+        @Json(name = "room_version") val roomVersion: String? = null,
+        @Json(name = "predecessor") val predecessor: Predecessor? = null
+)
+
+

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/model/message/MessageContent.kt

@@ -25,4 +25,9 @@ interface MessageContent {
     val body: String
     val relatesTo: RelationDefaultContent?
     val newContent: Content?
-}
+}
+
+
+fun MessageContent?.isReply(): Boolean {
+    return this?.relatesTo?.inReplyTo?.eventId != null
+}

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/model/relation/RelationContent.kt

@@ -16,7 +16,10 @@
 
 package im.vector.matrix.android.api.session.room.model.relation
 
+import im.vector.matrix.android.api.session.events.model.RelationType
+
 interface RelationContent {
+    /** See [RelationType] for known possible values */
     val type: String?
     val eventId: String?
     val inReplyTo: ReplyToContent?

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/model/relation/RelationService.kt

@@ -16,6 +16,8 @@
 package im.vector.matrix.android.api.session.room.model.relation
 
 import androidx.lifecycle.LiveData
+import im.vector.matrix.android.api.MatrixCallback
+import im.vector.matrix.android.api.session.events.model.Event
 import im.vector.matrix.android.api.session.room.model.EventAnnotationsSummary
 import im.vector.matrix.android.api.session.room.timeline.TimelineEvent
 import im.vector.matrix.android.api.util.Cancelable
@@ -79,6 +81,25 @@ interface RelationService {
                         compatibilityBodyText: String = "* $newBodyText"): Cancelable
 
 
+    /**
+     * Edit a reply. This is a special case because replies contains fallback text as a prefix.
+     * This method will take the new body (stripped from fallbacks) and re-add them before sending.
+     * @param replyToEdit The event to edit
+     * @param originalTimelineEvent the message that this reply (being edited) is relating to
+     * @param newBodyText The edited body (stripped from in reply to content)
+     * @param compatibilityBodyText The text that will appear on clients that don't support yet edition
+     */
+    fun editReply(replyToEdit: TimelineEvent,
+                  originalTimelineEvent: TimelineEvent,
+                  newBodyText: String,
+                  compatibilityBodyText: String = "* $newBodyText"): Cancelable
+
+    /**
+     * Get's the edit history of the given event
+     */
+    fun fetchEditHistory(eventId: String, callback: MatrixCallback<List<Event>>)
+
+
     /**
      * Reply to an event in the timeline (must be in same room)
      * https://matrix.org/docs/spec/client_server/r0.4.0.html#id350
@@ -91,4 +112,6 @@ interface RelationService {
                        autoMarkdown: Boolean = false): Cancelable?
 
     fun getEventSummaryLive(eventId: String): LiveData<EventAnnotationsSummary>
+
+
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/model/relation/ReplyToContent.kt

@@ -21,5 +21,5 @@ import com.squareup.moshi.JsonClass
 
 @JsonClass(generateAdapter = true)
 data class ReplyToContent(
-        @Json(name = "event_id") val eventId: String
+        @Json(name = "event_id") val eventId: String? = null
-)
+)

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/model/tombstone/RoomTombstoneContent.kt

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2019 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.matrix.android.api.session.room.model.tombstone
+
+import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
+
+/**
+ * Class to contains Tombstone information
+ */
+@JsonClass(generateAdapter = true)
+data class RoomTombstoneContent(
+        @Json(name = "body") val body: String? = null,
+        @Json(name = "replacement_room") val replacementRoom: String?
+)

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/read/ReadService.kt

@@ -16,7 +16,9 @@
 
 package im.vector.matrix.android.api.session.room.read
 
+import androidx.lifecycle.LiveData
 import im.vector.matrix.android.api.MatrixCallback
+import im.vector.matrix.android.api.session.room.model.ReadReceipt
 
 /**
  * This interface defines methods to handle read receipts and read marker in a room. It's implemented at the room level.
@@ -39,4 +41,6 @@ interface ReadService {
     fun setReadMarker(fullyReadEventId: String, callback: MatrixCallback<Unit>)
 
     fun isEventRead(eventId: String): Boolean
+
+    fun getEventReadReceiptsLive(eventId: String): LiveData<List<ReadReceipt>>
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/send/SendService.kt

@@ -19,6 +19,7 @@ package im.vector.matrix.android.api.session.room.send
 import im.vector.matrix.android.api.session.content.ContentAttachmentData
 import im.vector.matrix.android.api.session.events.model.Event
 import im.vector.matrix.android.api.session.room.model.message.MessageType
+import im.vector.matrix.android.api.session.room.timeline.TimelineEvent
 import im.vector.matrix.android.api.util.Cancelable
 
 
@@ -65,4 +66,31 @@ interface SendService {
      */
     fun redactEvent(event: Event, reason: String?): Cancelable
 
+
+    /**
+     * Schedule this message to be resent
+     * @param localEcho the unsent local echo
+     */
+    fun resendTextMessage(localEcho: TimelineEvent): Cancelable?
+
+    /**
+     * Schedule this message to be resent
+     * @param localEcho the unsent local echo
+     */
+    fun resendMediaMessage(localEcho: TimelineEvent): Cancelable?
+
+
+    /**
+     * Remove this failed message from the timeline
+     * @param localEcho the unsent local echo
+     */
+    fun deleteFailedEcho(localEcho: TimelineEvent)
+
+    fun clearSendingQueue()
+
+    /**
+     * Resend all failed messages one by one (and keep order)
+     */
+    fun resendAllFailedMessages()
+
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/send/SendState.kt

@@ -16,6 +16,7 @@
 
 package im.vector.matrix.android.api.session.room.send
 
+
 enum class SendState {
     UNKNOWN,
     // the event has not been sent
@@ -33,12 +34,19 @@ enum class SendState {
     // the event failed to be sent because some unknown devices have been found while encrypting it
     FAILED_UNKNOWN_DEVICES;
 
-    fun isSent(): Boolean {
+    internal companion object {
-        return this == SENT || this == SYNCED
+        val HAS_FAILED_STATES = listOf(UNDELIVERED, FAILED_UNKNOWN_DEVICES)
+        val IS_SENT_STATES = listOf(SENT, SYNCED)
+        val IS_SENDING_STATES = listOf(UNSENT, ENCRYPTING, SENDING)
+        val PENDING_STATES = IS_SENDING_STATES + HAS_FAILED_STATES
     }
 
-    fun hasFailed(): Boolean {
+    fun isSent() = IS_SENT_STATES.contains(this)
-        return this == UNDELIVERED || this == FAILED_UNKNOWN_DEVICES
+
-    }
+    fun hasFailed() = HAS_FAILED_STATES.contains(this)
+
+    fun isSending() = IS_SENDING_STATES.contains(this)
 
 }
+
+

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/state/StateService.kt

@@ -17,6 +17,7 @@
 package im.vector.matrix.android.api.session.room.state
 
 import im.vector.matrix.android.api.MatrixCallback
+import im.vector.matrix.android.api.session.events.model.Event
 
 interface StateService {
 
@@ -25,4 +26,6 @@ interface StateService {
      */
     fun updateTopic(topic: String, callback: MatrixCallback<Unit>)
 
+    fun getStateEvent(eventType: String): Event?
+
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/timeline/Timeline.kt

@@ -56,6 +56,9 @@ interface Timeline {
      */
     fun paginate(direction: Direction, count: Int)
 
+    fun pendingEventCount() : Int
+
+    fun failedToDeliverEventCount() : Int
 
     interface Listener {
         /**

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/timeline/TimelineEvent.kt

@@ -20,8 +20,11 @@ import im.vector.matrix.android.api.session.events.model.Event
 import im.vector.matrix.android.api.session.events.model.EventType
 import im.vector.matrix.android.api.session.events.model.toModel
 import im.vector.matrix.android.api.session.room.model.EventAnnotationsSummary
+import im.vector.matrix.android.api.session.room.model.ReadReceipt
 import im.vector.matrix.android.api.session.room.model.message.MessageContent
-import im.vector.matrix.android.api.session.room.send.SendState
+import im.vector.matrix.android.api.session.room.model.message.isReply
+import im.vector.matrix.android.api.util.ContentUtils.extractUsefulTextFromReply
+import im.vector.matrix.android.internal.crypto.model.event.EncryptedEventContent
 
 /**
  * This data class is a wrapper around an Event. It allows to get useful data in the context of a timeline.
@@ -35,8 +38,8 @@ data class TimelineEvent(
         val senderName: String?,
         val isUniqueDisplayName: Boolean,
         val senderAvatar: String?,
-        val sendState: SendState,
+        val annotations: EventAnnotationsSummary? = null,
-        val annotations: EventAnnotationsSummary? = null
+        val readReceipts: List<ReadReceipt> = emptyList()
 ) {
 
     val metadata = HashMap<String, Any>()
@@ -64,8 +67,8 @@ data class TimelineEvent(
                 "$name (${root.senderId})"
             }
         }
-                ?: root.senderId
+               ?: root.senderId
-                ?: ""
+               ?: ""
     }
 
     /**
@@ -83,8 +86,26 @@ data class TimelineEvent(
     }
 }
 
+
+/**
+ * Tells if the event has been edited
+ */
+fun TimelineEvent.hasBeenEdited() = annotations?.editSummary != null
+
 /**
  * Get last MessageContent, after a possible edition
  */
 fun TimelineEvent.getLastMessageContent(): MessageContent? = annotations?.editSummary?.aggregatedContent?.toModel()
-        ?: root.getClearContent().toModel()
+                                                             ?: root.getClearContent().toModel()
+
+
+fun TimelineEvent.getTextEditableContent(): String? {
+    val originalContent = root.getClearContent().toModel<MessageContent>() ?: return null
+    val isReply = originalContent.isReply() || root.content.toModel<EncryptedEventContent>()?.relatesTo?.inReplyTo?.eventId != null
+    val lastContent = getLastMessageContent()
+    return if (isReply) {
+        return extractUsefulTextFromReply(lastContent?.body ?: "")
+    } else {
+        lastContent?.body ?: ""
+    }
+}

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/timeline/TimelineService.kt

@@ -25,12 +25,12 @@ interface TimelineService {
 
     /**
      * Instantiate a [Timeline] with an optional initial eventId, to be used with permalink.
-     * You can filter the type you want to grab with the allowedTypes param.
+     * You can also configure some settings with the [settings] param.
      * @param eventId the optional initial eventId.
-     * @param allowedTypes the optional filter types
+     * @param settings settings to configure the timeline.
      * @return the instantiated timeline
      */
-    fun createTimeline(eventId: String?, allowedTypes: List<String>? = null): Timeline
+    fun createTimeline(eventId: String?, settings: TimelineSettings): Timeline
 
 
     fun getTimeLineEvent(eventId: String): TimelineEvent?

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/timeline/TimelineSettings.kt

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2019 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.matrix.android.api.session.room.timeline
+
+/**
+ * Data class holding setting values for a [Timeline] instance.
+ */
+data class TimelineSettings(
+        /**
+         * The initial number of events to retrieve from cache. You might get less events if you don't have loaded enough yet.
+         */
+        val initialSize: Int,
+        /**
+         * A flag to filter edit events
+         */
+        val filterEdits: Boolean = false,
+        /**
+         * A flag to filter by types. It should be used with [allowedTypes] field
+         */
+        val filterTypes: Boolean = false,
+        /**
+         * If [filterTypes] is true, the list of types allowed by the list.
+         */
+        val allowedTypes: List<String> = emptyList(),
+        /**
+         * If true, will build read receipts for each event.
+         */
+        val buildReadReceipts: Boolean = true
+
+)

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/sync/SyncState.kt

@@ -18,7 +18,7 @@ package im.vector.matrix.android.api.session.sync
 
 sealed class SyncState {
     object IDLE : SyncState()
-    data class RUNNING(val catchingUp: Boolean) : SyncState()
+    data class RUNNING(val afterPause: Boolean) : SyncState()
     object PAUSED : SyncState()
     object KILLING : SyncState()
     object KILLED : SyncState()

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/user/UserService.kt

@@ -17,7 +17,10 @@
 package im.vector.matrix.android.api.session.user
 
 import androidx.lifecycle.LiveData
+import androidx.paging.PagedList
+import im.vector.matrix.android.api.MatrixCallback
 import im.vector.matrix.android.api.session.user.model.User
+import im.vector.matrix.android.api.util.Cancelable
 
 /**
  * This interface defines methods to get users. It's implemented at the session level.
@@ -31,11 +34,34 @@ interface UserService {
      */
     fun getUser(userId: String): User?
 
+    /**
+     * Search list of users on server directory.
+     * @param search the searched term
+     * @param limit the max number of users to return
+     * @param excludedUserIds the user ids to filter from the search
+     * @param callback the async callback
+     * @return Cancelable
+     */
+    fun searchUsersDirectory(search: String, limit: Int, excludedUserIds: Set<String>, callback: MatrixCallback<List<User>>): Cancelable
+
     /**
      * Observe a live user from a userId
      * @param userId the userId to look for.
      * @return a Livedata of user with userId
      */
-    fun observeUser(userId: String): LiveData<User?>
+    fun liveUser(userId: String): LiveData<User?>
+
+    /**
+     * Observe a live list of users sorted alphabetically
+     * @return a Livedata of users
+     */
+    fun liveUsers(): LiveData<List<User>>
+
+    /**
+     * Observe a live [PagedList] of users sorted alphabetically. You can filter the users.
+     * @param filter the filter. It will look into userId and displayName.
+     * @return a Livedata of users
+     */
+    fun livePagedUsers(filter: String? = null): LiveData<PagedList<User>>
 
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/util/CancelableBag.kt

@@ -19,5 +19,6 @@ package im.vector.matrix.android.api.util
 class CancelableBag : Cancelable, MutableList<Cancelable> by ArrayList() {
     override fun cancel() {
         forEach { it.cancel() }
+        clear()
     }
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/util/ContentUtils.kt

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2019 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.matrix.android.api.util
+
+
+object ContentUtils {
+    fun extractUsefulTextFromReply(repliedBody: String): String {
+        val lines = repliedBody.lines()
+        var wellFormed = repliedBody.startsWith(">")
+        var endOfPreviousFound = false
+        val usefullines = ArrayList<String>()
+        lines.forEach {
+            if (it == "") {
+                endOfPreviousFound = true
+                return@forEach
+            }
+            if (!endOfPreviousFound) {
+                wellFormed = wellFormed && it.startsWith(">")
+            } else {
+                usefullines.add(it)
+            }
+        }
+        return usefullines.joinToString("\n").takeIf { wellFormed } ?: repliedBody
+    }
+
+    fun extractUsefulTextFromHtmlReply(repliedBody: String): String {
+        if (repliedBody.startsWith("<mx-reply>")) {
+            val closingTagIndex = repliedBody.lastIndexOf("</mx-reply>")
+            if (closingTagIndex != -1)
+                return repliedBody.substring(closingTagIndex + "</mx-reply>".length).trim()
+        }
+        return repliedBody
+    }
+}

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/util/SecretStoringUtils.kt

@@ -27,7 +27,7 @@ import java.math.BigInteger
 import java.security.KeyPairGenerator
 import java.security.KeyStore
 import java.security.SecureRandom
-import java.util.*
+import java.util.Calendar
 import javax.crypto.*
 import javax.crypto.spec.GCMParameterSpec
 import javax.crypto.spec.IvParameterSpec
@@ -479,12 +479,7 @@ object SecretStoringUtils {
         val output = Cipher.getInstance(RSA_MODE)
         output.init(Cipher.DECRYPT_MODE, privateKeyEntry.privateKey)
 
-        val bos = ByteArrayOutputStream()
+        return CipherInputStream(encrypted, output).use { it.readBytes() }
-        CipherInputStream(encrypted, output).use {
-            it.copyTo(bos)
-        }
-
-        return bos.toByteArray()
     }
 
     private fun formatMExtract(bis: InputStream): Pair<ByteArray, ByteArray> {
@@ -495,14 +490,7 @@ object SecretStoringUtils {
         val iv = ByteArray(ivSize)
         bis.read(iv, 0, ivSize)
 
-
+        val encrypted = bis.readBytes()
-        val bos = ByteArrayOutputStream()
-        var next = bis.read()
-        while (next != -1) {
-            bos.write(next)
-            next = bis.read()
-        }
-        val encrypted = bos.toByteArray()
         return Pair(iv, encrypted)
     }
 
@@ -530,14 +518,7 @@ object SecretStoringUtils {
         val iv = ByteArray(ivSize)
         bis.read(iv)
 
-        val bos = ByteArrayOutputStream()
+        val encrypted = bis.readBytes()
-
-        var next = bis.read()
-        while (next != -1) {
-            bos.write(next)
-            next = bis.read()
-        }
-        val encrypted = bos.toByteArray()
         return Triple(encryptedKey, iv, encrypted)
     }
 
@@ -579,14 +560,7 @@ object SecretStoringUtils {
         val iv = ByteArray(ivSize)
         bis.read(iv)
 
-        val bos = ByteArrayOutputStream()
+        val encrypted = bis.readBytes()
-
-        var next = bis.read()
-        while (next != -1) {
-            bos.write(next)
-            next = bis.read()
-        }
-        val encrypted = bos.toByteArray()
         return Triple(salt, iv, encrypted)
     }
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/SessionManager.kt

@@ -50,16 +50,10 @@ internal class SessionManager @Inject constructor(private val matrixComponent: M
     }
 
     private fun getOrCreateSessionComponent(sessionParams: SessionParams): SessionComponent {
-        val userId = sessionParams.credentials.userId
+        return sessionComponents.getOrPut(sessionParams.credentials.userId) {
-        if (sessionComponents.containsKey(userId)) {
+            DaggerSessionComponent
-            return sessionComponents[userId]!!
+                    .factory()
+                    .create(matrixComponent, sessionParams)
         }
-        return DaggerSessionComponent
-                .factory()
-                .create(matrixComponent, sessionParams)
-                .also {
-                    sessionComponents[sessionParams.credentials.userId] = it
-                }
     }
-
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/auth/DefaultAuthenticator.kt

@@ -68,7 +68,9 @@ internal class DefaultAuthenticator @Inject constructor(@Unauthenticated
                               callback: MatrixCallback<Session>): Cancelable {
 
         val job = GlobalScope.launch(coroutineDispatchers.main) {
-            val sessionOrFailure = authenticate(homeServerConnectionConfig, login, password)
+            val sessionOrFailure = runCatching {
+                authenticate(homeServerConnectionConfig, login, password)
+            }
             sessionOrFailure.foldToCallback(callback)
         }
         return CancelableCoroutine(job)
@@ -85,16 +87,12 @@ internal class DefaultAuthenticator @Inject constructor(@Unauthenticated
         } else {
             PasswordLoginParams.userIdentifier(login, password, "Mobile")
         }
-        executeRequest<Credentials> {
+        val credentials = executeRequest<Credentials> {
             apiCall = authAPI.login(loginParams)
-        }.map {
-            val sessionParams = SessionParams(it, homeServerConnectionConfig)
-            sessionParamsStore.save(sessionParams)
-            sessionParams
-        }.map {
-            sessionManager.getOrCreateSession(it)
         }
-
+        val sessionParams = SessionParams(credentials, homeServerConnectionConfig)
+        sessionParamsStore.save(sessionParams)
+        sessionManager.getOrCreateSession(sessionParams)
     }
 
     private fun buildAuthAPI(homeServerConnectionConfig: HomeServerConnectionConfig): AuthAPI {

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/auth/SessionParamsStore.kt

@@ -27,7 +27,7 @@ internal interface SessionParamsStore {
 
     fun getAll(): List<SessionParams>
 
-    fun save(sessionParams: SessionParams): Try<SessionParams>
+    fun save(sessionParams: SessionParams): Try<Unit>
 
     fun delete(userId: String): Try<Unit>
 

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/auth/db/RealmSessionParamsStore.kt

@@ -62,7 +62,7 @@ internal class RealmSessionParamsStore @Inject constructor(private val mapper: S
         return sessionParams
     }
 
-    override fun save(sessionParams: SessionParams): Try<SessionParams> {
+    override fun save(sessionParams: SessionParams): Try<Unit> {
         return Try {
             val entity = mapper.map(sessionParams)
             if (entity != null) {
@@ -72,7 +72,6 @@ internal class RealmSessionParamsStore @Inject constructor(private val mapper: S
                 }
                 realm.close()
             }
-            sessionParams
         }
     }
 

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/auth/db/SessionParamsMapper.kt

@@ -20,7 +20,6 @@ import com.squareup.moshi.Moshi
 import im.vector.matrix.android.api.auth.data.Credentials
 import im.vector.matrix.android.api.auth.data.HomeServerConnectionConfig
 import im.vector.matrix.android.api.auth.data.SessionParams
-import im.vector.matrix.android.internal.di.MatrixScope
 import javax.inject.Inject
 
 internal class SessionParamsMapper @Inject constructor(moshi: Moshi) {

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/CryptoModule.kt

@@ -105,7 +105,7 @@ internal abstract class CryptoModule {
     }
 
     @Binds
-    abstract fun bindCryptoService(cryptoManager: CryptoManager): CryptoService
+    abstract fun bindCryptoService(cryptoService: DefaultCryptoService): CryptoService
 
     @Binds
     abstract fun bindDeleteDeviceTask(deleteDeviceTask: DefaultDeleteDeviceTask): DeleteDeviceTask

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/DefaultCryptoService.kt

@@ -21,7 +21,6 @@ package im.vector.matrix.android.internal.crypto
 import android.content.Context
 import android.os.Handler
 import android.os.Looper
-import android.text.TextUtils
 import arrow.core.Try
 import com.squareup.moshi.Types
 import com.zhuinden.monarchy.Monarchy
@@ -73,17 +72,15 @@ import im.vector.matrix.android.internal.session.room.membership.RoomMembers
 import im.vector.matrix.android.internal.session.sync.model.SyncResponse
 import im.vector.matrix.android.internal.task.TaskExecutor
 import im.vector.matrix.android.internal.task.configureWith
-import im.vector.matrix.android.internal.task.toConfigurableTask
 import im.vector.matrix.android.internal.util.JsonCanonicalizer
 import im.vector.matrix.android.internal.util.MatrixCoroutineDispatchers
 import im.vector.matrix.android.internal.util.fetchCopied
 import kotlinx.coroutines.*
 import org.matrix.olm.OlmManager
 import timber.log.Timber
-import java.util.*
 import java.util.concurrent.atomic.AtomicBoolean
 import javax.inject.Inject
-import kotlin.coroutines.EmptyCoroutineContext
+import kotlin.math.max
 
 /**
  * A `CryptoService` class instance manages the end-to-end crypto for a session.
@@ -96,7 +93,7 @@ import kotlin.coroutines.EmptyCoroutineContext
  * Specially, it tracks all room membership changes events in order to do keys updates.
  */
 @SessionScope
-internal class CryptoManager @Inject constructor(
+internal class DefaultCryptoService @Inject constructor(
         // Olm Manager
         private val olmManager: OlmManager,
         // The credentials,
@@ -169,22 +166,25 @@ internal class CryptoManager @Inject constructor(
 
     override fun setDeviceName(deviceId: String, deviceName: String, callback: MatrixCallback<Unit>) {
         setDeviceNameTask
-                .configureWith(SetDeviceNameTask.Params(deviceId, deviceName))
+                .configureWith(SetDeviceNameTask.Params(deviceId, deviceName)) {
-                .dispatchTo(callback)
+                    this.callback = callback
+                }
                 .executeBy(taskExecutor)
     }
 
     override fun deleteDevice(deviceId: String, callback: MatrixCallback<Unit>) {
         deleteDeviceTask
-                .configureWith(DeleteDeviceTask.Params(deviceId))
+                .configureWith(DeleteDeviceTask.Params(deviceId)) {
-                .dispatchTo(callback)
+                    this.callback = callback
+                }
                 .executeBy(taskExecutor)
     }
 
     override fun deleteDeviceWithUserPassword(deviceId: String, authSession: String?, password: String, callback: MatrixCallback<Unit>) {
         deleteDeviceWithUserPasswordTask
-                .configureWith(DeleteDeviceWithUserPasswordTask.Params(deviceId, authSession, password))
+                .configureWith(DeleteDeviceWithUserPasswordTask.Params(deviceId, authSession, password)) {
-                .dispatchTo(callback)
+                    this.callback = callback
+                }
                 .executeBy(taskExecutor)
     }
 
@@ -198,8 +198,9 @@ internal class CryptoManager @Inject constructor(
 
     override fun getDevicesList(callback: MatrixCallback<DevicesListResponse>) {
         getDevicesTask
-                .toConfigurableTask()
+                .configureWith {
-                .dispatchTo(callback)
+                    this.callback = callback
+                }
                 .executeBy(taskExecutor)
     }
 
@@ -248,7 +249,7 @@ internal class CryptoManager @Inject constructor(
             return
         }
         isStarting.set(true)
-        CoroutineScope(coroutineDispatchers.crypto).launch {
+        GlobalScope.launch(coroutineDispatchers.crypto) {
             internalStart(isInitialSync)
         }
     }
@@ -256,35 +257,36 @@ internal class CryptoManager @Inject constructor(
     private suspend fun internalStart(isInitialSync: Boolean) {
         // Open the store
         cryptoStore.open()
-        uploadDeviceKeys()
+        runCatching {
-                .flatMap { oneTimeKeysUploader.maybeUploadOneTimeKeys() }
+            uploadDeviceKeys()
-                .fold(
+            oneTimeKeysUploader.maybeUploadOneTimeKeys()
-                        {
+            outgoingRoomKeyRequestManager.start()
-                            Timber.e("Start failed: $it")
+            keysBackup.checkAndStartKeysBackup()
-                            delay(1000)
+            if (isInitialSync) {
-                            isStarting.set(false)
+                // refresh the devices list for each known room members
-                            internalStart(isInitialSync)
+                deviceListManager.invalidateAllDeviceLists()
-                        },
+                deviceListManager.refreshOutdatedDeviceLists()
-                        {
+            } else {
-                            outgoingRoomKeyRequestManager.start()
+                incomingRoomKeyRequestManager.processReceivedRoomKeyRequests()
-                            keysBackup.checkAndStartKeysBackup()
+            }
-                            if (isInitialSync) {
+        }.fold(
-                                // refresh the devices list for each known room members
+                {
-                                deviceListManager.invalidateAllDeviceLists()
+                    isStarting.set(false)
-                                deviceListManager.refreshOutdatedDeviceLists()
+                    isStarted.set(true)
-                            } else {
+                },
-                                incomingRoomKeyRequestManager.processReceivedRoomKeyRequests()
+                {
-                            }
+                    Timber.e("Start failed: $it")
-                            isStarting.set(false)
+                    delay(1000)
-                            isStarted.set(true)
+                    isStarting.set(false)
-                        }
+                    internalStart(isInitialSync)
-                )
+                }
+        )
     }
 
     /**
      * Close the crypto
      */
-    fun close() {
+    fun close() = runBlocking(coroutineDispatchers.crypto) {
         olmDevice.release()
         cryptoStore.close()
         outgoingRoomKeyRequestManager.stop()
@@ -315,7 +317,7 @@ internal class CryptoManager @Inject constructor(
      * @param syncResponse the syncResponse
      */
     fun onSyncCompleted(syncResponse: SyncResponse) {
-        CoroutineScope(coroutineDispatchers.crypto).launch {
+        GlobalScope.launch(coroutineDispatchers.crypto) {
             if (syncResponse.deviceLists != null) {
                 deviceListManager.handleDeviceListsChanges(syncResponse.deviceLists.changed, syncResponse.deviceLists.left)
             }
@@ -340,7 +342,7 @@ internal class CryptoManager @Inject constructor(
      * @return the device info, or null if not found / unsupported algorithm / crypto released
      */
     override fun deviceWithIdentityKey(senderKey: String, algorithm: String): MXDeviceInfo? {
-        return if (!TextUtils.equals(algorithm, MXCRYPTO_ALGORITHM_MEGOLM) && !TextUtils.equals(algorithm, MXCRYPTO_ALGORITHM_OLM)) {
+        return if (algorithm != MXCRYPTO_ALGORITHM_MEGOLM && algorithm != MXCRYPTO_ALGORITHM_OLM) {
             // We only deal in olm keys
             null
         } else cryptoStore.deviceWithIdentityKey(senderKey)
@@ -353,8 +355,8 @@ internal class CryptoManager @Inject constructor(
      * @param deviceId the device id
      */
     override fun getDeviceInfo(userId: String, deviceId: String?): MXDeviceInfo? {
-        return if (!TextUtils.isEmpty(userId) && !TextUtils.isEmpty(deviceId)) {
+        return if (userId.isNotEmpty() && !deviceId.isNullOrEmpty()) {
-            cryptoStore.getUserDevice(deviceId!!, userId)
+            cryptoStore.getUserDevice(deviceId, userId)
         } else {
             null
         }
@@ -439,7 +441,7 @@ internal class CryptoManager @Inject constructor(
         // (for now at least. Maybe we should alert the user somehow?)
         val existingAlgorithm = cryptoStore.getRoomAlgorithm(roomId)
 
-        if (!TextUtils.isEmpty(existingAlgorithm) && !TextUtils.equals(existingAlgorithm, algorithm)) {
+        if (!existingAlgorithm.isNullOrEmpty() && existingAlgorithm != algorithm) {
             Timber.e("## setEncryptionInRoom() : Ignoring m.room.encryption event which requests a change of config in $roomId")
             return false
         }
@@ -535,7 +537,7 @@ internal class CryptoManager @Inject constructor(
                                      eventType: String,
                                      roomId: String,
                                      callback: MatrixCallback<MXEncryptEventContentResult>) {
-        CoroutineScope(coroutineDispatchers.crypto).launch {
+        GlobalScope.launch(coroutineDispatchers.crypto) {
             if (!isStarted()) {
                 Timber.v("## encryptEventContent() : wait after e2e init")
                 internalStart(false)
@@ -558,13 +560,16 @@ internal class CryptoManager @Inject constructor(
             if (safeAlgorithm != null) {
                 val t0 = System.currentTimeMillis()
                 Timber.v("## encryptEventContent() starts")
-                safeAlgorithm.encryptEventContent(eventContent, eventType, userIds)
+                runCatching {
+                    safeAlgorithm.encryptEventContent(eventContent, eventType, userIds)
+                }
                         .fold(
-                                { callback.onFailure(it) },
                                 {
                                     Timber.v("## encryptEventContent() : succeeds after ${System.currentTimeMillis() - t0} ms")
                                     callback.onSuccess(MXEncryptEventContentResult(it, EventType.ENCRYPTED))
-                                }
+                                },
+                                { callback.onFailure(it) }
+
                         )
             } else {
                 val algorithm = getEncryptionAlgorithm(roomId)
@@ -586,10 +591,7 @@ internal class CryptoManager @Inject constructor(
     @Throws(MXCryptoError::class)
     override fun decryptEvent(event: Event, timeline: String): MXEventDecryptionResult {
         return runBlocking {
-            internalDecryptEvent(event, timeline).fold(
+            internalDecryptEvent(event, timeline)
-                    { throw it },
-                    { it }
-            )
         }
     }
 
@@ -601,9 +603,11 @@ internal class CryptoManager @Inject constructor(
      * @param callback the callback to return data or null
      */
     override fun decryptEventAsync(event: Event, timeline: String, callback: MatrixCallback<MXEventDecryptionResult>) {
-        GlobalScope.launch(EmptyCoroutineContext) {
+        GlobalScope.launch {
-            val result = withContext(coroutineDispatchers.crypto) {
+            val result = runCatching {
-                internalDecryptEvent(event, timeline)
+                withContext(coroutineDispatchers.crypto) {
+                    internalDecryptEvent(event, timeline)
+                }
             }
             result.foldToCallback(callback)
         }
@@ -614,22 +618,22 @@ internal class CryptoManager @Inject constructor(
      *
      * @param event    the raw event.
      * @param timeline the id of the timeline where the event is decrypted. It is used to prevent replay attack.
-     * @return the MXEventDecryptionResult data, or null in case of error wrapped into [Try]
+     * @return the MXEventDecryptionResult data, or null in case of error
      */
-    private suspend fun internalDecryptEvent(event: Event, timeline: String): Try<MXEventDecryptionResult> {
+    private suspend fun internalDecryptEvent(event: Event, timeline: String): MXEventDecryptionResult {
         val eventContent = event.content
-        return if (eventContent == null) {
+        if (eventContent == null) {
             Timber.e("## decryptEvent : empty event content")
-            Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.BAD_ENCRYPTED_MESSAGE, MXCryptoError.BAD_ENCRYPTED_MESSAGE_REASON))
+            throw MXCryptoError.Base(MXCryptoError.ErrorType.BAD_ENCRYPTED_MESSAGE, MXCryptoError.BAD_ENCRYPTED_MESSAGE_REASON)
         } else {
             val algorithm = eventContent["algorithm"]?.toString()
             val alg = roomDecryptorProvider.getOrCreateRoomDecryptor(event.roomId, algorithm)
             if (alg == null) {
                 val reason = String.format(MXCryptoError.UNABLE_TO_DECRYPT_REASON, event.eventId, algorithm)
                 Timber.e("## decryptEvent() : $reason")
-                Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.UNABLE_TO_DECRYPT, reason))
+                throw MXCryptoError.Base(MXCryptoError.ErrorType.UNABLE_TO_DECRYPT, reason)
             } else {
-                alg.decryptEvent(event, timeline)
+                return alg.decryptEvent(event, timeline)
             }
         }
     }
@@ -649,7 +653,7 @@ internal class CryptoManager @Inject constructor(
      * @param event the event
      */
     fun onToDeviceEvent(event: Event) {
-        CoroutineScope(coroutineDispatchers.crypto).launch {
+        GlobalScope.launch(coroutineDispatchers.crypto) {
             when (event.getClearType()) {
                 EventType.ROOM_KEY, EventType.FORWARDED_ROOM_KEY -> {
                     onRoomKeyEvent(event)
@@ -671,7 +675,7 @@ internal class CryptoManager @Inject constructor(
      */
     private fun onRoomKeyEvent(event: Event) {
         val roomKeyContent = event.getClearContent().toModel<RoomKeyContent>() ?: return
-        if (TextUtils.isEmpty(roomKeyContent.roomId) || TextUtils.isEmpty(roomKeyContent.algorithm)) {
+        if (roomKeyContent.roomId.isNullOrEmpty() || roomKeyContent.algorithm.isNullOrEmpty()) {
             Timber.e("## onRoomKeyEvent() : missing fields")
             return
         }
@@ -689,14 +693,15 @@ internal class CryptoManager @Inject constructor(
      * @param event the encryption event.
      */
     private fun onRoomEncryptionEvent(roomId: String, event: Event) {
-        CoroutineScope(coroutineDispatchers.crypto).launch {
+        GlobalScope.launch(coroutineDispatchers.crypto) {
             val params = LoadRoomMembersTask.Params(roomId)
-            loadRoomMembersTask
+            try {
-                    .execute(params)
+                loadRoomMembersTask.execute(params)
-                    .map { _ ->
+                val userIds = getRoomUserIds(roomId)
-                        val userIds = getRoomUserIds(roomId)
+                setEncryptionInRoom(roomId, event.content?.get("algorithm")?.toString(), true, userIds)
-                        setEncryptionInRoom(roomId, event.content?.get("algorithm")?.toString(), true, userIds)
+            } catch (throwable: Throwable) {
-                    }
+                Timber.e(throwable)
+            }
         }
     }
 
@@ -738,7 +743,7 @@ internal class CryptoManager @Inject constructor(
             val membership = roomMember?.membership
             if (membership == Membership.JOIN) {
                 // make sure we are tracking the deviceList for this user.
-                deviceListManager.startTrackingDeviceList(Arrays.asList(userId))
+                deviceListManager.startTrackingDeviceList(listOf(userId))
             } else if (membership == Membership.INVITE
                     && shouldEncryptForInvitedMembers(roomId)
                     && cryptoConfig.enableEncryptionForInvitedMembers) {
@@ -747,7 +752,7 @@ internal class CryptoManager @Inject constructor(
                 // know what other servers are in the room at the time they've been invited.
                 // They therefore will not send device updates if a user logs in whilst
                 // their state is invite.
-                deviceListManager.startTrackingDeviceList(Arrays.asList(userId))
+                deviceListManager.startTrackingDeviceList(listOf(userId))
             }
         }
     }
@@ -763,7 +768,7 @@ internal class CryptoManager @Inject constructor(
     /**
      * Upload my user's device keys.
      */
-    private suspend fun uploadDeviceKeys(): Try<KeysUploadResponse> {
+    private suspend fun uploadDeviceKeys(): KeysUploadResponse {
         // Prepare the device keys data to send
         // Sign it
         val canonicalJson = JsonCanonicalizer.getCanonicalJson(Map::class.java, getMyDevice().signalableJSONDictionary())
@@ -782,7 +787,11 @@ internal class CryptoManager @Inject constructor(
      * @param callback the exported keys
      */
     override fun exportRoomKeys(password: String, callback: MatrixCallback<ByteArray>) {
-        exportRoomKeys(password, MXMegolmExportEncryption.DEFAULT_ITERATION_COUNT, callback)
+        GlobalScope.launch(coroutineDispatchers.main) {
+            runCatching {
+                exportRoomKeys(password, MXMegolmExportEncryption.DEFAULT_ITERATION_COUNT)
+            }.fold(callback::onSuccess, callback::onFailure)
+        }
     }
 
     /**
@@ -792,30 +801,16 @@ internal class CryptoManager @Inject constructor(
      * @param anIterationCount the encryption iteration count (0 means no encryption)
      * @param callback         the exported keys
      */
-    private fun exportRoomKeys(password: String, anIterationCount: Int, callback: MatrixCallback<ByteArray>) {
+    private suspend fun exportRoomKeys(password: String, anIterationCount: Int): ByteArray {
-        GlobalScope.launch(coroutineDispatchers.main) {
+        return withContext(coroutineDispatchers.crypto) {
-            withContext(coroutineDispatchers.crypto) {
+            val iterationCount = max(0, anIterationCount)
-                Try {
-                    val iterationCount = Math.max(0, anIterationCount)
 
-                    val exportedSessions = ArrayList<MegolmSessionData>()
+            val exportedSessions = cryptoStore.getInboundGroupSessions().mapNotNull { it.exportKeys() }
 
-                    val inboundGroupSessions = cryptoStore.getInboundGroupSessions()
+            val adapter = MoshiProvider.providesMoshi()
+                    .adapter(List::class.java)
 
-                    for (session in inboundGroupSessions) {
+            MXMegolmExportEncryption.encryptMegolmKeyFile(adapter.toJson(exportedSessions), password, iterationCount)
-                        val megolmSessionData = session.exportKeys()
-
-                        if (null != megolmSessionData) {
-                            exportedSessions.add(megolmSessionData)
-                        }
-                    }
-
-                    val adapter = MoshiProvider.providesMoshi()
-                            .adapter(List::class.java)
-
-                    MXMegolmExportEncryption.encryptMegolmKeyFile(adapter.toJson(exportedSessions), password, iterationCount)
-                }
-            }.foldToCallback(callback)
         }
     }
 
@@ -879,11 +874,9 @@ internal class CryptoManager @Inject constructor(
      */
     fun checkUnknownDevices(userIds: List<String>, callback: MatrixCallback<Unit>) {
         // force the refresh to ensure that the devices list is up-to-date
-        CoroutineScope(coroutineDispatchers.crypto).launch {
+        GlobalScope.launch(coroutineDispatchers.crypto) {
-            deviceListManager
+            runCatching { deviceListManager.downloadKeys(userIds, true) }
-                    .downloadKeys(userIds, true)
                     .fold(
-                            { callback.onFailure(it) },
                             {
                                 val unknownDevices = getUnknownDevices(it)
                                 if (unknownDevices.map.isEmpty()) {
@@ -892,7 +885,8 @@ internal class CryptoManager @Inject constructor(
                                     // trigger an an unknown devices exception
                                     callback.onFailure(Failure.CryptoError(MXCryptoError.UnknownDevice(unknownDevices)))
                                 }
-                            }
+                            },
+                            { callback.onFailure(it) }
                     )
         }
     }
@@ -944,7 +938,7 @@ internal class CryptoManager @Inject constructor(
         val roomIds = cryptoStore.getRoomsListBlacklistUnverifiedDevices().toMutableList()
 
         if (add) {
-            if (!roomIds.contains(roomId)) {
+            if (roomId !in roomIds) {
                 roomIds.add(roomId)
             }
         } else {
@@ -1033,8 +1027,7 @@ internal class CryptoManager @Inject constructor(
         val unknownDevices = MXUsersDevicesMap<MXDeviceInfo>()
         val userIds = devicesInRoom.userIds
         for (userId in userIds) {
-            val deviceIds = devicesInRoom.getUserDeviceIds(userId)
+            devicesInRoom.getUserDeviceIds(userId)?.forEach { deviceId ->
-            deviceIds?.forEach { deviceId ->
                 devicesInRoom.getObject(userId, deviceId)
                         ?.takeIf { it.isUnknown }
                         ?.let {
@@ -1047,17 +1040,18 @@ internal class CryptoManager @Inject constructor(
     }
 
     override fun downloadKeys(userIds: List<String>, forceDownload: Boolean, callback: MatrixCallback<MXUsersDevicesMap<MXDeviceInfo>>) {
-        CoroutineScope(coroutineDispatchers.crypto).launch {
+        GlobalScope.launch(coroutineDispatchers.crypto) {
-            deviceListManager
+            runCatching {
-                    .downloadKeys(userIds, forceDownload)
+                deviceListManager.downloadKeys(userIds, forceDownload)
-                    .foldToCallback(callback)
+            }.foldToCallback(callback)
         }
     }
 
     override fun clearCryptoCache(callback: MatrixCallback<Unit>) {
         clearCryptoDataTask
-                .toConfigurableTask()
+                .configureWith {
-                .dispatchTo(callback)
+                    this.callback = callback
+                }
                 .executeBy(taskExecutor)
     }
 
@@ -1073,6 +1067,6 @@ internal class CryptoManager @Inject constructor(
      * ========================================================================================== */
 
     override fun toString(): String {
-        return "CryptoManager of " + credentials.userId + " (" + credentials.deviceId + ")"
+        return "DefaultCryptoService of " + credentials.userId + " (" + credentials.deviceId + ")"
     }
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/DeviceListManager.kt

@@ -18,14 +18,12 @@
 package im.vector.matrix.android.internal.crypto
 
 import android.text.TextUtils
-import arrow.core.Try
 import im.vector.matrix.android.api.MatrixPatterns
 import im.vector.matrix.android.api.auth.data.Credentials
 import im.vector.matrix.android.internal.crypto.model.MXDeviceInfo
 import im.vector.matrix.android.internal.crypto.model.MXUsersDevicesMap
 import im.vector.matrix.android.internal.crypto.store.IMXCryptoStore
 import im.vector.matrix.android.internal.crypto.tasks.DownloadKeysForUsersTask
-import im.vector.matrix.android.internal.extensions.onError
 import im.vector.matrix.android.internal.session.SessionScope
 import im.vector.matrix.android.internal.session.sync.SyncTokenStore
 import timber.log.Timber
@@ -237,7 +235,7 @@ internal class DeviceListManager @Inject constructor(private val cryptoStore: IM
      * @param forceDownload Always download the keys even if cached.
      * @param callback      the asynchronous callback
      */
-    suspend fun downloadKeys(userIds: List<String>?, forceDownload: Boolean): Try<MXUsersDevicesMap<MXDeviceInfo>> {
+    suspend fun downloadKeys(userIds: List<String>?, forceDownload: Boolean): MXUsersDevicesMap<MXDeviceInfo> {
         Timber.v("## downloadKeys() : forceDownload $forceDownload : $userIds")
         // Map from userId -> deviceId -> MXDeviceInfo
         val stored = MXUsersDevicesMap<MXDeviceInfo>()
@@ -268,16 +266,15 @@ internal class DeviceListManager @Inject constructor(private val cryptoStore: IM
         }
         return if (downloadUsers.isEmpty()) {
             Timber.v("## downloadKeys() : no new user device")
-            Try.just(stored)
+            stored
         } else {
             Timber.v("## downloadKeys() : starts")
             val t0 = System.currentTimeMillis()
-            doKeyDownloadForUsers(downloadUsers)
+            val result = doKeyDownloadForUsers(downloadUsers)
-                    .map {
+            Timber.v("## downloadKeys() : doKeyDownloadForUsers succeeds after " + (System.currentTimeMillis() - t0) + " ms")
-                        Timber.v("## downloadKeys() : doKeyDownloadForUsers succeeds after " + (System.currentTimeMillis() - t0) + " ms")
+            result.also {
-                        it.addEntriesFromMap(stored)
+                it.addEntriesFromMap(stored)
-                        it
+            }
-                    }
         }
     }
 
@@ -286,60 +283,60 @@ internal class DeviceListManager @Inject constructor(private val cryptoStore: IM
      *
      * @param downloadUsers the user ids list
      */
-    private suspend fun doKeyDownloadForUsers(downloadUsers: MutableList<String>): Try<MXUsersDevicesMap<MXDeviceInfo>> {
+    private suspend fun doKeyDownloadForUsers(downloadUsers: MutableList<String>): MXUsersDevicesMap<MXDeviceInfo> {
         Timber.v("## doKeyDownloadForUsers() : doKeyDownloadForUsers $downloadUsers")
         // get the user ids which did not already trigger a keys download
         val filteredUsers = downloadUsers.filter { MatrixPatterns.isUserId(it) }
         if (filteredUsers.isEmpty()) {
             // trigger nothing
-            return Try.just(MXUsersDevicesMap())
+            return MXUsersDevicesMap()
         }
         val params = DownloadKeysForUsersTask.Params(filteredUsers, syncTokenStore.getLastToken())
-        return downloadKeysForUsersTask.execute(params)
+        val response = try {
-                .map { response ->
+            downloadKeysForUsersTask.execute(params)
-                    Timber.v("## doKeyDownloadForUsers() : Got keys for " + filteredUsers.size + " users")
+        } catch (throwable: Throwable) {
-                    for (userId in filteredUsers) {
+            Timber.e(throwable, "##doKeyDownloadForUsers(): error")
-                        val devices = response.deviceKeys?.get(userId)
+            onKeysDownloadFailed(filteredUsers)
-                        Timber.v("## doKeyDownloadForUsers() : Got keys for $userId : $devices")
+            throw throwable
-                        if (devices != null) {
+        }
-                            val mutableDevices = HashMap(devices)
+        Timber.v("## doKeyDownloadForUsers() : Got keys for " + filteredUsers.size + " users")
-                            val deviceIds = ArrayList(mutableDevices.keys)
+        for (userId in filteredUsers) {
-                            for (deviceId in deviceIds) {
+            val devices = response.deviceKeys?.get(userId)
-                                // Get the potential previously store device keys for this device
+            Timber.v("## doKeyDownloadForUsers() : Got keys for $userId : $devices")
-                                val previouslyStoredDeviceKeys = cryptoStore.getUserDevice(deviceId, userId)
+            if (devices != null) {
-                                val deviceInfo = mutableDevices[deviceId]
+                val mutableDevices = HashMap(devices)
+                val deviceIds = ArrayList(mutableDevices.keys)
+                for (deviceId in deviceIds) {
+                    // Get the potential previously store device keys for this device
+                    val previouslyStoredDeviceKeys = cryptoStore.getUserDevice(deviceId, userId)
+                    val deviceInfo = mutableDevices[deviceId]
 
-                                // in some race conditions (like unit tests)
+                    // in some race conditions (like unit tests)
-                                // the self device must be seen as verified
+                    // the self device must be seen as verified
-                                if (TextUtils.equals(deviceInfo!!.deviceId, credentials.deviceId) && TextUtils.equals(userId, credentials.userId)) {
+                    if (TextUtils.equals(deviceInfo!!.deviceId, credentials.deviceId) && TextUtils.equals(userId, credentials.userId)) {
-                                    deviceInfo.verified = MXDeviceInfo.DEVICE_VERIFICATION_VERIFIED
+                        deviceInfo.verified = MXDeviceInfo.DEVICE_VERIFICATION_VERIFIED
-                                }
+                    }
-                                // Validate received keys
+                    // Validate received keys
-                                if (!validateDeviceKeys(deviceInfo, userId, deviceId, previouslyStoredDeviceKeys)) {
+                    if (!validateDeviceKeys(deviceInfo, userId, deviceId, previouslyStoredDeviceKeys)) {
-                                    // New device keys are not valid. Do not store them
+                        // New device keys are not valid. Do not store them
-                                    mutableDevices.remove(deviceId)
+                        mutableDevices.remove(deviceId)
-                                    if (null != previouslyStoredDeviceKeys) {
+                        if (null != previouslyStoredDeviceKeys) {
-                                        // But keep old validated ones if any
+                            // But keep old validated ones if any
-                                        mutableDevices[deviceId] = previouslyStoredDeviceKeys
+                            mutableDevices[deviceId] = previouslyStoredDeviceKeys
-                                    }
+                        }
-                                } else if (null != previouslyStoredDeviceKeys) {
+                    } else if (null != previouslyStoredDeviceKeys) {
-                                    // The verified status is not sync'ed with hs.
+                        // The verified status is not sync'ed with hs.
-                                    // This is a client side information, valid only for this client.
+                        // This is a client side information, valid only for this client.
-                                    // So, transfer its previous value
+                        // So, transfer its previous value
-                                    mutableDevices[deviceId]!!.verified = previouslyStoredDeviceKeys.verified
+                        mutableDevices[deviceId]!!.verified = previouslyStoredDeviceKeys.verified
-                                }
-                            }
-                            // Update the store
-                            // Note that devices which aren't in the response will be removed from the stores
-                            cryptoStore.storeUserDevices(userId, mutableDevices)
-                        }
                     }
-                    onKeysDownloadSucceed(filteredUsers, response.failures)
-                }
-                .onError {
-                    Timber.e(it, "##doKeyDownloadForUsers(): error")
-                    onKeysDownloadFailed(filteredUsers)
                 }
+                // Update the store
+                // Note that devices which aren't in the response will be removed from the stores
+                cryptoStore.storeUserDevices(userId, mutableDevices)
+            }
+        }
+        return onKeysDownloadSucceed(filteredUsers, response.failures)
     }
 
     /**
@@ -465,15 +462,16 @@ internal class DeviceListManager @Inject constructor(private val cryptoStore: IM
         }
 
         cryptoStore.saveDeviceTrackingStatuses(deviceTrackingStatuses)
-        doKeyDownloadForUsers(users)
+        runCatching {
-                .fold(
+            doKeyDownloadForUsers(users)
-                        {
+        }.fold(
-                            Timber.e(it, "## refreshOutdatedDeviceLists() : ERROR updating device keys for users $users")
+                {
-                        },
+                    Timber.v("## refreshOutdatedDeviceLists() : done")
-                        {
+                },
-                            Timber.v("## refreshOutdatedDeviceLists() : done")
+                {
-                        }
+                    Timber.e(it, "## refreshOutdatedDeviceLists() : ERROR updating device keys for users $users")
-                )
+                }
+        )
     }
 
     companion object {

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/MXOlmDevice.kt

@@ -18,7 +18,6 @@
 package im.vector.matrix.android.internal.crypto
 
 import android.text.TextUtils
-import arrow.core.Try
 import im.vector.matrix.android.api.session.crypto.MXCryptoError
 import im.vector.matrix.android.api.util.JSON_DICT_PARAMETERIZED_TYPE
 import im.vector.matrix.android.api.util.JsonDict
@@ -80,8 +79,7 @@ internal class MXOlmDevice @Inject constructor(
     //
     // The first level keys are timeline ids.
     // The second level keys are strings of form "<senderKey>|<session_id>|<message_index>"
-    // Values are true.
+    private val inboundGroupSessionMessageIndexes: MutableMap<String, MutableSet<String>> = HashMap()
-    private val inboundGroupSessionMessageIndexes: MutableMap<String, MutableMap<String, Boolean>> = HashMap()
 
     init {
         // Retrieve the account from the store
@@ -506,25 +504,25 @@ internal class MXOlmDevice @Inject constructor(
                                keysClaimed: Map<String, String>,
                                exportFormat: Boolean): Boolean {
         val session = OlmInboundGroupSessionWrapper(sessionKey, exportFormat)
+        runCatching { getInboundGroupSession(sessionId, senderKey, roomId) }
+                .fold(
+                        {
+                            // If we already have this session, consider updating it
+                            Timber.e("## addInboundGroupSession() : Update for megolm session $senderKey/$sessionId")
 
-        getInboundGroupSession(sessionId, senderKey, roomId).fold(
+                            val existingFirstKnown = it.firstKnownIndex!!
-                {
+                            val newKnownFirstIndex = session.firstKnownIndex
-                    // Nothing to do in case of error
-                },
-                {
-                    // If we already have this session, consider updating it
-                    Timber.e("## addInboundGroupSession() : Update for megolm session $senderKey/$sessionId")
 
-                    val existingFirstKnown = it.firstKnownIndex!!
+                            //If our existing session is better we keep it
-                    val newKnownFirstIndex = session.firstKnownIndex
+                            if (newKnownFirstIndex != null && existingFirstKnown <= newKnownFirstIndex) {
-
+                                session.olmInboundGroupSession?.releaseSession()
-                    //If our existing session is better we keep it
+                                return false
-                    if (newKnownFirstIndex != null && existingFirstKnown <= newKnownFirstIndex) {
+                            }
-                        session.olmInboundGroupSession?.releaseSession()
+                        },
-                        return false
+                        {
-                    }
+                            // Nothing to do in case of error
-                }
+                        }
-        )
+                )
 
         // sanity check
         if (null == session.olmInboundGroupSession) {
@@ -595,12 +593,8 @@ internal class MXOlmDevice @Inject constructor(
                 continue
             }
 
-            getInboundGroupSession(sessionId, senderKey, roomId)
+            runCatching { getInboundGroupSession(sessionId, senderKey, roomId) }
                     .fold(
-                            {
-                                // Session does not already exist, add it
-                                sessions.add(session)
-                            },
                             {
                                 // If we already have this session, consider updating it
                                 Timber.e("## importInboundGroupSession() : Update for megolm session $senderKey/$sessionId")
@@ -613,7 +607,12 @@ internal class MXOlmDevice @Inject constructor(
                                     sessions.add(session)
                                 }
                                 Unit
+                            },
+                            {
+                                // Session does not already exist, add it
+                                sessions.add(session)
                             }
+
                     )
         }
 
@@ -648,61 +647,55 @@ internal class MXOlmDevice @Inject constructor(
                             roomId: String,
                             timeline: String?,
                             sessionId: String,
-                            senderKey: String): Try<OlmDecryptionResult> {
+                            senderKey: String): OlmDecryptionResult {
-        return getInboundGroupSession(sessionId, senderKey, roomId)
+        val session = getInboundGroupSession(sessionId, senderKey, roomId)
-                .flatMap { session ->
+        // Check that the room id matches the original one for the session. This stops
-                    // Check that the room id matches the original one for the session. This stops
+        // the HS pretending a message was targeting a different room.
-                    // the HS pretending a message was targeting a different room.
+        if (roomId == session.roomId) {
-                    if (roomId == session.roomId) {
+            var decryptResult: OlmInboundGroupSession.DecryptMessageResult? = null
-                        var decryptResult: OlmInboundGroupSession.DecryptMessageResult? = null
+            try {
-                        try {
+                decryptResult = session.olmInboundGroupSession!!.decryptMessage(body)
-                            decryptResult = session.olmInboundGroupSession!!.decryptMessage(body)
+            } catch (e: OlmException) {
-                        } catch (e: OlmException) {
+                Timber.e(e, "## decryptGroupMessage () : decryptMessage failed")
-                            Timber.e(e, "## decryptGroupMessage () : decryptMessage failed")
+                throw MXCryptoError.OlmError(e)
-                            return@flatMap Try.Failure(MXCryptoError.OlmError(e))
+            }
-                        }
 
-                        if (null != timeline) {
+            if (null != timeline) {
-                            if (!inboundGroupSessionMessageIndexes.containsKey(timeline)) {
+                val timelineSet = inboundGroupSessionMessageIndexes.getOrPut(timeline) { mutableSetOf() }
-                                inboundGroupSessionMessageIndexes[timeline] = HashMap()
-                            }
 
-                            val messageIndexKey = senderKey + "|" + sessionId + "|" + decryptResult.mIndex
+                val messageIndexKey = senderKey + "|" + sessionId + "|" + decryptResult.mIndex
 
-                            if (inboundGroupSessionMessageIndexes[timeline]?.get(messageIndexKey) != null) {
+                if (timelineSet.contains(messageIndexKey)) {
-                                val reason = String.format(MXCryptoError.DUPLICATE_MESSAGE_INDEX_REASON, decryptResult.mIndex)
+                    val reason = String.format(MXCryptoError.DUPLICATE_MESSAGE_INDEX_REASON, decryptResult.mIndex)
-                                Timber.e("## decryptGroupMessage() : $reason")
+                    Timber.e("## decryptGroupMessage() : $reason")
-                                return@flatMap Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.DUPLICATED_MESSAGE_INDEX, reason))
+                    throw MXCryptoError.Base(MXCryptoError.ErrorType.DUPLICATED_MESSAGE_INDEX, reason)
-                            }
-
-                            inboundGroupSessionMessageIndexes[timeline]!!.put(messageIndexKey, true)
-                        }
-
-                        store.storeInboundGroupSessions(listOf(session))
-                        val payload = try {
-                            val adapter = MoshiProvider.providesMoshi().adapter<JsonDict>(JSON_DICT_PARAMETERIZED_TYPE)
-                            val payloadString = convertFromUTF8(decryptResult.mDecryptedMessage)
-                            adapter.fromJson(payloadString)
-                        } catch (e: Exception) {
-                            Timber.e("## decryptGroupMessage() : fails to parse the payload")
-                            return@flatMap Try.Failure(
-                                    MXCryptoError.Base(MXCryptoError.ErrorType.BAD_DECRYPTED_FORMAT, MXCryptoError.BAD_DECRYPTED_FORMAT_TEXT_REASON))
-                        }
-
-                        return@flatMap Try.just(
-                                OlmDecryptionResult(
-                                        payload,
-                                        session.keysClaimed,
-                                        senderKey,
-                                        session.forwardingCurve25519KeyChain
-                                )
-                        )
-                    } else {
-                        val reason = String.format(MXCryptoError.INBOUND_SESSION_MISMATCH_ROOM_ID_REASON, roomId, session.roomId)
-                        Timber.e("## decryptGroupMessage() : $reason")
-                        return@flatMap Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.INBOUND_SESSION_MISMATCH_ROOM_ID, reason))
-                    }
                 }
+
+                timelineSet.add(messageIndexKey)
+            }
+
+            store.storeInboundGroupSessions(listOf(session))
+            val payload = try {
+                val adapter = MoshiProvider.providesMoshi().adapter<JsonDict>(JSON_DICT_PARAMETERIZED_TYPE)
+                val payloadString = convertFromUTF8(decryptResult.mDecryptedMessage)
+                adapter.fromJson(payloadString)
+            } catch (e: Exception) {
+                Timber.e("## decryptGroupMessage() : fails to parse the payload")
+                throw
+                MXCryptoError.Base(MXCryptoError.ErrorType.BAD_DECRYPTED_FORMAT, MXCryptoError.BAD_DECRYPTED_FORMAT_TEXT_REASON)
+            }
+
+            return OlmDecryptionResult(
+                    payload,
+                    session.keysClaimed,
+                    senderKey,
+                    session.forwardingCurve25519KeyChain
+            )
+        } else {
+            val reason = String.format(MXCryptoError.INBOUND_SESSION_MISMATCH_ROOM_ID_REASON, roomId, session.roomId)
+            Timber.e("## decryptGroupMessage() : $reason")
+            throw MXCryptoError.Base(MXCryptoError.ErrorType.INBOUND_SESSION_MISMATCH_ROOM_ID, reason)
+        }
     }
 
     /**
@@ -766,26 +759,26 @@ internal class MXOlmDevice @Inject constructor(
      * @param senderKey the base64-encoded curve25519 key of the sender.
      * @return the inbound group session.
      */
-    fun getInboundGroupSession(sessionId: String?, senderKey: String?, roomId: String?): Try<OlmInboundGroupSessionWrapper> {
+    fun getInboundGroupSession(sessionId: String?, senderKey: String?, roomId: String?): OlmInboundGroupSessionWrapper {
         if (sessionId.isNullOrBlank() || senderKey.isNullOrBlank()) {
-            return Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_SENDER_KEY, MXCryptoError.ERROR_MISSING_PROPERTY_REASON))
+            throw MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_SENDER_KEY, MXCryptoError.ERROR_MISSING_PROPERTY_REASON)
         }
 
         val session = store.getInboundGroupSession(sessionId, senderKey)
 
-        return if (null != session) {
+        if (session != null) {
             // Check that the room id matches the original one for the session. This stops
             // the HS pretending a message was targeting a different room.
             if (!TextUtils.equals(roomId, session.roomId)) {
                 val errorDescription = String.format(MXCryptoError.INBOUND_SESSION_MISMATCH_ROOM_ID_REASON, roomId, session.roomId)
                 Timber.e("## getInboundGroupSession() : $errorDescription")
-                Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.INBOUND_SESSION_MISMATCH_ROOM_ID, errorDescription))
+                throw MXCryptoError.Base(MXCryptoError.ErrorType.INBOUND_SESSION_MISMATCH_ROOM_ID, errorDescription)
             } else {
-                Try.just(session)
+                return session
             }
         } else {
             Timber.e("## getInboundGroupSession() : Cannot retrieve inbound group session $sessionId")
-            Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.UNKNOWN_INBOUND_SESSION_ID, MXCryptoError.UNKNOWN_INBOUND_SESSION_ID_REASON))
+            throw MXCryptoError.Base(MXCryptoError.ErrorType.UNKNOWN_INBOUND_SESSION_ID, MXCryptoError.UNKNOWN_INBOUND_SESSION_ID_REASON)
         }
     }
 
@@ -798,6 +791,6 @@ internal class MXOlmDevice @Inject constructor(
      * @return true if the unbound session keys are known.
      */
     fun hasInboundSessionKeys(roomId: String, senderKey: String, sessionId: String): Boolean {
-        return getInboundGroupSession(sessionId, senderKey, roomId).isSuccess()
+        return runCatching { getInboundGroupSession(sessionId, senderKey, roomId) }.isSuccess
     }
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/ObjectSigner.kt

@@ -17,8 +17,6 @@
 package im.vector.matrix.android.internal.crypto
 
 import im.vector.matrix.android.api.auth.data.Credentials
-import im.vector.matrix.android.internal.session.SessionScope
-import java.util.*
 import javax.inject.Inject
 
 internal class ObjectSigner @Inject constructor(private val credentials: Credentials,

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/OneTimeKeysUploader.kt

@@ -16,8 +16,6 @@
 
 package im.vector.matrix.android.internal.crypto
 
-import arrow.core.Try
-import arrow.instances.`try`.applicativeError.handleError
 import im.vector.matrix.android.api.auth.data.Credentials
 import im.vector.matrix.android.internal.crypto.model.MXKey
 import im.vector.matrix.android.internal.crypto.model.rest.KeysUploadResponse
@@ -59,13 +57,13 @@ internal class OneTimeKeysUploader @Inject constructor(
     /**
      * Check if the OTK must be uploaded.
      */
-    suspend fun maybeUploadOneTimeKeys(): Try<Unit> {
+    suspend fun maybeUploadOneTimeKeys() {
         if (oneTimeKeyCheckInProgress) {
-            return Try.just(Unit)
+            return
         }
         if (System.currentTimeMillis() - lastOneTimeKeyCheck < ONE_TIME_KEY_UPLOAD_PERIOD) {
             // we've done a key upload recently.
-            return Try.just(Unit)
+            return
         }
 
         lastOneTimeKeyCheck = System.currentTimeMillis()
@@ -81,41 +79,31 @@ internal class OneTimeKeysUploader @Inject constructor(
         // discard the oldest private keys first. This will eventually clean
         // out stale private keys that won't receive a message.
         val keyLimit = Math.floor(maxOneTimeKeys / 2.0).toInt()
-        val result = if (oneTimeKeyCount != null) {
+        if (oneTimeKeyCount != null) {
             uploadOTK(oneTimeKeyCount!!, keyLimit)
         } else {
             // ask the server how many keys we have
             val uploadKeysParams = UploadKeysTask.Params(null, null, credentials.deviceId!!)
-            uploadKeysTask.execute(uploadKeysParams)
+            val response = uploadKeysTask.execute(uploadKeysParams)
-                    .flatMap {
+            // We need to keep a pool of one time public keys on the server so that
-                        // We need to keep a pool of one time public keys on the server so that
+            // other devices can start conversations with us. But we can only store
-                        // other devices can start conversations with us. But we can only store
+            // a finite number of private keys in the olm Account object.
-                        // a finite number of private keys in the olm Account object.
+            // To complicate things further then can be a delay between a device
-                        // To complicate things further then can be a delay between a device
+            // claiming a public one time key from the server and it sending us a
-                        // claiming a public one time key from the server and it sending us a
+            // message. We need to keep the corresponding private key locally until
-                        // message. We need to keep the corresponding private key locally until
+            // we receive the message.
-                        // we receive the message.
+            // But that message might never arrive leaving us stuck with duff
-                        // But that message might never arrive leaving us stuck with duff
+            // private keys clogging up our local storage.
-                        // private keys clogging up our local storage.
+            // So we need some kind of engineering compromise to balance all of
-                        // So we need some kind of engineering compromise to balance all of
+            // these factors.
-                        // these factors.
+            // TODO Why we do not set oneTimeKeyCount here?
-                        // TODO Why we do not set oneTimeKeyCount here?
+            // TODO This is not needed anymore, see https://github.com/matrix-org/matrix-js-sdk/pull/493 (TODO on iOS also)
-                        // TODO This is not needed anymore, see https://github.com/matrix-org/matrix-js-sdk/pull/493 (TODO on iOS also)
+            val keyCount = response.oneTimeKeyCountsForAlgorithm(MXKey.KEY_SIGNED_CURVE_25519_TYPE)
-                        val keyCount = it.oneTimeKeyCountsForAlgorithm(MXKey.KEY_SIGNED_CURVE_25519_TYPE)
+            uploadOTK(keyCount, keyLimit)
-                        uploadOTK(keyCount, keyLimit)
-                    }
         }
-        return result
+        Timber.v("## uploadKeys() : success")
-                .map {
+        oneTimeKeyCount = null
-                    Timber.v("## uploadKeys() : success")
+        oneTimeKeyCheckInProgress = false
-                    oneTimeKeyCount = null
-                    oneTimeKeyCheckInProgress = false
-                }
-                .handleError {
-                    Timber.e(it, "## uploadKeys() : failed")
-                    oneTimeKeyCount = null
-                    oneTimeKeyCheckInProgress = false
-                }
     }
 
     /**
@@ -124,29 +112,26 @@ internal class OneTimeKeysUploader @Inject constructor(
      * @param keyCount the key count
      * @param keyLimit the limit
      */
-    private suspend fun uploadOTK(keyCount: Int, keyLimit: Int): Try<Unit> {
+    private suspend fun uploadOTK(keyCount: Int, keyLimit: Int) {
         if (keyLimit <= keyCount) {
             // If we don't need to generate any more keys then we are done.
-            return Try.just(Unit)
+            return
         }
-
         val keysThisLoop = Math.min(keyLimit - keyCount, ONE_TIME_KEY_GENERATION_MAX_NUMBER)
         olmDevice.generateOneTimeKeys(keysThisLoop)
-        return uploadOneTimeKeys()
+        val response = uploadOneTimeKeys()
-                .flatMap {
+        if (response.hasOneTimeKeyCountsForAlgorithm(MXKey.KEY_SIGNED_CURVE_25519_TYPE)) {
-                    if (it.hasOneTimeKeyCountsForAlgorithm(MXKey.KEY_SIGNED_CURVE_25519_TYPE)) {
+            uploadOTK(response.oneTimeKeyCountsForAlgorithm(MXKey.KEY_SIGNED_CURVE_25519_TYPE), keyLimit)
-                        uploadOTK(it.oneTimeKeyCountsForAlgorithm(MXKey.KEY_SIGNED_CURVE_25519_TYPE), keyLimit)
+        } else {
-                    } else {
+            Timber.e("## uploadLoop() : response for uploading keys does not contain one_time_key_counts.signed_curve25519")
-                        Timber.e("## uploadLoop() : response for uploading keys does not contain one_time_key_counts.signed_curve25519")
+            throw Exception("response for uploading keys does not contain one_time_key_counts.signed_curve25519")
-                        Try.raise(Exception("response for uploading keys does not contain one_time_key_counts.signed_curve25519"))
+        }
-                    }
-                }
     }
 
     /**
      * Upload my user's one time keys.
      */
-    private suspend fun uploadOneTimeKeys(): Try<KeysUploadResponse> {
+    private suspend fun uploadOneTimeKeys(): KeysUploadResponse {
         val oneTimeKeys = olmDevice.getOneTimeKeys()
         val oneTimeJson = HashMap<String, Any>()
 
@@ -169,13 +154,10 @@ internal class OneTimeKeysUploader @Inject constructor(
         // For now, we set the device id explicitly, as we may not be using the
         // same one as used in login.
         val uploadParams = UploadKeysTask.Params(null, oneTimeJson, credentials.deviceId!!)
-        return uploadKeysTask
+        val response = uploadKeysTask.execute(uploadParams)
-                .execute(uploadParams)
+        lastPublishedOneTimeKeys = oneTimeKeys
-                .map {
+        olmDevice.markKeysAsPublished()
-                    lastPublishedOneTimeKeys = oneTimeKeys
+        return response
-                    olmDevice.markKeysAsPublished()
-                    it
-                }
     }
 
     companion object {

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/OutgoingRoomKeyRequestManager.kt

@@ -299,10 +299,12 @@ internal class OutgoingRoomKeyRequestManager @Inject constructor(
             // TODO Change this two hard coded key to something better
             contentMap.setObject(recipient["userId"], recipient["deviceId"], message)
         }
-        sendToDeviceTask.configureWith(SendToDeviceTask.Params(EventType.ROOM_KEY_REQUEST, contentMap, transactionId))
+        sendToDeviceTask
-                .dispatchTo(callback)
+                .configureWith(SendToDeviceTask.Params(EventType.ROOM_KEY_REQUEST, contentMap, transactionId)) {
-                .executeOn(TaskThread.CALLER)
+                    this.callback = callback
-                .callbackOn(TaskThread.CALLER)
+                    this.callbackThread = TaskThread.CALLER
+                    this.executionThread = TaskThread.CALLER
+                }
                 .executeBy(taskExecutor)
     }
 

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/actions/EnsureOlmSessionsForDevicesAction.kt

@@ -17,7 +17,6 @@
 package im.vector.matrix.android.internal.crypto.actions
 
 import android.text.TextUtils
-import arrow.core.Try
 import im.vector.matrix.android.internal.crypto.MXOlmDevice
 import im.vector.matrix.android.internal.crypto.model.MXDeviceInfo
 import im.vector.matrix.android.internal.crypto.model.MXKey
@@ -32,7 +31,7 @@ internal class EnsureOlmSessionsForDevicesAction @Inject constructor(private val
                                                                      private val oneTimeKeysForUsersDeviceTask: ClaimOneTimeKeysForUsersDeviceTask) {
 
 
-    suspend fun handle(devicesByUser: Map<String, List<MXDeviceInfo>>): Try<MXUsersDevicesMap<MXOlmSessionResult>> {
+    suspend fun handle(devicesByUser: Map<String, List<MXDeviceInfo>>): MXUsersDevicesMap<MXOlmSessionResult> {
         val devicesWithoutSession = ArrayList<MXDeviceInfo>()
 
         val results = MXUsersDevicesMap<MXOlmSessionResult>()
@@ -58,7 +57,7 @@ internal class EnsureOlmSessionsForDevicesAction @Inject constructor(private val
         }
 
         if (devicesWithoutSession.size == 0) {
-            return Try.just(results)
+            return results
         }
 
         // Prepare the request for claiming one-time keys
@@ -79,39 +78,36 @@ internal class EnsureOlmSessionsForDevicesAction @Inject constructor(private val
         Timber.v("## claimOneTimeKeysForUsersDevices() : $usersDevicesToClaim")
 
         val claimParams = ClaimOneTimeKeysForUsersDeviceTask.Params(usersDevicesToClaim)
-        return oneTimeKeysForUsersDeviceTask
+        val oneTimeKeys = oneTimeKeysForUsersDeviceTask.execute(claimParams)
-                .execute(claimParams)
+        Timber.v("## claimOneTimeKeysForUsersDevices() : keysClaimResponse.oneTimeKeys: $oneTimeKeys")
-                .map {
+        for (userId in userIds) {
-                    Timber.v("## claimOneTimeKeysForUsersDevices() : keysClaimResponse.oneTimeKeys: $it")
+            val deviceInfos = devicesByUser[userId]
-                    for (userId in userIds) {
+            for (deviceInfo in deviceInfos!!) {
-                        val deviceInfos = devicesByUser[userId]
+                var oneTimeKey: MXKey? = null
-                        for (deviceInfo in deviceInfos!!) {
+                val deviceIds = oneTimeKeys.getUserDeviceIds(userId)
-                            var oneTimeKey: MXKey? = null
+                if (null != deviceIds) {
-                            val deviceIds = it.getUserDeviceIds(userId)
+                    for (deviceId in deviceIds) {
-                            if (null != deviceIds) {
+                        val olmSessionResult = results.getObject(userId, deviceId)
-                                for (deviceId in deviceIds) {
+                        if (olmSessionResult!!.sessionId != null) {
-                                    val olmSessionResult = results.getObject(userId, deviceId)
+                            // We already have a result for this device
-                                    if (olmSessionResult!!.sessionId != null) {
+                            continue
-                                        // We already have a result for this device
-                                        continue
-                                    }
-                                    val key = it.getObject(userId, deviceId)
-                                    if (key?.type == oneTimeKeyAlgorithm) {
-                                        oneTimeKey = key
-                                    }
-                                    if (oneTimeKey == null) {
-                                        Timber.v("## ensureOlmSessionsForDevices() : No one-time keys " + oneTimeKeyAlgorithm
-                                                + " for device " + userId + " : " + deviceId)
-                                        continue
-                                    }
-                                    // Update the result for this device in results
-                                    olmSessionResult.sessionId = verifyKeyAndStartSession(oneTimeKey, userId, deviceInfo)
-                                }
-                            }
                         }
+                        val key = oneTimeKeys.getObject(userId, deviceId)
+                        if (key?.type == oneTimeKeyAlgorithm) {
+                            oneTimeKey = key
+                        }
+                        if (oneTimeKey == null) {
+                            Timber.v("## ensureOlmSessionsForDevices() : No one-time keys " + oneTimeKeyAlgorithm
+                                    + " for device " + userId + " : " + deviceId)
+                            continue
+                        }
+                        // Update the result for this device in results
+                        olmSessionResult.sessionId = verifyKeyAndStartSession(oneTimeKey, userId, deviceInfo)
                     }
-                    results
                 }
+            }
+        }
+        return results
     }
 
     private fun verifyKeyAndStartSession(oneTimeKey: MXKey, userId: String, deviceInfo: MXDeviceInfo): String? {

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/actions/EnsureOlmSessionsForUsersAction.kt

@@ -17,14 +17,11 @@
 package im.vector.matrix.android.internal.crypto.actions
 
 import android.text.TextUtils
-import arrow.core.Try
-import im.vector.matrix.android.api.MatrixCallback
 import im.vector.matrix.android.internal.crypto.MXOlmDevice
 import im.vector.matrix.android.internal.crypto.model.MXDeviceInfo
 import im.vector.matrix.android.internal.crypto.model.MXOlmSessionResult
 import im.vector.matrix.android.internal.crypto.model.MXUsersDevicesMap
 import im.vector.matrix.android.internal.crypto.store.IMXCryptoStore
-import im.vector.matrix.android.internal.session.SessionScope
 import timber.log.Timber
 import java.util.*
 import javax.inject.Inject
@@ -37,7 +34,7 @@ internal class EnsureOlmSessionsForUsersAction @Inject constructor(private val o
      * Try to make sure we have established olm sessions for the given users.
      * @param users    a list of user ids.
      */
-    suspend fun handle(users: List<String>) : Try<MXUsersDevicesMap<MXOlmSessionResult>> {
+    suspend fun handle(users: List<String>) : MXUsersDevicesMap<MXOlmSessionResult> {
         Timber.v("## ensureOlmSessionsForUsers() : ensureOlmSessionsForUsers $users")
         val devicesByUser = HashMap<String /* userId */, MutableList<MXDeviceInfo>>()
 

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/actions/MegolmSessionDataImporter.kt

@@ -26,7 +26,6 @@ import im.vector.matrix.android.internal.crypto.RoomDecryptorProvider
 import im.vector.matrix.android.internal.crypto.model.ImportRoomKeysResult
 import im.vector.matrix.android.internal.crypto.model.rest.RoomKeyRequestBody
 import im.vector.matrix.android.internal.crypto.store.IMXCryptoStore
-import im.vector.matrix.android.internal.session.SessionScope
 import timber.log.Timber
 import javax.inject.Inject
 

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/actions/SetDeviceVerificationAction.kt

@@ -19,7 +19,6 @@ package im.vector.matrix.android.internal.crypto.actions
 import im.vector.matrix.android.api.auth.data.Credentials
 import im.vector.matrix.android.internal.crypto.keysbackup.KeysBackup
 import im.vector.matrix.android.internal.crypto.store.IMXCryptoStore
-import im.vector.matrix.android.internal.session.SessionScope
 import timber.log.Timber
 import javax.inject.Inject
 

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/IMXDecrypting.kt

@@ -17,7 +17,6 @@
 
 package im.vector.matrix.android.internal.crypto.algorithms
 
-import arrow.core.Try
 import im.vector.matrix.android.api.session.events.model.Event
 import im.vector.matrix.android.internal.crypto.IncomingRoomKeyRequest
 import im.vector.matrix.android.internal.crypto.MXEventDecryptionResult
@@ -35,7 +34,7 @@ internal interface IMXDecrypting {
      * @param timeline the id of the timeline where the event is decrypted. It is used to prevent replay attack.
      * @return the decryption information, or an error
      */
-    suspend fun decryptEvent(event: Event, timeline: String): Try<MXEventDecryptionResult>
+    suspend fun decryptEvent(event: Event, timeline: String): MXEventDecryptionResult
 
     /**
      * Handle a key event.

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/IMXEncrypting.kt

@@ -17,7 +17,6 @@
 
 package im.vector.matrix.android.internal.crypto.algorithms
 
-import arrow.core.Try
 import im.vector.matrix.android.api.session.events.model.Content
 
 /**
@@ -31,7 +30,7 @@ internal interface IMXEncrypting {
      * @param eventContent the content of the event.
      * @param eventType    the type of the event.
      * @param userIds      the room members the event will be sent to.
-     * @return the encrypted content wrapped by [Try]
+     * @return the encrypted content
      */
-    suspend fun encryptEventContent(eventContent: Content, eventType: String, userIds: List<String>): Try<Content>
+    suspend fun encryptEventContent(eventContent: Content, eventType: String, userIds: List<String>): Content
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/megolm/MXMegolmDecryption.kt

@@ -18,7 +18,6 @@
 package im.vector.matrix.android.internal.crypto.algorithms.megolm
 
 import android.text.TextUtils
-import arrow.core.Try
 import im.vector.matrix.android.api.auth.data.Credentials
 import im.vector.matrix.android.api.session.crypto.MXCryptoError
 import im.vector.matrix.android.api.session.events.model.Event
@@ -29,7 +28,6 @@ import im.vector.matrix.android.internal.crypto.actions.EnsureOlmSessionsForDevi
 import im.vector.matrix.android.internal.crypto.actions.MessageEncrypter
 import im.vector.matrix.android.internal.crypto.algorithms.IMXDecrypting
 import im.vector.matrix.android.internal.crypto.keysbackup.KeysBackup
-import im.vector.matrix.android.internal.crypto.model.MXDeviceInfo
 import im.vector.matrix.android.internal.crypto.model.MXUsersDevicesMap
 import im.vector.matrix.android.internal.crypto.model.event.EncryptedEventContent
 import im.vector.matrix.android.internal.crypto.model.event.RoomKeyContent
@@ -38,11 +36,9 @@ import im.vector.matrix.android.internal.crypto.model.rest.RoomKeyRequestBody
 import im.vector.matrix.android.internal.crypto.store.IMXCryptoStore
 import im.vector.matrix.android.internal.crypto.tasks.SendToDeviceTask
 import im.vector.matrix.android.internal.util.MatrixCoroutineDispatchers
-import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.launch
 import timber.log.Timber
-import java.util.*
-import kotlin.collections.HashMap
 
 internal class MXMegolmDecryption(private val credentials: Credentials,
                                   private val olmDevice: MXOlmDevice,
@@ -63,30 +59,46 @@ internal class MXMegolmDecryption(private val credentials: Credentials,
      */
     private var pendingEvents: MutableMap<String /* senderKey|sessionId */, MutableMap<String /* timelineId */, MutableList<Event>>> = HashMap()
 
-    override suspend fun decryptEvent(event: Event, timeline: String): Try<MXEventDecryptionResult> {
+    override suspend fun decryptEvent(event: Event, timeline: String): MXEventDecryptionResult {
         return decryptEvent(event, timeline, true)
     }
 
-    private fun decryptEvent(event: Event, timeline: String, requestKeysOnFail: Boolean): Try<MXEventDecryptionResult> {
+    private suspend fun decryptEvent(event: Event, timeline: String, requestKeysOnFail: Boolean): MXEventDecryptionResult {
         if (event.roomId.isNullOrBlank()) {
-            return Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_FIELDS, MXCryptoError.MISSING_FIELDS_REASON))
+            throw MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_FIELDS, MXCryptoError.MISSING_FIELDS_REASON)
         }
 
         val encryptedEventContent = event.content.toModel<EncryptedEventContent>()
-                ?: return Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_FIELDS, MXCryptoError.MISSING_FIELDS_REASON))
+                ?: throw MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_FIELDS, MXCryptoError.MISSING_FIELDS_REASON)
 
         if (encryptedEventContent.senderKey.isNullOrBlank()
                 || encryptedEventContent.sessionId.isNullOrBlank()
                 || encryptedEventContent.ciphertext.isNullOrBlank()) {
-            return Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_FIELDS, MXCryptoError.MISSING_FIELDS_REASON))
+            throw MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_FIELDS, MXCryptoError.MISSING_FIELDS_REASON)
         }
 
-        return olmDevice.decryptGroupMessage(encryptedEventContent.ciphertext,
+        return runCatching {
-                event.roomId,
+            olmDevice.decryptGroupMessage(encryptedEventContent.ciphertext,
-                timeline,
+                    event.roomId,
-                encryptedEventContent.sessionId,
+                    timeline,
-                encryptedEventContent.senderKey)
+                    encryptedEventContent.sessionId,
+                    encryptedEventContent.senderKey)
+        }
                 .fold(
+                        { olmDecryptionResult ->
+                            // the decryption succeeds
+                            if (olmDecryptionResult.payload != null) {
+                                MXEventDecryptionResult(
+                                        clearEvent = olmDecryptionResult.payload,
+                                        senderCurve25519Key = olmDecryptionResult.senderKey,
+                                        claimedEd25519Key = olmDecryptionResult.keysClaimed?.get("ed25519"),
+                                        forwardingCurve25519KeyChain = olmDecryptionResult.forwardingCurve25519KeyChain
+                                                ?: emptyList()
+                                )
+                            } else {
+                                throw MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_FIELDS, MXCryptoError.MISSING_FIELDS_REASON)
+                            }
+                        },
                         { throwable ->
                             if (throwable is MXCryptoError.OlmError) {
                                 // TODO Check the value of .message
@@ -100,10 +112,10 @@ internal class MXMegolmDecryption(private val credentials: Credentials,
                                 val reason = String.format(MXCryptoError.OLM_REASON, throwable.olmException.message)
                                 val detailedReason = String.format(MXCryptoError.DETAILED_OLM_REASON, encryptedEventContent.ciphertext, reason)
 
-                                Try.Failure(MXCryptoError.Base(
+                                throw MXCryptoError.Base(
                                         MXCryptoError.ErrorType.OLM,
                                         reason,
-                                        detailedReason))
+                                        detailedReason)
                             }
                             if (throwable is MXCryptoError.Base) {
                                 if (throwable.errorType == MXCryptoError.ErrorType.UNKNOWN_INBOUND_SESSION_ID) {
@@ -113,23 +125,7 @@ internal class MXMegolmDecryption(private val credentials: Credentials,
                                     }
                                 }
                             }
-
+                            throw throwable
-                            Try.Failure(throwable)
-                        },
-                        { olmDecryptionResult ->
-                            // the decryption succeeds
-                            if (olmDecryptionResult.payload != null) {
-                                Try.just(
-                                        MXEventDecryptionResult(
-                                                clearEvent = olmDecryptionResult.payload,
-                                                senderCurve25519Key = olmDecryptionResult.senderKey,
-                                                claimedEd25519Key = olmDecryptionResult.keysClaimed?.get("ed25519"),
-                                                forwardingCurve25519KeyChain = olmDecryptionResult.forwardingCurve25519KeyChain ?: emptyList()
-                                        )
-                                )
-                            } else {
-                                Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_FIELDS, MXCryptoError.MISSING_FIELDS_REASON))
-                            }
                         }
                 )
     }
@@ -312,54 +308,49 @@ internal class MXMegolmDecryption(private val credentials: Credentials,
             return
         }
         val userId = request.userId ?: return
-        CoroutineScope(coroutineDispatchers.crypto).launch {
+        GlobalScope.launch(coroutineDispatchers.crypto) {
-            deviceListManager
+            runCatching { deviceListManager.downloadKeys(listOf(userId), false) }
-                    .downloadKeys(listOf(userId), false)
+                    .mapCatching {
-                    .flatMap {
                         val deviceId = request.deviceId
                         val deviceInfo = cryptoStore.getUserDevice(deviceId ?: "", userId)
                         if (deviceInfo == null) {
                             throw RuntimeException()
                         } else {
-                            val devicesByUser = HashMap<String, List<MXDeviceInfo>>()
+                            val devicesByUser = mapOf(userId to listOf(deviceInfo))
-                            devicesByUser[userId] = ArrayList(Arrays.asList(deviceInfo))
+                            val usersDeviceMap = ensureOlmSessionsForDevicesAction.handle(devicesByUser)
-                            ensureOlmSessionsForDevicesAction
+                            val body = request.requestBody
-                                    .handle(devicesByUser)
+                            val olmSessionResult = usersDeviceMap.getObject(userId, deviceId)
-                                    .flatMap {
+                            if (olmSessionResult?.sessionId == null) {
-                                        val body = request.requestBody
+                                // no session with this device, probably because there
-                                        val olmSessionResult = it.getObject(userId, deviceId)
+                                // were no one-time keys.
-                                        if (olmSessionResult?.sessionId == null) {
+                                return@mapCatching
-                                            // no session with this device, probably because there
+                            }
-                                            // were no one-time keys.
+                            Timber.v("## shareKeysWithDevice() : sharing keys for session" +
-                                            Try.just(Unit)
+                                    " ${body?.senderKey}|${body?.sessionId} with device $userId:$deviceId")
-                                        }
-                                        Timber.v("## shareKeysWithDevice() : sharing keys for session" +
-                                                " ${body?.senderKey}|${body?.sessionId} with device $userId:$deviceId")
 
-                                        val payloadJson = HashMap<String, Any>()
+                            val payloadJson = mutableMapOf<String, Any>("type" to EventType.FORWARDED_ROOM_KEY)
-                                        payloadJson["type"] = EventType.FORWARDED_ROOM_KEY
+                            runCatching { olmDevice.getInboundGroupSession(body?.sessionId, body?.senderKey, body?.roomId) }
+                                    .fold(
+                                            {
+                                                // TODO
+                                                payloadJson["content"] = it.exportKeys()
+                                                        ?: ""
+                                            },
+                                            {
+                                                // TODO
+                                            }
 
-                                        olmDevice.getInboundGroupSession(body?.sessionId, body?.senderKey, body?.roomId)
+                                    )
-                                                .fold(
-                                                        {
-                                                            // TODO
-                                                        },
-                                                        {
-                                                            // TODO
-                                                            payloadJson["content"] = it.exportKeys() ?: ""
-                                                        }
-                                                )
 
-                                        val encodedPayload = messageEncrypter.encryptMessage(payloadJson, Arrays.asList(deviceInfo))
+                            val encodedPayload = messageEncrypter.encryptMessage(payloadJson, listOf(deviceInfo))
-                                        val sendToDeviceMap = MXUsersDevicesMap<Any>()
+                            val sendToDeviceMap = MXUsersDevicesMap<Any>()
-                                        sendToDeviceMap.setObject(userId, deviceId, encodedPayload)
+                            sendToDeviceMap.setObject(userId, deviceId, encodedPayload)
-                                        Timber.v("## shareKeysWithDevice() : sending to $userId:$deviceId")
+                            Timber.v("## shareKeysWithDevice() : sending to $userId:$deviceId")
-                                        val sendToDeviceParams = SendToDeviceTask.Params(EventType.ENCRYPTED, sendToDeviceMap)
+                            val sendToDeviceParams = SendToDeviceTask.Params(EventType.ENCRYPTED, sendToDeviceMap)
-                                        sendToDeviceTask.execute(sendToDeviceParams)
+                            sendToDeviceTask.execute(sendToDeviceParams)
-                                    }
                         }
                     }
         }
     }
-
 }
+

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/megolm/MXMegolmDecryptionFactory.kt

@@ -24,7 +24,6 @@ import im.vector.matrix.android.internal.crypto.actions.EnsureOlmSessionsForDevi
 import im.vector.matrix.android.internal.crypto.actions.MessageEncrypter
 import im.vector.matrix.android.internal.crypto.store.IMXCryptoStore
 import im.vector.matrix.android.internal.crypto.tasks.SendToDeviceTask
-import im.vector.matrix.android.internal.session.SessionScope
 import im.vector.matrix.android.internal.util.MatrixCoroutineDispatchers
 import javax.inject.Inject
 

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/megolm/MXMegolmEncryption.kt

@@ -19,7 +19,6 @@
 package im.vector.matrix.android.internal.crypto.algorithms.megolm
 
 import android.text.TextUtils
-import arrow.core.Try
 import im.vector.matrix.android.api.auth.data.Credentials
 import im.vector.matrix.android.api.session.crypto.MXCryptoError
 import im.vector.matrix.android.api.session.events.model.Content
@@ -69,12 +68,10 @@ internal class MXMegolmEncryption(
 
     override suspend fun encryptEventContent(eventContent: Content,
                                              eventType: String,
-                                             userIds: List<String>): Try<Content> {
+                                             userIds: List<String>): Content {
-        return getDevicesInRoom(userIds)
+        val devices = getDevicesInRoom(userIds)
-                .flatMap { ensureOutboundSession(it) }
+        val outboundSession = ensureOutboundSession(devices)
-                .flatMap {
+        return encryptContent(outboundSession, eventType, eventContent)
-                    encryptContent(it, eventType, eventContent)
-                }
     }
 
     /**
@@ -101,7 +98,7 @@ internal class MXMegolmEncryption(
      *
      * @param devicesInRoom the devices list
      */
-    private suspend fun ensureOutboundSession(devicesInRoom: MXUsersDevicesMap<MXDeviceInfo>): Try<MXOutboundSessionInfo> {
+    private suspend fun ensureOutboundSession(devicesInRoom: MXUsersDevicesMap<MXDeviceInfo>): MXOutboundSessionInfo {
         var session = outboundSession
         if (session == null
                 // Need to make a brand new session?
@@ -126,7 +123,8 @@ internal class MXMegolmEncryption(
                 }
             }
         }
-        return shareKey(safeSession, shareMap).map { safeSession!! }
+        shareKey(safeSession, shareMap)
+        return safeSession
     }
 
     /**
@@ -136,11 +134,11 @@ internal class MXMegolmEncryption(
      * @param devicesByUsers the devices map
      */
     private suspend fun shareKey(session: MXOutboundSessionInfo,
-                                 devicesByUsers: Map<String, List<MXDeviceInfo>>): Try<Unit> {
+                                 devicesByUsers: Map<String, List<MXDeviceInfo>>) {
         // nothing to send, the task is done
         if (devicesByUsers.isEmpty()) {
             Timber.v("## shareKey() : nothing more to do")
-            return Try.just(Unit)
+            return
         }
         // reduce the map size to avoid request timeout when there are too many devices (Users size  * devices per user)
         val subMap = HashMap<String, List<MXDeviceInfo>>()
@@ -157,11 +155,9 @@ internal class MXMegolmEncryption(
             }
         }
         Timber.v("## shareKey() ; userId $userIds")
-        return shareUserDevicesKey(session, subMap)
+        shareUserDevicesKey(session, subMap)
-                .flatMap {
+        val remainingDevices = devicesByUsers.filterKeys { userIds.contains(it).not() }
-                    val remainingDevices = devicesByUsers.filterKeys { userIds.contains(it).not() }
+        shareKey(session, remainingDevices)
-                    shareKey(session, remainingDevices)
-                }
     }
 
     /**
@@ -172,7 +168,7 @@ internal class MXMegolmEncryption(
      * @param callback      the asynchronous callback
      */
     private suspend fun shareUserDevicesKey(session: MXOutboundSessionInfo,
-                                            devicesByUser: Map<String, List<MXDeviceInfo>>): Try<Unit> {
+                                            devicesByUser: Map<String, List<MXDeviceInfo>>) {
         val sessionKey = olmDevice.getSessionKey(session.sessionId)
         val chainIndex = olmDevice.getMessageIndex(session.sessionId)
 
@@ -190,94 +186,86 @@ internal class MXMegolmEncryption(
         var t0 = System.currentTimeMillis()
         Timber.v("## shareUserDevicesKey() : starts")
 
-        return ensureOlmSessionsForDevicesAction.handle(devicesByUser)
+        val results = ensureOlmSessionsForDevicesAction.handle(devicesByUser)
-                .flatMap {
+        Timber.v("## shareUserDevicesKey() : ensureOlmSessionsForDevices succeeds after "
-                    Timber.v("## shareUserDevicesKey() : ensureOlmSessionsForDevices succeeds after "
+                + (System.currentTimeMillis() - t0) + " ms")
-                            + (System.currentTimeMillis() - t0) + " ms")
+        val contentMap = MXUsersDevicesMap<Any>()
-                    val contentMap = MXUsersDevicesMap<Any>()
+        var haveTargets = false
-                    var haveTargets = false
+        val userIds = results.userIds
-                    val userIds = it.userIds
+        for (userId in userIds) {
-                    for (userId in userIds) {
+            val devicesToShareWith = devicesByUser[userId]
-                        val devicesToShareWith = devicesByUser[userId]
+            for ((deviceID) in devicesToShareWith!!) {
-                        for ((deviceID) in devicesToShareWith!!) {
+                val sessionResult = results.getObject(userId, deviceID)
-                            val sessionResult = it.getObject(userId, deviceID)
+                if (sessionResult?.sessionId == null) {
-                            if (sessionResult?.sessionId == null) {
+                    // no session with this device, probably because there
-                                // no session with this device, probably because there
+                    // were no one-time keys.
-                                // were no one-time keys.
+                    //
-                                //
+                    // we could send them a to_device message anyway, as a
-                                // we could send them a to_device message anyway, as a
+                    // signal that they have missed out on the key sharing
-                                // signal that they have missed out on the key sharing
+                    // message because of the lack of keys, but there's not
-                                // message because of the lack of keys, but there's not
+                    // much point in that really; it will mostly serve to clog
-                                // much point in that really; it will mostly serve to clog
+                    // up to_device inboxes.
-                                // up to_device inboxes.
+                    //
-                                //
+                    // ensureOlmSessionsForUsers has already done the logging,
-                                // ensureOlmSessionsForUsers has already done the logging,
+                    // so just skip it.
-                                // so just skip it.
+                    continue
-                                continue
-                            }
-                            Timber.v("## shareUserDevicesKey() : Sharing keys with device $userId:$deviceID")
-                            //noinspection ArraysAsListWithZeroOrOneArgument,ArraysAsListWithZeroOrOneArgument
-                            contentMap.setObject(userId, deviceID, messageEncrypter.encryptMessage(payload, Arrays.asList(sessionResult.deviceInfo)))
-                            haveTargets = true
-                        }
-                    }
-                    if (haveTargets) {
-                        t0 = System.currentTimeMillis()
-                        Timber.v("## shareUserDevicesKey() : has target")
-                        val sendToDeviceParams = SendToDeviceTask.Params(EventType.ENCRYPTED, contentMap)
-                        sendToDeviceTask.execute(sendToDeviceParams)
-                                .map {
-                                    Timber.v("## shareUserDevicesKey() : sendToDevice succeeds after "
-                                            + (System.currentTimeMillis() - t0) + " ms")
-
-                                    // Add the devices we have shared with to session.sharedWithDevices.
-                                    // we deliberately iterate over devicesByUser (ie, the devices we
-                                    // attempted to share with) rather than the contentMap (those we did
-                                    // share with), because we don't want to try to claim a one-time-key
-                                    // for dead devices on every message.
-                                    for (userId in devicesByUser.keys) {
-                                        val devicesToShareWith = devicesByUser[userId]
-                                        for ((deviceId) in devicesToShareWith!!) {
-                                            session.sharedWithDevices.setObject(userId, deviceId, chainIndex)
-                                        }
-                                    }
-                                    Unit
-                                }
-                    } else {
-                        Timber.v("## shareUserDevicesKey() : no need to sharekey")
-                        Try.just(Unit)
-                    }
                 }
+                Timber.v("## shareUserDevicesKey() : Sharing keys with device $userId:$deviceID")
+                //noinspection ArraysAsListWithZeroOrOneArgument,ArraysAsListWithZeroOrOneArgument
+                contentMap.setObject(userId, deviceID, messageEncrypter.encryptMessage(payload, Arrays.asList(sessionResult.deviceInfo)))
+                haveTargets = true
+            }
+        }
+        if (haveTargets) {
+            t0 = System.currentTimeMillis()
+            Timber.v("## shareUserDevicesKey() : has target")
+            val sendToDeviceParams = SendToDeviceTask.Params(EventType.ENCRYPTED, contentMap)
+            sendToDeviceTask.execute(sendToDeviceParams)
+            Timber.v("## shareUserDevicesKey() : sendToDevice succeeds after "
+                    + (System.currentTimeMillis() - t0) + " ms")
+
+            // Add the devices we have shared with to session.sharedWithDevices.
+            // we deliberately iterate over devicesByUser (ie, the devices we
+            // attempted to share with) rather than the contentMap (those we did
+            // share with), because we don't want to try to claim a one-time-key
+            // for dead devices on every message.
+            for (userId in devicesByUser.keys) {
+                val devicesToShareWith = devicesByUser[userId]
+                for ((deviceId) in devicesToShareWith!!) {
+                    session.sharedWithDevices.setObject(userId, deviceId, chainIndex)
+                }
+            }
+        } else {
+            Timber.v("## shareUserDevicesKey() : no need to sharekey")
+        }
     }
 
     /**
      * process the pending encryptions
      */
-    private fun encryptContent(session: MXOutboundSessionInfo, eventType: String, eventContent: Content): Try<Content> {
+    private fun encryptContent(session: MXOutboundSessionInfo, eventType: String, eventContent: Content): Content {
-        return Try<Content> {
+        // Everything is in place, encrypt all pending events
-            // Everything is in place, encrypt all pending events
+        val payloadJson = HashMap<String, Any>()
-            val payloadJson = HashMap<String, Any>()
+        payloadJson["room_id"] = roomId
-            payloadJson["room_id"] = roomId
+        payloadJson["type"] = eventType
-            payloadJson["type"] = eventType
+        payloadJson["content"] = eventContent
-            payloadJson["content"] = eventContent
 
-            // Get canonical Json from
+        // Get canonical Json from
 
-            val payloadString = convertToUTF8(JsonCanonicalizer.getCanonicalJson(Map::class.java, payloadJson))
+        val payloadString = convertToUTF8(JsonCanonicalizer.getCanonicalJson(Map::class.java, payloadJson))
-            val ciphertext = olmDevice.encryptGroupMessage(session.sessionId, payloadString!!)
+        val ciphertext = olmDevice.encryptGroupMessage(session.sessionId, payloadString!!)
 
-            val map = HashMap<String, Any>()
+        val map = HashMap<String, Any>()
-            map["algorithm"] = MXCRYPTO_ALGORITHM_MEGOLM
+        map["algorithm"] = MXCRYPTO_ALGORITHM_MEGOLM
-            map["sender_key"] = olmDevice.deviceCurve25519Key!!
+        map["sender_key"] = olmDevice.deviceCurve25519Key!!
-            map["ciphertext"] = ciphertext!!
+        map["ciphertext"] = ciphertext!!
-            map["session_id"] = session.sessionId
+        map["session_id"] = session.sessionId
 
-            // Include our device ID so that recipients can send us a
+        // Include our device ID so that recipients can send us a
-            // m.new_device message if they don't have our session key.
+        // m.new_device message if they don't have our session key.
-            map["device_id"] = credentials.deviceId!!
+        map["device_id"] = credentials.deviceId!!
-            session.useCount++
+        session.useCount++
-            map
+        return map
-        }
     }
 
     /**
@@ -287,50 +275,47 @@ internal class MXMegolmEncryption(
      * @param userIds  the user ids whose devices must be checked.
      * @param callback the asynchronous callback
      */
-    private suspend fun getDevicesInRoom(userIds: List<String>): Try<MXUsersDevicesMap<MXDeviceInfo>> {
+    private suspend fun getDevicesInRoom(userIds: List<String>): MXUsersDevicesMap<MXDeviceInfo> {
         // We are happy to use a cached version here: we assume that if we already
         // have a list of the user's devices, then we already share an e2e room
         // with them, which means that they will have announced any new devices via
         // an m.new_device.
-        return deviceListManager
+        val keys = deviceListManager.downloadKeys(userIds, false)
-                .downloadKeys(userIds, false)
+        val encryptToVerifiedDevicesOnly = cryptoStore.getGlobalBlacklistUnverifiedDevices()
-                .flatMap {
+                || cryptoStore.getRoomsListBlacklistUnverifiedDevices().contains(roomId)
-                    val encryptToVerifiedDevicesOnly = cryptoStore.getGlobalBlacklistUnverifiedDevices()
-                            || cryptoStore.getRoomsListBlacklistUnverifiedDevices().contains(roomId)
 
-                    val devicesInRoom = MXUsersDevicesMap<MXDeviceInfo>()
+        val devicesInRoom = MXUsersDevicesMap<MXDeviceInfo>()
-                    val unknownDevices = MXUsersDevicesMap<MXDeviceInfo>()
+        val unknownDevices = MXUsersDevicesMap<MXDeviceInfo>()
 
-                    for (userId in it.userIds) {
+        for (userId in keys.userIds) {
-                        val deviceIds = it.getUserDeviceIds(userId) ?: continue
+            val deviceIds = keys.getUserDeviceIds(userId) ?: continue
-                        for (deviceId in deviceIds) {
+            for (deviceId in deviceIds) {
-                            val deviceInfo = it.getObject(userId, deviceId) ?: continue
+                val deviceInfo = keys.getObject(userId, deviceId) ?: continue
-                            if (warnOnUnknownDevicesRepository.warnOnUnknownDevices() && deviceInfo.isUnknown) {
+                if (warnOnUnknownDevicesRepository.warnOnUnknownDevices() && deviceInfo.isUnknown) {
-                                // The device is not yet known by the user
+                    // The device is not yet known by the user
-                                unknownDevices.setObject(userId, deviceId, deviceInfo)
+                    unknownDevices.setObject(userId, deviceId, deviceInfo)
-                                continue
+                    continue
-                            }
-                            if (deviceInfo.isBlocked) {
-                                // Remove any blocked devices
-                                continue
-                            }
-
-                            if (!deviceInfo.isVerified && encryptToVerifiedDevicesOnly) {
-                                continue
-                            }
-
-                            if (TextUtils.equals(deviceInfo.identityKey(), olmDevice.deviceCurve25519Key)) {
-                                // Don't bother sending to ourself
-                                continue
-                            }
-                            devicesInRoom.setObject(userId, deviceId, deviceInfo)
-                        }
-                    }
-                    if (unknownDevices.isEmpty) {
-                        Try.just(devicesInRoom)
-                    } else {
-                        Try.Failure(MXCryptoError.UnknownDevice(unknownDevices))
-                    }
                 }
+                if (deviceInfo.isBlocked) {
+                    // Remove any blocked devices
+                    continue
+                }
+
+                if (!deviceInfo.isVerified && encryptToVerifiedDevicesOnly) {
+                    continue
+                }
+
+                if (TextUtils.equals(deviceInfo.identityKey(), olmDevice.deviceCurve25519Key)) {
+                    // Don't bother sending to ourself
+                    continue
+                }
+                devicesInRoom.setObject(userId, deviceId, deviceInfo)
+            }
+        }
+        if (unknownDevices.isEmpty) {
+            return devicesInRoom
+        } else {
+            throw MXCryptoError.UnknownDevice(unknownDevices)
+        }
     }
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/olm/MXOlmDecryption.kt

@@ -17,7 +17,6 @@
 
 package im.vector.matrix.android.internal.crypto.algorithms.olm
 
-import arrow.core.Try
 import im.vector.matrix.android.api.auth.data.Credentials
 import im.vector.matrix.android.api.session.crypto.MXCryptoError
 import im.vector.matrix.android.api.session.events.model.Event
@@ -32,7 +31,6 @@ import im.vector.matrix.android.internal.crypto.model.event.OlmPayloadContent
 import im.vector.matrix.android.internal.di.MoshiProvider
 import im.vector.matrix.android.internal.util.convertFromUTF8
 import timber.log.Timber
-import java.util.*
 
 internal class MXOlmDecryption(
         // The olm device interface
@@ -41,29 +39,28 @@ internal class MXOlmDecryption(
         private val credentials: Credentials)
     : IMXDecrypting {
 
-    override suspend fun decryptEvent(event: Event, timeline: String): Try<MXEventDecryptionResult> {
+    override suspend fun decryptEvent(event: Event, timeline: String): MXEventDecryptionResult {
         val olmEventContent = event.content.toModel<OlmEventContent>() ?: run {
             Timber.e("## decryptEvent() : bad event format")
-            return Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.BAD_EVENT_FORMAT,
+            throw MXCryptoError.Base(MXCryptoError.ErrorType.BAD_EVENT_FORMAT,
-                    MXCryptoError.BAD_EVENT_FORMAT_TEXT_REASON))
+                    MXCryptoError.BAD_EVENT_FORMAT_TEXT_REASON)
         }
 
         val cipherText = olmEventContent.ciphertext ?: run {
             Timber.e("## decryptEvent() : missing cipher text")
-            return Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_CIPHER_TEXT,
+            throw MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_CIPHER_TEXT,
-                    MXCryptoError.MISSING_CIPHER_TEXT_REASON))
+                    MXCryptoError.MISSING_CIPHER_TEXT_REASON)
         }
 
         val senderKey = olmEventContent.senderKey ?: run {
             Timber.e("## decryptEvent() : missing sender key")
-            return Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_SENDER_KEY,
+            throw MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_SENDER_KEY,
-                    MXCryptoError.MISSING_SENDER_KEY_TEXT_REASON))
+                    MXCryptoError.MISSING_SENDER_KEY_TEXT_REASON)
         }
 
         val messageAny = cipherText[olmDevice.deviceCurve25519Key] ?: run {
             Timber.e("## decryptEvent() : our device ${olmDevice.deviceCurve25519Key} is not included in recipients")
-            return Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.NOT_INCLUDE_IN_RECIPIENTS,
+            throw MXCryptoError.Base(MXCryptoError.ErrorType.NOT_INCLUDE_IN_RECIPIENTS, MXCryptoError.NOT_INCLUDED_IN_RECIPIENT_REASON)
-                    MXCryptoError.NOT_INCLUDED_IN_RECIPIENT_REASON))
         }
 
         // The message for myUser
@@ -73,14 +70,12 @@ internal class MXOlmDecryption(
 
         if (decryptedPayload == null) {
             Timber.e("## decryptEvent() Failed to decrypt Olm event (id= ${event.eventId} from $senderKey")
-            return Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.BAD_ENCRYPTED_MESSAGE,
+            throw MXCryptoError.Base(MXCryptoError.ErrorType.BAD_ENCRYPTED_MESSAGE, MXCryptoError.BAD_ENCRYPTED_MESSAGE_REASON)
-                    MXCryptoError.BAD_ENCRYPTED_MESSAGE_REASON))
         }
         val payloadString = convertFromUTF8(decryptedPayload)
         if (payloadString == null) {
             Timber.e("## decryptEvent() Failed to decrypt Olm event (id= ${event.eventId} from $senderKey")
-            return Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.BAD_ENCRYPTED_MESSAGE,
+            throw MXCryptoError.Base(MXCryptoError.ErrorType.BAD_ENCRYPTED_MESSAGE, MXCryptoError.BAD_ENCRYPTED_MESSAGE_REASON)
-                    MXCryptoError.BAD_ENCRYPTED_MESSAGE_REASON))
         }
 
         val adapter = MoshiProvider.providesMoshi().adapter<JsonDict>(JSON_DICT_PARAMETERIZED_TYPE)
@@ -88,73 +83,70 @@ internal class MXOlmDecryption(
 
         if (payload == null) {
             Timber.e("## decryptEvent failed : null payload")
-            return Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.UNABLE_TO_DECRYPT,
+            throw MXCryptoError.Base(MXCryptoError.ErrorType.UNABLE_TO_DECRYPT, MXCryptoError.MISSING_CIPHER_TEXT_REASON)
-                    MXCryptoError.MISSING_CIPHER_TEXT_REASON))
         }
 
         val olmPayloadContent = OlmPayloadContent.fromJsonString(payloadString) ?: run {
             Timber.e("## decryptEvent() : bad olmPayloadContent format")
-            return Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.BAD_DECRYPTED_FORMAT,
+            throw MXCryptoError.Base(MXCryptoError.ErrorType.BAD_DECRYPTED_FORMAT, MXCryptoError.BAD_DECRYPTED_FORMAT_TEXT_REASON)
-                    MXCryptoError.BAD_DECRYPTED_FORMAT_TEXT_REASON))
         }
 
         if (olmPayloadContent.recipient.isNullOrBlank()) {
             val reason = String.format(MXCryptoError.ERROR_MISSING_PROPERTY_REASON, "recipient")
             Timber.e("## decryptEvent() : $reason")
-            return Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_PROPERTY,
+            throw MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_PROPERTY, reason)
-                    reason))
         }
 
         if (olmPayloadContent.recipient != credentials.userId) {
             Timber.e("## decryptEvent() : Event ${event.eventId}:" +
                     " Intended recipient ${olmPayloadContent.recipient} does not match our id ${credentials.userId}")
-            return Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.BAD_RECIPIENT,
+            throw MXCryptoError.Base(MXCryptoError.ErrorType.BAD_RECIPIENT,
-                    String.format(MXCryptoError.BAD_RECIPIENT_REASON, olmPayloadContent.recipient)))
+                    String.format(MXCryptoError.BAD_RECIPIENT_REASON, olmPayloadContent.recipient))
         }
 
         val recipientKeys = olmPayloadContent.recipient_keys ?: run {
             Timber.e("## decryptEvent() : Olm event (id=${event.eventId}) contains no 'recipient_keys' property; cannot prevent unknown-key attack")
-            return Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_PROPERTY,
+            throw MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_PROPERTY,
-                    String.format(MXCryptoError.ERROR_MISSING_PROPERTY_REASON, "recipient_keys")))
+                    String.format(MXCryptoError.ERROR_MISSING_PROPERTY_REASON, "recipient_keys"))
         }
 
         val ed25519 = recipientKeys["ed25519"]
 
         if (ed25519 != olmDevice.deviceEd25519Key) {
             Timber.e("## decryptEvent() : Event ${event.eventId}: Intended recipient ed25519 key $ed25519 did not match ours")
-            return Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.BAD_RECIPIENT_KEY,
+            throw MXCryptoError.Base(MXCryptoError.ErrorType.BAD_RECIPIENT_KEY,
-                    MXCryptoError.BAD_RECIPIENT_KEY_REASON))
+                    MXCryptoError.BAD_RECIPIENT_KEY_REASON)
         }
 
         if (olmPayloadContent.sender.isNullOrBlank()) {
             Timber.e("## decryptEvent() : Olm event (id=${event.eventId}) contains no 'sender' property; cannot prevent unknown-key attack")
-            return Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_PROPERTY,
+            throw MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_PROPERTY,
-                    String.format(MXCryptoError.ERROR_MISSING_PROPERTY_REASON, "sender")))
+                    String.format(MXCryptoError.ERROR_MISSING_PROPERTY_REASON, "sender"))
         }
 
         if (olmPayloadContent.sender != event.senderId) {
             Timber.e("Event ${event.eventId}: original sender ${olmPayloadContent.sender} does not match reported sender ${event.senderId}")
-            return Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.FORWARDED_MESSAGE,
+            throw MXCryptoError.Base(MXCryptoError.ErrorType.FORWARDED_MESSAGE,
-                    String.format(MXCryptoError.FORWARDED_MESSAGE_REASON, olmPayloadContent.sender)))
+                    String.format(MXCryptoError.FORWARDED_MESSAGE_REASON, olmPayloadContent.sender))
         }
 
         if (olmPayloadContent.room_id != event.roomId) {
             Timber.e("## decryptEvent() : Event ${event.eventId}: original room ${olmPayloadContent.room_id} does not match reported room ${event.roomId}")
-            return Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.BAD_ROOM,
+            throw MXCryptoError.Base(MXCryptoError.ErrorType.BAD_ROOM,
-                    String.format(MXCryptoError.BAD_ROOM_REASON, olmPayloadContent.room_id)))
+                    String.format(MXCryptoError.BAD_ROOM_REASON, olmPayloadContent.room_id))
         }
 
         val keys = olmPayloadContent.keys ?: run {
             Timber.e("## decryptEvent failed : null keys")
-            return Try.Failure(MXCryptoError.Base(MXCryptoError.ErrorType.UNABLE_TO_DECRYPT,
+            throw MXCryptoError.Base(MXCryptoError.ErrorType.UNABLE_TO_DECRYPT,
-                    MXCryptoError.MISSING_CIPHER_TEXT_REASON))
+                    MXCryptoError.MISSING_CIPHER_TEXT_REASON)
         }
 
-        return Try.just(MXEventDecryptionResult(
+        return MXEventDecryptionResult(
                 clearEvent = payload,
                 senderCurve25519Key = senderKey,
                 claimedEd25519Key = keys["ed25519"]
-        ))
+        )
     }
 
     /**
@@ -165,33 +157,14 @@ internal class MXOlmDecryption(
      * @return payload, if decrypted successfully.
      */
     private fun decryptMessage(message: JsonDict, theirDeviceIdentityKey: String): String? {
-        val sessionIdsSet = olmDevice.getSessionIds(theirDeviceIdentityKey)
+        val sessionIds = olmDevice.getSessionIds(theirDeviceIdentityKey) ?: emptySet()
 
-        val sessionIds: List<String>
+        val messageBody = message["body"] as? String ?: return null
-
+        val messageType = when (val typeAsVoid = message["type"]) {
-        if (null == sessionIdsSet) {
+            is Double -> typeAsVoid.toInt()
-            sessionIds = ArrayList()
+            is Int -> typeAsVoid
-        } else {
+            is Long -> typeAsVoid.toInt()
-            sessionIds = ArrayList(sessionIdsSet)
+            else -> return null
-        }
-
-        val messageBody = message["body"] as? String
-        var messageType: Int? = null
-
-        val typeAsVoid = message["type"]
-
-        if (null != typeAsVoid) {
-            if (typeAsVoid is Double) {
-                messageType = typeAsVoid.toInt()
-            } else if (typeAsVoid is Int) {
-                messageType = typeAsVoid
-            } else if (typeAsVoid is Long) {
-                messageType = typeAsVoid.toInt()
-            }
-        }
-
-        if (null == messageBody || null == messageType) {
-            return null
         }
 
         // Try each session in turn

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/olm/MXOlmDecryptionFactory.kt

@@ -18,7 +18,6 @@ package im.vector.matrix.android.internal.crypto.algorithms.olm
 
 import im.vector.matrix.android.api.auth.data.Credentials
 import im.vector.matrix.android.internal.crypto.MXOlmDevice
-import im.vector.matrix.android.internal.session.SessionScope
 import javax.inject.Inject
 
 internal class MXOlmDecryptionFactory @Inject constructor(private val olmDevice: MXOlmDevice,

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/olm/MXOlmEncryption.kt

@@ -19,7 +19,6 @@
 package im.vector.matrix.android.internal.crypto.algorithms.olm
 
 import android.text.TextUtils
-import arrow.core.Try
 import im.vector.matrix.android.api.session.events.model.Content
 import im.vector.matrix.android.api.session.events.model.toContent
 import im.vector.matrix.android.internal.crypto.DeviceListManager
@@ -40,37 +39,35 @@ internal class MXOlmEncryption(
         private val ensureOlmSessionsForUsersAction: EnsureOlmSessionsForUsersAction)
     : IMXEncrypting {
 
-    override suspend fun encryptEventContent(eventContent: Content, eventType: String, userIds: List<String>): Try<Content> {
+    override suspend fun encryptEventContent(eventContent: Content, eventType: String, userIds: List<String>): Content {
         // pick the list of recipients based on the membership list.
         //
         // TODO: there is a race condition here! What if a new user turns up
-        return ensureSession(userIds)
+        ensureSession(userIds)
-                .map {
+        val deviceInfos = ArrayList<MXDeviceInfo>()
-                    val deviceInfos = ArrayList<MXDeviceInfo>()
+        for (userId in userIds) {
-                    for (userId in userIds) {
+            val devices = cryptoStore.getUserDevices(userId)?.values ?: emptyList()
-                        val devices = cryptoStore.getUserDevices(userId)?.values ?: emptyList()
+            for (device in devices) {
-                        for (device in devices) {
+                val key = device.identityKey()
-                            val key = device.identityKey()
+                if (TextUtils.equals(key, olmDevice.deviceCurve25519Key)) {
-                            if (TextUtils.equals(key, olmDevice.deviceCurve25519Key)) {
+                    // Don't bother setting up session to ourself
-                                // Don't bother setting up session to ourself
+                    continue
-                                continue
-                            }
-                            if (device.isBlocked) {
-                                // Don't bother setting up sessions with blocked users
-                                continue
-                            }
-                            deviceInfos.add(device)
-                        }
-                    }
-
-                    val messageMap = HashMap<String, Any>()
-                    messageMap["room_id"] = roomId
-                    messageMap["type"] = eventType
-                    messageMap["content"] = eventContent
-
-                    messageEncrypter.encryptMessage(messageMap, deviceInfos)
-                    messageMap.toContent()!!
                 }
+                if (device.isBlocked) {
+                    // Don't bother setting up sessions with blocked users
+                    continue
+                }
+                deviceInfos.add(device)
+            }
+        }
+
+        val messageMap = HashMap<String, Any>()
+        messageMap["room_id"] = roomId
+        messageMap["type"] = eventType
+        messageMap["content"] = eventContent
+
+        messageEncrypter.encryptMessage(messageMap, deviceInfos)
+        return messageMap.toContent()!!
     }
 
 
@@ -78,13 +75,9 @@ internal class MXOlmEncryption(
      * Ensure that the session
      *
      * @param users    the user ids list
-     * @param callback the asynchronous callback
      */
-    private suspend fun ensureSession(users: List<String>): Try<Unit> {
+    private suspend fun ensureSession(users: List<String>) {
-        return deviceListManager
+        deviceListManager.downloadKeys(users, false)
-                .downloadKeys(users, false)
+        ensureOlmSessionsForUsersAction.handle(users)
-                .flatMap { ensureOlmSessionsForUsersAction.handle(users) }
-                .map { Unit }
-
     }
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/olm/MXOlmEncryptionFactory.kt

@@ -21,7 +21,6 @@ import im.vector.matrix.android.internal.crypto.MXOlmDevice
 import im.vector.matrix.android.internal.crypto.actions.EnsureOlmSessionsForUsersAction
 import im.vector.matrix.android.internal.crypto.actions.MessageEncrypter
 import im.vector.matrix.android.internal.crypto.store.IMXCryptoStore
-import im.vector.matrix.android.internal.session.SessionScope
 import im.vector.matrix.android.internal.util.MatrixCoroutineDispatchers
 import javax.inject.Inject
 

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/api/CryptoApi.kt

@@ -18,8 +18,6 @@ package im.vector.matrix.android.internal.crypto.api
 
 
 import im.vector.matrix.android.internal.crypto.model.rest.*
-import im.vector.matrix.android.internal.crypto.model.rest.KeysUploadBody
-import im.vector.matrix.android.internal.crypto.model.rest.SendToDeviceBody
 import im.vector.matrix.android.internal.network.NetworkConstants
 import retrofit2.Call
 import retrofit2.http.*

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/attachments/MXEncryptedAttachments.kt

@@ -26,7 +26,6 @@ import java.io.ByteArrayOutputStream
 import java.io.InputStream
 import java.security.MessageDigest
 import java.security.SecureRandom
-import java.util.*
 import javax.crypto.Cipher
 import javax.crypto.spec.IvParameterSpec
 import javax.crypto.spec.SecretKeySpec
@@ -59,8 +58,7 @@ object MXEncryptedAttachments {
         // Half of the IV is random, the lower order bits are zeroed
         // such that the counter never wraps.
         // See https://github.com/matrix-org/matrix-ios-kit/blob/3dc0d8e46b4deb6669ed44f72ad79be56471354c/MatrixKit/Models/Room/MXEncryptedAttachments.m#L75
-        val initVectorBytes = ByteArray(16)
+        val initVectorBytes = ByteArray(16) { 0.toByte() }
-        Arrays.fill(initVectorBytes, 0.toByte())
 
         val ivRandomPart = ByteArray(8)
         secureRandom.nextBytes(ivRandomPart)
@@ -115,7 +113,7 @@ object MXEncryptedAttachments {
                     encryptedByteArray = outStream.toByteArray()
             )
 
-            Timber.v("Encrypt in " + (System.currentTimeMillis() - t0) + " ms")
+            Timber.v("Encrypt in ${System.currentTimeMillis() - t0} ms")
             return Try.just(result)
         } catch (oom: OutOfMemoryError) {
             Timber.e(oom, "## encryptAttachment failed")
@@ -206,13 +204,13 @@ object MXEncryptedAttachments {
             val decryptedStream = ByteArrayInputStream(outStream.toByteArray())
             outStream.close()
 
-            Timber.v("Decrypt in " + (System.currentTimeMillis() - t0) + " ms")
+            Timber.v("Decrypt in ${System.currentTimeMillis() - t0} ms")
 
             return decryptedStream
         } catch (oom: OutOfMemoryError) {
-            Timber.e(oom, "## decryptAttachment() :  failed " + oom.message)
+            Timber.e(oom, "## decryptAttachment() :  failed ${oom.message}")
         } catch (e: Exception) {
-            Timber.e(e, "## decryptAttachment() :  failed " + e.message)
+            Timber.e(e, "## decryptAttachment() :  failed ${e.message}")
         }
 
         try {
@@ -228,34 +226,20 @@ object MXEncryptedAttachments {
      * Base64 URL conversion methods
      */
 
-    private fun base64UrlToBase64(base64Url: String?): String? {
+    private fun base64UrlToBase64(base64Url: String): String {
-        var result = base64Url
+        return base64Url.replace('-', '+')
-        if (null != result) {
+                .replace('_', '/')
-            result = result.replace("-".toRegex(), "+")
-            result = result.replace("_".toRegex(), "/")
-        }
-
-        return result
     }
 
-    private fun base64ToBase64Url(base64: String?): String? {
+    private fun base64ToBase64Url(base64: String): String {
-        var result = base64
+        return base64.replace("\n".toRegex(), "")
-        if (null != result) {
+                .replace("\\+".toRegex(), "-")
-            result = result.replace("\n".toRegex(), "")
+                .replace('/', '_')
-            result = result.replace("\\+".toRegex(), "-")
+                .replace("=", "")
-            result = result.replace("/".toRegex(), "_")
-            result = result.replace("=".toRegex(), "")
-        }
-        return result
     }
 
-    private fun base64ToUnpaddedBase64(base64: String?): String? {
+    private fun base64ToUnpaddedBase64(base64: String): String {
-        var result = base64
+        return base64.replace("\n".toRegex(), "")
-        if (null != result) {
+                .replace("=", "")
-            result = result.replace("\n".toRegex(), "")
-            result = result.replace("=".toRegex(), "")
-        }
-
-        return result
     }
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/keysbackup/KeysBackup.kt

@@ -51,7 +51,6 @@ import im.vector.matrix.android.internal.crypto.store.db.model.KeysBackupDataEnt
 import im.vector.matrix.android.internal.di.MoshiProvider
 import im.vector.matrix.android.internal.extensions.foldToCallback
 import im.vector.matrix.android.internal.session.SessionScope
-import im.vector.matrix.android.internal.task.*
 import im.vector.matrix.android.internal.task.Task
 import im.vector.matrix.android.internal.task.TaskExecutor
 import im.vector.matrix.android.internal.task.TaskThread
@@ -67,9 +66,8 @@ import org.matrix.olm.OlmPkEncryption
 import org.matrix.olm.OlmPkMessage
 import timber.log.Timber
 import java.security.InvalidParameterException
-import java.util.*
 import javax.inject.Inject
-import kotlin.collections.HashMap
+import kotlin.random.Random
 
 /**
  * A KeysBackup class instance manage incremental backup of e2e keys (megolm keys)
@@ -115,8 +113,6 @@ internal class KeysBackup @Inject constructor(
     // The backup key being used.
     private var backupOlmPkEncryption: OlmPkEncryption? = null
 
-    private val random = Random()
-
     private var backupAllGroupSessionsCallback: MatrixCallback<Unit>? = null
 
     private var keysBackupStateListener: KeysBackupStateListener? = null
@@ -204,31 +200,32 @@ internal class KeysBackup @Inject constructor(
         keysBackupStateManager.state = KeysBackupState.Enabling
 
         createKeysBackupVersionTask
-                .configureWith(createKeysBackupVersionBody)
+                .configureWith(createKeysBackupVersionBody) {
-                .dispatchTo(object : MatrixCallback<KeysVersion> {
+                    this.callback = object : MatrixCallback<KeysVersion> {
-                    override fun onSuccess(info: KeysVersion) {
+                        override fun onSuccess(info: KeysVersion) {
-                        // Reset backup markers.
+                            // Reset backup markers.
-                        cryptoStore.resetBackupMarkers()
+                            cryptoStore.resetBackupMarkers()
 
-                        val keyBackupVersion = KeysVersionResult()
+                            val keyBackupVersion = KeysVersionResult()
-                        keyBackupVersion.algorithm = createKeysBackupVersionBody.algorithm
+                            keyBackupVersion.algorithm = createKeysBackupVersionBody.algorithm
-                        keyBackupVersion.authData = createKeysBackupVersionBody.authData
+                            keyBackupVersion.authData = createKeysBackupVersionBody.authData
-                        keyBackupVersion.version = info.version
+                            keyBackupVersion.version = info.version
 
-                        // We can consider that the server does not have keys yet
+                            // We can consider that the server does not have keys yet
-                        keyBackupVersion.count = 0
+                            keyBackupVersion.count = 0
-                        keyBackupVersion.hash = null
+                            keyBackupVersion.hash = null
 
-                        enableKeysBackup(keyBackupVersion)
+                            enableKeysBackup(keyBackupVersion)
 
-                        callback.onSuccess(info)
+                            callback.onSuccess(info)
+                        }
+
+                        override fun onFailure(failure: Throwable) {
+                            keysBackupStateManager.state = KeysBackupState.Disabled
+                            callback.onFailure(failure)
+                        }
                     }
-
+                }
-                    override fun onFailure(failure: Throwable) {
-                        keysBackupStateManager.state = KeysBackupState.Disabled
-                        callback.onFailure(failure)
-                    }
-                })
                 .executeBy(taskExecutor)
     }
 
@@ -243,27 +240,29 @@ internal class KeysBackup @Inject constructor(
                     keysBackupStateManager.state = KeysBackupState.Unknown
                 }
 
-                deleteBackupTask.configureWith(DeleteBackupTask.Params(version))
+                deleteBackupTask
-                        .dispatchTo(object : MatrixCallback<Unit> {
+                        .configureWith(DeleteBackupTask.Params(version)) {
-                            private fun eventuallyRestartBackup() {
+                            this.callback = object : MatrixCallback<Unit> {
-                                // Do not stay in KeysBackupState.Unknown but check what is available on the homeserver
+                                private fun eventuallyRestartBackup() {
-                                if (state == KeysBackupState.Unknown) {
+                                    // Do not stay in KeysBackupState.Unknown but check what is available on the homeserver
-                                    checkAndStartKeysBackup()
+                                    if (state == KeysBackupState.Unknown) {
+                                        checkAndStartKeysBackup()
+                                    }
+                                }
+
+                                override fun onSuccess(data: Unit) {
+                                    eventuallyRestartBackup()
+
+                                    uiHandler.post { callback?.onSuccess(Unit) }
+                                }
+
+                                override fun onFailure(failure: Throwable) {
+                                    eventuallyRestartBackup()
+
+                                    uiHandler.post { callback?.onFailure(failure) }
                                 }
                             }
-
+                        }
-                            override fun onSuccess(data: Unit) {
-                                eventuallyRestartBackup()
-
-                                uiHandler.post { callback?.onSuccess(Unit) }
-                            }
-
-                            override fun onFailure(failure: Throwable) {
-                                eventuallyRestartBackup()
-
-                                uiHandler.post { callback?.onFailure(failure) }
-                            }
-                        })
                         .executeBy(taskExecutor)
             }
         }
@@ -355,15 +354,14 @@ internal class KeysBackup @Inject constructor(
                                     callback: MatrixCallback<KeysBackupVersionTrust>) {
         // TODO Validate with François that this is correct
         object : Task<KeysVersionResult, KeysBackupVersionTrust> {
-            override suspend fun execute(params: KeysVersionResult): Try<KeysBackupVersionTrust> {
+            override suspend fun execute(params: KeysVersionResult): KeysBackupVersionTrust {
-                return Try {
+                return getKeysBackupTrustBg(params)
-                    getKeysBackupTrustBg(params)
-                }
             }
         }
-                .configureWith(keysBackupVersion)
+                .configureWith(keysBackupVersion) {
-                .dispatchTo(callback)
+                    this.callback = callback
-                .executeOn(TaskThread.COMPUTATION)
+                    this.executionThread = TaskThread.COMPUTATION
+                }
                 .executeBy(taskExecutor)
     }
 
@@ -454,7 +452,8 @@ internal class KeysBackup @Inject constructor(
                     val myUserId = credentials.userId
 
                     // Get current signatures, or create an empty set
-                    val myUserSignatures = authData.signatures?.get(myUserId)?.toMutableMap() ?: HashMap()
+                    val myUserSignatures = authData.signatures?.get(myUserId)?.toMutableMap()
+                            ?: HashMap()
 
                     if (trust) {
                         // Add current device signature
@@ -492,27 +491,28 @@ internal class KeysBackup @Inject constructor(
 
                 // And send it to the homeserver
                 updateKeysBackupVersionTask
-                        .configureWith(UpdateKeysBackupVersionTask.Params(keysBackupVersion.version!!, updateKeysBackupVersionBody))
+                        .configureWith(UpdateKeysBackupVersionTask.Params(keysBackupVersion.version!!, updateKeysBackupVersionBody)) {
-                        .dispatchTo(object : MatrixCallback<Unit> {
+                            this.callback = object : MatrixCallback<Unit> {
-                            override fun onSuccess(data: Unit) {
+                                override fun onSuccess(data: Unit) {
-                                // Relaunch the state machine on this updated backup version
+                                    // Relaunch the state machine on this updated backup version
-                                val newKeysBackupVersion = KeysVersionResult()
+                                    val newKeysBackupVersion = KeysVersionResult()
 
-                                newKeysBackupVersion.version = keysBackupVersion.version
+                                    newKeysBackupVersion.version = keysBackupVersion.version
-                                newKeysBackupVersion.algorithm = keysBackupVersion.algorithm
+                                    newKeysBackupVersion.algorithm = keysBackupVersion.algorithm
-                                newKeysBackupVersion.count = keysBackupVersion.count
+                                    newKeysBackupVersion.count = keysBackupVersion.count
-                                newKeysBackupVersion.hash = keysBackupVersion.hash
+                                    newKeysBackupVersion.hash = keysBackupVersion.hash
-                                newKeysBackupVersion.authData = updateKeysBackupVersionBody.authData
+                                    newKeysBackupVersion.authData = updateKeysBackupVersionBody.authData
 
-                                checkAndStartWithKeysBackupVersion(newKeysBackupVersion)
+                                    checkAndStartWithKeysBackupVersion(newKeysBackupVersion)
 
-                                callback.onSuccess(data)
+                                    callback.onSuccess(data)
+                                }
+
+                                override fun onFailure(failure: Throwable) {
+                                    callback.onFailure(failure)
+                                }
                             }
-
+                        }
-                            override fun onFailure(failure: Throwable) {
-                                callback.onFailure(failure)
-                            }
-                        })
                         .executeBy(taskExecutor)
             }
         }
@@ -758,49 +758,52 @@ internal class KeysBackup @Inject constructor(
         if (roomId != null && sessionId != null) {
             // Get key for the room and for the session
             getRoomSessionDataTask
-                    .configureWith(GetRoomSessionDataTask.Params(roomId, sessionId, version))
+                    .configureWith(GetRoomSessionDataTask.Params(roomId, sessionId, version)) {
-                    .dispatchTo(object : MatrixCallback<KeyBackupData> {
+                        this.callback = object : MatrixCallback<KeyBackupData> {
-                        override fun onSuccess(data: KeyBackupData) {
+                            override fun onSuccess(data: KeyBackupData) {
-                            // Convert to KeysBackupData
+                                // Convert to KeysBackupData
-                            val keysBackupData = KeysBackupData()
+                                val keysBackupData = KeysBackupData()
-                            keysBackupData.roomIdToRoomKeysBackupData = HashMap()
+                                keysBackupData.roomIdToRoomKeysBackupData = HashMap()
-                            val roomKeysBackupData = RoomKeysBackupData()
+                                val roomKeysBackupData = RoomKeysBackupData()
-                            roomKeysBackupData.sessionIdToKeyBackupData = HashMap()
+                                roomKeysBackupData.sessionIdToKeyBackupData = HashMap()
-                            roomKeysBackupData.sessionIdToKeyBackupData[sessionId] = data
+                                roomKeysBackupData.sessionIdToKeyBackupData[sessionId] = data
-                            keysBackupData.roomIdToRoomKeysBackupData[roomId] = roomKeysBackupData
+                                keysBackupData.roomIdToRoomKeysBackupData[roomId] = roomKeysBackupData
 
-                            callback.onSuccess(keysBackupData)
+                                callback.onSuccess(keysBackupData)
-                        }
+                            }
 
-                        override fun onFailure(failure: Throwable) {
+                            override fun onFailure(failure: Throwable) {
-                            callback.onFailure(failure)
+                                callback.onFailure(failure)
+                            }
                         }
-                    })
+                    }
                     .executeBy(taskExecutor)
         } else if (roomId != null) {
             // Get all keys for the room
             getRoomSessionsDataTask
-                    .configureWith(GetRoomSessionsDataTask.Params(roomId, version))
+                    .configureWith(GetRoomSessionsDataTask.Params(roomId, version)) {
-                    .dispatchTo(object : MatrixCallback<RoomKeysBackupData> {
+                        this.callback = object : MatrixCallback<RoomKeysBackupData> {
-                        override fun onSuccess(data: RoomKeysBackupData) {
+                            override fun onSuccess(data: RoomKeysBackupData) {
-                            // Convert to KeysBackupData
+                                // Convert to KeysBackupData
-                            val keysBackupData = KeysBackupData()
+                                val keysBackupData = KeysBackupData()
-                            keysBackupData.roomIdToRoomKeysBackupData = HashMap()
+                                keysBackupData.roomIdToRoomKeysBackupData = HashMap()
-                            keysBackupData.roomIdToRoomKeysBackupData[roomId] = data
+                                keysBackupData.roomIdToRoomKeysBackupData[roomId] = data
 
-                            callback.onSuccess(keysBackupData)
+                                callback.onSuccess(keysBackupData)
-                        }
+                            }
 
-                        override fun onFailure(failure: Throwable) {
+                            override fun onFailure(failure: Throwable) {
-                            callback.onFailure(failure)
+                                callback.onFailure(failure)
+                            }
                         }
-                    })
+                    }
                     .executeBy(taskExecutor)
         } else {
             // Get all keys
             getSessionsDataTask
-                    .configureWith(GetSessionsDataTask.Params(version))
+                    .configureWith(GetSessionsDataTask.Params(version)) {
-                    .dispatchTo(callback)
+                        this.callback = callback
+                    }
                     .executeBy(taskExecutor)
         }
     }
@@ -842,7 +845,7 @@ internal class KeysBackup @Inject constructor(
                 // Wait between 0 and 10 seconds, to avoid backup requests from
                 // different clients hitting the server all at the same time when a
                 // new key is sent
-                val delayInMs = random.nextInt(KEY_BACKUP_WAITING_TIME_TO_SEND_KEY_BACKUP_MILLIS).toLong()
+                val delayInMs = Random.nextLong(KEY_BACKUP_WAITING_TIME_TO_SEND_KEY_BACKUP_MILLIS)
 
                 uiHandler.postDelayed({ backupKeys() }, delayInMs)
             }
@@ -855,45 +858,47 @@ internal class KeysBackup @Inject constructor(
     override fun getVersion(version: String,
                             callback: MatrixCallback<KeysVersionResult?>) {
         getKeysBackupVersionTask
-                .configureWith(version)
+                .configureWith(version) {
-                .dispatchTo(object : MatrixCallback<KeysVersionResult> {
+                    this.callback = object : MatrixCallback<KeysVersionResult> {
-                    override fun onSuccess(data: KeysVersionResult) {
+                        override fun onSuccess(data: KeysVersionResult) {
-                        callback.onSuccess(data)
+                            callback.onSuccess(data)
-                    }
+                        }
 
-                    override fun onFailure(failure: Throwable) {
+                        override fun onFailure(failure: Throwable) {
-                        if (failure is Failure.ServerError
+                            if (failure is Failure.ServerError
-                                && failure.error.code == MatrixError.NOT_FOUND) {
+                                    && failure.error.code == MatrixError.NOT_FOUND) {
-                            // Workaround because the homeserver currently returns M_NOT_FOUND when there is no key backup
+                                // Workaround because the homeserver currently returns M_NOT_FOUND when there is no key backup
-                            callback.onSuccess(null)
+                                callback.onSuccess(null)
-                        } else {
+                            } else {
-                            // Transmit the error
+                                // Transmit the error
-                            callback.onFailure(failure)
+                                callback.onFailure(failure)
+                            }
                         }
                     }
-                })
+                }
                 .executeBy(taskExecutor)
     }
 
     override fun getCurrentVersion(callback: MatrixCallback<KeysVersionResult?>) {
         getKeysBackupLastVersionTask
-                .toConfigurableTask()
+                .configureWith {
-                .dispatchTo(object : MatrixCallback<KeysVersionResult> {
+                    this.callback = object : MatrixCallback<KeysVersionResult> {
-                    override fun onSuccess(data: KeysVersionResult) {
+                        override fun onSuccess(data: KeysVersionResult) {
-                        callback.onSuccess(data)
+                            callback.onSuccess(data)
-                    }
+                        }
 
-                    override fun onFailure(failure: Throwable) {
+                        override fun onFailure(failure: Throwable) {
-                        if (failure is Failure.ServerError
+                            if (failure is Failure.ServerError
-                                && failure.error.code == MatrixError.NOT_FOUND) {
+                                    && failure.error.code == MatrixError.NOT_FOUND) {
-                            // Workaround because the homeserver currently returns M_NOT_FOUND when there is no key backup
+                                // Workaround because the homeserver currently returns M_NOT_FOUND when there is no key backup
-                            callback.onSuccess(null)
+                                callback.onSuccess(null)
-                        } else {
+                            } else {
-                            // Transmit the error
+                                // Transmit the error
-                            callback.onFailure(failure)
+                                callback.onFailure(failure)
+                            }
                         }
                     }
-                })
+                }
                 .executeBy(taskExecutor)
     }
 
@@ -1236,69 +1241,72 @@ internal class KeysBackup @Inject constructor(
 
                 Timber.v("backupKeys: 4 - Sending request")
 
-                // Make the request
+                val sendingRequestCallback = object : MatrixCallback<BackupKeysResult> {
-                storeSessionDataTask
+                    override fun onSuccess(data: BackupKeysResult) {
-                        .configureWith(StoreSessionsDataTask.Params(keysBackupVersion!!.version!!, keysBackupData))
+                        uiHandler.post {
-                        .dispatchTo(object : MatrixCallback<BackupKeysResult> {
+                            Timber.v("backupKeys: 5a - Request complete")
-                            override fun onSuccess(data: BackupKeysResult) {
-                                uiHandler.post {
-                                    Timber.v("backupKeys: 5a - Request complete")
 
-                                    // Mark keys as backed up
+                            // Mark keys as backed up
-                                    cryptoStore.markBackupDoneForInboundGroupSessions(olmInboundGroupSessionWrappers)
+                            cryptoStore.markBackupDoneForInboundGroupSessions(olmInboundGroupSessionWrappers)
 
-                                    if (olmInboundGroupSessionWrappers.size < KEY_BACKUP_SEND_KEYS_MAX_COUNT) {
+                            if (olmInboundGroupSessionWrappers.size < KEY_BACKUP_SEND_KEYS_MAX_COUNT) {
-                                        Timber.v("backupKeys: All keys have been backed up")
+                                Timber.v("backupKeys: All keys have been backed up")
-                                        onServerDataRetrieved(data.count, data.hash)
+                                onServerDataRetrieved(data.count, data.hash)
 
-                                        // Note: Changing state will trigger the call to backupAllGroupSessionsCallback.onSuccess()
+                                // Note: Changing state will trigger the call to backupAllGroupSessionsCallback.onSuccess()
-                                        keysBackupStateManager.state = KeysBackupState.ReadyToBackUp
+                                keysBackupStateManager.state = KeysBackupState.ReadyToBackUp
-                                    } else {
+                            } else {
-                                        Timber.v("backupKeys: Continue to back up keys")
+                                Timber.v("backupKeys: Continue to back up keys")
-                                        keysBackupStateManager.state = KeysBackupState.WillBackUp
+                                keysBackupStateManager.state = KeysBackupState.WillBackUp
 
-                                        backupKeys()
+                                backupKeys()
-                                    }
-                                }
                             }
+                        }
+                    }
 
-                            override fun onFailure(failure: Throwable) {
+                    override fun onFailure(failure: Throwable) {
-                                if (failure is Failure.ServerError) {
+                        if (failure is Failure.ServerError) {
-                                    uiHandler.post {
+                            uiHandler.post {
-                                        Timber.e(failure, "backupKeys: backupKeys failed.")
+                                Timber.e(failure, "backupKeys: backupKeys failed.")
 
-                                        when (failure.error.code) {
+                                when (failure.error.code) {
-                                            MatrixError.NOT_FOUND,
+                                    MatrixError.NOT_FOUND,
-                                            MatrixError.WRONG_ROOM_KEYS_VERSION -> {
+                                    MatrixError.WRONG_ROOM_KEYS_VERSION -> {
-                                                // Backup has been deleted on the server, or we are not using the last backup version
+                                        // Backup has been deleted on the server, or we are not using the last backup version
-                                                keysBackupStateManager.state = KeysBackupState.WrongBackUpVersion
+                                        keysBackupStateManager.state = KeysBackupState.WrongBackUpVersion
-                                                backupAllGroupSessionsCallback?.onFailure(failure)
-                                                resetBackupAllGroupSessionsListeners()
-                                                resetKeysBackupData()
-                                                keysBackupVersion = null
-
-                                                // Do not stay in KeysBackupState.WrongBackUpVersion but check what is available on the homeserver
-                                                checkAndStartKeysBackup()
-                                            }
-                                            else                                ->
-                                                // Come back to the ready state so that we will retry on the next received key
-                                                keysBackupStateManager.state = KeysBackupState.ReadyToBackUp
-                                        }
-                                    }
-                                } else {
-                                    uiHandler.post {
                                         backupAllGroupSessionsCallback?.onFailure(failure)
                                         resetBackupAllGroupSessionsListeners()
+                                        resetKeysBackupData()
+                                        keysBackupVersion = null
 
-                                        Timber.e("backupKeys: backupKeys failed.")
+                                        // Do not stay in KeysBackupState.WrongBackUpVersion but check what is available on the homeserver
-
+                                        checkAndStartKeysBackup()
-                                        // Retry a bit later
-                                        keysBackupStateManager.state = KeysBackupState.ReadyToBackUp
-                                        maybeBackupKeys()
                                     }
+                                    else                                ->
+                                        // Come back to the ready state so that we will retry on the next received key
+                                        keysBackupStateManager.state = KeysBackupState.ReadyToBackUp
                                 }
                             }
-                        })
+                        } else {
+                            uiHandler.post {
+                                backupAllGroupSessionsCallback?.onFailure(failure)
+                                resetBackupAllGroupSessionsListeners()
+
+                                Timber.e("backupKeys: backupKeys failed.")
+
+                                // Retry a bit later
+                                keysBackupStateManager.state = KeysBackupState.ReadyToBackUp
+                                maybeBackupKeys()
+                            }
+                        }
+                    }
+                }
+
+                // Make the request
+                storeSessionDataTask
+                        .configureWith(StoreSessionsDataTask.Params(keysBackupVersion!!.version!!, keysBackupData)) {
+                            this.callback = sendingRequestCallback
+                        }
                         .executeBy(taskExecutor)
             }
         }
@@ -1394,7 +1402,7 @@ internal class KeysBackup @Inject constructor(
 
     companion object {
         // Maximum delay in ms in {@link maybeBackupKeys}
-        private const val KEY_BACKUP_WAITING_TIME_TO_SEND_KEY_BACKUP_MILLIS = 10000
+        private const val KEY_BACKUP_WAITING_TIME_TO_SEND_KEY_BACKUP_MILLIS = 10_000L
 
         // Maximum number of keys to send at a time to the homeserver.
         private const val KEY_BACKUP_SEND_KEYS_MAX_COUNT = 100

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/keysbackup/KeysBackupPassword.kt

@@ -22,7 +22,7 @@ package im.vector.matrix.android.internal.crypto.keysbackup
 import androidx.annotation.WorkerThread
 import im.vector.matrix.android.api.listeners.ProgressListener
 import timber.log.Timber
-import java.util.*
+import java.util.UUID
 import javax.crypto.Mac
 import javax.crypto.spec.SecretKeySpec
 import kotlin.experimental.xor
@@ -142,12 +142,11 @@ private fun deriveKey(password: String,
  * Generate a 32 chars salt
  */
 private fun generateSalt(): String {
-    var salt = ""
+    val salt = buildString {
-
+        do {
-    do {
+            append(UUID.randomUUID().toString())
-        salt += UUID.randomUUID().toString()
+        } while (length < SALT_LENGTH)
-    } while (salt.length < SALT_LENGTH)
+    }
-
 
     return salt.substring(0, SALT_LENGTH)
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/keysbackup/KeysBackupStateManager.kt

@@ -20,7 +20,6 @@ import android.os.Handler
 import im.vector.matrix.android.api.session.crypto.keysbackup.KeysBackupState
 import im.vector.matrix.android.api.session.crypto.keysbackup.KeysBackupStateListener
 import timber.log.Timber
-import java.util.*
 
 internal class KeysBackupStateManager(private val uiHandler: Handler) {
 

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/keysbackup/tasks/CreateKeysBackupVersionTask.kt

@@ -16,7 +16,6 @@
 
 package im.vector.matrix.android.internal.crypto.keysbackup.tasks
 
-import arrow.core.Try
 import im.vector.matrix.android.internal.crypto.keysbackup.api.RoomKeysApi
 import im.vector.matrix.android.internal.crypto.keysbackup.model.rest.CreateKeysBackupVersionBody
 import im.vector.matrix.android.internal.crypto.keysbackup.model.rest.KeysVersion
@@ -30,7 +29,7 @@ internal class DefaultCreateKeysBackupVersionTask @Inject constructor(private va
     : CreateKeysBackupVersionTask {
 
 
-    override suspend fun execute(params: CreateKeysBackupVersionBody): Try<KeysVersion> {
+    override suspend fun execute(params: CreateKeysBackupVersionBody): KeysVersion {
         return executeRequest {
             apiCall = roomKeysApi.createKeysBackupVersion(params)
         }

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/keysbackup/tasks/DeleteBackupTask.kt

@@ -16,10 +16,8 @@
 
 package im.vector.matrix.android.internal.crypto.keysbackup.tasks
 
-import arrow.core.Try
 import im.vector.matrix.android.internal.crypto.keysbackup.api.RoomKeysApi
 import im.vector.matrix.android.internal.network.executeRequest
-import im.vector.matrix.android.internal.session.SessionScope
 import im.vector.matrix.android.internal.task.Task
 import javax.inject.Inject
 
@@ -33,10 +31,9 @@ internal interface DeleteBackupTask : Task<DeleteBackupTask.Params, Unit> {
 internal class DefaultDeleteBackupTask @Inject constructor(private val roomKeysApi: RoomKeysApi)
     : DeleteBackupTask {
 
-    override suspend fun execute(params: DeleteBackupTask.Params): Try<Unit> {
+    override suspend fun execute(params: DeleteBackupTask.Params) {
         return executeRequest {
-            apiCall = roomKeysApi.deleteBackup(
+            apiCall = roomKeysApi.deleteBackup(params.version)
-                    params.version)
         }
     }
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/keysbackup/tasks/DeleteRoomSessionDataTask.kt

@@ -16,10 +16,8 @@
 
 package im.vector.matrix.android.internal.crypto.keysbackup.tasks
 
-import arrow.core.Try
 import im.vector.matrix.android.internal.crypto.keysbackup.api.RoomKeysApi
 import im.vector.matrix.android.internal.network.executeRequest
-import im.vector.matrix.android.internal.session.SessionScope
 import im.vector.matrix.android.internal.task.Task
 import javax.inject.Inject
 
@@ -34,7 +32,7 @@ internal interface DeleteRoomSessionDataTask : Task<DeleteRoomSessionDataTask.Pa
 internal class DefaultDeleteRoomSessionDataTask @Inject constructor(private val roomKeysApi: RoomKeysApi)
     : DeleteRoomSessionDataTask {
 
-    override suspend fun execute(params: DeleteRoomSessionDataTask.Params): Try<Unit> {
+    override suspend fun execute(params: DeleteRoomSessionDataTask.Params) {
         return executeRequest {
             apiCall = roomKeysApi.deleteRoomSessionData(
                     params.roomId,

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/keysbackup/tasks/DeleteRoomSessionsDataTask.kt

@@ -16,10 +16,8 @@
 
 package im.vector.matrix.android.internal.crypto.keysbackup.tasks
 
-import arrow.core.Try
 import im.vector.matrix.android.internal.crypto.keysbackup.api.RoomKeysApi
 import im.vector.matrix.android.internal.network.executeRequest
-import im.vector.matrix.android.internal.session.SessionScope
 import im.vector.matrix.android.internal.task.Task
 import javax.inject.Inject
 
@@ -33,7 +31,7 @@ internal interface DeleteRoomSessionsDataTask : Task<DeleteRoomSessionsDataTask.
 internal class DefaultDeleteRoomSessionsDataTask @Inject constructor(private val roomKeysApi: RoomKeysApi)
     : DeleteRoomSessionsDataTask {
 
-    override suspend fun execute(params: DeleteRoomSessionsDataTask.Params): Try<Unit> {
+    override suspend fun execute(params: DeleteRoomSessionsDataTask.Params) {
         return executeRequest {
             apiCall = roomKeysApi.deleteRoomSessionsData(
                     params.roomId,

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/keysbackup/tasks/DeleteSessionsDataTask.kt

@@ -16,10 +16,8 @@
 
 package im.vector.matrix.android.internal.crypto.keysbackup.tasks
 
-import arrow.core.Try
 import im.vector.matrix.android.internal.crypto.keysbackup.api.RoomKeysApi
 import im.vector.matrix.android.internal.network.executeRequest
-import im.vector.matrix.android.internal.session.SessionScope
 import im.vector.matrix.android.internal.task.Task
 import javax.inject.Inject
 
@@ -32,10 +30,9 @@ internal interface DeleteSessionsDataTask : Task<DeleteSessionsDataTask.Params,
 internal class DefaultDeleteSessionsDataTask @Inject constructor(private val roomKeysApi: RoomKeysApi)
     : DeleteSessionsDataTask {
 
-    override suspend fun execute(params: DeleteSessionsDataTask.Params): Try<Unit> {
+    override suspend fun execute(params: DeleteSessionsDataTask.Params) {
         return executeRequest {
-            apiCall = roomKeysApi.deleteSessionsData(
+            apiCall = roomKeysApi.deleteSessionsData(params.version)
-                    params.version)
         }
     }
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/keysbackup/tasks/GetKeysBackupLastVersionTask.kt

@@ -16,7 +16,6 @@
 
 package im.vector.matrix.android.internal.crypto.keysbackup.tasks
 
-import arrow.core.Try
 import im.vector.matrix.android.internal.crypto.keysbackup.api.RoomKeysApi
 import im.vector.matrix.android.internal.crypto.keysbackup.model.rest.KeysVersionResult
 import im.vector.matrix.android.internal.network.executeRequest
@@ -29,7 +28,7 @@ internal class DefaultGetKeysBackupLastVersionTask @Inject constructor(private v
     : GetKeysBackupLastVersionTask {
 
 
-    override suspend fun execute(params: Unit): Try<KeysVersionResult> {
+    override suspend fun execute(params: Unit): KeysVersionResult {
         return executeRequest {
             apiCall = roomKeysApi.getKeysBackupLastVersion()
         }

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/keysbackup/tasks/GetKeysBackupVersionTask.kt

@@ -16,7 +16,6 @@
 
 package im.vector.matrix.android.internal.crypto.keysbackup.tasks
 
-import arrow.core.Try
 import im.vector.matrix.android.internal.crypto.keysbackup.api.RoomKeysApi
 import im.vector.matrix.android.internal.crypto.keysbackup.model.rest.KeysVersionResult
 import im.vector.matrix.android.internal.network.executeRequest
@@ -29,7 +28,7 @@ internal class DefaultGetKeysBackupVersionTask @Inject constructor(private val r
     : GetKeysBackupVersionTask {
 
 
-    override suspend fun execute(params: String): Try<KeysVersionResult> {
+    override suspend fun execute(params: String): KeysVersionResult {
         return executeRequest {
             apiCall = roomKeysApi.getKeysBackupVersion(params)
         }

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/keysbackup/tasks/GetRoomSessionDataTask.kt

@@ -16,11 +16,9 @@
 
 package im.vector.matrix.android.internal.crypto.keysbackup.tasks
 
-import arrow.core.Try
 import im.vector.matrix.android.internal.crypto.keysbackup.api.RoomKeysApi
 import im.vector.matrix.android.internal.crypto.keysbackup.model.rest.KeyBackupData
 import im.vector.matrix.android.internal.network.executeRequest
-import im.vector.matrix.android.internal.session.SessionScope
 import im.vector.matrix.android.internal.task.Task
 import javax.inject.Inject
 
@@ -35,7 +33,7 @@ internal interface GetRoomSessionDataTask : Task<GetRoomSessionDataTask.Params,
 internal class DefaultGetRoomSessionDataTask @Inject constructor(private val roomKeysApi: RoomKeysApi)
     : GetRoomSessionDataTask {
 
-    override suspend fun execute(params: GetRoomSessionDataTask.Params): Try<KeyBackupData> {
+    override suspend fun execute(params: GetRoomSessionDataTask.Params): KeyBackupData {
         return executeRequest {
             apiCall = roomKeysApi.getRoomSessionData(
                     params.roomId,

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/keysbackup/tasks/GetRoomSessionsDataTask.kt

@@ -16,11 +16,9 @@
 
 package im.vector.matrix.android.internal.crypto.keysbackup.tasks
 
-import arrow.core.Try
 import im.vector.matrix.android.internal.crypto.keysbackup.api.RoomKeysApi
 import im.vector.matrix.android.internal.crypto.keysbackup.model.rest.RoomKeysBackupData
 import im.vector.matrix.android.internal.network.executeRequest
-import im.vector.matrix.android.internal.session.SessionScope
 import im.vector.matrix.android.internal.task.Task
 import javax.inject.Inject
 
@@ -35,7 +33,7 @@ internal interface GetRoomSessionsDataTask : Task<GetRoomSessionsDataTask.Params
 internal class DefaultGetRoomSessionsDataTask @Inject constructor(private val roomKeysApi: RoomKeysApi)
     : GetRoomSessionsDataTask {
 
-    override suspend fun execute(params: GetRoomSessionsDataTask.Params): Try<RoomKeysBackupData> {
+    override suspend fun execute(params: GetRoomSessionsDataTask.Params): RoomKeysBackupData {
         return executeRequest {
             apiCall = roomKeysApi.getRoomSessionsData(
                     params.roomId,