Merge branch 'release/0.91.3-beta'

Clear dynamic shortcuts when user logs out

.buildkite/pipeline.yml

@@ -1,53 +0,0 @@
-# Use Docker file from https://hub.docker.com/r/runmymind/docker-android-sdk
-# Last docker plugin version can be found here:
-# https://github.com/buildkite-plugins/docker-buildkite-plugin/releases
-
-# Build debug version of the RiotX application, from the develop branch and the features branches
-
-steps:
-  - label: "Assemble GPlay Debug version"
-    agents:
-      # We use a medium sized instance instead of the normal small ones because
-      # gradle build is long
-      queue: "medium"
-    commands:
-      - "./gradlew clean lintGplayRelease assembleGplayDebug --stacktrace"
-    artifact_paths:
-      - "vector/build/outputs/apk/gplay/debug/*.apk"
-    branches: "!master"
-    plugins:
-      - docker#v3.1.0:
-          image: "runmymind/docker-android-sdk"
-
-  - label: "Assemble FDroid Debug version"
-    agents:
-      # We use a medium sized instance instead of the normal small ones because
-      # gradle build is long
-      queue: "medium"
-    commands:
-      - "./gradlew clean lintFdroidRelease assembleFdroidDebug --stacktrace"
-    artifact_paths:
-      - "vector/build/outputs/apk/fdroid/debug/*.apk"
-    branches: "!master"
-    plugins:
-      - docker#v3.1.0:
-          image: "runmymind/docker-android-sdk"
-
-  - label: "Build Google Play unsigned APK"
-    agents:
-      # We use a medium sized instance instead of the normal small ones because
-      # gradle build is long
-      queue: "medium"
-    commands:
-      - "./gradlew clean assembleGplayRelease --stacktrace"
-    artifact_paths:
-      - "vector/build/outputs/apk/gplay/release/*.apk"
-    branches: "master"
-    plugins:
-      - docker#v3.1.0:
-          image: "runmymind/docker-android-sdk"
-
-  # Code quality
-
-  - label: "Code quality"
-    command: "./tools/check/check_code_quality.sh"

.editorconfig

@@ -0,0 +1,33 @@
+# For ktlint configuration. Ref: https://ktlint.github.io/
+
+[*.{kt,kts}]
+# possible values: number (e.g. 2), "unset" (makes ktlint ignore indentation completely)
+indent_size=unset
+# true (recommended) / false
+insert_final_newline=true
+# possible values: number (e.g. 120) (package name, imports & comments are ignored), "off"
+# it's automatically set to 100 on `ktlint --android ...` (per Android Kotlin Style Guide)
+max_line_length=off
+
+# Comma-separated list of rules to disable (Since 0.34.0)
+# Note that rules in any ruleset other than the standard ruleset will need to be prefixed
+# by the ruleset identifier.
+disabled_rules=no-multi-spaces,colon-spacing,chain-wrapping,import-ordering,experimental:annotation
+
+# The following (so far identified) rules are kept:
+# no-blank-line-before-rbrace
+# final-newline
+# no-consecutive-blank-lines
+# comment-spacing
+# filename
+# comma-spacing
+# paren-spacing
+# op-spacing
+# string-template
+# no-unused-imports
+# curly-spacing
+# no-semi
+# no-empty-class-body
+# experimental:multiline-if-else
+# experimental:no-empty-first-line-in-method-block
+# no-wildcard-imports

.github/PULL_REQUEST_TEMPLATE.md

@@ -7,4 +7,4 @@
 - [ ] Pull request is based on the develop branch
 - [ ] Pull request updates [CHANGES.md](https://github.com/vector-im/riotX-android/blob/develop/CHANGES.md)
 - [ ] Pull request includes screenshots or videos if containing UI changes
-- [ ] Pull request includes a [sign off](https://github.com/matrix-org/synapse/blob/master/CONTRIBUTING.rst#sign-off)
+- [ ] Pull request includes a [sign off](https://github.com/matrix-org/synapse/blob/master/CONTRIBUTING.md#sign-off)

.gitignore

@@ -1,14 +1,16 @@
 *.iml
 .gradle
 /local.properties
-.idea/*
-/.idea/*
-/.idea/libraries
-/.idea/modules.xml
-/.idea/workspace.xml
+# idea files: exclude everything except dictionnaries
+.idea/caches
+.idea/libraries
+.idea/inspectionProfiles
+.idea/*.xml
 .DS_Store
 /build
 /captures
 .externalNativeBuild
 
 /tmp
+
+ktlint

.idea/codeStyles/Project.xml

@@ -0,0 +1,156 @@
+<component name="ProjectCodeStyleConfiguration">
+  <code_scheme name="Project" version="173">
+    <option name="RIGHT_MARGIN" value="160" />
+    <JetCodeStyleSettings>
+      <option name="PACKAGES_TO_USE_STAR_IMPORTS">
+        <value>
+          <package name="kotlinx.android.synthetic" withSubpackages="true" static="false" />
+        </value>
+      </option>
+      <option name="ALIGN_IN_COLUMNS_CASE_BRANCH" value="true" />
+      <option name="NAME_COUNT_TO_USE_STAR_IMPORT" value="2147483647" />
+      <option name="NAME_COUNT_TO_USE_STAR_IMPORT_FOR_MEMBERS" value="2147483647" />
+      <option name="CONTINUATION_INDENT_IN_PARAMETER_LISTS" value="true" />
+      <option name="CONTINUATION_INDENT_IN_ARGUMENT_LISTS" value="true" />
+      <option name="CONTINUATION_INDENT_FOR_EXPRESSION_BODIES" value="true" />
+      <option name="CONTINUATION_INDENT_FOR_CHAINED_CALLS" value="true" />
+      <option name="CONTINUATION_INDENT_IN_SUPERTYPE_LISTS" value="true" />
+      <option name="CONTINUATION_INDENT_IN_IF_CONDITIONS" value="true" />
+      <option name="CONTINUATION_INDENT_IN_ELVIS" value="true" />
+      <option name="WRAP_EXPRESSION_BODY_FUNCTIONS" value="0" />
+      <option name="IF_RPAREN_ON_NEW_LINE" value="false" />
+      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
+    </JetCodeStyleSettings>
+    <codeStyleSettings language="XML">
+      <option name="RIGHT_MARGIN" value="160" />
+      <indentOptions>
+        <option name="CONTINUATION_INDENT_SIZE" value="4" />
+      </indentOptions>
+      <arrangement>
+        <rules>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>xmlns:android</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>xmlns:.*</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+              <order>BY_NAME</order>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*:id</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>http://schemas.android.com/apk/res/android</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*:name</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>http://schemas.android.com/apk/res/android</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>name</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>style</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+              <order>BY_NAME</order>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>http://schemas.android.com/apk/res/android</XML_NAMESPACE>
+                </AND>
+              </match>
+              <order>ANDROID_ATTRIBUTE_ORDER</order>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>.*</XML_NAMESPACE>
+                </AND>
+              </match>
+              <order>BY_NAME</order>
+            </rule>
+          </section>
+        </rules>
+      </arrangement>
+    </codeStyleSettings>
+    <codeStyleSettings language="kotlin">
+      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
+      <option name="RIGHT_MARGIN" value="160" />
+      <option name="KEEP_BLANK_LINES_IN_DECLARATIONS" value="1" />
+      <option name="KEEP_BLANK_LINES_IN_CODE" value="1" />
+      <option name="KEEP_BLANK_LINES_BEFORE_RBRACE" value="0" />
+      <option name="CALL_PARAMETERS_WRAP" value="0" />
+      <option name="CALL_PARAMETERS_LPAREN_ON_NEXT_LINE" value="false" />
+      <option name="CALL_PARAMETERS_RPAREN_ON_NEXT_LINE" value="false" />
+      <option name="METHOD_PARAMETERS_WRAP" value="0" />
+      <option name="METHOD_PARAMETERS_LPAREN_ON_NEXT_LINE" value="false" />
+      <option name="METHOD_PARAMETERS_RPAREN_ON_NEXT_LINE" value="false" />
+      <option name="EXTENDS_LIST_WRAP" value="0" />
+      <option name="METHOD_CALL_CHAIN_WRAP" value="0" />
+      <option name="ASSIGNMENT_WRAP" value="0" />
+      <option name="CLASS_ANNOTATION_WRAP" value="0" />
+      <option name="FIELD_ANNOTATION_WRAP" value="1" />
+    </codeStyleSettings>
+  </code_scheme>
+</component>

.idea/codeStyles/codeStyleConfig.xml

@@ -0,0 +1,6 @@
+<component name="ProjectCodeStyleConfiguration">
+  <state>
+    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
+    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
+  </state>
+</component>

.idea/copyright/NewVector.xml

@@ -0,0 +1,6 @@
+<component name="CopyrightManager">
+  <copyright>
+    <option name="notice" value="Copyright (c) &amp;#36;today.year New Vector Ltd&#10;&#10;Licensed under the Apache License, Version 2.0 (the &quot;License&quot;);&#10;you may not use this file except in compliance with the License.&#10;You may obtain a copy of the License at&#10;&#10;    http://www.apache.org/licenses/LICENSE-2.0&#10;&#10;Unless required by applicable law or agreed to in writing, software&#10;distributed under the License is distributed on an &quot;AS IS&quot; BASIS,&#10;WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.&#10;See the License for the specific language governing permissions and&#10;limitations under the License." />
+    <option name="myName" value="NewVector" />
+  </copyright>
+</component>

.idea/copyright/profiles_settings.xml

@@ -0,0 +1,8 @@
+<component name="CopyrightManager">
+  <settings default="NewVector">
+    <LanguageOptions name="XML">
+      <option name="fileTypeOverride" value="1" />
+      <option name="prefixLines" value="false" />
+    </LanguageOptions>
+  </settings>
+</component>

.idea/dictionaries/bmarty.xml

@@ -0,0 +1,35 @@
+<component name="ProjectDictionaryState">
+  <dictionary name="bmarty">
+    <words>
+      <w>backstack</w>
+      <w>bytearray</w>
+      <w>checkables</w>
+      <w>ciphertext</w>
+      <w>coroutine</w>
+      <w>decryptor</w>
+      <w>displayname</w>
+      <w>emoji</w>
+      <w>emojis</w>
+      <w>fdroid</w>
+      <w>gplay</w>
+      <w>hmac</w>
+      <w>homeserver</w>
+      <w>ktlint</w>
+      <w>linkified</w>
+      <w>linkify</w>
+      <w>megolm</w>
+      <w>msisdn</w>
+      <w>msisdns</w>
+      <w>pbkdf</w>
+      <w>pids</w>
+      <w>pkcs</w>
+      <w>riotx</w>
+      <w>signin</w>
+      <w>signout</w>
+      <w>signup</w>
+      <w>ssss</w>
+      <w>threepid</w>
+      <w>unwedging</w>
+    </words>
+  </dictionary>
+</component>

.travis.yml

@@ -23,10 +23,10 @@ android:
     - platform-tools
 
     # The BuildTools version used by your project
-    - build-tools-28.0.3
+    - build-tools-29.0.3
 
     # The SDK version used to compile your project
-    - android-28
+    - android-29
 
 before_cache:
   - rm -f  $HOME/.gradle/caches/modules-2/modules-2.lock
@@ -49,12 +49,12 @@ script:
   # Build Android test (assembleAndroidTest) (disabled for now)
   # Code quality (lintGplayRelease lintFdroidRelease)
   # Split into two steps because if a task contain Fdroid, PlayService will be disabled
-  - ./gradlew clean assembleGplayRelease lintGplayRelease --stacktrace
-  - ./gradlew clean assembleFdroidRelease lintFdroidRelease --stacktrace
+  # Done by Buildkite now: - ./gradlew clean assembleGplayRelease lintGplayRelease --stacktrace
+  # Done by Buildkite now: - ./gradlew clean assembleFdroidRelease lintFdroidRelease --stacktrace
   # Run unitary test (Disable for now, see https://travis-ci.org/vector-im/riot-android/builds/502504370)
   # - ./gradlew testGplayReleaseUnitTest --stacktrace
   # Other code quality check
-  - ./tools/check/check_code_quality.sh
+  # Done by Buildkite now: - ./tools/check/check_code_quality.sh
   - ./tools/travis/check_pr.sh
   # Check that indonesians file are identical. Due to Android issue, the resource folder must be value-in/, and Weblate export data into value-id/.
-  - diff ./vector/src/main/res/values-id/strings.xml ./vector/src/main/res/values-in/strings.xml
+  # Done by Buildkite now: - diff ./vector/src/main/res/values-id/strings.xml ./vector/src/main/res/values-in/strings.xml

AUTHORS.md

@@ -0,0 +1,35 @@
+A full developer contributors list can be found [here](https://github.com/vector-im/riotX-android/graphs/contributors). 
+
+# Core team:
+
+Even if we try to be able to work on all the functionalities, we have more knowledge about what we have developed ourselves.
+
+## Benoit: Android team leader
+
+[@benoit.marty:matrix.org](https://matrix.to/#/@benoit.marty:matrix.org)
+- Android team leader and project leader, Android developer, GitHub community manager.
+- Specialist of the account creation, and many other fun features.
+- Reviewing and polishing developed features, code quality manager, PRs reviewer, GitHub community manager.
+- Release manager on the Play Store
+
+## François: Software architect
+
+[@ganfra:matrix.org](https://matrix.to/#/@ganfra:matrix.org)
+- Software architect, Android developer
+- First developer on the project.
+- Work mainly on the global architecture of the project.
+- Specialist of the timeline, and lots of other features.
+
+## Valere: Product manager, Android developer
+
+[@valere35:matrix.org](https://matrix.to/#/@valere35:matrix.org)
+- Product manager, Android developer
+- Specialist on the crypto implementation.
+
+# Other contributors
+
+First of all, we thank all contributors who use RiotX and report problems on this GitHub project or via the integrated rageshake function.
+
+We do not forget all translators, for their work of translating RiotX into many languages. They are also the authors of RiotX.
+
+Feel free to add your name below, when you contribute to the project!

CHANGES.md

@@ -1,25 +1,571 @@
-Changes in RiotX 0.4.0 (2019-XX-XX)
+Changes in Riot.imX 0.91.3 (2020-07-01)
+===================================================
+
+Notes:
+ - This version is the third beta version of RiotX codebase published as Riot-Android on the PlayStore.
+ - Changelog below includes changes of v0.91.0, v0.91.1, and v0.91.2, because the first beta versions have been tagged and
+ published from the branch feature/migration_from_legacy.
+ - This version uses temporary name `Riot.imX`, to distinguish the app with RiotX app.
+
+Features ✨:
+ - Call with WebRTC support (##611)
+ - Add capability to change the display name (#1529)
+
+Improvements 🙌:
+ - "Add Matrix app" menu is now always visible (#1495)
+ - Handle `/op`, `/deop`, and `/nick` commands (#12)
+ - Prioritising Recovery key over Recovery passphrase (#1463)
+ - Room Settings: Name, Topic, Photo, Aliases, History Visibility (#1455)
+ - Update user avatar (#1054)
+ - Allow self-signed certificate (#1564)
+ - Improve file download and open in timeline
+ - Catchup tab is removed temporarily (#1565)
+ - Render room avatar change (#1319)
+
+Bugfix 🐛:
+ - Fix dark theme issue on login screen (#1097)
+ - Incomplete predicate in RealmCryptoStore#getOutgoingRoomKeyRequest (#1519)
+ - User could not redact message that they have sent (#1543)
+ - Use vendor prefix for non merged MSC (#1537)
+ - Compress images before sending (#1333)
+ - Searching by displayname is case sensitive (#1468)
+ - Fix layout overlap issue (#1407)
+
+Build 🧱:
+ - Enable code optimization (Proguard)
+ - SDK is now API level 21 minimum, and so RiotX (#405)
+
+Other changes:
+ - Use `SharedPreferences#edit` extension function consistently (#1545)
+ - Use `retrofit2.Call.awaitResponse` extension provided by Retrofit 2. (#1526)
+ - Fix minor typo in contribution guide (#1512)
+ - Fix self-assignment of callback in `DefaultRoomPushRuleService#setRoomNotificationState` (#1520)
+ - Random housekeeping clean-ups indicated by Lint (#1520, #1541)
+ - Keys Backup API now use the unstable prefix (#1503)
+ - Remove deviceId from /keys/upload/{deviceId} as not spec-compliant (#1502)
+
+Changes in RiotX 0.22.0 (2020-06-15)
+===================================================
+
+Features ✨:
+ - Integration Manager and Widget support (#48)
+ - Send stickers (#51)
+
+Improvements 🙌:
+ - New wording for notice when current user is the sender
+ - Hide "X made no changes" event by default in timeline (#1430)
+ - Hide left rooms in breadcrumbs (#766)
+ - Handle PowerLevel properly (#627)
+ - Correctly handle SSO login redirection
+ - SSO login is now performed in the default browser, or in Chrome Custom tab if available (#1400)
+ - Improve checking of homeserver version support (#1442)
+ - Add capability to add and remove a room from the favorites (#1217)
+
+Bugfix 🐛:
+ - Switch theme is not fully taken into account without restarting the app
+ - Temporary fix to show error when user is creating an account on matrix.org with userId containing only digits (#1410)
+ - Reply composer overlay stays on screen too long after send (#1169)
+ - Fix navigation bar icon contrast on API in [21,27[ (#1342)
+ - Fix status bar icon contrast on API in [21,23[
+ - Wrong /query request (#1444)
+ - Make Credentials.homeServer optional because it is deprecated (#1443)
+ - Fix issue on dark themes, after alert popup dismiss
+
+Other changes:
+ - Send plain text in the body of events containing formatted body, as per https://matrix.org/docs/spec/client_server/latest#m-room-message-msgtypes
+ - Update link to Modular url from "https://modular.im/" to "https://modular.im/services/matrix-hosting-riot" and open it using ChromeCustomTab
+
+Changes in RiotX 0.21.0 (2020-05-28)
+===================================================
+
+Features ✨:
+ - Identity server support (#607)
+ - Switch language support (#41)
+ - Display list of attachments of a room (#860)
+
+Improvements 🙌:
+ - Better connectivity lost indicator when airplane mode is on
+ - Add a setting to hide redacted events (#951)
+ - Render formatted_body for m.notice and m.emote (#1196)
+ - Change icon to magnifying-glass to filter room (#1384)
+
+Bugfix 🐛:
+ - After jump to unread, newer messages are never loaded (#1008)
+ - Fix issues with FontScale switch (#69, #645)
+ - "Seen by" uses 12h time (#1378)
+ - Enable markdown (if active) when sending emote (#734)
+ - Screenshots for Rageshake now includes Dialogs such as BottomSheet (#1349)
+
+SDK API changes ⚠️:
+ - initialize with proxy configuration
+
+Other changes:
+ - support new key agreement method for SAS (#1374)
+
+Changes in RiotX 0.20.0 (2020-05-15)
+===================================================
+
+Features ✨:
+ - Add Direct Shortcuts (#652)
+
+Improvements 🙌:
+ - Invite member(s) to an existing room (#1276)
+ - Improve notification accessibility with ticker text (#1226)
+ - Support homeserver discovery from MXID (DISABLED: waiting for design) (#476)
+
+Bugfix 🐛:
+ - Fix | Verify Manually by Text crashes if private SSK not known (#1337)
+ - Sometimes the same device appears twice in the list of devices of a user (#1329)
+ - Random Crashes while doing sth with cross signing keys (#1364)
+ - Crash | crash while restoring key backup (#1366)
+
+SDK API changes ⚠️:
+ - excludedUserIds parameter added to the UserService.getPagedUsersLive() function
+
+Changes in RiotX 0.19.0 (2020-05-04)
+===================================================
+
+Features ✨:
+ - Change password (#528)
+ - Cross-Signing | Support SSSS secret sharing (#944)
+ - Cross-Signing | Verify new session from existing session (#1134)
+ - Cross-Signing | Bootstraping cross signing with 4S from mobile (#985)
+ - Save media files to Gallery (#973)
+ - Account deactivation (with password only) (#35)
+
+Improvements 🙌:
+ - Verification DM / Handle concurrent .start after .ready (#794)
+ - Reimplementation of multiple attachment picker
+ - Cross-Signing | Update Shield Logic for DM (#963)
+ - Cross-Signing | Complete security new session design update (#1135)
+ - Cross-Signing | Setup key backup as part of SSSS bootstrapping (#1201)
+ - Cross-Signing | Gossip key backup recovery key (#1200)
+ - Show room encryption status as a bubble tile (#1078)
+ - UX/UI | Add indicator to home tab on invite (#957)
+ - Cross-Signing | Restore history after recover from passphrase (#1214)
+ - Cross-Sign | QR code scan confirmation screens design update (#1187)
+ - Emoji Verification | It's not the same butterfly! (#1220)
+ - Cross-Signing | Composer decoration: shields (#1077)
+ - Cross-Signing | Migrate existing keybackup to cross signing with 4S from mobile (#1197)
+ - Show a warning dialog if the text of the clicked link does not match the link target (#922)
+ - Cross-Signing | Consider not using a spinner on the 'complete security' prompt (#1271)
+ - Restart broken Olm sessions ([MSC1719](https://github.com/matrix-org/matrix-doc/pull/1719))
+ - Cross-Signing | Hide Use recovery key when 4S is not setup (#1007)
+ - Cross-Signing | Trust account xSigning keys by entering Recovery Key (select file or copy) #1199
+ - E2E timeline decoration (#1279)
+ - Manage Session Settings / Cross Signing update (#1295)
+ - Cross-Signing | Review sessions toast update old vs new (#1293, #1306)
+
+Bugfix 🐛:
+ - Fix summary notification staying after "mark as read"
+ - Missing avatar/displayname after verification request message (#841)
+ - Crypto | RiotX sometimes rotate the current device keys (#1170)
+ - RiotX can't restore cross signing keys saved by web in SSSS (#1174)
+ - Cross- Signing | After signin in new session, verification paper trail in DM is off (#1191)
+ - Failed to encrypt message in room (message stays in red), [thanks to pwr22] (#925)
+ - Cross-Signing | web <-> riotX After QR code scan, gossiping fails (#1210)
+ - Fix crash when trying to download file without internet connection (#1229)
+ - Local echo are not updated in timeline (for failed & encrypted states)
+ - Render image event even if thumbnail_info does not have mimetype defined (#1209)
+ - RiotX now uses as many threads as it needs to do work and send messages (#1221)
+ - Fix issue with media path (#1227)
+ - Add user to direct chat by user id (#1065)
+ - Use correct URL for SSO connection (#1178)
+ - Emoji completion :tada: does not completes to 🎉 like on web (#1285)
+ - Fix bad Shield Logic for DM (#963)
+
+Translations 🗣:
+ - Weblate now create PR directly to RiotX GitHub project
+
+SDK API changes ⚠️:
+ - Increase targetSdkVersion to 29
+
+Build 🧱:
+ - Compile with Android SDK 29 (Android Q)
+
+Other changes:
+ - Add a setting to prevent screenshots of the application, disabled by default (#1027)
+ - Increase File Logger capacities ( + use dev log preferences)
+
+Changes in RiotX 0.18.1 (2020-03-17)
+===================================================
+
+Improvements 🙌:
+ - Implementation of /join command
+
+Bugfix 🐛:
+ - Message transitions in encrypted rooms are jarring #518
+ - Images that failed to send are waiting to be sent forever #1145
+ - Fix / Crashed when trying to send a gif from the Gboard #1136
+ - Fix / Cannot click on key backup banner when new keys are available
+
+
+Changes in RiotX 0.18.0 (2020-03-11)
+===================================================
+
+Improvements 🙌:
+ - Share image and other media from e2e rooms (#677)
+ - Add support for `/plain` command (#12)
+ - Detect spaces in password if user fail to login (#1038)
+ - FTUE: do not display a different color when encrypting message when not in developer mode.
+ - Open room member profile from avatar of the room member state event (#935)
+ - Restore the push rules configuration in the settings
+
+Bugfix 🐛:
+ - Fix crash on attachment preview screen (#1088)
+ - "Share" option is not appearing in encrypted rooms for images (#1031)
+ - Set "image/jpeg" as MIME type of images instead of "image/jpg" (#1075)
+ - Self verification via QR code is failing (#1130)
+
+SDK API changes ⚠️:
+ - PushRuleService.getPushRules() now returns a RuleSet. Use getAllRules() on this object to get all the rules.
+
+Build 🧱:
+ - Upgrade ktlint to version 0.36.0
+ - Pipeline file for Buildkite is now hosted on another Github repository: https://github.com/matrix-org/pipelines/blob/master/riotx-android/pipeline.yml
+
+Other changes:
+ - Restore availability to Chromebooks (#932)
+ - Add a [documentation](./docs/integration_tests.md) to run integration tests
+
+Changes in RiotX 0.17.0 (2020-02-27)
+===================================================
+
+Features ✨:
+ - Secured Shared Storage Support (#984, #936)
+ - It's now possible to select several rooms (with a possible mix of clear/encrypted rooms) when sharing elements to RiotX (#1010)
+ - Media preview: media are previewed before being sent to a room (#1010)
+ - Image edition: it's now possible to edit image before sending: crop, rotate, and delete actions are supported (#1010)
+ - Sending image: image are sent to rooms with a reduced size. It's still possible to send original image file (#1010)
+
+Improvements 🙌:
+ - Migrate to binary QR code verification (#994)
+ - Share action is added to room profile and room member profile (#858)
+ - Display avatar in fullscreen (#861)
+ - Fix some performance issues with crypto
+
+Bugfix 🐛:
+ - Account creation: wrongly hints that an email can be used to create an account (#941)
+ - Fix crash in the room directory, when public room has no name (#1023)
+ - Fix restoring keys backup with passphrase (#526)
+ - Fix rotation of full-size image (#647)
+ - Fix joining rooms from directory via federation isn't working. (#808)
+ - Leaving a room creates a stuck "leaving room" loading screen. (#1041)
+ - Fix some invitation handling issues (#1013)
+ - New direct chat: selecting a participant sometimes results in two breadcrumbs (#1022)
+ - New direct chat: selecting several participants was not adding the room to the direct chats list
+ - Room overview shows deleted messages as “Encrypted message” (#758)
+
+SDK API changes ⚠️:
+ - Get crypto methods through Session.cryptoService()
+ - ProgressListener.onProgress() function will be invoked on the background thread instead of UI thread
+ - Improve CreateRoomParams API (#1070)
+
+Changes in RiotX 0.16.0 (2020-02-14)
+===================================================
+
+Features ✨:
+ - Polls and Bot Buttons (MSC 2192 matrix-org/matrix-doc#2192)
+
+Improvements 🙌:
+ - Show confirmation dialog before deleting a message (#967, #1003)
+ - Open room member profile from reactions list and read receipts list (#875)
+
+Bugfix 🐛:
+ - Fix crash by removing all notifications after clearing cache (#878)
+ - Fix issue with verification when other client declares it can only show QR code (#988)
+ - Fix too errors in the code (1941862499c9ec5268cc80882512ced379cafcfd, a250a895fe0a4acf08c671e03434edcd29ccd84f)
+
+SDK API changes ⚠️:
+ - Javadoc improved for PushersService
+ - PushersService.pushers() has been renamed to PushersService.getPushers()
+
+Changes in RiotX 0.15.0 (2020-02-10)
+===================================================
+
+Improvements 🙌:
+ - Improve navigation to the timeline (#789, #862)
+ - Improve network detection. It is now based on the sync request status (#873, #882)
+
+Other changes:
+ - Support SSO login with Firefox account (#606)
+
+Bugfix 🐛:
+ - Ask for permission before opening the camera (#934)
+ - Encrypt for invited users by default, if the room state allows it (#803)
+
+Changes in RiotX 0.14.3 (2020-02-03)
+===================================================
+
+Bugfix 🐛:
+ - Fix Exception in DeviceListManager
+
+Changes in RiotX 0.14.2 (2020-02-02)
+===================================================
+
+Bugfix 🐛:
+ - Fix RiotX not starting issue
+
+Changes in RiotX 0.14.1 (2020-02-02)
+===================================================
+
+Bugfix 🐛:
+ - Cross-signing: fix UX issue when closing the bottom sheet verification (#813)
+ - Room and room member profile: fix issues on dark and black themes
+
+Changes in RiotX 0.14.0 (2020-02-01)
+===================================================
+
+Features ✨:
+ - First implementation of Cross-signing
+ - Enable encryption in unencrypted rooms, from the room settings (#212)
+ - Negotiate E2E by default for DMs (#907)
+
+Improvements 🙌:
+ - Sharing things to RiotX: sort list by recent room first (#771)
+ - Hide the algorithm when turning on e2e (#897)
+ - Sort room members by display names
+
+Other changes:
+ - Add support for /rainbow and /rainbowme commands (#879)
+
+Build 🧱:
+ - Ensure builds are reproducible (#842)
+ - F-Droid: fix the "-dev" issue in version name (#815)
+
+Changes in RiotX 0.13.0 (2020-01-17)
+===================================================
+
+Features ✨:
+ - Send and render typing events (#564)
+ - Create Room Profile screen (#54)
+ - Create Room Member Profile screen (#59)
+
+Improvements 🙌:
+ - Render events m.room.encryption and m.room.guest_access in the timeline
+
+Bugfix 🐛:
+ - Fix broken background sync in F-Droid version
+ - Fix issue with downloaded file on encrypted rooms. The file was not properly decrypted
+
+Build 🧱:
+ - Change the way versionCode is computed (#827)
+
+Changes in RiotX 0.12.0 (2020-01-09)
+===================================================
+
+Improvements 🙌:
+ - The initial sync is now handled by a foreground service
+ - Render aliases and canonical alias change in the timeline
+ - Introduce developer mode in the settings (#745, #796)
+ - Improve devices list screen
+ - Add settings for rageshake sensibility
+ - Fix autocompletion issues and add support for rooms, groups, and emoji (#780)
+ - Show skip to bottom FAB while scrolling down (#752)
+ - Enable encryption on a room, SDK part (#212)
+
+Other changes:
+ - Change the way RiotX identifies a session to allow the SDK to support several sessions with the same user (#800)
+ - Exclude play-services-oss-licenses library from F-Droid build (#814)
+ - Email domain can be limited on some homeservers, i18n of the displayed error (#754)
+
+Bugfix 🐛:
+ - Fix crash when opening room creation screen from the room filtering screen
+ - Fix avatar image disappearing (#777)
+ - Fix read marker banner when permalink
+ - Fix joining upgraded rooms (#697)
+ - Fix matrix.org room directory not being browsable (#807)
+ - Hide non working settings (#751)
+
+Changes in RiotX 0.11.0 (2019-12-19)
+===================================================
+
+Features ✨:
+ - Implement soft logout (#281)
+
+Improvements 🙌:
+ - Handle navigation to room via room alias (#201)
+ - Open matrix.to link in RiotX (#57)
+ - Limit sticker size in the timeline
+
+Other changes:
+ - Use same default room colors than Riot-Web
+
+Bugfix 🐛:
+ - Scroll breadcrumbs to top when opened
+ - Render default room name when it starts with an emoji (#477)
+ - Do not display " (IRC)" in display names https://github.com/vector-im/riot-android/issues/444
+ - Fix rendering issue with HTML formatted body
+ - Disable click on Stickers (#703)
+
+Build 🧱:
+ - Include diff-match-patch sources as dependency
+
+Changes in RiotX 0.10.0 (2019-12-10)
+===================================================
+
+Features ✨:
+ - Breadcrumbs: switch from one room to another quickly (#571)
+
+Improvements 🙌:
+ - Support entering a RiotWeb client URL instead of the homeserver URL during connection (#744)
+
+Other changes:
+ - Add reason for all membership events (https://github.com/matrix-org/matrix-doc/pull/2367)
+
+Bugfix 🐛:
+ - When automardown is ON, pills are sent as MD in body (#739)
+ - "ban" event are not rendered correctly (#716)
+ - Fix crash when rotating screen in Room timeline
+
+Changes in RiotX 0.9.1 (2019-12-05)
+===================================================
+
+Bugfix 🐛:
+ - Fix an issue with DB transaction (#740)
+
+Changes in RiotX 0.9.0 (2019-12-05)
+===================================================
+
+Features ✨:
+ - Account creation. It's now possible to create account on any homeserver with RiotX (#34)
+ - Iteration of the login flow (#613)
+ - [SDK] MSC2241 / verification in DMs (#707)
+
+Improvements 🙌:
+ - Send mention Pills from composer
+ - Links in message preview in the bottom sheet are now active. 
+ - Rework the read marker to make it more usable
+
+Other changes:
+ - Fix a small grammatical error when an empty room list is shown.
+
+Bugfix 🐛:
+ - Do not show long click help if only invitation are displayed
+ - Fix emoji filtering not working
+ - Fix issue of closing Realm in another thread (#725)
+ - Attempt to properly cancel the crypto module when user signs out (#724)
+
+Changes in RiotX 0.8.0 (2019-11-19)
+===================================================
+
+Features ✨:
+ - Handle long click on room in the room list (#395)
+ - Ignore/UnIgnore users, and display list of ignored users (#542, #617)
+
+Improvements 🙌:
+ - Search reaction by name or keyword in emoji picker
+ - Handle code tags (#567)
+ - Support spoiler messages
+ - Support m.sticker and m.room.join_rules events in timeline
+
+Other changes:
+ - Markdown set to off by default (#412)
+ - Accessibility improvements to the attachment file type chooser
+
+Bugfix 🐛:
+ - Fix issues with some member events rendering (#498)
+ - Passphrase does not match (Export room keys) (#644)
+ - Ask for permission to write external storage when uri comes from the keyboard (#658)
+ - Fix issue with english US/GB translation (#671)
+
+Changes in RiotX 0.7.0 (2019-10-24)
+===================================================
+
+Features:
+ - Share elements from other app to RiotX (#58)
+ - Read marker (#84)
+ - Add ability to report content (#515)
+
+Improvements:
+ - Persist active tab between sessions (#503)
+ - Do not upload file too big for the homeserver (#587)
+ - Attachments: start using system pickers (#52)
+ - Mark all messages as read (#396)
+
+
+Other changes:
+ - Accessibility improvements to read receipts in the room timeline and reactions emoji chooser
+
+Bugfix:
+ - Fix issue on upload error in loop (#587)
+ - Fix opening a permalink: the targeted event is displayed twice (#556)
+ - Fix opening a permalink paginates all the history up to the last event (#282)
+ - after login, the icon in the top left is a green 'A' for (all communities) rather than my avatar (#267)
+ - Picture uploads are unreliable, pictures are shown in wrong aspect ratio on desktop client (#517)
+ - Invitation notifications are not dismissed automatically if room is joined from another client (#347)
+ - Opening links from RiotX reuses browser tab (#599)
+
+Changes in RiotX 0.6.1 (2019-09-24)
+===================================================
+
+Bugfix:
+ - Fix crash: MergedHeaderItem was missing dimensionConverter
+
+Changes in RiotX 0.6.0 (2019-09-24)
+===================================================
+
+Features:
+ - Save draft of a message when exiting a room with non empty composer (#329)
+
+Improvements:
+ - Add unread indent on room list (#485)
+ - Message Editing: Update notifications (#128)
+ - Remove any notification of a redacted event (#563)
+
+Other changes:
+ - Fix a few accessibility issues
+
+Bugfix:
+ - Fix characters erased from the Search field when the result are coming (#545)
+ - "No connection" banner was displayed by mistake
+ - Leaving community (from another client) has no effect on RiotX (#497)
+ - Push rules was not retrieved after a clear cache
+ - m.notice messages trigger push notifications (#238)
+ - Embiggen messages with multiple emojis also for edited messages (#458)
+
+Build:
+ - Fix (again) issue with bad versionCode generated by Buildkite (#553)
+
+Changes in RiotX 0.5.0 (2019-09-17)
+===================================================
+
+Features:
+ - Implementation of login to homeserver with SSO (#557)
+ - Handle M_CONSENT_NOT_GIVEN error (#64)
+ - Auto configure homeserver and identity server URLs of LoginActivity with a magic link
+
+Improvements:
+ - Reduce default release build log level, and lab option to enable more logs.
+ - Display a no network indicator when there is no network (#559)
+
+Bugfix:
+ - Fix crash due to missing informationData (#535)
+ - Progress in initial sync dialog is decreasing for a step and should not (#532)
+ - Fix rendering issue of accepted third party invitation event
+ - All current notifications were dismissed by mistake when the app is launched from the launcher
+
+Build:
+ - Fix issue with version name (#533)
+ - Fix issue with bad versionCode generated by Buildkite (#553)
+
+Changes in RiotX 0.4.0 (2019-08-30)
 ===================================================
 
 Features:
  - Display read receipts in timeline (#81)
 
 Improvements:
- -
-
-Other changes:
- -
+ - 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)
-
-Translations:
- -
-
-Build:
- -
+ - 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)
 ===================================================
@@ -47,6 +593,7 @@ Bugfix:
  - 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)
+ - KeyBackup / SSSS | Should get the key from SSSS instead of asking recovery Key (#1163)
 
 Build:
  - Split APK: generate one APK per arch, to reduce APK size of about 30%
@@ -90,24 +637,26 @@ Mode details here: https://medium.com/@RiotChat/introducing-the-riotx-beta-for-a
 =======================================================
 
 
-Changes in RiotX 0.0.0 (2019-XX-XX)
+Changes in RiotX 0.X.0 (2020-XX-XX)
 ===================================================
 
-Features:
+Features ✨:
  -
 
-Improvements:
+Improvements 🙌:
+ -
+
+Bugfix 🐛:
+ -
+
+Translations 🗣:
+ -
+
+SDK API changes ⚠️:
+ - 
+
+Build 🧱:
  -
 
 Other changes:
  -
-
-Bugfix:
- -
-
-Translations:
- -
-
-Build:
- -
-

CONTRIBUTING.md

@@ -1,6 +1,6 @@
 # Contributing code to Matrix
 
-Please read https://github.com/matrix-org/synapse/blob/master/CONTRIBUTING.rst
+Please read https://github.com/matrix-org/synapse/blob/master/CONTRIBUTING.md
 
 Android support can be found in this [![Riot Android Matrix room #riot-android:matrix.org](https://img.shields.io/matrix/riot-android:matrix.org.svg?label=%23riot-android:matrix.org&logo=matrix&server_fqdn=matrix.org)](https://matrix.to/#/#riot-android:matrix.org) room.
 
@@ -11,6 +11,29 @@ Dedicated room for RiotX: [![RiotX Android Matrix room #riot-android:matrix.org]
 ## Android Studio settings
 
 Please set the "hard wrap" setting of Android Studio to 160 chars, this is the setting we use internally to format the source code (Menu `Settings/Editor/Code Style` then `Hard wrap at`).
+Please ensure that your using the project formatting rules (which are in the project at .idea/codeStyles/), and format the file before committing them.
+
+### Template
+
+An Android Studio template has been added to the project to help creating all files needed when adding a new screen to the application. Fragment, ViewModel, Activity, etc.
+
+To install the template (to be done only once):
+- Go to folder `./tools/template`.
+- Mac OSX: Run the script `./configure.sh`.
+
+   Linux: Run `ANDROID_STUDIO=/path/to/android-studio ./configure`
+    - e.g. `ANDROID_STUDIO=/usr/local/android-studio ./configure`
+
+- Restart Android Studio.
+
+To create a new screen:
+- First create a new package in your code.
+- Then right click on the package, and select `New/New Vector/RiotX Feature`.
+- Follow the Wizard, especially replace `Main` by something more relevant to your feature.
+- Click on `Finish`.
+- Remaining steps are described as TODO in the generated files, or will be pointed out by the compilator, or at runtime :)
+
+Note that if the templates are modified, the only things to do is to restart Android Studio for the change to take effect.
 
 ## Compilation
 
@@ -40,26 +63,58 @@ Please add a line to the top of the file `CHANGES.md` describing your change.
 
 Make sure the following commands execute without any error:
 
-> ./tools/check/check_code_quality.sh
+#### Internal tool
 
-> ./gradlew lintGplayRelease
+<pre>
+./tools/check/check_code_quality.sh
+</pre>
+
+#### ktlint
+
+<pre>
+curl -sSLO https://github.com/pinterest/ktlint/releases/download/0.34.2/ktlint && chmod a+x ktlint
+./ktlint --android --experimental -v
+</pre>
+
+Note that you can run
+
+<pre>
+./ktlint --android --experimental -v -F
+</pre>
+
+For ktlint to fix some detected errors for you (you still have to check and commit the fix of course)
+
+#### lint
+
+<pre>
+./gradlew lintGplayRelease
+./gradlew lintFdroidRelease
+</pre>
 
 ### Unit tests
 
 Make sure the following commands execute without any error:
 
-> ./gradlew testGplayReleaseUnitTest
+<pre>
+./gradlew testGplayReleaseUnitTest
+</pre>
 
 ### Tests
 
-RiotX is currently supported on Android Jelly Bean (API 16+): please test your change on an Android device (or Android emulator) running with API 16. Many issues can happen (including crashes) on older devices.
+RiotX is currently supported on Android KitKat (API 19+): please test your change on an Android device (or Android emulator) running with API 19. Many issues can happen (including crashes) on older devices.
 Also, if possible, please test your change on a real device. Testing on Android emulator may not be sufficient.
 
+You should consider adding Unit tests with your PR, and also integration tests (AndroidTest). Please refer to [this document](./docs/integration_tests.md) to install and run the integration test environment.
+
 ### Internationalisation
 
 When adding new string resources, please only add new entries in file `value/strings.xml`. Translations will be added later by the community of translators with a specific tool named [Weblate](https://translate.riot.im/projects/riot-android/).
 Do not hesitate to use plurals when appropriate.
 
+### Accessibility
+
+Please consider accessibility as an important point. As a minimum requirement, in layout XML files please use attributes such as `android:contentDescription` and `android:importantForAccessibility`, and test with a screen reader if it's working well. You can add new string resources, dedicated to accessibility, in this case, please prefix theirs id with `a11y_`.
+
 ### Layout
 
 When adding or editing layouts, make sure the layout will render correctly if device uses a RTL (Right To Left) language.

README.md

@@ -11,13 +11,14 @@ RiotX is an Android Matrix Client currently in beta but in active development.
 
 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.
 
-[<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)
+[<img src="resources/img/google-play-badge.png" alt="Get it on Google Play" height="60">](https://play.google.com/store/apps/details?id=im.vector.riotx)
+[<img src="resources/img/f-droid-badge.png" alt="Get it on F-Droid" height="60">](https://f-droid.org/app/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.
+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 SDK is stable enough.
 
 
 # Roadmap

build.gradle

@@ -1,9 +1,7 @@
-import javax.tools.JavaCompiler
-
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 
 buildscript {
-    ext.kotlin_version = '1.3.21'
+    ext.kotlin_version = '1.3.50'
     repositories {
         google()
         jcenter()
@@ -12,11 +10,11 @@ buildscript {
         }
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.4.1'
-        classpath 'com.google.gms:google-services:4.2.0'
-        classpath "com.airbnb.okreplay:gradle-plugin:1.4.0"
+        classpath 'com.android.tools.build:gradle:3.5.3'
+        classpath 'com.google.gms:google-services:4.3.2'
+        classpath "com.airbnb.okreplay:gradle-plugin:1.5.0"
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-        classpath 'org.sonarsource.scanner.gradle:sonarqube-gradle-plugin:2.6.2'
+        classpath 'org.sonarsource.scanner.gradle:sonarqube-gradle-plugin:2.7.1'
         classpath 'com.google.android.gms:oss-licenses-plugin:0.9.5'
 
         // NOTE: Do not place your application dependencies here; they belong
@@ -36,6 +34,10 @@ allprojects {
                 includeGroupByRegex "com\\.github\\.jaiselrahman"
                 // And monarchy
                 includeGroupByRegex "com\\.github\\.Zhuinden"
+                // And ucrop
+                includeGroupByRegex "com\\.github\\.yalantis"
+                // JsonViewer
+                includeGroupByRegex 'com\\.github\\.BillCarsonFr'
             }
         }
         maven {
@@ -47,24 +49,11 @@ 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")
-        }
+    tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
+        // Warnings are potential errors, so stop ignoring them
+        kotlinOptions.allWarningsAsErrors = true
     }
 
 }

diff-match-patch/.gitignore

@@ -0,0 +1 @@
+/build

diff-match-patch/build.gradle

@@ -0,0 +1,8 @@
+apply plugin: 'java-library'
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+}
+
+sourceCompatibility = "8"
+targetCompatibility = "8"

docs/identity_server.md

@@ -0,0 +1,92 @@
+# Identity server
+
+Issue: #607
+PR: #1354
+
+## Introduction
+Identity Servers support contact discovery on Matrix by letting people look up Third Party Identifiers to see if the owner has publicly linked them with their Matrix ID.
+
+## Implementation
+
+The current implementation was Inspired by the code from Riot-Android.
+
+Difference though (list not exhaustive):
+- Only API v2 is supported (see https://matrix.org/docs/spec/identity_service/latest)
+- Homeserver has to be up to date to support binding (Versions.isLoginAndRegistrationSupportedBySdk() has to return true)
+- The SDK managed the session and client secret when binding ThreePid. Those data are not exposed to the client.
+- The SDK supports incremental sendAttempt (this is not used by RiotX)
+- The "Continue" button is now under the information, and not as the same place that the checkbox
+- The app can cancel a binding. Current data are erased from DB.
+- The API (IdentityService) is improved.
+- A new DB to store data related to the identity server management.
+
+Missing features (list not exhaustive):
+- Invite by 3Pid (will be in a dedicated PR)
+- Add email or phone to account (not P1, can be done on Riot-Web)
+- List email and phone of the account (could be done in a dedicated PR)
+- Search contact (not P1)
+- Logout from identity server when user sign out or deactivate his account.
+
+## Related MSCs
+The list can be found here: https://matrix.org/blog/2019/09/27/privacy-improvements-in-synapse-1-4-and-riot-1-4
+
+## Steps and requirements
+
+- Only one identity server by account can be set. The user's choice is stored in account data with key `m.identity_server`. But every clients will managed its own token to log in to the identity server
+```json
+{
+  "type": "m.identity_server",
+  "content": {
+    "base_url": "https://matrix.org"
+  }
+}
+```
+- The accepted terms are stored in the account data:
+```json
+{
+  "type": "m.accepted_terms",
+  "content": {
+    "accepted": [
+      "https://vector.im/identity-server-privacy-notice-1"
+    ]
+  }
+}
+```
+
+- Default identity server URL, from Wellknown data is proposed to the user.
+- Identity server can be set
+- Identity server can be changed on another user's device, so when the change is detected (thanks to account data sync) RiotX should properly disconnect from a previous identity server (I think it was not the case in Riot-Android, where we keep the token forever)
+- Registration to the identity server is managed with an openId token
+- Terms of service can be accepted when configuring the identity server.
+- Terms of service can be accepted after, if they change.
+- Identity server can be modified
+- Identity server can be disconnected with a warning dialog, with special content if there are current bound 3pid on this identity server.
+- Email can be bound
+- Email can be unbound
+- Phone can be bound
+- Phone can be unbound
+- Look up can be performed, to get matrixIds from local contact book (phone and email): Android permission correctly handled (not done yet)
+- Look up pepper can be updated if it is rotated on the identity server
+- Invitation using 3PID can be done (See #548) (not done yet)
+- Homeserver access-token will never be sent to an identity server
+- When user sign-out: logout from the identity server if any.
+- When user deactivate account: logout from the identity server if any.
+
+## Screens
+
+### Settings
+
+Identity server settings can be accessed from the internal setting of the application, both from "Discovery" section and from identity detail section.
+
+### Discovery screen
+
+This screen displays the identity server configuration and the binding of the user's ThreePid (email and msisdn). This is the main screen of the feature.
+
+### Set identity server screen
+
+This screen is a form to set a new identity server URL
+
+## Ref:
+- https://matrix.org/blog/2019/09/27/privacy-improvements-in-synapse-1-4-and-riot-1-4 is a good summary of the role of an Identity server and the proper way to configure and use it in respect to the privacy and the consent of the user.
+- API documentation: https://matrix.org/docs/spec/identity_service/latest
+- vector.im TOS: https://vector.im/identity-server-privacy-notice

docs/integration_tests.md

@@ -0,0 +1,103 @@
+# Integration tests
+
+Integration tests are useful to ensure that the code works well for any use cases.
+
+They can also be used as sample on how to use the Matrix SDK.
+
+In a ideal world, every API of the SDK should be covered by integration tests. For the moment, we have test mainly for the Crypto part, which is the tricky part. But it covers quite a lot of features: accounts creation, login to existing account, send encrypted messages, keys backup, verification, etc.
+
+The Matrix SDK is able to open multiple sessions, for the same user, of for different users. This way we can test communication between several sessions on a single device.
+
+## Pre requirements
+
+Integration tests need a homeserver running on localhost.
+
+The documentation describes what we do to have one, using [Synapse](https://github.com/matrix-org/synapse/), which is the Matrix reference homeserver.
+
+## Install and run Synapse
+
+Steps:
+
+- Install virtualenv
+
+```bash
+python3 -m pip install virtualenv
+```
+
+- Clone Synapse repository
+
+```bash
+git clone -b develop https://github.com/matrix-org/synapse.git
+```
+or
+```bash
+git clone -b develop git@github.com:matrix-org/synapse.git
+```
+
+You should have the develop branch cloned by default.
+
+- Run synapse, from the Synapse folder you just cloned
+
+```bash
+virtualenv -p python3 env
+source env/bin/activate
+pip install -e .
+demo/start.sh --no-rate-limit
+```
+
+Alternatively, to install the latest Synapse release package (and not a cloned branch) you can run the following instead of `pip install -e .`:
+
+```bash
+pip install matrix-synapse
+```
+
+You should now have 3 running federated Synapse instances 🎉, at http://127.0.0.1:8080/, http://127.0.0.1:8081/ and  http://127.0.0.1:8082/, which should display a "It Works! Synapse is running" message.
+
+## Run the test
+
+It's recommended to run tests using an Android Emulator and not a real device. First reason for that is that the tests will use http://10.0.2.2:8080 to connect to Synapse, which run locally on your machine.
+
+You can run all the tests in the `androidTest` folders.
+
+It can be done using this command:
+
+```bash
+./gradlew vector:connectedAndroidTest matrix-sdk-android:connectedAndroidTest
+```
+
+## Stop Synapse
+
+To stop Synapse, you can run the following commands:
+
+```bash
+./demo/stop.sh
+```
+
+And you can deactivate the virtualenv:
+
+```bash
+deactivate
+```
+
+## Troubleshoot
+
+You'll need python3 to be able to run synapse
+
+### Android Emulator does cannot reach the homeserver
+
+Try on the Emulator browser to open "http://10.0.2.2:8080". You should see the "Synapse is running" message.
+
+### virtualenv command fails
+
+You can try using
+```bash
+python3 -m venv env
+```
+or
+```bash
+python3 -m virtualenv env
+```
+instead of
+```bash
+virtualenv -p python3 env
+```

docs/notifications.md

@@ -38,10 +38,10 @@ When the client receives the new information, it immediately sends another reque
 This effectively emulates a server push feature.
 
 The HTTP long Polling can be fine tuned in the **SDK** using two parameters:
-* timout (Sync request timeout)
+* timeout (Sync request timeout)
 * delay (Delay between each sync)
 
-**timeout** is a server paramter, defined by:
+**timeout** is a server parameter, defined by:
 ```
 The maximum time to wait, in milliseconds, before returning this request.`
 If no events (or other data) become available before this time elapses, the server will return a response with empty fields.

docs/signin.md

@@ -0,0 +1,309 @@
+# Sign in to a homeserver
+
+This document describes the flow of signin to a homeserver, and also the flow when user want to reset his password. Examples come from the `matrix.org` homeserver.
+
+## Sign in flows
+
+### Get the flow
+
+Client request the sign-in flows, once the homeserver is chosen by the user and its url is known (in the example it's `https://matrix.org`)
+
+> curl -X GET 'https://matrix.org/_matrix/client/r0/login'
+
+200
+
+```json
+{
+  "flows": [
+    {
+      "type": "m.login.password"
+    }
+  ]
+}
+```
+
+### Login with username
+
+The user is able to connect using `m.login.password`
+
+> curl -X POST --data $'{"identifier":{"type":"m.id.user","user":"alice"},"password":"weak_password","type":"m.login.password","initial_device_display_name":"Portable"}' 'https://matrix.org/_matrix/client/r0/login'
+
+```json
+{
+  "identifier": {
+    "type": "m.id.user",
+    "user": "alice"
+  },
+  "password": "weak_password",
+  "type": "m.login.password",
+  "initial_device_display_name": "Portable"
+}
+```
+
+#### Incorrect password
+
+403
+
+```json
+{
+  "errcode": "M_FORBIDDEN",
+  "error": "Invalid password"
+}
+```
+
+#### Correct password:
+
+We get credential (200)
+
+```json
+{
+  "user_id": "@alice:matrix.org",
+  "access_token": "MDAxOGxvY2F0aW9uIG1hdHREDACTEDb2l0MDgxNjptYXRyaXgub3JnCjAwMTZjaWQgdHlwZSA9IGFjY2VzcwowMDIxY2lr",
+  "home_server": "matrix.org",
+  "device_id": "GTVREDALBF",
+  "well_known": {
+    "m.homeserver": {
+      "base_url": "https:\/\/matrix.org\/"
+    }
+  }
+}
+```
+
+### Login with email
+
+If the user has associated an email with its account, he can signin using the email.
+
+> curl -X POST --data $'{"identifier":{"type":"m.id.thirdparty","medium":"email","address":"alice@yopmail.com"},"password":"weak_password","type":"m.login.password","initial_device_display_name":"Portable"}' 'https://matrix.org/_matrix/client/r0/login'
+
+```json
+{
+  "identifier": {
+    "type": "m.id.thirdparty",
+    "medium": "email",
+    "address": "alice@yopmail.com"
+  },
+  "password": "weak_password",
+  "type": "m.login.password",
+  "initial_device_display_name": "Portable"
+}
+```
+
+#### Unknown email
+
+403
+
+```json
+{
+  "errcode": "M_FORBIDDEN",
+  "error": ""
+}
+```
+
+#### Known email, wrong password
+
+403
+
+```json
+{
+  "errcode": "M_FORBIDDEN",
+  "error": "Invalid password"
+}
+```
+
+##### Known email, correct password
+
+We get the credentials (200)
+
+```json
+{
+  "user_id": "@alice:matrix.org",
+  "access_token": "MDAxOGxvY2F0aW9uIG1hdHJpeC5vcmREDACTEDZXJfaWQgPSBAYmVub2l0MDgxNjptYXRyaXgub3Jnfrfdegfszsefddvf",
+  "home_server": "matrix.org",
+  "device_id": "WBSREDASND",
+  "well_known": {
+    "m.homeserver": {
+      "base_url": "https:\/\/matrix.org\/"
+    }
+  }
+}
+```
+
+It's worth noting that the response from the homeserver contains the userId of Alice.
+
+### Login with Msisdn
+
+Not supported yet in RiotX
+
+### Login with SSO
+
+> curl -X GET 'https://homeserver.with.sso/_matrix/client/r0/login'
+
+200
+
+```json
+{
+  "flows": [
+    {
+      "type": "m.login.sso"
+    },
+    {
+      "type": "m.login.token"
+    }
+  ]
+}
+```
+
+In this case, the user can click on "Sign in with SSO" and the native web browser, or a ChromeCustomTab if the device supports it, will be launched on the page
+
+> https://homeserver.with.sso/_matrix/client/r0/login/sso/redirect?redirectUrl=riotx%3A%2F%2Friotx
+
+The parameter `redirectUrl` is set to `riotx://riotx`.
+
+ChromeCustomTabs are an intermediate way to display a WebPage, between a WebView and using the external browser. More info can be found [here](https://developer.chrome.com/multidevice/android/customtabs)
+
+The browser will then take care of the SSO login, which may include creating a third party account, entering an email, settings a display name, or any other possibilities.
+
+During the process, user may be asked to validate an email by clicking on a link it contains. The link has to be opened in the browser which initiates the authentication. This is why we cannot use WebView anymore.
+
+Once the process is finished, the web page will call the `redirectUrl` with an extra parameter `loginToken`
+
+> riotx://riotx?loginToken=MDAxOWxvY2F0aW9uIG1vemlsbGEub3JnCjAwMTNpZGVudGlmaWVy
+
+This navigation is intercepted by RiotX by the `LoginActivity`, which will then ask the homeserver to convert this `loginToken` to an access token
+
+> curl -X POST --data $'{"type":"m.login.token","token":"MDAxOWxvY2F0aW9uIG1vemlsbGEub3JnCjAwMTNpZGVudGlmaWVy"}' 'https://homeserver.with.sso/_matrix/client/r0/login'
+
+```json
+{
+  "type": "m.login.token",
+  "token": "MDAxOWxvY2F0aW9uIG1vemlsbGEub3JnCjAwMTNpZGVudGlmaWVy"
+}
+```
+
+We get the credentials (200)
+
+```json
+{
+  "user_id": "@alice:homeserver.with.sso",
+  "access_token": "MDAxOWxvY2F0aW9uIG1vemlsbGEub3JnCjAwMTNpZGVudGlmaWVyIGtleQowMDEwY2lkIGdlbiA9IDEKMDAyY2NpZCB1c2",
+  "home_server": "homeserver.with.sso",
+  "device_id": "DETBTVAHCH",
+  "well_known": {
+    "m.homeserver": {
+      "base_url": "https:\/\/homeserver.with.sso\/"
+    },
+    "m.identity_server": {
+      "base_url": "https:\/\/vector.im"
+    }
+  }
+}
+```
+
+## Reset password
+
+Ref: `https://matrix.org/docs/spec/client_server/latest#post-matrix-client-r0-account-password-email-requesttoken`
+
+When the user has forgotten his password, he can reset it by providing an email and a new password.
+
+Here is the flow:
+
+### Send email
+
+User is asked to enter the email linked to his account and a new password.
+We display a warning regarding e2e.
+
+At the first step, we do not send the password, only the email and a client secret, generated by the application
+
+> curl -X POST --data $'{"client_secret":"6c57f284-85e2-421b-8270-fb1795a120a7","send_attempt":0,"email":"user@domain.com"}' 'https://matrix.org/_matrix/client/r0/account/password/email/requestToken'
+
+```json
+{
+  "client_secret": "6c57f284-85e2-421b-8270-fb1795a120a7",
+  "send_attempt": 0,
+  "email": "user@domain.com"
+}
+```
+
+#### When the email is not known
+
+We get a 400
+
+```json
+{
+  "errcode": "M_THREEPID_NOT_FOUND",
+  "error": "Email not found"
+}
+```
+
+#### When the email is known
+
+We get a 200 with a `sid`
+
+```json
+{
+  "sid": "tQNbrREDACTEDldA"
+}
+```
+
+Then the user is asked to click on the link in the email he just received, and to confirm when it's done.
+
+During this step, the new password is sent to the homeserver.
+
+If the user confirms before the link is clicked, we get an error:
+
+> curl -X POST --data $'{"auth":{"type":"m.login.email.identity","threepid_creds":{"client_secret":"6c57f284-85e2-421b-8270-fb1795a120a7","sid":"tQNbrREDACTEDldA"}},"new_password":"weak_password"}' 'https://matrix.org/_matrix/client/r0/account/password'
+
+```json
+{
+  "auth": {
+    "type": "m.login.email.identity",
+    "threepid_creds": {
+      "client_secret": "6c57f284-85e2-421b-8270-fb1795a120a7",
+      "sid": "tQNbrREDACTEDldA"
+    }
+  },
+  "new_password": "weak_password"
+}
+```
+
+401
+
+```json
+{
+  "errcode": "M_UNAUTHORIZED",
+  "error": ""
+}
+```
+
+### User clicks on the link
+
+The link has the form:
+
+https://matrix.org/_matrix/client/unstable/password_reset/email/submit_token?token=fzZLBlcqhTKeaFQFSRbsQnQCkzbwtGAD&client_secret=6c57f284-85e2-421b-8270-fb1795a120a7&sid=tQNbrREDACTEDldA
+
+It contains the client secret, a token and the sid
+
+When the user click the link, if validate his ownership and the new password can now be ent by the application (on user demand):
+
+> curl -X POST --data $'{"auth":{"type":"m.login.email.identity","threepid_creds":{"client_secret":"6c57f284-85e2-421b-8270-fb1795a120a7","sid":"tQNbrREDACTEDldA"}},"new_password":"weak_password"}' 'https://matrix.org/_matrix/client/r0/account/password'
+
+```json
+{
+  "auth": {
+    "type": "m.login.email.identity",
+    "threepid_creds": {
+      "client_secret": "6c57f284-85e2-421b-8270-fb1795a120a7",
+      "sid": "tQNbrREDACTEDldA"
+    }
+  },
+  "new_password": "weak_password"
+}
+```
+
+200
+
+```json
+{}
+```
+
+The password has been changed, and all the existing token are invalidated. User can now login with the new password.

docs/signup.md

@@ -0,0 +1,579 @@
+# Sign up to a homeserver
+
+This document describes the flow of registration to a homeserver. Examples come from the `matrix.org` homeserver.
+
+*Ref*: https://matrix.org/docs/spec/client_server/latest#account-registration-and-management
+
+## Sign up flows
+
+### First step
+
+Client request the sign-up flows, once the homeserver is chosen by the user and its url is known (in the example it's `https://matrix.org`)
+
+> curl -X POST --data $'{}' 'https://matrix.org/_matrix/client/r0/register'
+
+```json
+{
+}
+```
+
+We get the flows with a 401, which also means that the registration is possible on this homeserver.
+
+```json
+{
+  "session": "vwehdKMtkRedactedAMwgCACZ",
+  "flows": [
+    {
+      "stages": [
+        "m.login.recaptcha",
+        "m.login.terms",
+        "m.login.dummy"
+      ]
+    },
+    {
+      "stages": [
+        "m.login.recaptcha",
+        "m.login.terms",
+        "m.login.email.identity"
+      ]
+    }
+  ],
+  "params": {
+    "m.login.recaptcha": {
+      "public_key": "6LcgI54UAAAAAoREDACTEDoDdOocFpYVdjYBRe4zb"
+    },
+    "m.login.terms": {
+      "policies": {
+        "privacy_policy": {
+          "version": "1.0",
+          "en": {
+            "name": "Terms and Conditions",
+            "url": "https:\/\/matrix.org\/_matrix\/consent?v=1.0"
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+If the registration is not possible, we get a 403
+
+```json
+{
+  "errcode": "M_FORBIDDEN",
+  "error": "Registration is disabled"
+}
+```
+
+### Step 1: entering user name and password
+
+The app is displaying a form to enter username and password.
+
+> curl -X POST --data $'{"initial_device_display_name":"Mobile device","username":"alice","password": "weak_password"}' 'https://matrix.org/_matrix/client/r0/register'
+
+```json
+{
+  "initial_device_display_name": "Mobile device",
+  "username": "alice",
+  "password": "weak_password"
+}
+```
+
+401. Note that the `session` value has changed (because we did not provide the previous value in the request body), but it's ok, we will use the new value for the next steps.
+
+```json
+{
+  "session": "xptUYoREDACTEDogOWAGVnbJQ",
+  "flows": [
+    {
+      "stages": [
+        "m.login.recaptcha",
+        "m.login.terms",
+        "m.login.dummy"
+      ]
+    },
+    {
+      "stages": [
+        "m.login.recaptcha",
+        "m.login.terms",
+        "m.login.email.identity"
+      ]
+    }
+  ],
+  "params": {
+    "m.login.recaptcha": {
+      "public_key": "6LcgI54UAAAAAoREDACTEDoDdOocFpYVdjYBRe4zb"
+    },
+    "m.login.terms": {
+      "policies": {
+        "privacy_policy": {
+          "version": "1.0",
+          "en": {
+            "name": "Terms and Conditions",
+            "url": "https:\/\/matrix.org\/_matrix\/consent?v=1.0"
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+#### If username already exists
+
+We get a 400:
+
+```json
+{
+  "errcode": "M_USER_IN_USE",
+  "error": "User ID already taken."
+}
+```
+
+### Step 2: entering email
+
+User is proposed to enter an email. We skip this step.
+
+> curl -X POST --data $'{"auth":{"session":"xptUYoREDACTEDogOWAGVnbJQ","type":"m.login.dummy"}}' 'https://matrix.org/_matrix/client/r0/register'
+
+```json
+{
+  "auth": {
+    "session": "xptUYoREDACTEDogOWAGVnbJQ",
+    "type": "m.login.dummy"
+  }
+}
+```
+
+401
+
+```json
+{
+  "session": "xptUYoREDACTEDogOWAGVnbJQ",
+  "flows": [
+    {
+      "stages": [
+        "m.login.recaptcha",
+        "m.login.terms",
+        "m.login.dummy"
+      ]
+    },
+    {
+      "stages": [
+        "m.login.recaptcha",
+        "m.login.terms",
+        "m.login.email.identity"
+      ]
+    }
+  ],
+  "params": {
+    "m.login.recaptcha": {
+      "public_key": "6LcgI54UAAAAAoREDACTEDoDdOocFpYVdjYBRe4zb"
+    },
+    "m.login.terms": {
+      "policies": {
+        "privacy_policy": {
+          "version": "1.0",
+          "en": {
+            "name": "Terms and Conditions",
+            "url": "https:\/\/matrix.org\/_matrix\/consent?v=1.0"
+          }
+        }
+      }
+    }
+  },
+  "completed": [
+    "m.login.dummy"
+  ]
+}
+```
+
+### Step 2 bis: we enter an email
+
+We request a token to the homeserver. The `client_secret` is generated by the application
+
+> curl -X POST --data $'{"client_secret":"53e679ea-oRED-ACTED-92b8-3012c49c6cfa","email":"alice@yopmail.com","send_attempt":0}' 'https://matrix.org/_matrix/client/r0/register/email/requestToken'
+
+```json
+{
+  "client_secret": "53e679ea-oRED-ACTED-92b8-3012c49c6cfa",
+  "email": "alice@yopmail.com",
+  "send_attempt": 0
+}
+```
+
+200
+
+```json
+{
+  "sid": "qlBCREDACTEDEtgxD"
+}
+```
+
+And
+
+> curl -X POST --data $'{"auth":{"threepid_creds":{"client_secret":"53e679ea-oRED-ACTED-92b8-3012c49c6cfa","sid":"qlBCREDACTEDEtgxD"},"session":"xptUYoREDACTEDogOWAGVnbJQ","type":"m.login.email.identity"}}' 'https://matrix.org/_matrix/client/r0/register'
+
+```json
+{
+  "auth": {
+    "threepid_creds": {
+      "client_secret": "53e679ea-oRED-ACTED-92b8-3012c49c6cfa",
+      "sid": "qlBCREDACTEDEtgxD"
+    },
+    "session": "xptUYoREDACTEDogOWAGVnbJQ",
+    "type": "m.login.email.identity"
+  }
+}
+```
+
+We get 401 since the email is not validated yet:
+
+```json
+{
+  "errcode": "M_UNAUTHORIZED",
+  "error": ""
+}
+```
+
+The app is now polling on 
+
+> curl -X POST --data $'{"auth":{"threepid_creds":{"client_secret":"53e679ea-oRED-ACTED-92b8-3012c49c6cfa","sid":"qlBCREDACTEDEtgxD"},"session":"xptUYoREDACTEDogOWAGVnbJQ","type":"m.login.email.identity"}}' 'https://matrix.org/_matrix/client/r0/register'
+
+```json
+{
+  "auth": {
+    "threepid_creds": {
+      "client_secret": "53e679ea-oRED-ACTED-92b8-3012c49c6cfa",
+      "sid": "qlBCREDACTEDEtgxD"
+    },
+    "session": "xptUYoREDACTEDogOWAGVnbJQ",
+    "type": "m.login.email.identity"
+  }
+}
+```
+
+We click on the link received by email `https://matrix.org/_matrix/client/unstable/registration/email/submit_token?token=vtQjQIZfwdoREDACTEDozrmKYSWlCXsJ&client_secret=53e679ea-oRED-ACTED-92b8-3012c49c6cfa&sid=qlBCREDACTEDEtgxD` which contains:
+- A `token` vtQjQIZfwdoREDACTEDozrmKYSWlCXsJ
+- The `client_secret`: 53e679ea-oRED-ACTED-92b8-3012c49c6cfa
+- A `sid`: qlBCREDACTEDEtgxD
+
+Once the link is clicked, the registration request (polling) returns a 401 with the following content:
+
+```json
+{
+  "session": "xptUYoREDACTEDogOWAGVnbJQ",
+  "flows": [
+    {
+      "stages": [
+        "m.login.recaptcha",
+        "m.login.terms",
+        "m.login.dummy"
+      ]
+    },
+    {
+      "stages": [
+        "m.login.recaptcha",
+        "m.login.terms",
+        "m.login.email.identity"
+      ]
+    }
+  ],
+  "params": {
+    "m.login.recaptcha": {
+      "public_key": "6LcgI54UAAAAAoREDACTEDoDdOocFpYVdjYBRe4zb"
+    },
+    "m.login.terms": {
+      "policies": {
+        "privacy_policy": {
+          "version": "1.0",
+          "en": {
+            "name": "Terms and Conditions",
+            "url": "https:\/\/matrix.org\/_matrix\/consent?v=1.0"
+          }
+        }
+      }
+    }
+  },
+  "completed": [
+    "m.login.email.identity"
+  ]
+}
+```
+
+### Step 3: Accepting T&C
+
+User is proposed to accept T&C and he accepts them
+
+> curl -X POST --data $'{"auth":{"session":"xptUYoREDACTEDogOWAGVnbJQ","type":"m.login.terms"}}' 'https://matrix.org/_matrix/client/r0/register'
+
+```json
+{
+  "auth": {
+    "session": "xptUYoREDACTEDogOWAGVnbJQ",
+    "type": "m.login.terms"
+  }
+}
+```
+
+401
+
+```json
+{
+  "session": "xptUYoREDACTEDogOWAGVnbJQ",
+  "flows": [
+    {
+      "stages": [
+        "m.login.recaptcha",
+        "m.login.terms",
+        "m.login.dummy"
+      ]
+    },
+    {
+      "stages": [
+        "m.login.recaptcha",
+        "m.login.terms",
+        "m.login.email.identity"
+      ]
+    }
+  ],
+  "params": {
+    "m.login.recaptcha": {
+      "public_key": "6LcgI54UAAAAAoREDACTEDoDdOocFpYVdjYBRe4zb"
+    },
+    "m.login.terms": {
+      "policies": {
+        "privacy_policy": {
+          "version": "1.0",
+          "en": {
+            "name": "Terms and Conditions",
+            "url": "https:\/\/matrix.org\/_matrix\/consent?v=1.0"
+          }
+        }
+      }
+    }
+  },
+  "completed": [
+    "m.login.dummy",
+    "m.login.terms"
+  ]
+}
+```
+
+### Step 4: Captcha
+
+User is proposed to prove he is not a robot and he does it:
+
+> curl -X POST --data $'{"auth":{"response":"03AOLTBLSiGS9GhFDpAMblJ2nlXOmHXqAYJ5OvHCPUjiVLBef3k9snOYI_BDC32-t4D2jv-tpvkaiEI_uloobFd9RUTPpJ7con2hMddbKjSCYqXqcUQFhzhbcX6kw8uBnh2sbwBe80_ihrHGXEoACXQkL0ki1Q0uEtOeW20YBRjbNABsZPpLNZhGIWC0QVXnQ4FouAtZrl3gOAiyM-oG3cgP6M9pcANIAC_7T2P2amAHbtsTlSR9CsazNyS-rtDR9b5MywdtnWN9Aw8fTJb8cXQk_j7nvugMxzofPjSOrPKcr8h5OqPlpUCyxxnFtag6cuaPSUwh43D2L0E-ZX7djzaY2Yh_U2n6HegFNPOQ22CJmfrKwDlodmAfMPvAXyq77n3HpoREDACTEDo3830RHF4BfkGXUaZjctgg-A1mvC17hmQmQpkG7IhDqyw0onU-0vF_-ehCjq_CcQEDpS_O3uiHJaG5xGf-0rhLm57v_wA3deugbsZuO4uTuxZZycN_mKxZ97jlDVBetl9hc_5REPbhcT1w3uzTCSx7Q","session":"xptUYoREDACTEDogOWAGVnbJQ","type":"m.login.recaptcha"}}' 'https://matrix.org/_matrix/client/r0/register'
+
+```json
+{
+  "auth": {
+    "response": "03AOLTBLSiGS9GhFDpAMblJ2nlXOmHXqAYJ5OvHCPUjiVLBef3k9snOYI_BDC32-t4D2jv-tpvkaiEI_uloobFd9RUTPpJ7con2hMddbKjSCYqXqcUQFhzhbcX6kw8uBnh2sbwBe80_ihrHGXEoACXQkL0ki1Q0uEtOeW20YBRjbNABsZPpLNZhGIWC0QVXnQ4FouAtZrl3gOAiyM-oG3cgP6M9pcANIAC_7T2P2amAHbtsTlSR9CsazNyS-rtDR9b5MywdtnWN9Aw8fTJb8cXQk_j7nvugMxzofPjSOrPKcr8h5OqPlpUCyxxnFtag6cuaPSUwh43D2L0E-ZX7djzaY2Yh_U2n6HegFNPOQ22CJmfrKwDlodmAfMPvAXyq77n3HpoREDACTEDo3830RHF4BfkGXUaZjctgg-A1mvC17hmQmQpkG7IhDqyw0onU-0vF_-ehCjq_CcQEDpS_O3uiHJaG5xGf-0rhLm57v_wA3deugbsZuO4uTuxZZycN_mKxZ97jlDVBetl9hc_5REPbhcT1w3uzTCSx7Q",
+    "session": "xptUYoREDACTEDogOWAGVnbJQ",
+    "type": "m.login.recaptcha"
+  }
+}
+```
+
+200
+
+```json
+{
+  "user_id": "@alice:matrix.org",
+  "home_server": "matrix.org",
+  "access_token": "MDAxOGxvY2F0aW9uIG1hdHJpeC5vcmcKMoREDACTEDo50aWZpZXIga2V5CjAwMTBjaWQgZ2VuID0gMQowMDI5Y2lkIHVzZXJfaWQgPSBAYmVub2l0eHh4eDptYXRoREDACTEDoCjAwMTZjaWQgdHlwZSA9IGFjY2VzcwowMDIxY2lkIG5vbmNlID0gNHVSVm00aVFDaWlKdoREDACTEDoJmc2lnbmF0dXJlIOmHnTLRfxiPjhrWhS-dThUX-qAzZktfRThzH1YyAsxaCg",
+  "device_id": "FLBAREDAJZ"
+}
+```
+
+The account is created!
+
+### Step 5: MSISDN
+
+Some homeservers may require the user to enter MSISDN.
+
+On matrix.org, it's not required, and not even optional, but it's still possible for the app to add a MSISDN during the registration.
+
+The user enter a phone number and select a country, the `client_secret` is generated by the application
+
+> curl -X POST --data $'{"client_secret":"d3e285f6-972a-496c-9a22-7915a2db57c7","send_attempt":1,"country":"FR","phone_number":"+33611223344"}'  'https://matrix.org/_matrix/client/r0/register/msisdn/requestToken'
+
+```json
+{
+  "client_secret": "d3e285f6-972a-496c-9a22-7915a2db57c7",
+  "send_attempt": 1,
+  "country": "FR",
+  "phone_number": "+33611223344"
+}
+```
+
+If the msisdn is already associated to another account, you will received an error:
+
+```json
+{
+  "errcode": "M_THREEPID_IN_USE",
+  "error": "Phone number is already in use"
+}
+```
+
+If it is not the case, the homeserver send the SMS and returns some data, especially a `sid` and a `submit_url`:
+
+```json
+{
+  "msisdn": "33611223344",
+  "intl_fmt": "+336 11 22 33 44",
+  "success": true,
+  "sid": "1678881798",
+  "submit_url": "https:\/\/matrix.org\/_matrix\/client\/unstable\/add_threepid\/msisdn\/submit_token"
+}
+```
+
+When you execute the register request, with the received `sid`, you get an error since the MSISDN is not validated yet:
+
+> curl -X POST --data $'{"auth":{"type":"m.login.msisdn","session":"xptUYoREDACTEDogOWAGVnbJQ","threepid_creds":{"client_secret":"d3e285f6-972a-496c-9a22-7915a2db57c7","sid":"1678881798"}}}' 'https://matrix.org/_matrix/client/r0/register'
+
+
+```json
+  "auth": {
+    "type": "m.login.msisdn",
+    "session": "xptUYoREDACTEDogOWAGVnbJQ",
+    "threepid_creds": {
+      "client_secret": "d3e285f6-972a-496c-9a22-7915a2db57c7",
+      "sid": "1678881798"
+    }
+  }
+}
+```
+
+There is an issue on Synapse, which return a 401, it sends too much data along with the classical MatrixError fields:
+
+```json
+{
+  "session": "xptUYoREDACTEDogOWAGVnbJQ",
+  "flows": [
+    {
+      "stages": [
+        "m.login.recaptcha",
+        "m.login.terms",
+        "m.login.dummy"
+      ]
+    },
+    {
+      "stages": [
+        "m.login.recaptcha",
+        "m.login.terms",
+        "m.login.email.identity"
+      ]
+    }
+  ],
+  "params": {
+    "m.login.recaptcha": {
+      "public_key": "6LcgI54UAAAAABGdGmruw6DdOocFpYVdjYBRe4zb"
+    },
+    "m.login.terms": {
+      "policies": {
+        "privacy_policy": {
+          "version": "1.0",
+          "en": {
+            "name": "Terms and Conditions",
+            "url": "https:\/\/matrix.org\/_matrix\/consent?v=1.0"
+          }
+        }
+      }
+    }
+  },
+  "completed": [],
+  "error": "",
+  "errcode": "M_UNAUTHORIZED"
+}
+```
+
+The user receive the SMS, he can enter the SMS code in the app, which is sent using the "submit_url" received ie the response of the `requestToken` request:
+
+> curl -X POST --data $'{"client_secret":"d3e285f6-972a-496c-9a22-7915a2db57c7","sid":"1678881798","token":"123456"}' 'https://matrix.org/_matrix/client/unstable/add_threepid/msisdn/submit_token'
+
+```json
+{
+  "client_secret": "d3e285f6-972a-496c-9a22-7915a2db57c7",
+  "sid": "1678881798",
+  "token": "123456"
+}
+```
+
+If the code is not correct, we get a 200 with:
+
+```json
+{
+  "success": false
+}
+```
+
+And if the code is correct we get a 200 with:
+
+```json
+{
+  "success": true
+}
+```
+
+We can now execute the registration request, to the homeserver
+
+> curl -X POST --data $'{"auth":{"type":"m.login.msisdn","session":"xptUYoREDACTEDogOWAGVnbJQ","threepid_creds":{"client_secret":"d3e285f6-972a-496c-9a22-7915a2db57c7","sid":"1678881798"}}}' 'https://matrix.org/_matrix/client/r0/register'
+
+```json
+{
+  "auth": {
+    "type": "m.login.msisdn",
+    "session": "xptUYoREDACTEDogOWAGVnbJQ",
+    "threepid_creds": {
+      "client_secret": "d3e285f6-972a-496c-9a22-7915a2db57c7",
+      "sid": "1678881798"
+    }
+  }
+}
+```
+
+Now the homeserver consider that the `m.login.msisdn` step is completed (401):
+
+```json
+{
+  "session": "xptUYoREDACTEDogOWAGVnbJQ",
+  "flows": [
+    {
+      "stages": [
+        "m.login.recaptcha",
+        "m.login.terms",
+        "m.login.dummy"
+      ]
+    },
+    {
+      "stages": [
+        "m.login.recaptcha",
+        "m.login.terms",
+        "m.login.email.identity"
+      ]
+    }
+  ],
+  "params": {
+    "m.login.recaptcha": {
+      "public_key": "6LcgI54UAAAAABGdGmruw6DdOocFpYVdjYBRe4zb"
+    },
+    "m.login.terms": {
+      "policies": {
+        "privacy_policy": {
+          "version": "1.0",
+          "en": {
+            "name": "Terms and Conditions",
+            "url": "https:\/\/matrix.org\/_matrix\/consent?v=1.0"
+          }
+        }
+      }
+    }
+  },
+  "completed": [
+    "m.login.msisdn"
+  ]
+}
+```

docs/voip_signaling.md

@@ -0,0 +1,424 @@
+Useful links:
+- https://codelabs.developers.google.com/codelabs/webrtc-web/#0
+
+
+   ╔════════════════════════════════════════════════╗
+   ║                                                ║
+   ║A] Placing a call offer                         ║
+   ║                                                ║
+   ╚════════════════════════════════════════════════╝
+
+
+
+                                                    ┌───────────────┐
+                                                    │    Matrix     │
+                                                    ├───────────────┴ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
+                                                                                                                     │
+                                                    │
+                                                                                                                     │
+              ┌─────────────────┐                   │                  ┌───────────────────────────┐                                      ┌─────────────────┐
+              │     Caller      │                                      │      Signaling Room       │                 │                    │     Callee      │
+              └─────────────────┘                   │                  ├───────────────────────────┤                                      └─────────────────┘
+                                       ┌────┐                          │                           │                 │
+                                       │ 3  │       │                  │  ┌────────────────────┐   │
+              ┌─────────────────┐──────┴────┴──────────────────────────┼─▶│   m.call.invite    │   │                 │                    ┌─────────────────┐
+              │                 │                   │                  │  │      mx event      │   │                                      │                 │
+              │                 │                                      │  └────────────────────┘   │                 │                    │                 │
+              │                 │                   │                  │                           │                                      │                 │
+              │     Riot.im     │                                      │                           │                 │                    │     Riot.im     │
+           ┌──│       App       │                   │                  │                           │                                      │       App       │
+           │  │                 │                                      │                           │                 │                    │                 │
+           │  │                 │                   │                  │                           │                                      │                 │
+           │  │                 │                                      │                           │                 │                    │                 │
+           │  └─────────────────┘                   │                  │                           │                                      └─────────────────┘
+      ┌────┤     ▲                                                     │                           │                 │
+      │ 1  │     ├────┐                             │                  └───────────────────────────┘
+      └────┤     │ 2  │                              ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘
+           │  ┌──┴────┴─────────┐                                                                                                         ┌─────────────────┐
+           │  │                 │                                                                                                         │                 │
+           │  │                 │                                                                                                         │                 │
+           │  │     WebRtc      │                                                                                                         │     WebRtc      │
+           └─▶│                 │                                                                                                         │                 │
+              │                 │                                                                                                         │                 │
+              │                 │                                                                                                         │                 │
+              └─────────────────┘                                                                                                         └─────────────────┘
+
+
+
+
+
+
+
+
+
+       ┌────┐
+       │ 1  │  The Caller app get access to system resources (camera, mic), eventually stun/turn servers, define some
+       └────┘  constrains (video quality, format) and pass it to WebRtc in order to create a Peer Call offer
+
+       ┌────┐
+       │ 2  │  The WebRtc layer creates a call Offer (sdp) that needs to be sent to callee
+       └────┘
+
+       ┌────┐  The app layer, takes the webrtc offer, encapsulate it in a matrix event adds a callId and send it to the other
+       │ 3  │  user via the room
+       └────┘
+                   ┌──────────────┐
+                   │   mx event   │
+                   ├──────────────┴────────┐
+                   │ type: m.call.invite   │
+                   │ + callId              │
+                   │                       │
+                   │ ┌──────────────────┐  │
+                   │ │    webrtc sdp    │  │
+                   │ └──────────────────┘  │
+                   └───────────────────────┘
+
+
+
+
+
+
+
+   ╔════════════════════════════════════════════════╗
+   ║                                                ║
+   ║B] Sending connection establishment info        ║
+   ║                                                ║
+   ╚════════════════════════════════════════════════╝
+
+
+
+                                                   ┌───────────────┐
+                                                   │    Matrix     │
+                                                   ├───────────────┴ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
+                                                                                                                    │
+                                                   │
+                                                                                                                    │
+             ┌─────────────────┐                   │                  ┌───────────────────────────┐                                      ┌─────────────────┐
+             │     Caller      │                                      │      Signaling Room       │                 │                    │     Callee      │
+             └─────────────────┘                   │                  ├───────────────────────────┤                                      └─────────────────┘
+                                                                      │  ┌────────────────────┐   │                 │
+                                                   │                  │  │   m.call.invite    │   │
+             ┌─────────────────┐                                      │  │      mx event      │   │                 │                    ┌─────────────────┐
+             │                 │      ┌────┐       │                  │  └────────────────────┘   │                                      │                 │
+             │                 │      │ 3  │                          │  ┌────────────────────┐   │                 │                    │                 │
+             │                 │──────┴────┴───────┼──────────────────┼─▶│ m.call.candidates  │   │                                      │                 │
+             │     Riot.im     │                                      │  │      mx event      │   │                 │                    │     Riot.im     │
+             │       App       │                   │                  │  └────────────────────┘   │                                      │       App       │
+             │                 │                                      │                           │                 │                    │                 │
+             │                 │                   │                  │                           │                                      │                 │
+             │                 │                                      │                           │                 │                    │                 │
+             └─────────────────┘                   │                  │                           │                                      └─────────────────┘
+                     ▲                                                │                           │                 │
+                     ├────┐                        │                  └───────────────────────────┘
+                     │ 2  │                         ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘
+             ┌───────┴────┴────┐                                                                                                         ┌─────────────────┐
+             │                 │                                                                                                         │                 │
+             │                 │                                                                                                         │                 │
+             │     WebRtc      │                   ┌───────────────┐                                                                     │     WebRtc      │
+             │                 │                   │  Stun / Turn  │                                                                     │                 │
+             │                 │                   ├───────────────┴ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─                                         │                 │
+             │                 │                                                                │                                        │                 │
+             └─────────────────┘                   │                                                                                     └─────────────────┘
+                      ▲                                                                         │
+                      │                            │
+                      └──────────┬────┬───────────▶                                             │
+              ┌───────────────┐  │ 1  │            │
+              │               │  └────┘                                                         │
+              │ Network Stack │                    │
+              │               │                     ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘
+              │               │
+              └───────────────┘
+
+
+
+
+       ┌────┐
+       │ 1  │  The WebRtc layer gathers information on how it can be reach by the other peer directly (Ice candidates)
+       └────┘
+               ┌──────────────────────────────────────────────────────────────────┐
+               │candidate:1 1 tcp 1518149375 127.0.0.1 35990 typ host             │
+               └──────────────────────────────────────────────────────────────────┘
+               ┌──────────────────────────────────────────────────────────────────┐
+               │candidate:2 1 UDP 2130706431 192.168.1.102 1816 typ host          │
+               └──────────────────────────────────────────────────────────────────┘
+
+       ┌────┐
+       │ 2  │  The WebRTC layer notifies the App layer when it finds new Ice Candidates
+       └────┘
+
+
+
+       ┌────┐  The app layer, takes the ice candidates, encapsulate them in one or several matrix event adds the callId and
+       │ 3  │  send it to the other user via the room
+       └────┘
+                   ┌──────────────┐
+                   │   mx event   │
+                   ├──────────────┴────────────────────────┐
+                   │  type: m.call.candidates              │
+                   │                                       │
+                   │  +CallId                              │
+                   │                                       │
+                   │ ┌──────────────────┐                  │
+                   │ │ice candidate sdp │                  │
+                   │ └──────────────────┘                  │
+                   │ ┌──────────────────┐                  │
+                   │ │ice candidate sdp │                  │
+                   │ └──────────────────┘                  │
+                   │ ┌──────────────────┐                  │
+                   │ │ice candidate sdp │                  │
+                   │ └──────────────────┘                  │
+                   └───────────────────────────────────────┘
+
+
+
+
+
+    ╔════════════════════════════════════════════════╗
+    ║                                                ║
+    ║C] Receiving a call offer                       ║
+    ║                                                ║
+    ╚════════════════════════════════════════════════╝
+
+
+
+                                                    ┌───────────────┐
+                                                    │    Matrix     │
+                                                    ├───────────────┴ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
+                                                                                                                     │
+                                                    │                                                                                     ┌─────────────────┐
+                                                                                                                     │                    │     Callee      │
+              ┌─────────────────┐                   │                  ┌───────────────────────────┐                                      └─────────────────┘
+              │     Caller      │                                      │      Signaling Room       │                 │
+              └─────────────────┘                   │                  ├───────────────────────────┤
+                                                                       │  ┌────────────────────┐   │                 │                    ┌─────────────────┐
+                                                    │                  │  │   m.call.invite    │───┼────────────────────────────┬────┬───▶│                 │
+              ┌─────────────────┐                                      │  │      mx event      │   │                 │          │ 1  │    │                 │
+              │                 │                   │                  │  └────────────────────┘   │                            └────┘    │                 │
+              │                 │                                      │  ┌────────────────────┐   │                 │                    │     Riot.im     │
+              │                 │                   │                  │  │ m.call.candidates  │   │                                      │       App       │
+              │     Riot.im     │                                      │  │      mx event      │   │                 │                    │                 │
+              │       App       │                   │                  │  └────────────────────┘   │                                      │                 │
+              │                 │                                      │  ┌────────────────────┐◀──┼─────────────────┼───┬────┬───────────┤                 │
+              │                 │◀──────────────────┼──────────────────┼──│   m.call.answer    │   │                     │ 4  │           └──┬──────────────┘
+              │                 │                                      │  │      mx event      │   │                 │   └────┘              ├────┐    ▲
+              └────┬────────────┘                   │                  │  └────────────────────┘   │                                         │ 2  │    ├────┐
+                   │                                                   │                           │                 │                       ├────┘    │ 3  │
+                   │                                │                  └───────────────────────────┘                                      ┌──▼─────────┴────┤
+              ┌────▼────────────┐                    ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘                    │                 │
+              │                 │                                                                                                         │                 │
+              │                 │                                                                                                         │     WebRtc      │
+              │     WebRtc      │                                                                                                         │              ┌──┴─────────────────┐
+              │                 │                                                                                                         │              │    caller offer    │
+   ┌──────────┴─────────┐       │                                                                                                         │              └──┬─────────────────┘
+   │   callee answer    │       │                                                                                                         └─────────────────┘
+   └────────────────────┴───────┘
+
+
+
+
+
+
+
+        ┌────┐
+        │ 1  │  Bob receives a call.invite event in a room, then creates a WebRTC peer connection object
+        └────┘
+
+        ┌────┐
+        │ 2  │  The encapsulated call offer sdp from the mx event is transmitted to WebRTC
+        └────┘
+
+        ┌────┐
+        │ 3  │  WebRTC then creates a call answer for the offer and send it back to app layer
+        └────┘
+
+
+        ┌────┐  The app layer, takes the webrtc answer, encapsulate it in a matrix event adds a callId and send it to the
+        │ 3  │  other user via the room
+        └────┘
+                    ┌──────────────┐
+                    │   mx event   │
+                    ├──────────────┴────────┐
+                    │ type: m.call.answer   │
+                    │ + callId              │
+                    │                       │
+                    │ ┌──────────────────┐  │
+                    │ │    webrtc sdp    │  │
+                    │ └──────────────────┘  │
+                    └───────────────────────┘
+
+
+
+
+
+
+    ╔════════════════════════════════════════════════╗
+    ║                                                ║
+    ║D] Callee sends connection establishment info   ║
+    ║                                                ║
+    ╚════════════════════════════════════════════════╝
+
+
+
+                                                    ┌───────────────┐
+                                                    │    Matrix     │
+                                                    ├───────────────┴ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
+                                                                                                                     │
+                                                    │
+                                                                                                                     │
+              ┌─────────────────┐                   │                  ┌───────────────────────────┐                                      ┌─────────────────┐
+              │     Caller      │                                      │      Signaling Room       │                 │                    │     Callee      │
+              └─────────────────┘                   │                  ├───────────────────────────┤                                      └─────────────────┘
+                                                                       │  ┌────────────────────┐   │                 │
+                                                    │                  │  │   m.call.invite    │   │
+              ┌─────────────────┐                                      │  │      mx event      │   │                 │                    ┌─────────────────┐
+              │                 │                   │                  │  └────────────────────┘   │                                      │                 │
+              │                 │                                      │  ┌────────────────────┐   │                 │                    │                 │
+              │                 │                   │                  │  │ m.call.candidates  │   │                                      │                 │
+              │     Riot.im     │                                      │  │      mx event      │   │                 │                    │     Riot.im     │
+              │       App       │                   │                  │  └────────────────────┘   │                        ┌────┐        │       App       │
+              │                 │                                      │  ┌────────────────────┐   │                 │      │ 3  │        │                 │
+              │                 │◀──────────────────┼┐                 │  │   m.call.answer    │   │                ┌───────┴────┴────────│                 │
+              │                 │                    │                 │  │      mx event      │   │                ││                    │                 │
+              └─────────────────┘                   ││                 │  └────────────────────┘   │                │                     └─────────────────┘
+                   │                                 │                 │  ┌────────────────────┐   │                ││                         ▲
+                   │                                │└─────────────────┼──│ m.call.candidates  │   │                │                          ├────┐
+                   ▼                                                   │  │      mx event      │◀──┼────────────────┘│                         │ 2  │
+              ┌─────────────────┐                   │                  │  └────────────────────┘   │                                      ┌────┴────┴───────┐
+              │                 │                                      └───────────────────────────┘                 │                    │                 │
+              │                 │                   │                                                                                     │                 │
+              │     WebRtc      │                                                                                    │                    │     WebRtc      │
+              │                 │                   └ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─                     │             ┌───┴────────────────┐
+              │                 │                                                                                                         │             │    caller offer    │
+     ┌────────┴───────────┐     │                                                                                                         │             └───┬────────────────┘
+     │   callee answer    ├─────┘                                                  ┌───────────────┐                                      └─────────────────┘
+     ├────────────────────┤                                                        │  Stun / Turn  │                                               ▲
+     │     callee ice     │                                                        ├───────────────┴ ─ ─ ─ ─ ─ ─ ─ ─                       ┌────┐  │
+     │     candidates     │                                                                                         │                      │ 1  │  │
+     └────────────────────┘                                                        │                                                       ├────┴──┴───────┐
+                                                                                                                    │                      │               │
+                                                                                   │                                                       │ Network Stack │
+                                                                                                                    │◀─────────────────────┤               │
+                                                                                   │                                                       │               │
+                                                                                                                    │                      └───────────────┘
+                                                                                   │
+                                                                                    ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘
+
+
+        ┌────┐
+        │ 1  │  The WebRtc layer gathers information on how it can be reach by the other peer directly (Ice candidates)
+        └────┘
+                ┌──────────────────────────────────────────────────────────────────┐
+                │candidate:1 1 tcp 1518149375 127.0.0.1 35990 typ host             │
+                └──────────────────────────────────────────────────────────────────┘
+                ┌──────────────────────────────────────────────────────────────────┐
+                │candidate:2 1 UDP 2130706431 192.168.1.102 1816 typ host          │
+                └──────────────────────────────────────────────────────────────────┘
+
+        ┌────┐
+        │ 2  │  The WebRTC layer notifies the App layer when it finds new Ice Candidates
+        └────┘
+
+
+
+        ┌────┐  The app layer, takes the ice candidates, encapsulate them in one or several matrix event adds the callId and
+        │ 3  │  send it to the other user via the room
+        └────┘
+                    ┌──────────────┐
+                    │   mx event   │
+                    ├──────────────┴────────────────────────┐
+                    │  type: m.call.candidates              │
+                    │                                       │
+                    │  +CallId                              │
+                    │                                       │
+                    │ ┌──────────────────┐                  │
+                    │ │ice candidate sdp │                  │
+                    │ └──────────────────┘                  │
+                    │ ┌──────────────────┐                  │
+                    │ │ice candidate sdp │                  │
+                    │ └──────────────────┘                  │
+                    │ ┌──────────────────┐                  │
+                    │ │ice candidate sdp │                  │
+                    │ └──────────────────┘                  │
+                    └───────────────────────────────────────┘
+
+
+
+
+
+
+     ╔════════════════════════════════════════════════╗
+     ║                                                ║
+     ║D] Caller Callee connection                     ║
+     ║                                                ║
+     ╚════════════════════════════════════════════════╝
+
+
+
+
+
+
+
+
+                                                   ┌───────────────┐
+               ┌─────────────────┐                 │    Matrix     │                                                                       ┌─────────────────┐
+               │     Caller      │                 ├───────────────┴ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─                       │     Callee      │
+               └─────────────────┘                                                                                  │                      └─────────────────┘
+                                                   │
+                                                                                                                    │
+               ┌─────────────────┐                 │                                                                                       ┌─────────────────┐
+               │                 │                                                                                  │                      │                 │
+               │                 │                 │                                                                                       │                 │
+               │                 │                                                                                  │                      │                 │
+               │     Riot.im     │                 └ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─                       │     Riot.im     │
+               │       App       │                                                                                                         │       App       │
+               │                 │                                                                                                         │                 │
+               │                 │                                                                                                         │                 │
+               │                 │                                                                                                         │                 │
+               └─────────────────┘                                                                                                         └─────────────────┘
+                                                    ┌───────────────┐
+                                                    │   Internet    │
+                                                    ├───────────────┴ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
+               ┌─────────────────┐                                                                                   │                     ┌─────────────────┐
+               │                 │                  │                                                                                      │                 │
+               │                 ├───────────────────────────────────────────────────────────────────────────────────┴─────────────────────┤                 │
+               │     WebRtc      │█████████████████████████████████████████████████████████████████████████████████████████████████████████│     WebRtc      │
+ ┌─────────────┴──────┐          ├────────────────────────────────────────┬──────────────────────────┬───────────────┬─────────────────────┤           ┌─────┴──────────────┐
+ │   callee answer    │          │                  │                     │   Video / Audio Stream   │                                     │           │    caller offer    │
+ ├────────────────────┤          │                                        └──────────────────────────┘               │                     │           ├────────────────────┤
+ │     callee ice     ├──────────┘                  └ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─                      └───────────┤     caller ice     │
+ │     candidates     │                                                                                                                                │     candidates     │
+ └────────────────────┘                                                                                                                                └────────────────────┘
+
+
+
+                                                         ┌─────────────────────────────────────────────────────┐
+                                                         │                                                     │░
+                                                         │ If connection is impossible (firewall), and a turn  │░
+                                                         │server is available, connection could happen through │░
+                                                         │                       a relay                       │░
+                                                         │                                                     │░
+                                                         └─────────────────────────────────────────────────────┘░
+                                                          ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
+
+
+                                                     ┌───────────────┐
+                                                     │   Internet    │
+                                                     └─┬─────────────┴ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
+                ┌─────────────────┐                                                                                     │                   ┌─────────────────┐
+                │                 │                    │                   ┌─────────────────────────┐                                      │                 │
+                │                 ├───────────────────────────────────────┐│                         │                  │                   │                 │
+                │     WebRtc      │███████████████████████████████████████││                         │                                      │     WebRtc      │
+                │                 ├───────────────────────────────────────┘│                         │                  │                   │                 │
+                │                 │           ┌────────┴─────────────────┐ │          Relay          │┌─────────────────────────────────────┤                 │
+┌───────────────┴────┐            │           │   Video / Audio Stream   │ │                         ││█████████████████████████████████████│         ┌───────┴────────────┐
+│   callee answer    ├────────────┘           └────────┬─────────────────┘ │                         │└─────────────────────────────────────┴─────────┤    caller offer    │
+├────────────────────┤                                                     │                         │                  │                             ├────────────────────┤
+│     callee ice     │                                 │                   │                         │                                                │     caller ice     │
+│     candidates     │                                                     └─────────────────────────┘                  │                             │     candidates     │
+└────────────────────┘                                 │                                                                                              └────────────────────┘
+                                                                                                                        │
+                                                       │
+                                                                                                                        │
+                                                       │
+                                                                                                                        │
+                                                       └ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─

gradle.properties

@@ -8,7 +8,7 @@
 # The setting is particularly useful for tweaking memory settings.
 android.enableJetifier=true
 android.useAndroidX=true
-org.gradle.jvmargs=-Xmx1536m
+org.gradle.jvmargs=-Xmx8192m
 # When configured, Gradle will run in incubating parallel mode.
 # This option should only be used with decoupled projects. More details, visit
 # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
-#Tue Mar 19 09:53:05 CET 2019
+#Fri Sep 27 10:10:35 CEST 2019
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-5.2.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.4.1-all.zip

matrix-sdk-android-rx/build.gradle

@@ -3,18 +3,17 @@ apply plugin: 'kotlin-android'
 apply plugin: 'kotlin-kapt'
 
 android {
-    compileSdkVersion 28
-
-
+    compileSdkVersion 29
 
     defaultConfig {
-        minSdkVersion 16
-        targetSdkVersion 28
+        minSdkVersion 21
+        targetSdkVersion 29
         versionCode 1
         versionName "1.0"
 
+        // Multidex is useful for tests
+        multiDexEnabled true
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
-
     }
 
     buildTypes {
@@ -29,17 +28,22 @@ android {
         targetCompatibility JavaVersion.VERSION_1_8
     }
 
-
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
 }
 
 dependencies {
     implementation project(":matrix-sdk-android")
-    implementation 'androidx.appcompat:appcompat:1.1.0-beta01'
+    implementation 'androidx.appcompat:appcompat:1.1.0'
     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"
 
+    // Logging
+    implementation 'com.jakewharton.timber:timber:4.7.1'
+
     testImplementation 'junit:junit:4.12'
     androidTestImplementation 'androidx.test:runner:1.2.0'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'

matrix-sdk-android-rx/src/androidTest/java/im/vector/matrix/rx/ExampleInstrumentedTest.java

@@ -1,42 +0,0 @@
-/*
- * 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 android.content.Context;
-import androidx.test.InstrumentationRegistry;
-import androidx.test.runner.AndroidJUnit4;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import static org.junit.Assert.*;
-
-/**
- * Instrumented test, which will execute on an Android device.
- *
- * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
- */
-@RunWith(AndroidJUnit4.class)
-public class ExampleInstrumentedTest {
-    @Test
-    public void useAppContext() {
-        // Context of the app under test.
-        Context appContext = InstrumentationRegistry.getTargetContext();
-
-        assertEquals("im.vector.matrix.rx.test", appContext.getPackageName());
-    }
-}

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

@@ -60,4 +60,12 @@ private class LiveDataObservable<T>(
 
 fun <T> LiveData<T>.asObservable(): Observable<T> {
     return LiveDataObservable(this).observeOn(Schedulers.computation())
-}
+}
+
+internal fun <T> Observable<T>.startWithCallable(supplier: () -> T): Observable<T> {
+    val startObservable = Observable
+            .fromCallable(supplier)
+            .subscribeOn(Schedulers.io())
+            .observeOn(AndroidSchedulers.mainThread())
+    return startWith(startObservable)
+}

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

@@ -14,14 +14,17 @@
  * limitations under the License.
  */
 
-package im.vector.matrix.android.internal.session.sync.model
+package im.vector.matrix.rx
 
-internal interface UserAccountData {
+import im.vector.matrix.android.api.util.Optional
+import io.reactivex.Observable
 
-    companion object {
-        const val TYPE_IGNORED_USER_LIST = "m.ignored_user_list"
-        const val TYPE_DIRECT_MESSAGES = "m.direct"
-        const val TYPE_PREVIEW_URLS = "org.matrix.preview_urls"
-        const val TYPE_WIDGETS = "m.widgets"
+fun <T : Any> Observable<Optional<T>>.unwrap(): Observable<T> {
+    return filter { it.hasValue() }.map { it.get() }
+}
+
+fun <T : Any, U : Any> Observable<Optional<T>>.mapOptional(fn: (T) -> U?): Observable<Optional<U>> {
+    return map {
+        it.map(fn)
     }
-}
+}

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

@@ -0,0 +1,54 @@
+/*
+ * 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.Completable
+import io.reactivex.Single
+
+fun <T> singleBuilder(builder: (callback: MatrixCallback<T>) -> Cancelable): Single<T> = Single.create {
+    val callback: MatrixCallback<T> = object : MatrixCallback<T> {
+        override fun onSuccess(data: T) {
+            it.onSuccess(data)
+        }
+
+        override fun onFailure(failure: Throwable) {
+            it.tryOnError(failure)
+        }
+    }
+    val cancelable = builder(callback)
+    it.setCancellable {
+        cancelable.cancel()
+    }
+}
+
+fun <T> completableBuilder(builder: (callback: MatrixCallback<T>) -> Cancelable): Completable = Completable.create {
+    val callback: MatrixCallback<T> = object : MatrixCallback<T> {
+        override fun onSuccess(data: T) {
+            it.onComplete()
+        }
+
+        override fun onFailure(failure: Throwable) {
+            it.tryOnError(failure)
+        }
+    }
+    val cancelable = builder(callback)
+    it.setCancellable {
+        cancelable.cancel()
+    }
+}

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

@@ -16,46 +16,119 @@
 
 package im.vector.matrix.rx
 
+import android.net.Uri
+import im.vector.matrix.android.api.query.QueryStringValue
+import im.vector.matrix.android.api.session.events.model.Event
 import im.vector.matrix.android.api.session.room.Room
+import im.vector.matrix.android.api.session.room.members.RoomMemberQueryParams
 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.RoomHistoryVisibility
+import im.vector.matrix.android.api.session.room.model.RoomMemberSummary
 import im.vector.matrix.android.api.session.room.model.RoomSummary
+import im.vector.matrix.android.api.session.room.notification.RoomNotificationState
+import im.vector.matrix.android.api.session.room.send.UserDraft
 import im.vector.matrix.android.api.session.room.timeline.TimelineEvent
+import im.vector.matrix.android.api.util.Optional
+import im.vector.matrix.android.api.util.toOptional
+import io.reactivex.Completable
 import io.reactivex.Observable
 import io.reactivex.Single
 
 class RxRoom(private val room: Room) {
 
-    fun liveRoomSummary(): Observable<RoomSummary> {
-        return room.liveRoomSummary().asObservable()
+    fun liveRoomSummary(): Observable<Optional<RoomSummary>> {
+        return room.getRoomSummaryLive()
+                .asObservable()
+                .startWithCallable { room.roomSummary().toOptional() }
     }
 
-    fun liveRoomMemberIds(): Observable<List<String>> {
-        return room.getRoomMemberIdsLive().asObservable()
+    fun liveRoomMembers(queryParams: RoomMemberQueryParams): Observable<List<RoomMemberSummary>> {
+        return room.getRoomMembersLive(queryParams).asObservable()
+                .startWithCallable {
+                    room.getRoomMembers(queryParams)
+                }
     }
 
-    fun liveAnnotationSummary(eventId: String): Observable<EventAnnotationsSummary> {
-        return room.getEventSummaryLive(eventId).asObservable()
+    fun liveAnnotationSummary(eventId: String): Observable<Optional<EventAnnotationsSummary>> {
+        return room.getEventAnnotationsSummaryLive(eventId).asObservable()
+                .startWithCallable {
+                    room.getEventAnnotationsSummary(eventId).toOptional()
+                }
     }
 
-    fun liveTimelineEvent(eventId: String): Observable<TimelineEvent> {
-        return room.liveTimeLineEvent(eventId).asObservable()
+    fun liveTimelineEvent(eventId: String): Observable<Optional<TimelineEvent>> {
+        return room.getTimeLineEventLive(eventId).asObservable()
+                .startWithCallable {
+                    room.getTimeLineEvent(eventId).toOptional()
+                }
     }
 
-    fun loadRoomMembersIfNeeded(): Single<Unit> = Single.create {
-        room.loadRoomMembersIfNeeded(MatrixCallbackSingle(it)).toSingle(it)
+    fun liveStateEvent(eventType: String, stateKey: QueryStringValue): Observable<Optional<Event>> {
+        return room.getStateEventLive(eventType, stateKey).asObservable()
+                .startWithCallable {
+                    room.getStateEvent(eventType, stateKey).toOptional()
+                }
     }
 
-    fun joinRoom(viaServers: List<String> = emptyList()): Single<Unit> = Single.create {
-        room.join(viaServers, MatrixCallbackSingle(it)).toSingle(it)
+    fun liveReadMarker(): Observable<Optional<String>> {
+        return room.getReadMarkerLive().asObservable()
+    }
+
+    fun liveReadReceipt(): Observable<Optional<String>> {
+        return room.getMyReadReceiptLive().asObservable()
+    }
+
+    fun loadRoomMembersIfNeeded(): Single<Unit> = singleBuilder {
+        room.loadRoomMembersIfNeeded(it)
+    }
+
+    fun joinRoom(reason: String? = null,
+                 viaServers: List<String> = emptyList()): Single<Unit> = singleBuilder {
+        room.join(reason, viaServers, it)
     }
 
     fun liveEventReadReceipts(eventId: String): Observable<List<ReadReceipt>> {
         return room.getEventReadReceiptsLive(eventId).asObservable()
     }
 
+    fun liveDrafts(): Observable<List<UserDraft>> {
+        return room.getDraftsLive().asObservable()
+    }
+
+    fun liveNotificationState(): Observable<RoomNotificationState> {
+        return room.getLiveRoomNotificationState().asObservable()
+    }
+
+    fun invite(userId: String, reason: String? = null): Completable = completableBuilder<Unit> {
+        room.invite(userId, reason, it)
+    }
+
+    fun updateTopic(topic: String): Completable = completableBuilder<Unit> {
+        room.updateTopic(topic, it)
+    }
+
+    fun updateName(name: String): Completable = completableBuilder<Unit> {
+        room.updateName(name, it)
+    }
+
+    fun addRoomAlias(alias: String): Completable = completableBuilder<Unit> {
+        room.addRoomAlias(alias, it)
+    }
+
+    fun updateCanonicalAlias(alias: String): Completable = completableBuilder<Unit> {
+        room.updateCanonicalAlias(alias, it)
+    }
+
+    fun updateHistoryReadability(readability: RoomHistoryVisibility): Completable = completableBuilder<Unit> {
+        room.updateHistoryReadability(readability, it)
+    }
+
+    fun updateAvatar(avatarUri: Uri, fileName: String): Completable = completableBuilder<Unit> {
+        room.updateAvatar(avatarUri, fileName, it)
+    }
 }
 
 fun Room.rx(): RxRoom {
     return RxRoom(this)
-}
+}

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

@@ -17,58 +17,156 @@
 package im.vector.matrix.rx
 
 import androidx.paging.PagedList
+import im.vector.matrix.android.api.query.QueryStringValue
 import im.vector.matrix.android.api.session.Session
+import im.vector.matrix.android.api.session.crypto.crosssigning.MXCrossSigningInfo
+import im.vector.matrix.android.api.session.group.GroupSummaryQueryParams
 import im.vector.matrix.android.api.session.group.model.GroupSummary
+import im.vector.matrix.android.api.session.identity.ThreePid
 import im.vector.matrix.android.api.session.pushers.Pusher
+import im.vector.matrix.android.api.session.room.RoomSummaryQueryParams
 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 im.vector.matrix.android.api.session.widgets.model.Widget
+import im.vector.matrix.android.api.util.JsonDict
+import im.vector.matrix.android.api.util.Optional
+import im.vector.matrix.android.api.util.toOptional
+import im.vector.matrix.android.internal.crypto.model.CryptoDeviceInfo
+import im.vector.matrix.android.internal.crypto.model.rest.DeviceInfo
+import im.vector.matrix.android.internal.crypto.store.PrivateKeysInfo
+import im.vector.matrix.android.internal.session.sync.model.accountdata.UserAccountDataEvent
 import io.reactivex.Observable
 import io.reactivex.Single
 
 class RxSession(private val session: Session) {
 
-    fun liveRoomSummaries(): Observable<List<RoomSummary>> {
-        return session.liveRoomSummaries().asObservable()
+    fun liveRoomSummaries(queryParams: RoomSummaryQueryParams): Observable<List<RoomSummary>> {
+        return session.getRoomSummariesLive(queryParams).asObservable()
+                .startWithCallable {
+                    session.getRoomSummaries(queryParams)
+                }
     }
 
-    fun liveGroupSummaries(): Observable<List<GroupSummary>> {
-        return session.liveGroupSummaries().asObservable()
+    fun liveGroupSummaries(queryParams: GroupSummaryQueryParams): Observable<List<GroupSummary>> {
+        return session.getGroupSummariesLive(queryParams).asObservable()
+                .startWithCallable {
+                    session.getGroupSummaries(queryParams)
+                }
+    }
+
+    fun liveBreadcrumbs(queryParams: RoomSummaryQueryParams): Observable<List<RoomSummary>> {
+        return session.getBreadcrumbsLive(queryParams).asObservable()
+                .startWithCallable {
+                    session.getBreadcrumbs(queryParams)
+                }
+    }
+
+    fun liveMyDeviceInfo(): Observable<List<DeviceInfo>> {
+        return session.cryptoService().getLiveMyDevicesInfo().asObservable()
+                .startWithCallable {
+                    session.cryptoService().getMyDevicesInfo()
+                }
     }
 
     fun liveSyncState(): Observable<SyncState> {
-        return session.syncState().asObservable()
+        return session.getSyncStateLive().asObservable()
     }
 
     fun livePushers(): Observable<List<Pusher>> {
-        return session.livePushers().asObservable()
+        return session.getPushersLive().asObservable()
+    }
+
+    fun liveUser(userId: String): Observable<Optional<User>> {
+        return session.getUserLive(userId).asObservable()
+                .startWithCallable {
+                    session.getUser(userId).toOptional()
+                }
     }
 
     fun liveUsers(): Observable<List<User>> {
-        return session.liveUsers().asObservable()
+        return session.getUsersLive().asObservable()
     }
 
-    fun livePagedUsers(filter: String? = null): Observable<PagedList<User>> {
-        return session.livePagedUsers(filter).asObservable()
+    fun liveIgnoredUsers(): Observable<List<User>> {
+        return session.getIgnoredUsersLive().asObservable()
     }
 
-    fun createRoom(roomParams: CreateRoomParams): Single<String> = Single.create {
-        session.createRoom(roomParams, MatrixCallbackSingle(it)).toSingle(it)
+    fun livePagedUsers(filter: String? = null, excludedUserIds: Set<String>? = null): Observable<PagedList<User>> {
+        return session.getPagedUsersLive(filter, excludedUserIds).asObservable()
+    }
+
+    fun liveThreePIds(refreshData: Boolean): Observable<List<ThreePid>> {
+        return session.getThreePidsLive(refreshData).asObservable()
+                .startWithCallable { session.getThreePids() }
+    }
+
+    fun createRoom(roomParams: CreateRoomParams): Single<String> = singleBuilder {
+        session.createRoom(roomParams, it)
     }
 
     fun searchUsersDirectory(search: String,
                              limit: Int,
-                             excludedUserIds: Set<String>): Single<List<User>> = Single.create {
-        session.searchUsersDirectory(search, limit, excludedUserIds, MatrixCallbackSingle(it)).toSingle(it)
+                             excludedUserIds: Set<String>): Single<List<User>> = singleBuilder {
+        session.searchUsersDirectory(search, limit, excludedUserIds, it)
     }
 
-    fun joinRoom(roomId: String, viaServers: List<String> = emptyList()): Single<Unit> = Single.create {
-        session.joinRoom(roomId, viaServers, MatrixCallbackSingle(it)).toSingle(it)
+    fun joinRoom(roomIdOrAlias: String,
+                 reason: String? = null,
+                 viaServers: List<String> = emptyList()): Single<Unit> = singleBuilder {
+        session.joinRoom(roomIdOrAlias, reason, viaServers, it)
     }
 
+    fun getRoomIdByAlias(roomAlias: String,
+                         searchOnServer: Boolean): Single<Optional<String>> = singleBuilder {
+        session.getRoomIdByAlias(roomAlias, searchOnServer, it)
+    }
+
+    fun getProfileInfo(userId: String): Single<JsonDict> = singleBuilder {
+        session.getProfile(userId, it)
+    }
+
+    fun liveUserCryptoDevices(userId: String): Observable<List<CryptoDeviceInfo>> {
+        return session.cryptoService().getLiveCryptoDeviceInfo(userId).asObservable().startWithCallable {
+            session.cryptoService().getCryptoDeviceInfo(userId)
+        }
+    }
+
+    fun liveCrossSigningInfo(userId: String): Observable<Optional<MXCrossSigningInfo>> {
+        return session.cryptoService().crossSigningService().getLiveCrossSigningKeys(userId).asObservable()
+                .startWithCallable {
+                    session.cryptoService().crossSigningService().getUserCrossSigningKeys(userId).toOptional()
+                }
+    }
+
+    fun liveCrossSigningPrivateKeys(): Observable<Optional<PrivateKeysInfo>> {
+        return session.cryptoService().crossSigningService().getLiveCrossSigningPrivateKeys().asObservable()
+                .startWithCallable {
+                    session.cryptoService().crossSigningService().getCrossSigningPrivateKeys().toOptional()
+                }
+    }
+
+    fun liveAccountData(types: Set<String>): Observable<List<UserAccountDataEvent>> {
+        return session.getLiveAccountDataEvents(types).asObservable()
+                .startWithCallable {
+                    session.getAccountDataEvents(types)
+                }
+    }
+
+    fun liveRoomWidgets(
+            roomId: String,
+            widgetId: QueryStringValue,
+            widgetTypes: Set<String>? = null,
+            excludedTypes: Set<String>? = null
+    ): Observable<List<Widget>> {
+        return session.widgetService().getRoomWidgetsLive(roomId, widgetId, widgetTypes, excludedTypes).asObservable()
+                .startWithCallable {
+                    session.widgetService().getRoomWidgets(roomId, widgetId, widgetTypes, excludedTypes)
+                }
+    }
 }
 
 fun Session.rx(): RxSession {
     return RxSession(this)
-}
+}

matrix-sdk-android/build.gradle

@@ -10,7 +10,7 @@ buildscript {
         jcenter()
     }
     dependencies {
-        classpath "io.realm:realm-gradle-plugin:5.12.0"
+        classpath "io.realm:realm-gradle-plugin:6.1.0"
     }
 }
 
@@ -19,22 +19,35 @@ androidExtensions {
 }
 
 android {
-    compileSdkVersion 28
+    compileSdkVersion 29
     testOptions.unitTests.includeAndroidResources = true
 
     defaultConfig {
-        minSdkVersion 16
-        targetSdkVersion 28
+        minSdkVersion 21
+        targetSdkVersion 29
         versionCode 1
         versionName "0.0.1"
         // Multidex is useful for tests
         multiDexEnabled true
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
 
+        // The following argument makes the Android Test Orchestrator run its
+        // "pm clear" command after each test invocation. This command ensures
+        // that the app's state is completely cleared between tests.
+        testInstrumentationRunnerArguments clearPackageData: 'true'
+
         buildConfigField "String", "GIT_SDK_REVISION", "\"${gitRevision()}\""
         resValue "string", "git_sdk_revision", "\"${gitRevision()}\""
         resValue "string", "git_sdk_revision_unix_date", "\"${gitRevisionUnixDate()}\""
         resValue "string", "git_sdk_revision_date", "\"${gitRevisionDate()}\""
+
+        defaultConfig {
+            consumerProguardFiles 'proguard-rules.pro'
+        }
+    }
+
+    testOptions {
+        execution 'ANDROIDX_TEST_ORCHESTRATOR'
     }
 
     buildTypes {
@@ -49,9 +62,6 @@ android {
         release {
             buildConfigField "boolean", "LOG_PRIVATE_DATA", "false"
             buildConfigField "okhttp3.logging.HttpLoggingInterceptor.Level", "OKHTTP_LOGGING_LEVEL", "okhttp3.logging.HttpLoggingInterceptor.Level.NONE"
-
-            minifyEnabled false
-            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
         }
     }
 
@@ -67,10 +77,23 @@ android {
         sourceCompatibility JavaVersion.VERSION_1_8
         targetCompatibility JavaVersion.VERSION_1_8
     }
+
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
+
+    sourceSets {
+        androidTest {
+            java.srcDirs += "src/sharedTest/java"
+        }
+        test {
+            java.srcDirs += "src/sharedTest/java"
+        }
+    }
 }
 
 static def gitRevision() {
-    def cmd = "git rev-parse --short HEAD"
+    def cmd = "git rev-parse --short=8 HEAD"
     return cmd.execute().text.trim()
 }
 
@@ -86,41 +109,45 @@ static def gitRevisionDate() {
 
 dependencies {
 
-    def arrow_version = "0.8.0"
-    def support_version = '1.1.0-beta01'
+    def arrow_version = "0.8.2"
     def moshi_version = '1.8.0'
-    def lifecycle_version = '2.0.0'
-    def coroutines_version = "1.0.1"
-    def markwon_version = '3.0.0'
-    def daggerVersion = '2.23.1'
+    def lifecycle_version = '2.2.0'
+    def arch_version = '2.1.0'
+    def coroutines_version = "1.3.2"
+    def markwon_version = '3.1.0'
+    def daggerVersion = '2.25.4'
+    def work_version = '2.3.3'
 
     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"
 
-    implementation "androidx.appcompat:appcompat:1.1.0-rc01"
-    implementation "androidx.recyclerview:recyclerview:1.1.0-beta01"
+    implementation "androidx.appcompat:appcompat:1.1.0"
+    implementation "androidx.core:core-ktx:1.1.0"
 
     implementation "androidx.lifecycle:lifecycle-extensions:$lifecycle_version"
-    kapt "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
+    implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"
 
     // Network
-    implementation 'com.squareup.retrofit2:retrofit:2.6.0'
-    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.2.0'
+    implementation 'com.squareup.retrofit2:retrofit:2.6.2'
+    implementation 'com.squareup.retrofit2:converter-moshi:2.6.2'
+    implementation 'com.squareup.okhttp3:okhttp:4.2.2'
+    implementation 'com.squareup.okhttp3:logging-interceptor:4.2.2'
     implementation "com.squareup.moshi:moshi-adapters:$moshi_version"
     kapt "com.squareup.moshi:moshi-kotlin-codegen:$moshi_version"
 
     implementation "ru.noties.markwon:core:$markwon_version"
 
+    // Image
+    implementation 'androidx.exifinterface:exifinterface:1.3.0-alpha01'
+    implementation 'id.zelory:compressor:3.0.0'
+
     // Database
     implementation 'com.github.Zhuinden:realm-monarchy:0.5.1'
     kapt 'dk.ilios:realmfieldnameshelper:1.1.1'
 
     // Work
-    implementation "androidx.work:work-runtime-ktx:2.1.0-rc01"
+    implementation "androidx.work:work-runtime-ktx:$work_version"
 
     // FP
     implementation "io.arrow-kt:arrow-core:$arrow_version"
@@ -132,32 +159,51 @@ dependencies {
     // DI
     implementation "com.google.dagger:dagger:$daggerVersion"
     kapt "com.google.dagger:dagger-compiler:$daggerVersion"
-    compileOnly 'com.squareup.inject:assisted-inject-annotations-dagger2:0.4.0'
-    kapt 'com.squareup.inject:assisted-inject-processor-dagger2:0.4.0'
+    compileOnly 'com.squareup.inject:assisted-inject-annotations-dagger2:0.5.0'
+    kapt 'com.squareup.inject:assisted-inject-processor-dagger2:0.5.0'
 
     // Logging
     implementation 'com.jakewharton.timber:timber:4.7.1'
-    implementation 'com.facebook.stetho:stetho-okhttp3:1.5.0'
+    implementation 'com.facebook.stetho:stetho-okhttp3:1.5.1'
 
-    debugImplementation 'com.airbnb.okreplay:okreplay:1.4.0'
-    releaseImplementation 'com.airbnb.okreplay:noop:1.4.0'
-    androidTestImplementation 'com.airbnb.okreplay:espresso:1.4.0'
+    // Bus
+    implementation 'org.greenrobot:eventbus:3.1.1'
+
+    // Phone number https://github.com/google/libphonenumber
+    implementation 'com.googlecode.libphonenumber:libphonenumber:8.10.23'
+
+    // Web RTC
+    // TODO meant for development purposes only. See http://webrtc.github.io/webrtc-org/native-code/android/
+    implementation 'org.webrtc:google-webrtc:1.0.+'
+
+    debugImplementation 'com.airbnb.okreplay:okreplay:1.5.0'
+    releaseImplementation 'com.airbnb.okreplay:noop:1.5.0'
+    androidTestImplementation 'com.airbnb.okreplay:espresso:1.5.0'
 
     testImplementation 'junit:junit:4.12'
-    testImplementation 'org.robolectric:robolectric:4.0.2'
+    testImplementation 'org.robolectric:robolectric:4.3'
     //testImplementation 'org.robolectric:shadows-support-v4:3.0'
-    testImplementation "io.mockk:mockk:1.8.13.kotlin13"
+    // Note: version sticks to 1.9.2 due to https://github.com/mockk/mockk/issues/281
+    testImplementation 'io.mockk:mockk:1.9.2.kotlin12'
     testImplementation 'org.amshove.kluent:kluent-android:1.44'
     testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$coroutines_version"
+    // Plant Timber tree for test
+    testImplementation 'net.lachlanmckee:timber-junit-rule:1.0.1'
 
+    kaptAndroidTest "com.google.dagger:dagger-compiler:$daggerVersion"
     androidTestImplementation 'androidx.test:core:1.2.0'
     androidTestImplementation 'androidx.test:runner:1.2.0'
     androidTestImplementation 'androidx.test:rules:1.2.0'
     androidTestImplementation 'androidx.test.ext:junit:1.1.1'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
     androidTestImplementation 'org.amshove.kluent:kluent-android:1.44'
-    androidTestImplementation "io.mockk:mockk-android:1.8.13.kotlin13"
-    androidTestImplementation "androidx.arch.core:core-testing:$lifecycle_version"
+    // Note: version sticks to 1.9.2 due to https://github.com/mockk/mockk/issues/281
+    androidTestImplementation 'io.mockk:mockk-android:1.9.2.kotlin12'
+    androidTestImplementation "androidx.arch.core:core-testing:$arch_version"
     androidTestImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$coroutines_version"
+    // Plant Timber tree for test
+    androidTestImplementation 'net.lachlanmckee:timber-junit-rule:1.0.1'
+
+    androidTestUtil 'androidx.test:orchestrator:1.2.0'
 
 }

matrix-sdk-android/proguard-rules.pro

@@ -19,3 +19,48 @@
 # If you keep the line number information, uncomment this to
 # hide the original source file name.
 #-renamesourcefileattribute SourceFile
+
+
+### EVENT BUS ###
+
+-keepattributes *Annotation*
+-keepclassmembers class * {
+    @org.greenrobot.eventbus.Subscribe <methods>;
+}
+-keep enum org.greenrobot.eventbus.ThreadMode { *; }
+
+### MOSHI ###
+
+# JSR 305 annotations are for embedding nullability information.
+
+-dontwarn javax.annotation.**
+
+-keepclasseswithmembers class * {
+    @com.squareup.moshi.* <methods>;
+}
+
+-keep @com.squareup.moshi.JsonQualifier interface *
+
+# Enum field names are used by the integrated EnumJsonAdapter.
+# values() is synthesized by the Kotlin compiler and is used by EnumJsonAdapter indirectly
+# Annotate enums with @JsonClass(generateAdapter = false) to use them with Moshi.
+-keepclassmembers @com.squareup.moshi.JsonClass class * extends java.lang.Enum {
+    <fields>;
+    **[] values();
+}
+
+-keep class kotlin.reflect.jvm.internal.impl.builtins.BuiltInsLoaderImpl
+
+-keepclassmembers class kotlin.Metadata {
+    public <methods>;
+}
+
+### OKHTTP for Android Studio ###
+-keep class okhttp3.Headers { *; }
+-keep interface okhttp3.Interceptor.* { *; }
+
+### OLM JNI ###
+-keep class org.matrix.olm.** { *; }
+
+### Webrtc
+-keep class org.webrtc.** { *; }

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/InstrumentedTest.kt

@@ -17,15 +17,21 @@
 package im.vector.matrix.android
 
 import android.content.Context
-import androidx.test.InstrumentationRegistry
+import androidx.test.core.app.ApplicationProvider
+import im.vector.matrix.android.test.shared.createTimberTestRule
+import org.junit.Rule
 import java.io.File
 
 interface InstrumentedTest {
+
+    @Rule
+    fun timberTestRule() = createTimberTestRule()
+
     fun context(): Context {
-        return InstrumentationRegistry.getTargetContext()
+        return ApplicationProvider.getApplicationContext()
     }
 
     fun cacheDir(): File {
         return context().cacheDir
     }
-}
+}

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/OkReplayRuleChainNoActivity.kt

@@ -29,4 +29,4 @@ class OkReplayRuleChainNoActivity(
         return RuleChain.outerRule(PermissionRule(configuration))
                 .around(RecorderRule(configuration))
     }
-}
+}

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/SingleThreadCoroutineDispatcher.kt

@@ -18,5 +18,8 @@ package im.vector.matrix.android
 
 import im.vector.matrix.android.internal.util.MatrixCoroutineDispatchers
 import kotlinx.coroutines.Dispatchers.Main
+import kotlinx.coroutines.asCoroutineDispatcher
+import java.util.concurrent.Executors
 
-internal val testCoroutineDispatchers = MatrixCoroutineDispatchers(Main, Main, Main, Main, Main)
+internal val testCoroutineDispatchers = MatrixCoroutineDispatchers(Main, Main, Main, Main,
+        Executors.newSingleThreadExecutor().asCoroutineDispatcher())

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/account/AccountCreationTest.kt

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2020 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.account
+
+import im.vector.matrix.android.InstrumentedTest
+import im.vector.matrix.android.common.CommonTestHelper
+import im.vector.matrix.android.common.CryptoTestHelper
+import im.vector.matrix.android.common.SessionTestParams
+import im.vector.matrix.android.common.TestConstants
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import org.junit.runners.MethodSorters
+
+@RunWith(JUnit4::class)
+@FixMethodOrder(MethodSorters.JVM)
+class AccountCreationTest : InstrumentedTest {
+
+    private val commonTestHelper = CommonTestHelper(context())
+    private val cryptoTestHelper = CryptoTestHelper(commonTestHelper)
+
+    @Test
+    fun createAccountTest() {
+        val session = commonTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(withInitialSync = true))
+
+        commonTestHelper.signOutAndClose(session)
+    }
+
+    @Test
+    fun createAccountAndLoginAgainTest() {
+        val session = commonTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(withInitialSync = true))
+
+        // Log again to the same account
+        val session2 = commonTestHelper.logIntoAccount(session.myUserId, SessionTestParams(withInitialSync = true))
+
+        commonTestHelper.signOutAndClose(session)
+        commonTestHelper.signOutAndClose(session2)
+    }
+
+    @Test
+    fun simpleE2eTest() {
+        val res = cryptoTestHelper.doE2ETestWithAliceInARoom()
+
+        res.cleanUp(commonTestHelper)
+    }
+}

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/account/ChangePasswordTest.kt

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2020 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.account
+
+import im.vector.matrix.android.InstrumentedTest
+import im.vector.matrix.android.api.failure.isInvalidPassword
+import im.vector.matrix.android.common.CommonTestHelper
+import im.vector.matrix.android.common.SessionTestParams
+import im.vector.matrix.android.common.TestConstants
+import org.amshove.kluent.shouldBeTrue
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import org.junit.runners.MethodSorters
+
+@RunWith(JUnit4::class)
+@FixMethodOrder(MethodSorters.JVM)
+class ChangePasswordTest : InstrumentedTest {
+
+    private val commonTestHelper = CommonTestHelper(context())
+
+    companion object {
+        private const val NEW_PASSWORD = "this is a new password"
+    }
+
+    @Test
+    fun changePasswordTest() {
+        val session = commonTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(withInitialSync = false))
+
+        // Change password
+        commonTestHelper.doSync<Unit> {
+            session.changePassword(TestConstants.PASSWORD, NEW_PASSWORD, it)
+        }
+
+        // Try to login with the previous password, it will fail
+        val throwable = commonTestHelper.logAccountWithError(session.myUserId, TestConstants.PASSWORD)
+        throwable.isInvalidPassword().shouldBeTrue()
+
+        // Try to login with the new password, should work
+        val session2 = commonTestHelper.logIntoAccount(session.myUserId, NEW_PASSWORD, SessionTestParams(withInitialSync = false))
+
+        commonTestHelper.signOutAndClose(session)
+        commonTestHelper.signOutAndClose(session2)
+    }
+}

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/account/DeactivateAccountTest.kt

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2020 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.account
+
+import im.vector.matrix.android.InstrumentedTest
+import im.vector.matrix.android.api.auth.data.LoginFlowResult
+import im.vector.matrix.android.api.auth.registration.RegistrationResult
+import im.vector.matrix.android.api.failure.Failure
+import im.vector.matrix.android.api.failure.MatrixError
+import im.vector.matrix.android.common.CommonTestHelper
+import im.vector.matrix.android.common.SessionTestParams
+import im.vector.matrix.android.common.TestConstants
+import im.vector.matrix.android.common.TestMatrixCallback
+import org.junit.Assert.assertTrue
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import org.junit.runners.MethodSorters
+
+@RunWith(JUnit4::class)
+@FixMethodOrder(MethodSorters.JVM)
+class DeactivateAccountTest : InstrumentedTest {
+
+    private val commonTestHelper = CommonTestHelper(context())
+
+    @Test
+    fun deactivateAccountTest() {
+        val session = commonTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(withInitialSync = false))
+
+        // Deactivate the account
+        commonTestHelper.doSync<Unit> {
+            session.deactivateAccount(TestConstants.PASSWORD, false, it)
+        }
+
+        // Try to login on the previous account, it will fail (M_USER_DEACTIVATED)
+        val throwable = commonTestHelper.logAccountWithError(session.myUserId, TestConstants.PASSWORD)
+
+        // Test the error
+        assertTrue(throwable is Failure.ServerError
+                && throwable.error.code == MatrixError.M_USER_DEACTIVATED
+                && throwable.error.message == "This account has been deactivated")
+
+        // Try to create an account with the deactivate account user id, it will fail (M_USER_IN_USE)
+        val hs = commonTestHelper.createHomeServerConfig()
+
+        commonTestHelper.doSync<LoginFlowResult> {
+            commonTestHelper.matrix.authenticationService.getLoginFlow(hs, it)
+        }
+
+        var accountCreationError: Throwable? = null
+        commonTestHelper.waitWithLatch {
+            commonTestHelper.matrix.authenticationService
+                    .getRegistrationWizard()
+                    .createAccount(session.myUserId.substringAfter("@").substringBefore(":"),
+                            TestConstants.PASSWORD,
+                            null,
+                            object : TestMatrixCallback<RegistrationResult>(it, false) {
+                                override fun onFailure(failure: Throwable) {
+                                    accountCreationError = failure
+                                    super.onFailure(failure)
+                                }
+                            })
+        }
+
+        // Test the error
+        accountCreationError.let {
+            assertTrue(it is Failure.ServerError
+                    && it.error.code == MatrixError.M_USER_IN_USE)
+        }
+
+        // No need to close the session, it has been deactivated
+    }
+}

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/api/Matrix.kt

@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2020 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
+
+import android.content.Context
+import androidx.lifecycle.ProcessLifecycleOwner
+import androidx.work.Configuration
+import androidx.work.WorkManager
+import com.zhuinden.monarchy.Monarchy
+import im.vector.matrix.android.BuildConfig
+import im.vector.matrix.android.api.auth.AuthenticationService
+import im.vector.matrix.android.common.DaggerTestMatrixComponent
+import im.vector.matrix.android.internal.SessionManager
+import im.vector.matrix.android.internal.crypto.attachments.ElementToDecrypt
+import im.vector.matrix.android.internal.crypto.attachments.MXEncryptedAttachments
+import im.vector.matrix.android.internal.network.UserAgentHolder
+import im.vector.matrix.android.internal.util.BackgroundDetectionObserver
+import org.matrix.olm.OlmManager
+import java.io.InputStream
+import java.util.concurrent.Executors
+import java.util.concurrent.atomic.AtomicBoolean
+import javax.inject.Inject
+
+/**
+ * This is the main entry point to the matrix sdk.
+ * To get the singleton instance, use getInstance static method.
+ */
+class Matrix private constructor(context: Context, matrixConfiguration: MatrixConfiguration)  {
+
+    @Inject internal lateinit var authenticationService: AuthenticationService
+    @Inject internal lateinit var userAgentHolder: UserAgentHolder
+    @Inject internal lateinit var backgroundDetectionObserver: BackgroundDetectionObserver
+    @Inject internal lateinit var olmManager: OlmManager
+    @Inject internal lateinit var sessionManager: SessionManager
+
+    init {
+        Monarchy.init(context)
+        DaggerTestMatrixComponent.factory().create(context, matrixConfiguration).inject(this)
+        if (context.applicationContext !is Configuration.Provider) {
+            WorkManager.initialize(context, Configuration.Builder().setExecutor(Executors.newCachedThreadPool()).build())
+        }
+        ProcessLifecycleOwner.get().lifecycle.addObserver(backgroundDetectionObserver)
+    }
+
+    fun getUserAgent() = userAgentHolder.userAgent
+
+    fun authenticationService(): AuthenticationService {
+        return authenticationService
+    }
+
+    companion object {
+
+        private lateinit var instance: Matrix
+        private val isInit = AtomicBoolean(false)
+
+        fun initialize(context: Context, matrixConfiguration: MatrixConfiguration) {
+            if (isInit.compareAndSet(false, true)) {
+                instance = Matrix(context.applicationContext, matrixConfiguration)
+            }
+        }
+
+        fun getInstance(context: Context): Matrix {
+            if (isInit.compareAndSet(false, true)) {
+                val appContext = context.applicationContext
+                if (appContext is MatrixConfiguration.Provider) {
+                    val matrixConfiguration = (appContext as MatrixConfiguration.Provider).providesMatrixConfiguration()
+                    instance = Matrix(appContext, matrixConfiguration)
+                } else {
+                    throw IllegalStateException("Matrix is not initialized properly." +
+                            " You should call Matrix.initialize or let your application implements MatrixConfiguration.Provider.")
+                }
+            }
+            return instance
+        }
+
+        fun getSdkVersion(): String {
+            return BuildConfig.VERSION_NAME + " (" + BuildConfig.GIT_SDK_REVISION + ")"
+        }
+
+        fun decryptStream(inputStream: InputStream?, elementToDecrypt: ElementToDecrypt): InputStream? {
+            return MXEncryptedAttachments.decryptAttachment(inputStream, elementToDecrypt)
+        }
+    }
+}

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/auth/AuthenticatorTest.kt

@@ -1,64 +0,0 @@
-/*
- * 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.auth
-
-import androidx.test.annotation.UiThreadTest
-import androidx.test.rule.GrantPermissionRule
-import androidx.test.runner.AndroidJUnit4
-import im.vector.matrix.android.InstrumentedTest
-import im.vector.matrix.android.OkReplayRuleChainNoActivity
-import im.vector.matrix.android.api.auth.Authenticator
-import okreplay.*
-import org.junit.ClassRule
-import org.junit.Rule
-import org.junit.Test
-import org.junit.runner.RunWith
-
-
-@RunWith(AndroidJUnit4::class)
-internal class AuthenticatorTest : InstrumentedTest {
-
-    lateinit var authenticator: Authenticator
-    lateinit var okReplayInterceptor: OkReplayInterceptor
-
-    private val okReplayConfig = OkReplayConfig.Builder()
-            .tapeRoot(AndroidTapeRoot(
-                    context(), javaClass))
-            .defaultMode(TapeMode.READ_WRITE) // or TapeMode.READ_ONLY
-            .sslEnabled(true)
-            .interceptor(okReplayInterceptor)
-            .build()
-
-    @get:Rule
-    val testRule = OkReplayRuleChainNoActivity(okReplayConfig).get()
-
-    @Test
-    @UiThreadTest
-    @OkReplay(tape = "auth", mode = TapeMode.READ_WRITE)
-    fun auth() {
-
-    }
-
-    companion object {
-        @ClassRule
-        @JvmField
-        val grantExternalStoragePermissionRule: GrantPermissionRule =
-                GrantPermissionRule.grant(android.Manifest.permission.WRITE_EXTERNAL_STORAGE)
-    }
-
-
-}

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/common/CommonTestHelper.kt

@@ -0,0 +1,383 @@
+/*
+ * Copyright 2016 OpenMarket Ltd
+ * Copyright 2018 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.common
+
+import android.content.Context
+import android.net.Uri
+import androidx.lifecycle.Observer
+import im.vector.matrix.android.api.Matrix
+import im.vector.matrix.android.api.MatrixCallback
+import im.vector.matrix.android.api.MatrixConfiguration
+import im.vector.matrix.android.api.auth.data.HomeServerConnectionConfig
+import im.vector.matrix.android.api.auth.data.LoginFlowResult
+import im.vector.matrix.android.api.auth.registration.RegistrationResult
+import im.vector.matrix.android.api.session.Session
+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.Room
+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.timeline.Timeline
+import im.vector.matrix.android.api.session.room.timeline.TimelineEvent
+import im.vector.matrix.android.api.session.room.timeline.TimelineSettings
+import im.vector.matrix.android.api.session.sync.SyncState
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import java.util.ArrayList
+import java.util.UUID
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+
+/**
+ * This class exposes methods to be used in common cases
+ * Registration, login, Sync, Sending messages...
+ */
+class CommonTestHelper(context: Context) {
+
+    val matrix: Matrix
+
+    fun getTestInterceptor(session: Session): MockOkHttpInterceptor? = TestNetworkModule.interceptorForSession(session.sessionId) as? MockOkHttpInterceptor
+
+    init {
+        Matrix.initialize(context, MatrixConfiguration("TestFlavor"))
+        matrix = Matrix.getInstance(context)
+    }
+
+    fun createAccount(userNamePrefix: String, testParams: SessionTestParams): Session {
+        return createAccount(userNamePrefix, TestConstants.PASSWORD, testParams)
+    }
+
+    fun logIntoAccount(userId: String, testParams: SessionTestParams): Session {
+        return logIntoAccount(userId, TestConstants.PASSWORD, testParams)
+    }
+
+    /**
+     * Create a Home server configuration, with Http connection allowed for test
+     */
+    fun createHomeServerConfig(): HomeServerConnectionConfig {
+        return HomeServerConnectionConfig.Builder()
+                .withHomeServerUri(Uri.parse(TestConstants.TESTS_HOME_SERVER_URL))
+                .build()
+    }
+
+    /**
+     * This methods init the event stream and check for initial sync
+     *
+     * @param session    the session to sync
+     */
+    fun syncSession(session: Session) {
+        val lock = CountDownLatch(1)
+
+        GlobalScope.launch(Dispatchers.Main) { session.open() }
+
+        session.startSync(true)
+
+        val syncLiveData = runBlocking(Dispatchers.Main) {
+            session.getSyncStateLive()
+        }
+        val syncObserver = object : Observer<SyncState> {
+            override fun onChanged(t: SyncState?) {
+                if (session.hasAlreadySynced()) {
+                    lock.countDown()
+                    syncLiveData.removeObserver(this)
+                }
+            }
+        }
+        GlobalScope.launch(Dispatchers.Main) { syncLiveData.observeForever(syncObserver) }
+
+        await(lock)
+    }
+
+    /**
+     * Sends text messages in a room
+     *
+     * @param room         the room where to send the messages
+     * @param message      the message to send
+     * @param nbOfMessages the number of time the message will be sent
+     */
+    fun sendTextMessage(room: Room, message: String, nbOfMessages: Int): List<TimelineEvent> {
+        val timeline = room.createTimeline(null, TimelineSettings(10))
+        val sentEvents = ArrayList<TimelineEvent>(nbOfMessages)
+        val latch = CountDownLatch(1)
+        val timelineListener = object : Timeline.Listener {
+            override fun onTimelineFailure(throwable: Throwable) {
+            }
+
+            override fun onNewTimelineEvents(eventIds: List<String>) {
+                // noop
+            }
+
+            override fun onTimelineUpdated(snapshot: List<TimelineEvent>) {
+                val newMessages = snapshot
+                        .filter { it.root.sendState == SendState.SYNCED }
+                        .filter { it.root.getClearType() == EventType.MESSAGE }
+                        .filter { it.root.getClearContent().toModel<MessageContent>()?.body?.startsWith(message) == true }
+
+                if (newMessages.size == nbOfMessages) {
+                    sentEvents.addAll(newMessages)
+                    // Remove listener now, if not at the next update sendEvents could change
+                    timeline.removeListener(this)
+                    latch.countDown()
+                }
+            }
+        }
+        timeline.start()
+        timeline.addListener(timelineListener)
+        for (i in 0 until nbOfMessages) {
+            room.sendTextMessage(message + " #" + (i + 1))
+        }
+        // Wait 3 second more per message
+        await(latch, timeout = TestConstants.timeOutMillis + 3_000L * nbOfMessages)
+        timeline.dispose()
+
+        // Check that all events has been created
+        assertEquals("Message number do not match $sentEvents", nbOfMessages.toLong(), sentEvents.size.toLong())
+
+        return sentEvents
+    }
+
+    // PRIVATE METHODS *****************************************************************************
+
+    /**
+     * Creates a unique account
+     *
+     * @param userNamePrefix the user name prefix
+     * @param password       the password
+     * @param testParams     test params about the session
+     * @return the session associated with the newly created account
+     */
+    private fun createAccount(userNamePrefix: String,
+                              password: String,
+                              testParams: SessionTestParams): Session {
+        val session = createAccountAndSync(
+                userNamePrefix + "_" + System.currentTimeMillis() + UUID.randomUUID(),
+                password,
+                testParams
+        )
+        assertNotNull(session)
+        return session
+    }
+
+    /**
+     * Logs into an existing account
+     *
+     * @param userId     the userId to log in
+     * @param password   the password to log in
+     * @param testParams test params about the session
+     * @return the session associated with the existing account
+     */
+    fun logIntoAccount(userId: String,
+                       password: String,
+                       testParams: SessionTestParams): Session {
+        val session = logAccountAndSync(userId, password, testParams)
+        assertNotNull(session)
+        return session
+    }
+
+    /**
+     * Create an account and a dedicated session
+     *
+     * @param userName          the account username
+     * @param password          the password
+     * @param sessionTestParams parameters for the test
+     */
+    private fun createAccountAndSync(userName: String,
+                                     password: String,
+                                     sessionTestParams: SessionTestParams): Session {
+        val hs = createHomeServerConfig()
+
+        doSync<LoginFlowResult> {
+            matrix.authenticationService
+                    .getLoginFlow(hs, it)
+        }
+
+        doSync<RegistrationResult> {
+            matrix.authenticationService
+                    .getRegistrationWizard()
+                    .createAccount(userName, password, null, it)
+        }
+
+        // Preform dummy step
+        val registrationResult = doSync<RegistrationResult> {
+            matrix.authenticationService
+                    .getRegistrationWizard()
+                    .dummy(it)
+        }
+
+        assertTrue(registrationResult is RegistrationResult.Success)
+        val session = (registrationResult as RegistrationResult.Success).session
+        if (sessionTestParams.withInitialSync) {
+            syncSession(session)
+        }
+
+        return session
+    }
+
+    /**
+     * Start an account login
+     *
+     * @param userName          the account username
+     * @param password          the password
+     * @param sessionTestParams session test params
+     */
+    private fun logAccountAndSync(userName: String,
+                                  password: String,
+                                  sessionTestParams: SessionTestParams): Session {
+        val hs = createHomeServerConfig()
+
+        doSync<LoginFlowResult> {
+            matrix.authenticationService
+                    .getLoginFlow(hs, it)
+        }
+
+        val session = doSync<Session> {
+            matrix.authenticationService
+                    .getLoginWizard()
+                    .login(userName, password, "myDevice", it)
+        }
+
+        if (sessionTestParams.withInitialSync) {
+            syncSession(session)
+        }
+
+        return session
+    }
+
+    /**
+     * Log into the account and expect an error
+     *
+     * @param userName the account username
+     * @param password the password
+     */
+    fun logAccountWithError(userName: String,
+                            password: String): Throwable {
+        val hs = createHomeServerConfig()
+
+        doSync<LoginFlowResult> {
+            matrix.authenticationService
+                    .getLoginFlow(hs, it)
+        }
+
+        var requestFailure: Throwable? = null
+        waitWithLatch { latch ->
+            matrix.authenticationService
+                    .getLoginWizard()
+                    .login(userName, password, "myDevice", object : TestMatrixCallback<Session>(latch, onlySuccessful = false) {
+                        override fun onFailure(failure: Throwable) {
+                            requestFailure = failure
+                            super.onFailure(failure)
+                        }
+                    })
+        }
+
+        assertNotNull(requestFailure)
+        return requestFailure!!
+    }
+
+    fun createEventListener(latch: CountDownLatch, predicate: (List<TimelineEvent>) -> Boolean): Timeline.Listener {
+        return object : Timeline.Listener {
+            override fun onTimelineFailure(throwable: Throwable) {
+                // noop
+            }
+
+            override fun onNewTimelineEvents(eventIds: List<String>) {
+                // noop
+            }
+
+            override fun onTimelineUpdated(snapshot: List<TimelineEvent>) {
+                if (predicate(snapshot)) {
+                    latch.countDown()
+                }
+            }
+        }
+    }
+
+    /**
+     * Await for a latch and ensure the result is true
+     *
+     * @param latch
+     * @throws InterruptedException
+     */
+    fun await(latch: CountDownLatch, timeout: Long? = TestConstants.timeOutMillis) {
+        assertTrue(latch.await(timeout ?: TestConstants.timeOutMillis, TimeUnit.MILLISECONDS))
+    }
+
+    fun retryPeriodicallyWithLatch(latch: CountDownLatch, condition: (() -> Boolean)) {
+        GlobalScope.launch {
+            while (true) {
+                delay(1000)
+                if (condition()) {
+                    latch.countDown()
+                    return@launch
+                }
+            }
+        }
+    }
+
+    fun waitWithLatch(timeout: Long? = TestConstants.timeOutMillis, block: (CountDownLatch) -> Unit) {
+        val latch = CountDownLatch(1)
+        block(latch)
+        await(latch, timeout)
+    }
+
+    // Transform a method with a MatrixCallback to a synchronous method
+    inline fun <reified T> doSync(block: (MatrixCallback<T>) -> Unit): T {
+        val lock = CountDownLatch(1)
+        var result: T? = null
+
+        val callback = object : TestMatrixCallback<T>(lock) {
+            override fun onSuccess(data: T) {
+                result = data
+                super.onSuccess(data)
+            }
+        }
+
+        block.invoke(callback)
+
+        await(lock)
+
+        assertNotNull(result)
+        return result!!
+    }
+
+    /**
+     * Clear all provided sessions
+     */
+    fun Iterable<Session>.signOutAndClose() = forEach { signOutAndClose(it) }
+
+    fun signOutAndClose(session: Session) {
+        doSync<Unit> { session.signOut(true, it) }
+        session.close()
+    }
+}
+
+fun List<TimelineEvent>.checkSendOrder(baseTextMessage: String, numberOfMessages: Int, startIndex: Int): Boolean {
+    return drop(startIndex)
+            .take(numberOfMessages)
+            .foldRightIndexed(true) { index, timelineEvent, acc ->
+        val body = timelineEvent.root.content.toModel<MessageContent>()?.body
+        val currentMessageSuffix = numberOfMessages - index
+        acc && (body == null || body.startsWith(baseTextMessage) && body.endsWith("#$currentMessageSuffix"))
+    }
+}

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/common/CryptoTestData.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2018 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.common
+
+import im.vector.matrix.android.api.session.Session
+
+data class CryptoTestData(val firstSession: Session,
+                          val roomId: String,
+                          val secondSession: Session? = null,
+                          val thirdSession: Session? = null) {
+
+    fun cleanUp(testHelper: CommonTestHelper) {
+        testHelper.signOutAndClose(firstSession)
+        secondSession?.let { testHelper.signOutAndClose(it) }
+        thirdSession?.let { testHelper.signOutAndClose(it) }
+    }
+}

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/common/CryptoTestHelper.kt

@@ -0,0 +1,422 @@
+/*
+ * Copyright 2018 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.common
+
+import android.os.SystemClock
+import android.util.Log
+import androidx.lifecycle.Observer
+import im.vector.matrix.android.api.session.Session
+import im.vector.matrix.android.api.session.crypto.verification.IncomingSasVerificationTransaction
+import im.vector.matrix.android.api.session.crypto.verification.OutgoingSasVerificationTransaction
+import im.vector.matrix.android.api.session.crypto.verification.VerificationMethod
+import im.vector.matrix.android.api.session.crypto.verification.VerificationTxState
+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.toContent
+import im.vector.matrix.android.api.session.room.Room
+import im.vector.matrix.android.api.session.room.model.Membership
+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.room.roomSummaryQueryParams
+import im.vector.matrix.android.api.session.room.timeline.Timeline
+import im.vector.matrix.android.api.session.room.timeline.TimelineEvent
+import im.vector.matrix.android.api.session.room.timeline.TimelineSettings
+import im.vector.matrix.android.internal.crypto.MXCRYPTO_ALGORITHM_MEGOLM
+import im.vector.matrix.android.internal.crypto.MXCRYPTO_ALGORITHM_MEGOLM_BACKUP
+import im.vector.matrix.android.internal.crypto.keysbackup.model.MegolmBackupAuthData
+import im.vector.matrix.android.internal.crypto.keysbackup.model.MegolmBackupCreationInfo
+import im.vector.matrix.android.internal.crypto.model.rest.UserPasswordAuth
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import java.util.UUID
+import java.util.concurrent.CountDownLatch
+
+class CryptoTestHelper(private val mTestHelper: CommonTestHelper) {
+
+    private val messagesFromAlice: List<String> = listOf("0 - Hello I'm Alice!", "4 - Go!")
+    private val messagesFromBob: List<String> = listOf("1 - Hello I'm Bob!", "2 - Isn't life grand?", "3 - Let's go to the opera.")
+
+    private val defaultSessionParams = SessionTestParams(true)
+
+    /**
+     * @return alice session
+     */
+    fun doE2ETestWithAliceInARoom(encryptedRoom: Boolean = true): CryptoTestData {
+        val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, defaultSessionParams)
+
+        val roomId = mTestHelper.doSync<String> {
+            aliceSession.createRoom(CreateRoomParams(name = "MyRoom"), it)
+        }
+
+        if (encryptedRoom) {
+            val room = aliceSession.getRoom(roomId)!!
+
+            mTestHelper.doSync<Unit> {
+                room.enableEncryption(callback = it)
+            }
+        }
+
+        return CryptoTestData(aliceSession, roomId)
+    }
+
+    /**
+     * @return alice and bob sessions
+     */
+    fun doE2ETestWithAliceAndBobInARoom(encryptedRoom: Boolean = true): CryptoTestData {
+        val cryptoTestData = doE2ETestWithAliceInARoom(encryptedRoom)
+        val aliceSession = cryptoTestData.firstSession
+        val aliceRoomId = cryptoTestData.roomId
+
+        val aliceRoom = aliceSession.getRoom(aliceRoomId)!!
+
+        val bobSession = mTestHelper.createAccount(TestConstants.USER_BOB, defaultSessionParams)
+
+        val lock1 = CountDownLatch(1)
+
+        val bobRoomSummariesLive = runBlocking(Dispatchers.Main) {
+            bobSession.getRoomSummariesLive(roomSummaryQueryParams { })
+        }
+
+        val newRoomObserver = object : Observer<List<RoomSummary>> {
+            override fun onChanged(t: List<RoomSummary>?) {
+                if (t?.isNotEmpty() == true) {
+                    lock1.countDown()
+                    bobRoomSummariesLive.removeObserver(this)
+                }
+            }
+        }
+
+        GlobalScope.launch(Dispatchers.Main) {
+            bobRoomSummariesLive.observeForever(newRoomObserver)
+        }
+
+        mTestHelper.doSync<Unit> {
+            aliceRoom.invite(bobSession.myUserId, callback = it)
+        }
+
+        mTestHelper.await(lock1)
+
+        val lock = CountDownLatch(1)
+
+        val roomJoinedObserver = object : Observer<List<RoomSummary>> {
+            override fun onChanged(t: List<RoomSummary>?) {
+                if (bobSession.getRoom(aliceRoomId)
+                                ?.getRoomMember(aliceSession.myUserId)
+                                ?.membership == Membership.JOIN) {
+                    lock.countDown()
+                    bobRoomSummariesLive.removeObserver(this)
+                }
+            }
+        }
+
+        GlobalScope.launch(Dispatchers.Main) {
+            bobRoomSummariesLive.observeForever(roomJoinedObserver)
+        }
+
+        mTestHelper.doSync<Unit> { bobSession.joinRoom(aliceRoomId, callback = it) }
+
+        mTestHelper.await(lock)
+
+        // Ensure bob can send messages to the room
+//        val roomFromBobPOV = bobSession.getRoom(aliceRoomId)!!
+//        assertNotNull(roomFromBobPOV.powerLevels)
+//        assertTrue(roomFromBobPOV.powerLevels.maySendMessage(bobSession.myUserId))
+
+        return CryptoTestData(aliceSession, aliceRoomId, bobSession)
+    }
+
+    /**
+     * @return Alice, Bob and Sam session
+     */
+    fun doE2ETestWithAliceAndBobAndSamInARoom(): CryptoTestData {
+        val cryptoTestData = doE2ETestWithAliceAndBobInARoom()
+        val aliceSession = cryptoTestData.firstSession
+        val aliceRoomId = cryptoTestData.roomId
+
+        val room = aliceSession.getRoom(aliceRoomId)!!
+
+        val samSession = createSamAccountAndInviteToTheRoom(room)
+
+        // wait the initial sync
+        SystemClock.sleep(1000)
+
+        return CryptoTestData(aliceSession, aliceRoomId, cryptoTestData.secondSession, samSession)
+    }
+
+    /**
+     * Create Sam account and invite him in the room. He will accept the invitation
+     * @Return Sam session
+     */
+    fun createSamAccountAndInviteToTheRoom(room: Room): Session {
+        val samSession = mTestHelper.createAccount(TestConstants.USER_SAM, defaultSessionParams)
+
+        mTestHelper.doSync<Unit> {
+            room.invite(samSession.myUserId, null, it)
+        }
+
+        mTestHelper.doSync<Unit> {
+            samSession.joinRoom(room.roomId, null, it)
+        }
+
+        return samSession
+    }
+
+    /**
+     * @return Alice and Bob sessions
+     */
+    fun doE2ETestWithAliceAndBobInARoomWithEncryptedMessages(): CryptoTestData {
+        val cryptoTestData = doE2ETestWithAliceAndBobInARoom()
+        val aliceSession = cryptoTestData.firstSession
+        val aliceRoomId = cryptoTestData.roomId
+        val bobSession = cryptoTestData.secondSession!!
+
+        bobSession.cryptoService().setWarnOnUnknownDevices(false)
+
+        aliceSession.cryptoService().setWarnOnUnknownDevices(false)
+
+        val roomFromBobPOV = bobSession.getRoom(aliceRoomId)!!
+        val roomFromAlicePOV = aliceSession.getRoom(aliceRoomId)!!
+
+        val lock = CountDownLatch(1)
+
+        val bobEventsListener = object : Timeline.Listener {
+            override fun onTimelineFailure(throwable: Throwable) {
+                // noop
+            }
+
+            override fun onNewTimelineEvents(eventIds: List<String>) {
+                // noop
+            }
+
+            override fun onTimelineUpdated(snapshot: List<TimelineEvent>) {
+                val messages = snapshot.filter { it.root.getClearType() == EventType.MESSAGE }
+                        .groupBy { it.root.senderId!! }
+
+                // Alice has sent 2 messages and Bob has sent 3 messages
+                if (messages[aliceSession.myUserId]?.size == 2 && messages[bobSession.myUserId]?.size == 3) {
+                    lock.countDown()
+                }
+            }
+        }
+
+        val bobTimeline = roomFromBobPOV.createTimeline(null, TimelineSettings(20))
+        bobTimeline.start()
+        bobTimeline.addListener(bobEventsListener)
+
+        // Alice sends a message
+        roomFromAlicePOV.sendTextMessage(messagesFromAlice[0])
+
+        // Bob send 3 messages
+        roomFromBobPOV.sendTextMessage(messagesFromBob[0])
+        roomFromBobPOV.sendTextMessage(messagesFromBob[1])
+        roomFromBobPOV.sendTextMessage(messagesFromBob[2])
+
+        // Alice sends a message
+        roomFromAlicePOV.sendTextMessage(messagesFromAlice[1])
+
+        mTestHelper.await(lock)
+
+        bobTimeline.removeListener(bobEventsListener)
+        bobTimeline.dispose()
+
+        return cryptoTestData
+    }
+
+    fun checkEncryptedEvent(event: Event, roomId: String, clearMessage: String, senderSession: Session) {
+        assertEquals(EventType.ENCRYPTED, event.type)
+        assertNotNull(event.content)
+
+        val eventWireContent = event.content.toContent()
+        assertNotNull(eventWireContent)
+
+        assertNull(eventWireContent["body"])
+        assertEquals(MXCRYPTO_ALGORITHM_MEGOLM, eventWireContent["algorithm"])
+
+        assertNotNull(eventWireContent["ciphertext"])
+        assertNotNull(eventWireContent["session_id"])
+        assertNotNull(eventWireContent["sender_key"])
+
+        assertEquals(senderSession.sessionParams.deviceId, eventWireContent["device_id"])
+
+        assertNotNull(event.eventId)
+        assertEquals(roomId, event.roomId)
+        assertEquals(EventType.MESSAGE, event.getClearType())
+        // TODO assertTrue(event.getAge() < 10000)
+
+        val eventContent = event.toContent()
+        assertNotNull(eventContent)
+        assertEquals(clearMessage, eventContent["body"])
+        assertEquals(senderSession.myUserId, event.senderId)
+    }
+
+    fun createFakeMegolmBackupAuthData(): MegolmBackupAuthData {
+        return MegolmBackupAuthData(
+                publicKey = "abcdefg",
+                signatures = mapOf("something" to mapOf("ed25519:something" to "hijklmnop"))
+        )
+    }
+
+    fun createFakeMegolmBackupCreationInfo(): MegolmBackupCreationInfo {
+        return MegolmBackupCreationInfo(
+                algorithm = MXCRYPTO_ALGORITHM_MEGOLM_BACKUP,
+                authData = createFakeMegolmBackupAuthData()
+        )
+    }
+
+    fun createDM(alice: Session, bob: Session): String {
+        val roomId = mTestHelper.doSync<String> {
+            alice.createRoom(
+                    CreateRoomParams(invitedUserIds = listOf(bob.myUserId))
+                            .setDirectMessage()
+                            .enableEncryptionIfInvitedUsersSupportIt(),
+                    it
+            )
+        }
+
+        mTestHelper.waitWithLatch { latch ->
+            val bobRoomSummariesLive = runBlocking(Dispatchers.Main) {
+                bob.getRoomSummariesLive(roomSummaryQueryParams { })
+            }
+
+            val newRoomObserver = object : Observer<List<RoomSummary>> {
+                override fun onChanged(t: List<RoomSummary>?) {
+                    val indexOfFirst = t?.indexOfFirst { it.roomId == roomId } ?: -1
+                    if (indexOfFirst != -1) {
+                        latch.countDown()
+                        bobRoomSummariesLive.removeObserver(this)
+                    }
+                }
+            }
+
+            GlobalScope.launch(Dispatchers.Main) {
+                bobRoomSummariesLive.observeForever(newRoomObserver)
+            }
+        }
+
+        mTestHelper.waitWithLatch { latch ->
+            val bobRoomSummariesLive = runBlocking(Dispatchers.Main) {
+                bob.getRoomSummariesLive(roomSummaryQueryParams { })
+            }
+
+            val newRoomObserver = object : Observer<List<RoomSummary>> {
+                override fun onChanged(t: List<RoomSummary>?) {
+                    if (bob.getRoom(roomId)
+                                    ?.getRoomMember(bob.myUserId)
+                                    ?.membership == Membership.JOIN) {
+                        latch.countDown()
+                        bobRoomSummariesLive.removeObserver(this)
+                    }
+                }
+            }
+
+            GlobalScope.launch(Dispatchers.Main) {
+                bobRoomSummariesLive.observeForever(newRoomObserver)
+            }
+
+            mTestHelper.doSync<Unit> { bob.joinRoom(roomId, callback = it) }
+        }
+
+        return roomId
+    }
+
+    fun initializeCrossSigning(session: Session) {
+        mTestHelper.doSync<Unit> {
+            session.cryptoService().crossSigningService()
+                    .initializeCrossSigning(UserPasswordAuth(
+                            user = session.myUserId,
+                            password = TestConstants.PASSWORD
+                    ), it)
+        }
+    }
+
+    fun verifySASCrossSign(alice: Session, bob: Session, roomId: String) {
+        assertTrue(alice.cryptoService().crossSigningService().canCrossSign())
+        assertTrue(bob.cryptoService().crossSigningService().canCrossSign())
+
+        val requestID = UUID.randomUUID().toString()
+        val aliceVerificationService = alice.cryptoService().verificationService()
+        val bobVerificationService = bob.cryptoService().verificationService()
+
+        aliceVerificationService.beginKeyVerificationInDMs(
+                VerificationMethod.SAS,
+                requestID,
+                roomId,
+                bob.myUserId,
+                bob.sessionParams.credentials.deviceId!!,
+                null)
+
+        // we should reach SHOW SAS on both
+        var alicePovTx: OutgoingSasVerificationTransaction? = null
+        var bobPovTx: IncomingSasVerificationTransaction? = null
+
+        // wait for alice to get the ready
+        mTestHelper.waitWithLatch {
+            mTestHelper.retryPeriodicallyWithLatch(it) {
+                bobPovTx = bobVerificationService.getExistingTransaction(alice.myUserId, requestID) as? IncomingSasVerificationTransaction
+                Log.v("TEST", "== bobPovTx is ${alicePovTx?.uxState}")
+                if (bobPovTx?.state == VerificationTxState.OnStarted) {
+                    bobPovTx?.performAccept()
+                    true
+                } else {
+                    false
+                }
+            }
+        }
+
+        mTestHelper.waitWithLatch {
+            mTestHelper.retryPeriodicallyWithLatch(it) {
+                alicePovTx = aliceVerificationService.getExistingTransaction(bob.myUserId, requestID) as? OutgoingSasVerificationTransaction
+                Log.v("TEST", "== alicePovTx is ${alicePovTx?.uxState}")
+                alicePovTx?.state == VerificationTxState.ShortCodeReady
+            }
+        }
+        // wait for alice to get the ready
+        mTestHelper.waitWithLatch {
+            mTestHelper.retryPeriodicallyWithLatch(it) {
+                bobPovTx = bobVerificationService.getExistingTransaction(alice.myUserId, requestID) as? IncomingSasVerificationTransaction
+                Log.v("TEST", "== bobPovTx is ${alicePovTx?.uxState}")
+                if (bobPovTx?.state == VerificationTxState.OnStarted) {
+                    bobPovTx?.performAccept()
+                }
+                bobPovTx?.state == VerificationTxState.ShortCodeReady
+            }
+        }
+
+        assertEquals("SAS code do not match", alicePovTx!!.getDecimalCodeRepresentation(), bobPovTx!!.getDecimalCodeRepresentation())
+
+        bobPovTx!!.userHasVerifiedShortCode()
+        alicePovTx!!.userHasVerifiedShortCode()
+
+        mTestHelper.waitWithLatch {
+            mTestHelper.retryPeriodicallyWithLatch(it) {
+                alice.cryptoService().crossSigningService().isUserTrusted(bob.myUserId)
+            }
+        }
+
+        mTestHelper.waitWithLatch {
+            mTestHelper.retryPeriodicallyWithLatch(it) {
+                alice.cryptoService().crossSigningService().isUserTrusted(bob.myUserId)
+            }
+        }
+    }
+}

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/common/MockOkHttpInterceptor.kt

@@ -0,0 +1,90 @@
+/*
+ * 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.common
+
+import im.vector.matrix.android.internal.session.TestInterceptor
+import okhttp3.Interceptor
+import okhttp3.Protocol
+import okhttp3.Request
+import okhttp3.Response
+import okhttp3.ResponseBody.Companion.toResponseBody
+import javax.net.ssl.HttpsURLConnection
+
+/**
+ * Allows to intercept network requests for test purpose by
+ *   - re-writing the response
+ *   - changing the response code (200/404/etc..).
+ *   - Test delays..
+ *
+ * Basic usage:
+ * <code>
+ *     val mockInterceptor = MockOkHttpInterceptor()
+ *      mockInterceptor.addRule(MockOkHttpInterceptor.SimpleRule(".well-known/matrix/client", 200, "{}"))
+ *
+ *      RestHttpClientFactoryProvider.defaultProvider = RestClientHttpClientFactory(mockInterceptor)
+ *      AutoDiscovery().findClientConfig("matrix.org", <callback>)
+ * </code>
+ */
+class MockOkHttpInterceptor : TestInterceptor {
+
+    private var rules: ArrayList<Rule> = ArrayList()
+
+    fun addRule(rule: Rule) {
+        rules.add(rule)
+    }
+
+    fun clearRules() {
+        rules.clear()
+    }
+
+    override var sessionId: String? = null
+
+    override fun intercept(chain: Interceptor.Chain): Response {
+        val originalRequest = chain.request()
+
+        rules.forEach { rule ->
+            if (originalRequest.url.toString().contains(rule.match)) {
+                rule.process(originalRequest)?.let {
+                    return it
+                }
+            }
+        }
+
+        return chain.proceed(originalRequest)
+    }
+
+    abstract class Rule(val match: String) {
+        abstract fun process(originalRequest: Request): Response?
+    }
+
+    /**
+     * Simple rule that reply with the given body for any request that matches the match param
+     */
+    class SimpleRule(match: String,
+                     private val code: Int = HttpsURLConnection.HTTP_OK,
+                     private val body: String = "{}") : Rule(match) {
+
+        override fun process(originalRequest: Request): Response? {
+            return Response.Builder()
+                    .protocol(Protocol.HTTP_1_1)
+                    .request(originalRequest)
+                    .message("mocked answer")
+                    .body(body.toResponseBody(null))
+                    .code(code)
+                    .build()
+        }
+    }
+}

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/common/SessionTestParams.kt

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2018 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.common
+
+data class SessionTestParams @JvmOverloads constructor(val withInitialSync: Boolean = false)

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/common/TestAssertUtil.kt

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2018 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.common
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.fail
+
+/**
+ * Compare two lists and their content
+ */
+fun assertListEquals(list1: List<Any>?, list2: List<Any>?) {
+    if (list1 == null) {
+        assertNull(list2)
+    } else {
+        assertNotNull(list2)
+
+        assertEquals("List sizes must match", list1.size, list2!!.size)
+
+        for (i in list1.indices) {
+            assertEquals("Elements at index $i are not equal", list1[i], list2[i])
+        }
+    }
+}
+
+/**
+ * Compare two maps and their content
+ */
+fun assertDictEquals(dict1: Map<String, Any>?, dict2: Map<String, Any>?) {
+    if (dict1 == null) {
+        assertNull(dict2)
+    } else {
+        assertNotNull(dict2)
+
+        assertEquals("Map sizes must match", dict1.size, dict2!!.size)
+
+        for (i in dict1.keys) {
+            assertEquals("Values for key $i are not equal", dict1[i], dict2[i])
+        }
+    }
+}
+
+/**
+ * Compare two byte arrays content.
+ * Note that if the arrays have not the same size, it also fails.
+ */
+fun assertByteArrayNotEqual(a1: ByteArray, a2: ByteArray) {
+    if (a1.size != a2.size) {
+        fail("Arrays have not the same size.")
+    }
+
+    for (index in a1.indices) {
+        if (a1[index] != a2[index]) {
+            // Difference found!
+            return
+        }
+    }
+
+    fail("Arrays are equals.")
+}

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/common/TestConstants.kt

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2018 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.common
+
+import android.os.Debug
+
+object TestConstants {
+
+    const val TESTS_HOME_SERVER_URL = "http://10.0.2.2:8080"
+
+    // Time out to use when waiting for server response. 20s
+    private const val AWAIT_TIME_OUT_MILLIS = 20_000
+
+    // Time out to use when waiting for server response, when the debugger is connected. 10 minutes
+    private const val AWAIT_TIME_OUT_WITH_DEBUGGER_MILLIS = 10 * 60_000
+
+    const val USER_ALICE = "Alice"
+    const val USER_BOB = "Bob"
+    const val USER_SAM = "Sam"
+
+    const val PASSWORD = "password"
+
+    val timeOutMillis: Long
+        get() = if (Debug.isDebuggerConnected()) {
+            // Wait more
+            AWAIT_TIME_OUT_WITH_DEBUGGER_MILLIS.toLong()
+        } else {
+            AWAIT_TIME_OUT_MILLIS.toLong()
+        }
+}

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/common/TestMatrixCallback.kt

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2018 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.common
+
+import androidx.annotation.CallSuper
+import im.vector.matrix.android.api.MatrixCallback
+import org.junit.Assert.fail
+import timber.log.Timber
+import java.util.concurrent.CountDownLatch
+
+/**
+ * Simple implementation of MatrixCallback, which count down the CountDownLatch on each API callback
+ * @param onlySuccessful true to fail if an error occurs. This is the default behavior
+ * @param <T>
+ */
+open class TestMatrixCallback<T>(private val countDownLatch: CountDownLatch,
+                                 private val onlySuccessful: Boolean = true) : MatrixCallback<T> {
+
+    @CallSuper
+    override fun onSuccess(data: T) {
+        countDownLatch.countDown()
+    }
+
+    @CallSuper
+    override fun onFailure(failure: Throwable) {
+        Timber.e(failure, "TestApiCallback")
+
+        if (onlySuccessful) {
+            fail("onFailure " + failure.localizedMessage)
+        }
+
+        countDownLatch.countDown()
+    }
+}

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/common/TestMatrixComponent.kt

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2020 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.common
+
+import android.content.Context
+import dagger.BindsInstance
+import dagger.Component
+import im.vector.matrix.android.api.MatrixConfiguration
+import im.vector.matrix.android.internal.auth.AuthModule
+import im.vector.matrix.android.internal.di.MatrixComponent
+import im.vector.matrix.android.internal.di.MatrixModule
+import im.vector.matrix.android.internal.di.MatrixScope
+import im.vector.matrix.android.internal.di.NetworkModule
+
+@Component(modules = [TestModule::class, MatrixModule::class, NetworkModule::class, AuthModule::class, TestNetworkModule::class])
+@MatrixScope
+internal interface TestMatrixComponent : MatrixComponent {
+
+    @Component.Factory
+    interface Factory {
+        fun create(@BindsInstance context: Context,
+                   @BindsInstance matrixConfiguration: MatrixConfiguration): TestMatrixComponent
+    }
+}

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/common/TestModule.kt

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2020 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.common
+
+import dagger.Binds
+import dagger.Module
+import im.vector.matrix.android.internal.di.MatrixComponent
+
+@Module
+internal abstract class TestModule {
+    @Binds
+    abstract fun providesMatrixComponent(testMatrixComponent: TestMatrixComponent): MatrixComponent
+}

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/common/TestNetworkModule.kt

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 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.common
+
+import dagger.Module
+import dagger.Provides
+import im.vector.matrix.android.internal.session.MockHttpInterceptor
+import im.vector.matrix.android.internal.session.TestInterceptor
+
+@Module
+internal object TestNetworkModule {
+
+    val interceptors = ArrayList<TestInterceptor>()
+
+    fun interceptorForSession(sessionId: String): TestInterceptor? = interceptors.firstOrNull { it.sessionId == sessionId }
+
+    @Provides
+    @JvmStatic
+    @MockHttpInterceptor
+    fun providesTestInterceptor(): TestInterceptor? {
+        return MockOkHttpInterceptor().also {
+            interceptors.add(it)
+        }
+    }
+}

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

@@ -0,0 +1,148 @@
+/*
+ * 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.internal.crypto
+
+import android.os.MemoryFile
+import android.util.Base64
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import im.vector.matrix.android.internal.crypto.attachments.MXEncryptedAttachments
+import im.vector.matrix.android.internal.crypto.model.rest.EncryptedFileInfo
+import im.vector.matrix.android.internal.crypto.model.rest.EncryptedFileKey
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertNotNull
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+import java.io.ByteArrayInputStream
+import java.io.InputStream
+
+/**
+ * Unit tests AttachmentEncryptionTest.
+ */
+@Suppress("SpellCheckingInspection")
+@RunWith(AndroidJUnit4::class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+class AttachmentEncryptionTest {
+
+    private fun checkDecryption(input: String, encryptedFileInfo: EncryptedFileInfo): String {
+        val `in` = Base64.decode(input, Base64.DEFAULT)
+
+        val inputStream: InputStream
+
+        inputStream = if (`in`.isEmpty()) {
+            ByteArrayInputStream(`in`)
+        } else {
+            val memoryFile = MemoryFile("file" + System.currentTimeMillis(), `in`.size)
+            memoryFile.outputStream.write(`in`)
+            memoryFile.inputStream
+        }
+
+        val decryptedStream = MXEncryptedAttachments.decryptAttachment(inputStream, encryptedFileInfo)
+
+        assertNotNull(decryptedStream)
+
+        val buffer = ByteArray(100)
+
+        val len = decryptedStream!!.read(buffer)
+
+        decryptedStream.close()
+
+        return Base64.encodeToString(buffer, 0, len, Base64.DEFAULT).replace("\n".toRegex(), "").replace("=".toRegex(), "")
+    }
+
+    @Test
+    fun checkDecrypt1() {
+        val encryptedFileInfo = EncryptedFileInfo(
+                v = "v2",
+                hashes = mapOf("sha256" to "47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU"),
+                key = EncryptedFileKey(
+                        alg = "A256CTR",
+                        k = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+                        key_ops = listOf("encrypt", "decrypt"),
+                        kty = "oct",
+                        ext = true
+                ),
+                iv = "AAAAAAAAAAAAAAAAAAAAAA",
+                url = "dummyUrl"
+        )
+
+        assertEquals("", checkDecryption("", encryptedFileInfo))
+    }
+
+    @Test
+    fun checkDecrypt2() {
+        val encryptedFileInfo = EncryptedFileInfo(
+                v = "v2",
+                hashes = mapOf("sha256" to "YzF08lARDdOCzJpzuSwsjTNlQc4pHxpdHcXiD/wpK6k"),
+                key = EncryptedFileKey(
+                        alg = "A256CTR",
+                        k = "__________________________________________8",
+                        key_ops = listOf("encrypt", "decrypt"),
+                        kty = "oct",
+                        ext = true
+                ),
+                iv = "//////////8AAAAAAAAAAA",
+                url = "dummyUrl"
+        )
+
+        assertEquals("SGVsbG8sIFdvcmxk", checkDecryption("5xJZTt5cQicm+9f4", encryptedFileInfo))
+    }
+
+    @Test
+    fun checkDecrypt3() {
+        val encryptedFileInfo = EncryptedFileInfo(
+                v = "v2",
+                hashes = mapOf("sha256" to "IOq7/dHHB+mfHfxlRY5XMeCWEwTPmlf4cJcgrkf6fVU"),
+                key = EncryptedFileKey(
+                        alg = "A256CTR",
+                        k = "__________________________________________8",
+                        key_ops = listOf("encrypt", "decrypt"),
+                        kty = "oct",
+                        ext = true
+                ),
+                iv = "//////////8AAAAAAAAAAA",
+                url = "dummyUrl"
+        )
+
+        assertEquals("YWxwaGFudW1lcmljYWxseWFscGhhbnVtZXJpY2FsbHlhbHBoYW51bWVyaWNhbGx5YWxwaGFudW1lcmljYWxseQ",
+                checkDecryption("zhtFStAeFx0s+9L/sSQO+WQMtldqYEHqTxMduJrCIpnkyer09kxJJuA4K+adQE4w+7jZe/vR9kIcqj9rOhDR8Q",
+                        encryptedFileInfo))
+    }
+
+    @Test
+    fun checkDecrypt4() {
+        val encryptedFileInfo = EncryptedFileInfo(
+                v = "v2",
+                hashes = mapOf("sha256" to "LYG/orOViuFwovJpv2YMLSsmVKwLt7pY3f8SYM7KU5E"),
+                key = EncryptedFileKey(
+                        alg = "A256CTR",
+                        k = "__________________________________________8",
+                        key_ops = listOf("encrypt", "decrypt"),
+                        kty = "oct",
+                        ext = true
+                ),
+                iv = "/////////////////////w",
+                url = "dummyUrl"
+        )
+
+        assertNotEquals("YWxwaGFudW1lcmljYWxseWFscGhhbnVtZXJpY2FsbHlhbHBoYW51bWVyaWNhbGx5YWxwaGFudW1lcmljYWxseQ",
+                checkDecryption("tJVNBVJ/vl36UQt4Y5e5m84bRUrQHhcdLPvS/7EkDvlkDLZXamBB6k8THbiawiKZ5Mnq9PZMSSbgOCvmnUBOMA",
+                        encryptedFileInfo))
+    }
+}

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

@@ -20,8 +20,10 @@ import im.vector.matrix.android.api.auth.data.Credentials
 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 im.vector.matrix.android.internal.crypto.store.db.mapper.CrossSigningKeysMapper
+import im.vector.matrix.android.internal.di.MoshiProvider
 import io.realm.RealmConfiguration
-import java.util.*
+import kotlin.random.Random
 
 internal class CryptoStoreHelper {
 
@@ -31,14 +33,15 @@ internal class CryptoStoreHelper {
                         .name("test.realm")
                         .modules(RealmCryptoStoreModule())
                         .build(),
+                crossSigningKeysMapper = CrossSigningKeysMapper(MoshiProvider.providesMoshi()),
                 credentials = createCredential())
     }
 
     fun createCredential() = Credentials(
-            userId = "userId_" + Random().nextInt(),
+            userId = "userId_" + Random.nextInt(),
             homeServer = "http://matrix.org",
             accessToken = "access_token",
             refreshToken = null,
             deviceId = "deviceId_sample"
     )
-}
+}

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

@@ -16,37 +16,50 @@
 
 package im.vector.matrix.android.internal.crypto
 
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import im.vector.matrix.android.InstrumentedTest
 import im.vector.matrix.android.internal.crypto.model.OlmSessionWrapper
 import im.vector.matrix.android.internal.crypto.store.IMXCryptoStore
-import org.junit.Assert.*
+import io.realm.Realm
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertNull
+import org.junit.Before
 import org.junit.Test
+import org.junit.runner.RunWith
 import org.matrix.olm.OlmAccount
 import org.matrix.olm.OlmManager
 import org.matrix.olm.OlmSession
 
 private const val DUMMY_DEVICE_KEY = "DeviceKey"
 
-class CryptoStoreTest {
+@RunWith(AndroidJUnit4::class)
+class CryptoStoreTest : InstrumentedTest {
 
     private val cryptoStoreHelper = CryptoStoreHelper()
 
-    @Test
-    fun test_metadata_realm_ok() {
-        val cryptoStore: IMXCryptoStore = cryptoStoreHelper.createStore()
-
-        assertFalse(cryptoStore.hasData())
-
-        cryptoStore.open()
-
-        assertEquals("deviceId_sample", cryptoStore.getDeviceId())
-
-        assertTrue(cryptoStore.hasData())
-
-        // Cleanup
-        cryptoStore.close()
-        cryptoStore.deleteStore()
+    @Before
+    fun setup() {
+        Realm.init(context())
     }
 
+//    @Test
+//    fun test_metadata_realm_ok() {
+//        val cryptoStore: IMXCryptoStore = cryptoStoreHelper.createStore()
+//
+//        assertFalse(cryptoStore.hasData())
+//
+//        cryptoStore.open()
+//
+//        assertEquals("deviceId_sample", cryptoStore.getDeviceId())
+//
+//        assertTrue(cryptoStore.hasData())
+//
+//        // Cleanup
+//        cryptoStore.close()
+//        cryptoStore.deleteStore()
+//    }
+
     @Test
     fun test_lastSessionUsed() {
         // Ensure Olm is initialized
@@ -114,4 +127,4 @@ class CryptoStoreTest {
         olmAccount1.releaseAccount()
         olmAccount2.releaseAccount()
     }
-}
+}

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

@@ -0,0 +1,208 @@
+/*
+ * Copyright 2018 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.internal.crypto
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+
+/**
+ * Unit tests ExportEncryptionTest.
+ */
+@RunWith(AndroidJUnit4::class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+class ExportEncryptionTest {
+
+    @Test
+    fun checkExportError1() {
+        val password = "password"
+        val input = "-----"
+        var failed = false
+
+        try {
+            MXMegolmExportEncryption.decryptMegolmKeyFile(input.toByteArray(charset("UTF-8")), password)
+        } catch (e: Exception) {
+            failed = true
+        }
+
+        assertTrue(failed)
+    }
+
+    @Test
+    fun checkExportError2() {
+        val password = "password"
+        val input = "-----BEGIN MEGOLM SESSION DATA-----\n" + "-----"
+        var failed = false
+
+        try {
+            MXMegolmExportEncryption.decryptMegolmKeyFile(input.toByteArray(charset("UTF-8")), password)
+        } catch (e: Exception) {
+            failed = true
+        }
+
+        assertTrue(failed)
+    }
+
+    @Test
+    fun checkExportError3() {
+        val password = "password"
+        val input = "-----BEGIN MEGOLM SESSION DATA-----\n" +
+                " AXNhbHRzYWx0c2FsdHNhbHSIiIiIiIiIiIiIiIiIiIiIAAAACmIRUW2OjZ3L2l6j9h0lHlV3M2dx\n" +
+                " cissyYBxjsfsAn\n" +
+                " -----END MEGOLM SESSION DATA-----"
+        var failed = false
+
+        try {
+            MXMegolmExportEncryption.decryptMegolmKeyFile(input.toByteArray(charset("UTF-8")), password)
+        } catch (e: Exception) {
+            failed = true
+        }
+
+        assertTrue(failed)
+    }
+
+    @Test
+    fun checkExportDecrypt1() {
+        val password = "password"
+        val input = "-----BEGIN MEGOLM SESSION DATA-----\nAXNhbHRzYWx0c2FsdHNhbHSIiIiIiIiIiIiIiIiIiIiIAAAACmIRUW2OjZ3L2l6j9h0lHlV3M2dx\n" + "cissyYBxjsfsAndErh065A8=\n-----END MEGOLM SESSION DATA-----"
+        val expectedString = "plain"
+
+        var decodedString: String? = null
+        try {
+            decodedString = MXMegolmExportEncryption.decryptMegolmKeyFile(input.toByteArray(charset("UTF-8")), password)
+        } catch (e: Exception) {
+            fail("## checkExportDecrypt1() failed : " + e.message)
+        }
+
+        assertEquals("## checkExportDecrypt1() : expectedString $expectedString -- decodedString $decodedString",
+                expectedString,
+                decodedString)
+    }
+
+    @Test
+    fun checkExportDecrypt2() {
+        val password = "betterpassword"
+        val input = "-----BEGIN MEGOLM SESSION DATA-----\nAW1vcmVzYWx0bW9yZXNhbHT//////////wAAAAAAAAAAAAAD6KyBpe1Niv5M5NPm4ZATsJo5nghk\n" + "KYu63a0YQ5DRhUWEKk7CcMkrKnAUiZny\n-----END MEGOLM SESSION DATA-----"
+        val expectedString = "Hello, World"
+
+        var decodedString: String? = null
+        try {
+            decodedString = MXMegolmExportEncryption.decryptMegolmKeyFile(input.toByteArray(charset("UTF-8")), password)
+        } catch (e: Exception) {
+            fail("## checkExportDecrypt2() failed : " + e.message)
+        }
+
+        assertEquals("## checkExportDecrypt2() : expectedString $expectedString -- decodedString $decodedString",
+                expectedString,
+                decodedString)
+    }
+
+    @Test
+    fun checkExportDecrypt3() {
+        val password = "SWORDFISH"
+        val input = "-----BEGIN MEGOLM SESSION DATA-----\nAXllc3NhbHR5Z29vZG5lc3P//////////wAAAAAAAAAAAAAD6OIW+Je7gwvjd4kYrb+49gKCfExw\n" + "MgJBMD4mrhLkmgAngwR1pHjbWXaoGybtiAYr0moQ93GrBQsCzPbvl82rZhaXO3iH5uHo/RCEpOqp\nPgg29363BGR+/Ripq/VCLKGNbw==\n-----END MEGOLM SESSION DATA-----"
+        val expectedString = "alphanumericallyalphanumericallyalphanumericallyalphanumerically"
+
+        var decodedString: String? = null
+        try {
+            decodedString = MXMegolmExportEncryption.decryptMegolmKeyFile(input.toByteArray(charset("UTF-8")), password)
+        } catch (e: Exception) {
+            fail("## checkExportDecrypt3() failed : " + e.message)
+        }
+
+        assertEquals("## checkExportDecrypt3() : expectedString $expectedString -- decodedString $decodedString",
+                expectedString,
+                decodedString)
+    }
+
+    @Test
+    fun checkExportEncrypt1() {
+        val password = "password"
+        val expectedString = "plain"
+        var decodedString: String? = null
+
+        try {
+            decodedString = MXMegolmExportEncryption
+                    .decryptMegolmKeyFile(MXMegolmExportEncryption.encryptMegolmKeyFile(expectedString, password, 1000), password)
+        } catch (e: Exception) {
+            fail("## checkExportEncrypt1() failed : " + e.message)
+        }
+
+        assertEquals("## checkExportEncrypt1() : expectedString $expectedString -- decodedString $decodedString",
+                expectedString,
+                decodedString)
+    }
+
+    @Test
+    fun checkExportEncrypt2() {
+        val password = "betterpassword"
+        val expectedString = "Hello, World"
+        var decodedString: String? = null
+
+        try {
+            decodedString = MXMegolmExportEncryption
+                    .decryptMegolmKeyFile(MXMegolmExportEncryption.encryptMegolmKeyFile(expectedString, password, 1000), password)
+        } catch (e: Exception) {
+            fail("## checkExportEncrypt2() failed : " + e.message)
+        }
+
+        assertEquals("## checkExportEncrypt2() : expectedString $expectedString -- decodedString $decodedString",
+                expectedString,
+                decodedString)
+    }
+
+    @Test
+    fun checkExportEncrypt3() {
+        val password = "SWORDFISH"
+        val expectedString = "alphanumericallyalphanumericallyalphanumericallyalphanumerically"
+        var decodedString: String? = null
+
+        try {
+            decodedString = MXMegolmExportEncryption
+                    .decryptMegolmKeyFile(MXMegolmExportEncryption.encryptMegolmKeyFile(expectedString, password, 1000), password)
+        } catch (e: Exception) {
+            fail("## checkExportEncrypt3() failed : " + e.message)
+        }
+
+        assertEquals("## checkExportEncrypt3() : expectedString $expectedString -- decodedString $decodedString",
+                expectedString,
+                decodedString)
+    }
+
+    @Test
+    fun checkExportEncrypt4() {
+        val password = "passwordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpassword" + "passwordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpassword"
+        val expectedString = "alphanumericallyalphanumericallyalphanumericallyalphanumerically"
+        var decodedString: String? = null
+
+        try {
+            decodedString = MXMegolmExportEncryption
+                    .decryptMegolmKeyFile(MXMegolmExportEncryption.encryptMegolmKeyFile(expectedString, password, 1000), password)
+        } catch (e: Exception) {
+            fail("## checkExportEncrypt4() failed : " + e.message)
+        }
+
+        assertEquals("## checkExportEncrypt4() : expectedString $expectedString -- decodedString $decodedString",
+                expectedString,
+                decodedString)
+    }
+}

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

@@ -0,0 +1,247 @@
+/*
+ * Copyright (c) 2020 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.internal.crypto
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import im.vector.matrix.android.InstrumentedTest
+import im.vector.matrix.android.api.extensions.tryThis
+import im.vector.matrix.android.api.session.crypto.MXCryptoError
+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.timeline.Timeline
+import im.vector.matrix.android.api.session.room.timeline.TimelineEvent
+import im.vector.matrix.android.api.session.room.timeline.TimelineSettings
+import im.vector.matrix.android.common.CommonTestHelper
+import im.vector.matrix.android.common.CryptoTestHelper
+import im.vector.matrix.android.common.TestConstants
+import im.vector.matrix.android.internal.crypto.model.OlmSessionWrapper
+import im.vector.matrix.android.internal.crypto.model.event.EncryptedEventContent
+import im.vector.matrix.android.internal.crypto.model.rest.UserPasswordAuth
+import im.vector.matrix.android.internal.crypto.store.db.deserializeFromRealm
+import im.vector.matrix.android.internal.crypto.store.db.serializeForRealm
+import org.amshove.kluent.shouldBe
+import org.junit.Assert
+import org.junit.Before
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+import org.matrix.olm.OlmSession
+import timber.log.Timber
+import java.util.concurrent.CountDownLatch
+
+/**
+ * Ref:
+ * - https://github.com/matrix-org/matrix-doc/pull/1719
+ * - https://matrix.org/docs/spec/client_server/latest#recovering-from-undecryptable-messages
+ * - https://github.com/matrix-org/matrix-js-sdk/pull/780
+ * - https://github.com/matrix-org/matrix-ios-sdk/pull/778
+ * - https://github.com/matrix-org/matrix-ios-sdk/pull/784
+ */
+@RunWith(AndroidJUnit4::class)
+@FixMethodOrder(MethodSorters.JVM)
+class UnwedgingTest : InstrumentedTest {
+
+    private lateinit var messagesReceivedByBob: List<TimelineEvent>
+    private val mTestHelper = CommonTestHelper(context())
+    private val mCryptoTestHelper = CryptoTestHelper(mTestHelper)
+
+    @Before
+    fun init() {
+        messagesReceivedByBob = emptyList()
+    }
+
+    /**
+     * - Alice & Bob in a e2e room
+     * - Alice sends a 1st message with a 1st megolm session
+     * - Store the olm session between A&B devices
+     * - Alice sends a 2nd message with a 2nd megolm session
+     * - Simulate Alice using a backup of her OS and make her crypto state like after the first message
+     * - Alice sends a 3rd message with a 3rd megolm session but a wedged olm session
+     *
+     * What Bob must see:
+     * -> No issue with the 2 first messages
+     * -> The third event must fail to decrypt at first because Bob the olm session is wedged
+     * -> This is automatically fixed after SDKs restarted the olm session
+     */
+    @Test
+    fun testUnwedging() {
+        val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom()
+
+        val aliceSession = cryptoTestData.firstSession
+        val aliceRoomId = cryptoTestData.roomId
+        val bobSession = cryptoTestData.secondSession!!
+
+        val aliceCryptoStore = (aliceSession.cryptoService() as DefaultCryptoService).cryptoStoreForTesting
+
+        // bobSession.cryptoService().setWarnOnUnknownDevices(false)
+        // aliceSession.cryptoService().setWarnOnUnknownDevices(false)
+
+        val roomFromBobPOV = bobSession.getRoom(aliceRoomId)!!
+        val roomFromAlicePOV = aliceSession.getRoom(aliceRoomId)!!
+
+        val bobTimeline = roomFromBobPOV.createTimeline(null, TimelineSettings(20))
+        bobTimeline.start()
+
+        val bobFinalLatch = CountDownLatch(1)
+        val bobHasThreeDecryptedEventsListener = object : Timeline.Listener {
+            override fun onTimelineFailure(throwable: Throwable) {
+                // noop
+            }
+
+            override fun onNewTimelineEvents(eventIds: List<String>) {
+                // noop
+            }
+
+            override fun onTimelineUpdated(snapshot: List<TimelineEvent>) {
+                val decryptedEventReceivedByBob = snapshot.filter { it.root.type == EventType.ENCRYPTED }
+                Timber.d("Bob can now decrypt ${decryptedEventReceivedByBob.size} messages")
+                if (decryptedEventReceivedByBob.size == 3) {
+                    if (decryptedEventReceivedByBob[0].root.mCryptoError == MXCryptoError.ErrorType.UNKNOWN_INBOUND_SESSION_ID) {
+                        bobFinalLatch.countDown()
+                    }
+                }
+            }
+        }
+        bobTimeline.addListener(bobHasThreeDecryptedEventsListener)
+
+        var latch = CountDownLatch(1)
+        var bobEventsListener = createEventListener(latch, 1)
+        bobTimeline.addListener(bobEventsListener)
+        messagesReceivedByBob = emptyList()
+
+        // - Alice sends a 1st message with a 1st megolm session
+        roomFromAlicePOV.sendTextMessage("First message")
+
+        // Wait for the message to be received by Bob
+        mTestHelper.await(latch)
+        bobTimeline.removeListener(bobEventsListener)
+
+        messagesReceivedByBob.size shouldBe 1
+        val firstMessageSession = messagesReceivedByBob[0].root.content.toModel<EncryptedEventContent>()!!.sessionId!!
+
+        //  - Store the olm session between A&B devices
+        // Let us pickle our session with bob here so we can later unpickle it
+        // and wedge our session.
+        val sessionIdsForBob = aliceCryptoStore.getDeviceSessionIds(bobSession.cryptoService().getMyDevice().identityKey()!!)
+        sessionIdsForBob!!.size shouldBe 1
+        val olmSession = aliceCryptoStore.getDeviceSession(sessionIdsForBob.first(), bobSession.cryptoService().getMyDevice().identityKey()!!)!!
+
+        val oldSession = serializeForRealm(olmSession.olmSession)
+
+        aliceSession.cryptoService().discardOutboundSession(roomFromAlicePOV.roomId)
+        Thread.sleep(6_000)
+
+        latch = CountDownLatch(1)
+        bobEventsListener = createEventListener(latch, 2)
+        bobTimeline.addListener(bobEventsListener)
+        messagesReceivedByBob = emptyList()
+
+        Timber.i("## CRYPTO | testUnwedging:  Alice sends a 2nd message with a 2nd megolm session")
+        // - Alice sends a 2nd message with a 2nd megolm session
+        roomFromAlicePOV.sendTextMessage("Second message")
+
+        // Wait for the message to be received by Bob
+        mTestHelper.await(latch)
+        bobTimeline.removeListener(bobEventsListener)
+
+        messagesReceivedByBob.size shouldBe 2
+        // Session should have changed
+        val secondMessageSession = messagesReceivedByBob[0].root.content.toModel<EncryptedEventContent>()!!.sessionId!!
+        Assert.assertNotEquals(firstMessageSession, secondMessageSession)
+
+        // Let us wedge the session now. Set crypto state like after the first message
+        Timber.i("## CRYPTO | testUnwedging: wedge the session now. Set crypto state like after the first message")
+
+        aliceCryptoStore.storeSession(OlmSessionWrapper(deserializeFromRealm<OlmSession>(oldSession)!!), bobSession.cryptoService().getMyDevice().identityKey()!!)
+        Thread.sleep(6_000)
+
+        // Force new session, and key share
+        aliceSession.cryptoService().discardOutboundSession(roomFromAlicePOV.roomId)
+
+        // Wait for the message to be received by Bob
+        mTestHelper.waitWithLatch {
+            bobEventsListener = createEventListener(it, 3)
+            bobTimeline.addListener(bobEventsListener)
+            messagesReceivedByBob = emptyList()
+
+            Timber.i("## CRYPTO | testUnwedging: Alice sends a 3rd message with a 3rd megolm session but a wedged olm session")
+            // - Alice sends a 3rd message with a 3rd megolm session but a wedged olm session
+            roomFromAlicePOV.sendTextMessage("Third message")
+            // Bob should not be able to decrypt, because the session key could not be sent
+        }
+        bobTimeline.removeListener(bobEventsListener)
+
+        messagesReceivedByBob.size shouldBe 3
+
+        val thirdMessageSession = messagesReceivedByBob[0].root.content.toModel<EncryptedEventContent>()!!.sessionId!!
+        Timber.i("## CRYPTO | testUnwedging: third message session ID $thirdMessageSession")
+        Assert.assertNotEquals(secondMessageSession, thirdMessageSession)
+
+        Assert.assertEquals(EventType.ENCRYPTED, messagesReceivedByBob[0].root.getClearType())
+        Assert.assertEquals(EventType.MESSAGE, messagesReceivedByBob[1].root.getClearType())
+        Assert.assertEquals(EventType.MESSAGE, messagesReceivedByBob[2].root.getClearType())
+        // Bob Should not be able to decrypt last message, because session could not be sent as the olm channel was wedged
+        mTestHelper.await(bobFinalLatch)
+        bobTimeline.removeListener(bobHasThreeDecryptedEventsListener)
+
+        // It's a trick to force key request on fail to decrypt
+        mTestHelper.doSync<Unit> {
+            bobSession.cryptoService().crossSigningService()
+                    .initializeCrossSigning(UserPasswordAuth(
+                            user = bobSession.myUserId,
+                            password = TestConstants.PASSWORD
+                    ), it)
+        }
+
+        // Wait until we received back the key
+        mTestHelper.waitWithLatch {
+            mTestHelper.retryPeriodicallyWithLatch(it) {
+                // we should get back the key and be able to decrypt
+                val result = tryThis {
+                    bobSession.cryptoService().decryptEvent(messagesReceivedByBob[0].root, "")
+                }
+                Timber.i("## CRYPTO | testUnwedging: decrypt result  ${result?.clearEvent}")
+                result != null
+            }
+        }
+
+        bobTimeline.dispose()
+
+        cryptoTestData.cleanUp(mTestHelper)
+    }
+
+    private fun createEventListener(latch: CountDownLatch, expectedNumberOfMessages: Int): Timeline.Listener {
+        return object : Timeline.Listener {
+            override fun onTimelineFailure(throwable: Throwable) {
+                // noop
+            }
+
+            override fun onNewTimelineEvents(eventIds: List<String>) {
+                // noop
+            }
+
+            override fun onTimelineUpdated(snapshot: List<TimelineEvent>) {
+                messagesReceivedByBob = snapshot.filter { it.root.type == EventType.ENCRYPTED }
+
+                if (messagesReceivedByBob.size == expectedNumberOfMessages) {
+                    latch.countDown()
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2020 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.internal.crypto.crosssigning
+
+import org.amshove.kluent.shouldBeNull
+import org.amshove.kluent.shouldBeTrue
+import org.junit.Test
+
+@Suppress("SpellCheckingInspection")
+class ExtensionsKtTest {
+
+    @Test
+    fun testComparingBase64StringWithOrWithoutPadding() {
+        // Without padding
+        "NMJyumnhMic".fromBase64().contentEquals("NMJyumnhMic".fromBase64()).shouldBeTrue()
+        // With padding
+        "NMJyumnhMic".fromBase64().contentEquals("NMJyumnhMic=".fromBase64()).shouldBeTrue()
+    }
+
+    @Test
+    fun testBadBase64() {
+        "===".fromBase64Safe().shouldBeNull()
+    }
+}

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

@@ -0,0 +1,161 @@
+package im.vector.matrix.android.internal.crypto.crosssigning
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import im.vector.matrix.android.InstrumentedTest
+import im.vector.matrix.android.common.CommonTestHelper
+import im.vector.matrix.android.common.CryptoTestHelper
+import im.vector.matrix.android.common.SessionTestParams
+import im.vector.matrix.android.common.TestConstants
+import im.vector.matrix.android.internal.crypto.model.CryptoDeviceInfo
+import im.vector.matrix.android.internal.crypto.model.MXUsersDevicesMap
+import im.vector.matrix.android.internal.crypto.model.rest.UserPasswordAuth
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+
+@RunWith(AndroidJUnit4::class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+class XSigningTest : InstrumentedTest {
+
+    private val mTestHelper = CommonTestHelper(context())
+    private val mCryptoTestHelper = CryptoTestHelper(mTestHelper)
+
+    @Test
+    fun test_InitializeAndStoreKeys() {
+        val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true))
+
+        mTestHelper.doSync<Unit> {
+            aliceSession.cryptoService().crossSigningService()
+                    .initializeCrossSigning(UserPasswordAuth(
+                            user = aliceSession.myUserId,
+                            password = TestConstants.PASSWORD
+                    ), it)
+        }
+
+        val myCrossSigningKeys = aliceSession.cryptoService().crossSigningService().getMyCrossSigningKeys()
+        val masterPubKey = myCrossSigningKeys?.masterKey()
+        assertNotNull("Master key should be stored", masterPubKey?.unpaddedBase64PublicKey)
+        val selfSigningKey = myCrossSigningKeys?.selfSigningKey()
+        assertNotNull("SelfSigned key should be stored", selfSigningKey?.unpaddedBase64PublicKey)
+        val userKey = myCrossSigningKeys?.userKey()
+        assertNotNull("User key should be stored", userKey?.unpaddedBase64PublicKey)
+
+        assertTrue("Signing Keys should be trusted", myCrossSigningKeys?.isTrusted() == true)
+
+        assertTrue("Signing Keys should be trusted", aliceSession.cryptoService().crossSigningService().checkUserTrust(aliceSession.myUserId).isVerified())
+
+        mTestHelper.signOutAndClose(aliceSession)
+    }
+
+    @Test
+    fun test_CrossSigningCheckBobSeesTheKeys() {
+        val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom()
+
+        val aliceSession = cryptoTestData.firstSession
+        val bobSession = cryptoTestData.secondSession
+
+        val aliceAuthParams = UserPasswordAuth(
+                user = aliceSession.myUserId,
+                password = TestConstants.PASSWORD
+        )
+        val bobAuthParams = UserPasswordAuth(
+                user = bobSession!!.myUserId,
+                password = TestConstants.PASSWORD
+        )
+
+        mTestHelper.doSync<Unit> { aliceSession.cryptoService().crossSigningService().initializeCrossSigning(aliceAuthParams, it) }
+        mTestHelper.doSync<Unit> { bobSession.cryptoService().crossSigningService().initializeCrossSigning(bobAuthParams, it) }
+
+        // Check that alice can see bob keys
+        mTestHelper.doSync<MXUsersDevicesMap<CryptoDeviceInfo>> { aliceSession.cryptoService().downloadKeys(listOf(bobSession.myUserId), true, it) }
+
+        val bobKeysFromAlicePOV = aliceSession.cryptoService().crossSigningService().getUserCrossSigningKeys(bobSession.myUserId)
+        assertNotNull("Alice can see bob Master key", bobKeysFromAlicePOV!!.masterKey())
+        assertNull("Alice should not see bob User key", bobKeysFromAlicePOV.userKey())
+        assertNotNull("Alice can see bob SelfSigned key", bobKeysFromAlicePOV.selfSigningKey())
+
+        assertEquals("Bob keys from alice pov should match", bobKeysFromAlicePOV.masterKey()?.unpaddedBase64PublicKey, bobSession.cryptoService().crossSigningService().getMyCrossSigningKeys()?.masterKey()?.unpaddedBase64PublicKey)
+        assertEquals("Bob keys from alice pov should match", bobKeysFromAlicePOV.selfSigningKey()?.unpaddedBase64PublicKey, bobSession.cryptoService().crossSigningService().getMyCrossSigningKeys()?.selfSigningKey()?.unpaddedBase64PublicKey)
+
+        assertFalse("Bob keys from alice pov should not be trusted", bobKeysFromAlicePOV.isTrusted())
+
+        mTestHelper.signOutAndClose(aliceSession)
+        mTestHelper.signOutAndClose(bobSession)
+    }
+
+    @Test
+    fun test_CrossSigningTestAliceTrustBobNewDevice() {
+        val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom()
+
+        val aliceSession = cryptoTestData.firstSession
+        val bobSession = cryptoTestData.secondSession
+
+        val aliceAuthParams = UserPasswordAuth(
+                user = aliceSession.myUserId,
+                password = TestConstants.PASSWORD
+        )
+        val bobAuthParams = UserPasswordAuth(
+                user = bobSession!!.myUserId,
+                password = TestConstants.PASSWORD
+        )
+
+        mTestHelper.doSync<Unit> { aliceSession.cryptoService().crossSigningService().initializeCrossSigning(aliceAuthParams, it) }
+        mTestHelper.doSync<Unit> { bobSession.cryptoService().crossSigningService().initializeCrossSigning(bobAuthParams, it) }
+
+        // Check that alice can see bob keys
+        val bobUserId = bobSession.myUserId
+        mTestHelper.doSync<MXUsersDevicesMap<CryptoDeviceInfo>> { aliceSession.cryptoService().downloadKeys(listOf(bobUserId), true, it) }
+
+        val bobKeysFromAlicePOV = aliceSession.cryptoService().crossSigningService().getUserCrossSigningKeys(bobUserId)
+        assertTrue("Bob keys from alice pov should not be trusted", bobKeysFromAlicePOV?.isTrusted() == false)
+
+        mTestHelper.doSync<Unit> { aliceSession.cryptoService().crossSigningService().trustUser(bobUserId, it) }
+
+        // Now bobs logs in on a new device and verifies it
+        // We will want to test that in alice POV, this new device would be trusted by cross signing
+
+        val bobSession2 = mTestHelper.logIntoAccount(bobUserId, SessionTestParams(true))
+        val bobSecondDeviceId = bobSession2.sessionParams.deviceId!!
+
+        // Check that bob first session sees the new login
+        val data = mTestHelper.doSync<MXUsersDevicesMap<CryptoDeviceInfo>> {
+            bobSession.cryptoService().downloadKeys(listOf(bobUserId), true, it)
+        }
+
+        if (data.getUserDeviceIds(bobUserId)?.contains(bobSecondDeviceId) == false) {
+            fail("Bob should see the new device")
+        }
+
+        val bobSecondDevicePOVFirstDevice = bobSession.cryptoService().getDeviceInfo(bobUserId, bobSecondDeviceId)
+        assertNotNull("Bob Second device should be known and persisted from first", bobSecondDevicePOVFirstDevice)
+
+        // Manually mark it as trusted from first session
+        mTestHelper.doSync<Unit> {
+            bobSession.cryptoService().crossSigningService().trustDevice(bobSecondDeviceId, it)
+        }
+
+        // Now alice should cross trust bob's second device
+        val data2 = mTestHelper.doSync<MXUsersDevicesMap<CryptoDeviceInfo>> {
+            aliceSession.cryptoService().downloadKeys(listOf(bobUserId), true, it)
+        }
+
+        // check that the device is seen
+        if (data2.getUserDeviceIds(bobUserId)?.contains(bobSecondDeviceId) == false) {
+            fail("Alice should see the new device")
+        }
+
+        val result = aliceSession.cryptoService().crossSigningService().checkDeviceTrust(bobUserId, bobSecondDeviceId, null)
+        assertTrue("Bob second device should be trusted from alice POV", result.isCrossSignedVerified())
+
+        mTestHelper.signOutAndClose(aliceSession)
+        mTestHelper.signOutAndClose(bobSession)
+        mTestHelper.signOutAndClose(bobSession2)
+    }
+}

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

@@ -0,0 +1,296 @@
+/*
+ * Copyright (c) 2020 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.internal.crypto.gossiping
+
+import android.util.Log
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import im.vector.matrix.android.InstrumentedTest
+import im.vector.matrix.android.api.session.crypto.verification.IncomingSasVerificationTransaction
+import im.vector.matrix.android.api.session.crypto.verification.SasVerificationTransaction
+import im.vector.matrix.android.api.session.crypto.verification.VerificationMethod
+import im.vector.matrix.android.api.session.crypto.verification.VerificationService
+import im.vector.matrix.android.api.session.crypto.verification.VerificationTransaction
+import im.vector.matrix.android.api.session.crypto.verification.VerificationTxState
+import im.vector.matrix.android.api.session.events.model.toModel
+import im.vector.matrix.android.api.session.room.model.RoomDirectoryVisibility
+import im.vector.matrix.android.api.session.room.model.create.CreateRoomParams
+import im.vector.matrix.android.common.CommonTestHelper
+import im.vector.matrix.android.common.CryptoTestHelper
+import im.vector.matrix.android.common.SessionTestParams
+import im.vector.matrix.android.common.TestConstants
+import im.vector.matrix.android.internal.crypto.GossipingRequestState
+import im.vector.matrix.android.internal.crypto.OutgoingGossipingRequestState
+import im.vector.matrix.android.internal.crypto.crosssigning.DeviceTrustLevel
+import im.vector.matrix.android.internal.crypto.keysbackup.model.MegolmBackupCreationInfo
+import im.vector.matrix.android.internal.crypto.keysbackup.model.rest.KeysVersion
+import im.vector.matrix.android.internal.crypto.model.CryptoDeviceInfo
+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.rest.UserPasswordAuth
+import junit.framework.TestCase.assertEquals
+import junit.framework.TestCase.assertNotNull
+import junit.framework.TestCase.assertTrue
+import junit.framework.TestCase.fail
+import org.junit.Assert
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+import java.util.concurrent.CountDownLatch
+
+@RunWith(AndroidJUnit4::class)
+@FixMethodOrder(MethodSorters.JVM)
+class KeyShareTests : InstrumentedTest {
+
+    private val mTestHelper = CommonTestHelper(context())
+    private val mCryptoTestHelper = CryptoTestHelper(mTestHelper)
+
+    @Test
+    fun test_DoNotSelfShareIfNotTrusted() {
+        val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true))
+
+        // Create an encrypted room and add a message
+        val roomId = mTestHelper.doSync<String> {
+            aliceSession.createRoom(
+                    CreateRoomParams(RoomDirectoryVisibility.PRIVATE).enableEncryptionWithAlgorithm(true),
+                    it
+            )
+        }
+        val room = aliceSession.getRoom(roomId)
+        assertNotNull(room)
+        Thread.sleep(4_000)
+        assertTrue(room?.isEncrypted() == true)
+        val sentEventId = mTestHelper.sendTextMessage(room!!, "My Message", 1).first().eventId
+
+        // Open a new sessionx
+
+        val aliceSession2 = mTestHelper.logIntoAccount(aliceSession.myUserId, SessionTestParams(true))
+
+        val roomSecondSessionPOV = aliceSession2.getRoom(roomId)
+
+        val receivedEvent = roomSecondSessionPOV?.getTimeLineEvent(sentEventId)
+        assertNotNull(receivedEvent)
+        assert(receivedEvent!!.isEncrypted())
+
+        try {
+            aliceSession2.cryptoService().decryptEvent(receivedEvent.root, "foo")
+            fail("should fail")
+        } catch (failure: Throwable) {
+        }
+
+        val outgoingRequestsBefore = aliceSession2.cryptoService().getOutgoingRoomKeyRequests()
+        // Try to request
+        aliceSession2.cryptoService().requestRoomKeyForEvent(receivedEvent.root)
+
+        val waitLatch = CountDownLatch(1)
+        val eventMegolmSessionId = receivedEvent.root.content.toModel<EncryptedEventContent>()?.sessionId
+
+        var outGoingRequestId: String? = null
+
+        mTestHelper.retryPeriodicallyWithLatch(waitLatch) {
+            aliceSession2.cryptoService().getOutgoingRoomKeyRequests()
+                    .filter { req ->
+                        // filter out request that was known before
+                        !outgoingRequestsBefore.any { req.requestId == it.requestId }
+                    }
+                    .let {
+                        val outgoing = it.firstOrNull { it.sessionId == eventMegolmSessionId }
+                        outGoingRequestId = outgoing?.requestId
+                        outgoing != null
+                    }
+        }
+        mTestHelper.await(waitLatch)
+
+        Log.v("TEST", "=======> Outgoing requet Id is $outGoingRequestId")
+
+        val outgoingRequestAfter = aliceSession2.cryptoService().getOutgoingRoomKeyRequests()
+
+        // We should have a new request
+        Assert.assertTrue(outgoingRequestAfter.size > outgoingRequestsBefore.size)
+        Assert.assertNotNull(outgoingRequestAfter.first { it.sessionId == eventMegolmSessionId })
+
+        // The first session should see an incoming request
+        // the request should be refused, because the device is not trusted
+        mTestHelper.waitWithLatch { latch ->
+            mTestHelper.retryPeriodicallyWithLatch(latch) {
+                // DEBUG LOGS
+                aliceSession.cryptoService().getIncomingRoomKeyRequests().let {
+                    Log.v("TEST", "Incoming request Session 1 (looking for $outGoingRequestId)")
+                    Log.v("TEST", "=========================")
+                    it.forEach { keyRequest ->
+                        Log.v("TEST", "[ts${keyRequest.localCreationTimestamp}] requestId ${keyRequest.requestId}, for sessionId ${keyRequest.requestBody?.sessionId} is ${keyRequest.state}")
+                    }
+                    Log.v("TEST", "=========================")
+                }
+
+                val incoming = aliceSession.cryptoService().getIncomingRoomKeyRequests().firstOrNull { it.requestId == outGoingRequestId }
+                incoming?.state == GossipingRequestState.REJECTED
+            }
+        }
+
+        try {
+            aliceSession2.cryptoService().decryptEvent(receivedEvent.root, "foo")
+            fail("should fail")
+        } catch (failure: Throwable) {
+        }
+
+        // Mark the device as trusted
+        aliceSession.cryptoService().setDeviceVerification(DeviceTrustLevel(crossSigningVerified = false, locallyVerified = true), aliceSession.myUserId,
+                aliceSession2.sessionParams.deviceId ?: "")
+
+        // Re request
+        aliceSession2.cryptoService().reRequestRoomKeyForEvent(receivedEvent.root)
+
+        mTestHelper.waitWithLatch { latch ->
+            mTestHelper.retryPeriodicallyWithLatch(latch) {
+                aliceSession.cryptoService().getIncomingRoomKeyRequests().let {
+                    Log.v("TEST", "Incoming request Session 1")
+                    Log.v("TEST", "=========================")
+                    it.forEach {
+                        Log.v("TEST", "requestId ${it.requestId}, for sessionId ${it.requestBody?.sessionId} is ${it.state}")
+                    }
+                    Log.v("TEST", "=========================")
+
+                    it.any { it.requestBody?.sessionId == eventMegolmSessionId && it.state == GossipingRequestState.ACCEPTED }
+                }
+            }
+        }
+
+        Thread.sleep(6_000)
+        mTestHelper.waitWithLatch { latch ->
+            mTestHelper.retryPeriodicallyWithLatch(latch) {
+                aliceSession2.cryptoService().getOutgoingRoomKeyRequests().let {
+                    it.any { it.requestBody?.sessionId == eventMegolmSessionId && it.state == OutgoingGossipingRequestState.CANCELLED }
+                }
+            }
+        }
+
+        try {
+            aliceSession2.cryptoService().decryptEvent(receivedEvent.root, "foo")
+        } catch (failure: Throwable) {
+            fail("should have been able to decrypt")
+        }
+
+        mTestHelper.signOutAndClose(aliceSession)
+        mTestHelper.signOutAndClose(aliceSession2)
+    }
+
+    @Test
+    fun test_ShareSSSSSecret() {
+        val aliceSession1 = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true))
+
+        mTestHelper.doSync<Unit> {
+            aliceSession1.cryptoService().crossSigningService()
+                    .initializeCrossSigning(UserPasswordAuth(
+                            user = aliceSession1.myUserId,
+                            password = TestConstants.PASSWORD
+                    ), it)
+        }
+
+        // Also bootstrap keybackup on first session
+        val creationInfo = mTestHelper.doSync<MegolmBackupCreationInfo> {
+            aliceSession1.cryptoService().keysBackupService().prepareKeysBackupVersion(null, null, it)
+        }
+        val version = mTestHelper.doSync<KeysVersion> {
+            aliceSession1.cryptoService().keysBackupService().createKeysBackupVersion(creationInfo, it)
+        }
+        // Save it for gossiping
+        aliceSession1.cryptoService().keysBackupService().saveBackupRecoveryKey(creationInfo.recoveryKey, version = version.version)
+
+        val aliceSession2 = mTestHelper.logIntoAccount(aliceSession1.myUserId, SessionTestParams(true))
+
+        val aliceVerificationService1 = aliceSession1.cryptoService().verificationService()
+        val aliceVerificationService2 = aliceSession2.cryptoService().verificationService()
+
+        // force keys download
+        mTestHelper.doSync<MXUsersDevicesMap<CryptoDeviceInfo>> {
+            aliceSession1.cryptoService().downloadKeys(listOf(aliceSession1.myUserId), true, it)
+        }
+        mTestHelper.doSync<MXUsersDevicesMap<CryptoDeviceInfo>> {
+            aliceSession2.cryptoService().downloadKeys(listOf(aliceSession2.myUserId), true, it)
+        }
+
+        var session1ShortCode: String? = null
+        var session2ShortCode: String? = null
+
+        aliceVerificationService1.addListener(object : VerificationService.Listener {
+            override fun transactionUpdated(tx: VerificationTransaction) {
+                Log.d("#TEST", "AA: tx incoming?:${tx.isIncoming} state ${tx.state}")
+                if (tx is SasVerificationTransaction) {
+                    if (tx.state == VerificationTxState.OnStarted) {
+                        (tx as IncomingSasVerificationTransaction).performAccept()
+                    }
+                    if (tx.state == VerificationTxState.ShortCodeReady) {
+                        session1ShortCode = tx.getDecimalCodeRepresentation()
+                        Thread.sleep(500)
+                        tx.userHasVerifiedShortCode()
+                    }
+                }
+            }
+        })
+
+        aliceVerificationService2.addListener(object : VerificationService.Listener {
+            override fun transactionUpdated(tx: VerificationTransaction) {
+                Log.d("#TEST", "BB: tx incoming?:${tx.isIncoming} state ${tx.state}")
+                if (tx is SasVerificationTransaction) {
+                    if (tx.state == VerificationTxState.ShortCodeReady) {
+                        session2ShortCode = tx.getDecimalCodeRepresentation()
+                        Thread.sleep(500)
+                        tx.userHasVerifiedShortCode()
+                    }
+                }
+            }
+        })
+
+        val txId = "m.testVerif12"
+        aliceVerificationService2.beginKeyVerification(VerificationMethod.SAS, aliceSession1.myUserId, aliceSession1.sessionParams.deviceId
+                ?: "", txId)
+
+        mTestHelper.waitWithLatch { latch ->
+            mTestHelper.retryPeriodicallyWithLatch(latch) {
+                aliceSession1.cryptoService().getDeviceInfo(aliceSession1.myUserId, aliceSession2.sessionParams.deviceId ?: "")?.isVerified == true
+            }
+        }
+
+        assertNotNull(session1ShortCode)
+        Log.d("#TEST", "session1ShortCode: $session1ShortCode")
+        assertNotNull(session2ShortCode)
+        Log.d("#TEST", "session2ShortCode: $session2ShortCode")
+        assertEquals(session1ShortCode, session2ShortCode)
+
+        // SSK and USK private keys should have been shared
+
+        mTestHelper.waitWithLatch(60_000) { latch ->
+            mTestHelper.retryPeriodicallyWithLatch(latch) {
+                Log.d("#TEST", "CAN XS :${aliceSession2.cryptoService().crossSigningService().getMyCrossSigningKeys()}")
+                aliceSession2.cryptoService().crossSigningService().canCrossSign()
+            }
+        }
+
+        // Test that key backup key has been shared to
+        mTestHelper.waitWithLatch(60_000) { latch ->
+            val keysBackupService = aliceSession2.cryptoService().keysBackupService()
+            mTestHelper.retryPeriodicallyWithLatch(latch) {
+                Log.d("#TEST", "Recovery :${ keysBackupService.getKeyBackupRecoveryKeyInfo()?.recoveryKey}")
+                keysBackupService.getKeyBackupRecoveryKeyInfo()?.recoveryKey == creationInfo.recoveryKey
+            }
+        }
+
+        mTestHelper.signOutAndClose(aliceSession1)
+        mTestHelper.signOutAndClose(aliceSession2)
+    }
+}

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

@@ -0,0 +1,245 @@
+/*
+ * Copyright (c) 2020 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.internal.crypto.gossiping
+
+import android.util.Log
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import im.vector.matrix.android.InstrumentedTest
+import im.vector.matrix.android.api.NoOpMatrixCallback
+import im.vector.matrix.android.api.extensions.tryThis
+import im.vector.matrix.android.api.session.crypto.MXCryptoError
+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.common.CommonTestHelper
+import im.vector.matrix.android.common.CryptoTestHelper
+import im.vector.matrix.android.common.MockOkHttpInterceptor
+import im.vector.matrix.android.common.SessionTestParams
+import im.vector.matrix.android.common.TestConstants
+import im.vector.matrix.android.internal.crypto.model.event.EncryptedEventContent
+import im.vector.matrix.android.internal.crypto.model.event.WithHeldCode
+import org.junit.Assert
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+
+@RunWith(AndroidJUnit4::class)
+@FixMethodOrder(MethodSorters.JVM)
+class WithHeldTests : InstrumentedTest {
+
+    private val mTestHelper = CommonTestHelper(context())
+    private val mCryptoTestHelper = CryptoTestHelper(mTestHelper)
+
+    @Test
+    fun test_WithHeldUnverifiedReason() {
+        // =============================
+        // ARRANGE
+        // =============================
+
+        val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true))
+        val bobSession = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true))
+
+        // Initialize cross signing on both
+        mCryptoTestHelper.initializeCrossSigning(aliceSession)
+        mCryptoTestHelper.initializeCrossSigning(bobSession)
+
+        val roomId = mCryptoTestHelper.createDM(aliceSession, bobSession)
+        mCryptoTestHelper.verifySASCrossSign(aliceSession, bobSession, roomId)
+
+        val roomAlicePOV = aliceSession.getRoom(roomId)!!
+
+        val bobUnverifiedSession = mTestHelper.logIntoAccount(bobSession.myUserId, SessionTestParams(true))
+
+        // =============================
+        // ACT
+        // =============================
+
+        // Alice decide to not send to unverified sessions
+        aliceSession.cryptoService().setGlobalBlacklistUnverifiedDevices(true)
+
+        val timelineEvent = mTestHelper.sendTextMessage(roomAlicePOV, "Hello Bob", 1).first()
+
+        // await for bob unverified session to get the message
+        mTestHelper.waitWithLatch { latch ->
+            mTestHelper.retryPeriodicallyWithLatch(latch) {
+                bobUnverifiedSession.getRoom(roomId)?.getTimeLineEvent(timelineEvent.eventId) != null
+            }
+        }
+
+        val eventBobPOV = bobUnverifiedSession.getRoom(roomId)?.getTimeLineEvent(timelineEvent.eventId)!!
+
+        // =============================
+        // ASSERT
+        // =============================
+
+        // Bob should not be able to decrypt because the keys is withheld
+        try {
+            // .. might need to wait a bit for stability?
+            bobUnverifiedSession.cryptoService().decryptEvent(eventBobPOV.root, "")
+            Assert.fail("This session should not be able to decrypt")
+        } catch (failure: Throwable) {
+            val type = (failure as MXCryptoError.Base).errorType
+            val technicalMessage = failure.technicalMessage
+            Assert.assertEquals("Error should be withheld", MXCryptoError.ErrorType.KEYS_WITHHELD, type)
+            Assert.assertEquals("Cause should be unverified", WithHeldCode.UNVERIFIED.value, technicalMessage)
+        }
+
+        // enable back sending to unverified
+        aliceSession.cryptoService().setGlobalBlacklistUnverifiedDevices(false)
+
+        val secondEvent = mTestHelper.sendTextMessage(roomAlicePOV, "Verify your device!!", 1).first()
+
+        mTestHelper.waitWithLatch { latch ->
+            mTestHelper.retryPeriodicallyWithLatch(latch) {
+                val ev = bobUnverifiedSession.getRoom(roomId)?.getTimeLineEvent(secondEvent.eventId)
+                // wait until it's decrypted
+                ev?.root?.getClearType() == EventType.MESSAGE
+            }
+        }
+
+        // Previous message should still be undecryptable (partially withheld session)
+        try {
+            // .. might need to wait a bit for stability?
+            bobUnverifiedSession.cryptoService().decryptEvent(eventBobPOV.root, "")
+            Assert.fail("This session should not be able to decrypt")
+        } catch (failure: Throwable) {
+            val type = (failure as MXCryptoError.Base).errorType
+            val technicalMessage = failure.technicalMessage
+            Assert.assertEquals("Error should be withheld", MXCryptoError.ErrorType.KEYS_WITHHELD, type)
+            Assert.assertEquals("Cause should be unverified", WithHeldCode.UNVERIFIED.value, technicalMessage)
+        }
+
+        mTestHelper.signOutAndClose(aliceSession)
+        mTestHelper.signOutAndClose(bobSession)
+        mTestHelper.signOutAndClose(bobUnverifiedSession)
+    }
+
+    @Test
+    fun  test_WithHeldNoOlm() {
+        val testData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom()
+        val aliceSession = testData.firstSession
+        val bobSession = testData.secondSession!!
+        val aliceInterceptor = mTestHelper.getTestInterceptor(aliceSession)
+
+        // Simulate no OTK
+        aliceInterceptor!!.addRule(MockOkHttpInterceptor.SimpleRule(
+                "/keys/claim",
+                200,
+                """
+                   { "one_time_keys" : {} } 
+                """
+        ))
+        Log.d("#TEST", "Recovery :${aliceSession.sessionParams.credentials.accessToken}")
+
+        val roomAlicePov = aliceSession.getRoom(testData.roomId)!!
+
+        val eventId = mTestHelper.sendTextMessage(roomAlicePov, "first message", 1).first().eventId
+
+        // await for bob session to get the message
+        mTestHelper.waitWithLatch { latch ->
+            mTestHelper.retryPeriodicallyWithLatch(latch) {
+                bobSession.getRoom(testData.roomId)?.getTimeLineEvent(eventId) != null
+            }
+        }
+
+        // Previous message should still be undecryptable (partially withheld session)
+        val eventBobPOV = bobSession.getRoom(testData.roomId)?.getTimeLineEvent(eventId)
+        try {
+            // .. might need to wait a bit for stability?
+            bobSession.cryptoService().decryptEvent(eventBobPOV!!.root, "")
+            Assert.fail("This session should not be able to decrypt")
+        } catch (failure: Throwable) {
+            val type = (failure as MXCryptoError.Base).errorType
+            val technicalMessage = failure.technicalMessage
+            Assert.assertEquals("Error should be withheld", MXCryptoError.ErrorType.KEYS_WITHHELD, type)
+            Assert.assertEquals("Cause should be unverified", WithHeldCode.NO_OLM.value, technicalMessage)
+        }
+
+        // Ensure that alice has marked the session to be shared with bob
+        val sessionId = eventBobPOV!!.root.content.toModel<EncryptedEventContent>()!!.sessionId!!
+        val chainIndex = aliceSession.cryptoService().getSharedWithInfo(testData.roomId, sessionId).getObject(bobSession.myUserId, bobSession.sessionParams.credentials.deviceId)
+
+        Assert.assertEquals("Alice should have marked bob's device for this session", 0, chainIndex)
+        // Add a new device for bob
+
+        aliceInterceptor.clearRules()
+        val bobSecondSession = mTestHelper.logIntoAccount(bobSession.myUserId, SessionTestParams(withInitialSync = true))
+        // send a second message
+        val secondMessageId = mTestHelper.sendTextMessage(roomAlicePov, "second message", 1).first().eventId
+
+        // Check that the
+        // await for bob SecondSession session to get the message
+        mTestHelper.waitWithLatch { latch ->
+            mTestHelper.retryPeriodicallyWithLatch(latch) {
+                bobSecondSession.getRoom(testData.roomId)?.getTimeLineEvent(secondMessageId) != null
+            }
+        }
+
+        val chainIndex2 = aliceSession.cryptoService().getSharedWithInfo(testData.roomId, sessionId).getObject(bobSecondSession.myUserId, bobSecondSession.sessionParams.credentials.deviceId)
+
+        Assert.assertEquals("Alice should have marked bob's device for this session", 1, chainIndex2)
+
+        aliceInterceptor.clearRules()
+        testData.cleanUp(mTestHelper)
+        mTestHelper.signOutAndClose(bobSecondSession)
+    }
+
+    @Test
+    fun test_WithHeldKeyRequest() {
+        val testData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom()
+        val aliceSession = testData.firstSession
+        val bobSession = testData.secondSession!!
+
+        val roomAlicePov = aliceSession.getRoom(testData.roomId)!!
+
+        val eventId = mTestHelper.sendTextMessage(roomAlicePov, "first message", 1).first().eventId
+
+        mTestHelper.signOutAndClose(bobSession)
+
+        // Create a new session for bob
+
+        val bobSecondSession = mTestHelper.logIntoAccount(bobSession.myUserId, SessionTestParams(true))
+        // initialize to force request keys if missing
+        mCryptoTestHelper.initializeCrossSigning(bobSecondSession)
+
+        // Trust bob second device from Alice POV
+        aliceSession.cryptoService().crossSigningService().trustDevice(bobSecondSession.sessionParams.deviceId!!, NoOpMatrixCallback())
+        bobSecondSession.cryptoService().crossSigningService().trustDevice(aliceSession.sessionParams.deviceId!!, NoOpMatrixCallback())
+
+        var sessionId: String? = null
+        // Check that the
+        // await for bob SecondSession session to get the message
+        mTestHelper.waitWithLatch { latch ->
+            mTestHelper.retryPeriodicallyWithLatch(latch) {
+                val timeLineEvent = bobSecondSession.getRoom(testData.roomId)?.getTimeLineEvent(eventId)?.also {
+                    // try to decrypt and force key request
+                    tryThis { bobSecondSession.cryptoService().decryptEvent(it.root, "") }
+                }
+                sessionId = timeLineEvent?.root?.content?.toModel<EncryptedEventContent>()?.sessionId
+                timeLineEvent != null
+            }
+        }
+
+        // Check that bob second session requested the key
+        mTestHelper.waitWithLatch { latch ->
+            mTestHelper.retryPeriodicallyWithLatch(latch) {
+                val wc = bobSecondSession.cryptoService().getWithHeldMegolmSession(roomAlicePov.roomId, sessionId!!)
+                wc?.code == WithHeldCode.UNAUTHORISED
+            }
+        }
+    }
+}

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

@@ -0,0 +1,180 @@
+/*
+ * 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.internal.crypto.keysbackup
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import im.vector.matrix.android.InstrumentedTest
+import im.vector.matrix.android.api.listeners.ProgressListener
+import im.vector.matrix.android.common.assertByteArrayNotEqual
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+import org.matrix.olm.OlmManager
+import org.matrix.olm.OlmPkDecryption
+
+@RunWith(AndroidJUnit4::class)
+@FixMethodOrder(MethodSorters.JVM)
+class KeysBackupPasswordTest : InstrumentedTest {
+
+    @Before
+    fun ensureLibLoaded() {
+        OlmManager()
+    }
+
+    /**
+     * Check KeysBackupPassword utilities
+     */
+    @Test
+    fun passwordConverter_ok() {
+        val generatePrivateKeyResult = generatePrivateKeyWithPassword(PASSWORD, null)
+
+        assertEquals(32, generatePrivateKeyResult.salt.length)
+        assertEquals(500_000, generatePrivateKeyResult.iterations)
+        assertEquals(OlmPkDecryption.privateKeyLength(), generatePrivateKeyResult.privateKey.size)
+
+        // Reverse operation
+        val retrievedPrivateKey = retrievePrivateKeyWithPassword(PASSWORD,
+                generatePrivateKeyResult.salt,
+                generatePrivateKeyResult.iterations)
+
+        assertEquals(OlmPkDecryption.privateKeyLength(), retrievedPrivateKey.size)
+        assertArrayEquals(generatePrivateKeyResult.privateKey, retrievedPrivateKey)
+    }
+
+    /**
+     * Check generatePrivateKeyWithPassword progress listener behavior
+     */
+    @Test
+    fun passwordConverter_progress_ok() {
+        val progressValues = ArrayList<Int>(101)
+        var lastTotal = 0
+
+        generatePrivateKeyWithPassword(PASSWORD, object : ProgressListener {
+            override fun onProgress(progress: Int, total: Int) {
+                if (!progressValues.contains(progress)) {
+                    progressValues.add(progress)
+                }
+
+                lastTotal = total
+            }
+        })
+
+        assertEquals(100, lastTotal)
+
+        // Ensure all values are here
+        assertEquals(101, progressValues.size)
+
+        for (i in 0..100) {
+            assertTrue(progressValues[i] == i)
+        }
+    }
+
+    /**
+     * Check KeysBackupPassword utilities, with bad password
+     */
+    @Test
+    fun passwordConverter_badPassword_ok() {
+        val generatePrivateKeyResult = generatePrivateKeyWithPassword(PASSWORD, null)
+
+        assertEquals(32, generatePrivateKeyResult.salt.length)
+        assertEquals(500_000, generatePrivateKeyResult.iterations)
+        assertEquals(OlmPkDecryption.privateKeyLength(), generatePrivateKeyResult.privateKey.size)
+
+        // Reverse operation, with bad password
+        val retrievedPrivateKey = retrievePrivateKeyWithPassword(BAD_PASSWORD,
+                generatePrivateKeyResult.salt,
+                generatePrivateKeyResult.iterations)
+
+        assertEquals(OlmPkDecryption.privateKeyLength(), retrievedPrivateKey.size)
+        assertByteArrayNotEqual(generatePrivateKeyResult.privateKey, retrievedPrivateKey)
+    }
+
+    /**
+     * Check KeysBackupPassword utilities, with bad password
+     */
+    @Test
+    fun passwordConverter_badIteration_ok() {
+        val generatePrivateKeyResult = generatePrivateKeyWithPassword(PASSWORD, null)
+
+        assertEquals(32, generatePrivateKeyResult.salt.length)
+        assertEquals(500_000, generatePrivateKeyResult.iterations)
+        assertEquals(OlmPkDecryption.privateKeyLength(), generatePrivateKeyResult.privateKey.size)
+
+        // Reverse operation, with bad iteration
+        val retrievedPrivateKey = retrievePrivateKeyWithPassword(PASSWORD,
+                generatePrivateKeyResult.salt,
+                500_001)
+
+        assertEquals(OlmPkDecryption.privateKeyLength(), retrievedPrivateKey.size)
+        assertByteArrayNotEqual(generatePrivateKeyResult.privateKey, retrievedPrivateKey)
+    }
+
+    /**
+     * Check KeysBackupPassword utilities, with bad salt
+     */
+    @Test
+    fun passwordConverter_badSalt_ok() {
+        val generatePrivateKeyResult = generatePrivateKeyWithPassword(PASSWORD, null)
+
+        assertEquals(32, generatePrivateKeyResult.salt.length)
+        assertEquals(500_000, generatePrivateKeyResult.iterations)
+        assertEquals(OlmPkDecryption.privateKeyLength(), generatePrivateKeyResult.privateKey.size)
+
+        // Reverse operation, with bad iteration
+        val retrievedPrivateKey = retrievePrivateKeyWithPassword(PASSWORD,
+                BAD_SALT,
+                generatePrivateKeyResult.iterations)
+
+        assertEquals(OlmPkDecryption.privateKeyLength(), retrievedPrivateKey.size)
+        assertByteArrayNotEqual(generatePrivateKeyResult.privateKey, retrievedPrivateKey)
+    }
+
+    /**
+     * Check [retrievePrivateKeyWithPassword] with data coming from another platform (RiotWeb).
+     */
+    @Test
+    fun passwordConverter_crossPlatform_ok() {
+        val password = "This is a passphrase!"
+        val salt = "TO0lxhQ9aYgGfMsclVWPIAublg8h9Nlu"
+        val iteration = 500_000
+
+        val retrievedPrivateKey = retrievePrivateKeyWithPassword(password, salt, iteration)
+
+        assertEquals(OlmPkDecryption.privateKeyLength(), retrievedPrivateKey.size)
+
+        // Data from RiotWeb
+        val privateKeyBytes = byteArrayOf(
+                116.toByte(), 224.toByte(), 229.toByte(), 224.toByte(), 9.toByte(), 3.toByte(), 178.toByte(), 162.toByte(),
+                120.toByte(), 23.toByte(), 108.toByte(), 218.toByte(), 22.toByte(), 61.toByte(), 241.toByte(), 200.toByte(),
+                235.toByte(), 173.toByte(), 236.toByte(), 100.toByte(), 115.toByte(), 247.toByte(), 33.toByte(), 132.toByte(),
+                195.toByte(), 154.toByte(), 64.toByte(), 158.toByte(), 184.toByte(), 148.toByte(), 20.toByte(), 85.toByte())
+
+        assertArrayEquals(privateKeyBytes, retrievedPrivateKey)
+    }
+
+    companion object {
+        private const val PASSWORD = "password"
+        private const val BAD_PASSWORD = "passw0rd"
+
+        private const val BAD_SALT = "AA0lxhQ9aYgGfMsclVWPIAublg8h9Nlu"
+    }
+}

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

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2020 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.internal.crypto.keysbackup
+
+import im.vector.matrix.android.api.session.Session
+import im.vector.matrix.android.common.CommonTestHelper
+import im.vector.matrix.android.common.CryptoTestData
+import im.vector.matrix.android.internal.crypto.model.OlmInboundGroupSessionWrapper2
+
+/**
+ * Data class to store result of [KeysBackupTestHelper.createKeysBackupScenarioWithPassword]
+ */
+data class KeysBackupScenarioData(val cryptoTestData: CryptoTestData,
+                                  val aliceKeys: List<OlmInboundGroupSessionWrapper2>,
+                                  val prepareKeysBackupDataResult: PrepareKeysBackupDataResult,
+                                  val aliceSession2: Session) {
+    fun cleanUp(testHelper: CommonTestHelper) {
+        cryptoTestData.cleanUp(testHelper)
+        testHelper.signOutAndClose(aliceSession2)
+    }
+}

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

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2020 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.internal.crypto.keysbackup
+
+import im.vector.matrix.android.common.SessionTestParams
+
+object KeysBackupTestConstants {
+    val defaultSessionParams = SessionTestParams(withInitialSync = false)
+    val defaultSessionParamsWithInitialSync = SessionTestParams(withInitialSync = true)
+}

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

@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) 2020 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.internal.crypto.keysbackup
+
+import im.vector.matrix.android.api.listeners.ProgressListener
+import im.vector.matrix.android.api.session.Session
+import im.vector.matrix.android.api.session.crypto.keysbackup.KeysBackupService
+import im.vector.matrix.android.api.session.crypto.keysbackup.KeysBackupState
+import im.vector.matrix.android.api.session.crypto.keysbackup.KeysBackupStateListener
+import im.vector.matrix.android.common.CommonTestHelper
+import im.vector.matrix.android.common.CryptoTestHelper
+import im.vector.matrix.android.common.assertDictEquals
+import im.vector.matrix.android.common.assertListEquals
+import im.vector.matrix.android.internal.crypto.MegolmSessionData
+import im.vector.matrix.android.internal.crypto.keysbackup.model.MegolmBackupCreationInfo
+import im.vector.matrix.android.internal.crypto.keysbackup.model.rest.KeysVersion
+import org.junit.Assert
+import java.util.concurrent.CountDownLatch
+
+class KeysBackupTestHelper(
+        private val mTestHelper: CommonTestHelper,
+        private val mCryptoTestHelper: CryptoTestHelper) {
+
+    /**
+     * Common initial condition
+     * - Do an e2e backup to the homeserver
+     * - Log Alice on a new device, and wait for its keysBackup object to be ready (in state NotTrusted)
+     *
+     * @param password optional password
+     */
+    fun createKeysBackupScenarioWithPassword(password: String?): KeysBackupScenarioData {
+        val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages()
+
+        val cryptoStore = (cryptoTestData.firstSession.cryptoService().keysBackupService() as DefaultKeysBackupService).store
+        val keysBackup = cryptoTestData.firstSession.cryptoService().keysBackupService()
+
+        val stateObserver = StateObserver(keysBackup)
+
+        val aliceKeys = cryptoStore.inboundGroupSessionsToBackup(100)
+
+        // - Do an e2e backup to the homeserver
+        val prepareKeysBackupDataResult = prepareAndCreateKeysBackupData(keysBackup, password)
+
+        var lastProgress = 0
+        var lastTotal = 0
+        mTestHelper.doSync<Unit> {
+            keysBackup.backupAllGroupSessions(object : ProgressListener {
+                override fun onProgress(progress: Int, total: Int) {
+                    lastProgress = progress
+                    lastTotal = total
+                }
+            }, it)
+        }
+
+        Assert.assertEquals(2, lastProgress)
+        Assert.assertEquals(2, lastTotal)
+
+        val aliceUserId = cryptoTestData.firstSession.myUserId
+
+        // - Log Alice on a new device
+        val aliceSession2 = mTestHelper.logIntoAccount(aliceUserId, KeysBackupTestConstants.defaultSessionParamsWithInitialSync)
+
+        // Test check: aliceSession2 has no keys at login
+        Assert.assertEquals(0, aliceSession2.cryptoService().inboundGroupSessionsCount(false))
+
+        // Wait for backup state to be NotTrusted
+        waitForKeysBackupToBeInState(aliceSession2, KeysBackupState.NotTrusted)
+
+        stateObserver.stopAndCheckStates(null)
+
+        return KeysBackupScenarioData(cryptoTestData,
+                aliceKeys,
+                prepareKeysBackupDataResult,
+                aliceSession2)
+    }
+
+    fun prepareAndCreateKeysBackupData(keysBackup: KeysBackupService,
+                                       password: String? = null): PrepareKeysBackupDataResult {
+        val stateObserver = StateObserver(keysBackup)
+
+        val megolmBackupCreationInfo = mTestHelper.doSync<MegolmBackupCreationInfo> {
+            keysBackup.prepareKeysBackupVersion(password, null, it)
+        }
+
+        Assert.assertNotNull(megolmBackupCreationInfo)
+
+        Assert.assertFalse(keysBackup.isEnabled)
+
+        // Create the version
+        val keysVersion = mTestHelper.doSync<KeysVersion> {
+            keysBackup.createKeysBackupVersion(megolmBackupCreationInfo, it)
+        }
+
+        Assert.assertNotNull(keysVersion.version)
+
+        // Backup must be enable now
+        Assert.assertTrue(keysBackup.isEnabled)
+
+        stateObserver.stopAndCheckStates(null)
+        return PrepareKeysBackupDataResult(megolmBackupCreationInfo, keysVersion.version!!)
+    }
+
+    /**
+     * As KeysBackup is doing asynchronous call to update its internal state, this method help to wait for the
+     * KeysBackup object to be in the specified state
+     */
+    fun waitForKeysBackupToBeInState(session: Session, state: KeysBackupState) {
+        // If already in the wanted state, return
+        if (session.cryptoService().keysBackupService().state == state) {
+            return
+        }
+
+        // Else observe state changes
+        val latch = CountDownLatch(1)
+
+        session.cryptoService().keysBackupService().addListener(object : KeysBackupStateListener {
+            override fun onStateChange(newState: KeysBackupState) {
+                if (newState == state) {
+                    session.cryptoService().keysBackupService().removeListener(this)
+                    latch.countDown()
+                }
+            }
+        })
+
+        mTestHelper.await(latch)
+    }
+
+    fun assertKeysEquals(keys1: MegolmSessionData?, keys2: MegolmSessionData?) {
+        Assert.assertNotNull(keys1)
+        Assert.assertNotNull(keys2)
+
+        Assert.assertEquals(keys1?.algorithm, keys2?.algorithm)
+        Assert.assertEquals(keys1?.roomId, keys2?.roomId)
+        // No need to compare the shortcut
+        // assertEquals(keys1?.sender_claimed_ed25519_key, keys2?.sender_claimed_ed25519_key)
+        Assert.assertEquals(keys1?.senderKey, keys2?.senderKey)
+        Assert.assertEquals(keys1?.sessionId, keys2?.sessionId)
+        Assert.assertEquals(keys1?.sessionKey, keys2?.sessionKey)
+
+        assertListEquals(keys1?.forwardingCurve25519KeyChain, keys2?.forwardingCurve25519KeyChain)
+        assertDictEquals(keys1?.senderClaimedKeys, keys2?.senderClaimedKeys)
+    }
+
+    /**
+     * Common restore success check after [KeysBackupTestHelper.createKeysBackupScenarioWithPassword]:
+     * - Imported keys number must be correct
+     * - The new device must have the same count of megolm keys
+     * - Alice must have the same keys on both devices
+     */
+    fun checkRestoreSuccess(testData: KeysBackupScenarioData,
+                            total: Int,
+                            imported: Int) {
+        // - Imported keys number must be correct
+        Assert.assertEquals(testData.aliceKeys.size, total)
+        Assert.assertEquals(total, imported)
+
+        // - The new device must have the same count of megolm keys
+        Assert.assertEquals(testData.aliceKeys.size, testData.aliceSession2.cryptoService().inboundGroupSessionsCount(false))
+
+        // - Alice must have the same keys on both devices
+        for (aliceKey1 in testData.aliceKeys) {
+            val aliceKey2 = (testData.aliceSession2.cryptoService().keysBackupService() as DefaultKeysBackupService).store
+                    .getInboundGroupSession(aliceKey1.olmInboundGroupSession!!.sessionIdentifier(), aliceKey1.senderKey!!)
+            Assert.assertNotNull(aliceKey2)
+            assertKeysEquals(aliceKey1.exportKeys(), aliceKey2!!.exportKeys())
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2020 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.internal.crypto.keysbackup
+
+import im.vector.matrix.android.internal.crypto.keysbackup.model.MegolmBackupCreationInfo
+
+data class PrepareKeysBackupDataResult(val megolmBackupCreationInfo: MegolmBackupCreationInfo,
+                                       val version: String)

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

@@ -0,0 +1,104 @@
+/*
+ * 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.internal.crypto.keysbackup
+
+import im.vector.matrix.android.api.session.crypto.keysbackup.KeysBackupService
+import im.vector.matrix.android.api.session.crypto.keysbackup.KeysBackupState
+import im.vector.matrix.android.api.session.crypto.keysbackup.KeysBackupStateListener
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import java.util.concurrent.CountDownLatch
+
+/**
+ * This class observe the state change of a KeysBackup object and provide a method to check the several state change
+ * It checks all state transitions and detected forbidden transition
+ */
+internal class StateObserver(private val keysBackup: KeysBackupService,
+                             private val latch: CountDownLatch? = null,
+                             private val expectedStateChange: Int = -1) : KeysBackupStateListener {
+
+    private val allowedStateTransitions = listOf(
+            KeysBackupState.BackingUp to KeysBackupState.ReadyToBackUp,
+            KeysBackupState.BackingUp to KeysBackupState.WrongBackUpVersion,
+
+            KeysBackupState.CheckingBackUpOnHomeserver to KeysBackupState.Disabled,
+            KeysBackupState.CheckingBackUpOnHomeserver to KeysBackupState.NotTrusted,
+            KeysBackupState.CheckingBackUpOnHomeserver to KeysBackupState.ReadyToBackUp,
+            KeysBackupState.CheckingBackUpOnHomeserver to KeysBackupState.Unknown,
+            KeysBackupState.CheckingBackUpOnHomeserver to KeysBackupState.WrongBackUpVersion,
+
+            KeysBackupState.Disabled to KeysBackupState.Enabling,
+
+            KeysBackupState.Enabling to KeysBackupState.Disabled,
+            KeysBackupState.Enabling to KeysBackupState.ReadyToBackUp,
+
+            KeysBackupState.NotTrusted to KeysBackupState.CheckingBackUpOnHomeserver,
+            // This transition happens when we trust the device
+            KeysBackupState.NotTrusted to KeysBackupState.ReadyToBackUp,
+
+            KeysBackupState.ReadyToBackUp to KeysBackupState.WillBackUp,
+
+            KeysBackupState.Unknown to KeysBackupState.CheckingBackUpOnHomeserver,
+
+            KeysBackupState.WillBackUp to KeysBackupState.BackingUp,
+
+            KeysBackupState.WrongBackUpVersion to KeysBackupState.CheckingBackUpOnHomeserver,
+
+            // FIXME These transitions are observed during test, and I'm not sure they should occur. Don't have time to investigate now
+            KeysBackupState.ReadyToBackUp to KeysBackupState.BackingUp,
+            KeysBackupState.ReadyToBackUp to KeysBackupState.ReadyToBackUp,
+            KeysBackupState.WillBackUp to KeysBackupState.ReadyToBackUp,
+            KeysBackupState.WillBackUp to KeysBackupState.Unknown
+    )
+
+    private val stateList = ArrayList<KeysBackupState>()
+    private var lastTransitionError: String? = null
+
+    init {
+        keysBackup.addListener(this)
+    }
+
+    // TODO Make expectedStates mandatory to enforce test
+    fun stopAndCheckStates(expectedStates: List<KeysBackupState>?) {
+        keysBackup.removeListener(this)
+
+        expectedStates?.let {
+            assertEquals(it.size, stateList.size)
+
+            for (i in it.indices) {
+                assertEquals("The state $i is not correct. states: " + stateList.joinToString(separator = " "), it[i], stateList[i])
+            }
+        }
+
+        assertNull("states: " + stateList.joinToString(separator = " "), lastTransitionError)
+    }
+
+    override fun onStateChange(newState: KeysBackupState) {
+        stateList.add(newState)
+
+        // Check that state transition is valid
+        if (stateList.size >= 2
+                && !allowedStateTransitions.contains(stateList[stateList.size - 2] to newState)) {
+            // Forbidden transition detected
+            lastTransitionError = "Forbidden transition detected from " + stateList[stateList.size - 2] + " to " + newState
+        }
+
+        if (expectedStateChange == stateList.size) {
+            latch?.countDown()
+        }
+    }
+}

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

@@ -0,0 +1,363 @@
+/*
+ * Copyright (c) 2020 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.internal.crypto.ssss
+
+import androidx.lifecycle.Observer
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import im.vector.matrix.android.InstrumentedTest
+import im.vector.matrix.android.api.MatrixCallback
+import im.vector.matrix.android.api.session.Session
+import im.vector.matrix.android.api.session.securestorage.EncryptedSecretContent
+import im.vector.matrix.android.api.session.securestorage.KeySigner
+import im.vector.matrix.android.api.session.securestorage.RawBytesKeySpec
+import im.vector.matrix.android.api.session.securestorage.SecretStorageKeyContent
+import im.vector.matrix.android.api.session.securestorage.SharedSecretStorageService
+import im.vector.matrix.android.api.session.securestorage.SsssKeyCreationInfo
+import im.vector.matrix.android.api.util.Optional
+import im.vector.matrix.android.common.CommonTestHelper
+import im.vector.matrix.android.common.SessionTestParams
+import im.vector.matrix.android.common.TestConstants
+import im.vector.matrix.android.common.TestMatrixCallback
+import im.vector.matrix.android.internal.crypto.SSSS_ALGORITHM_AES_HMAC_SHA2
+import im.vector.matrix.android.internal.crypto.crosssigning.toBase64NoPadding
+import im.vector.matrix.android.internal.crypto.secrets.DefaultSharedSecretStorageService
+import im.vector.matrix.android.internal.session.sync.model.accountdata.UserAccountDataEvent
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import org.amshove.kluent.shouldBe
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+import java.util.concurrent.CountDownLatch
+
+@RunWith(AndroidJUnit4::class)
+@FixMethodOrder(MethodSorters.JVM)
+class QuadSTests : InstrumentedTest {
+
+    private val mTestHelper = CommonTestHelper(context())
+
+    private val emptyKeySigner = object : KeySigner {
+        override fun sign(canonicalJson: String): Map<String, Map<String, String>>? {
+            return null
+        }
+    }
+
+    @Test
+    fun test_Generate4SKey() {
+        val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true))
+
+        val quadS = aliceSession.sharedSecretStorageService
+
+        val TEST_KEY_ID = "my.test.Key"
+
+        mTestHelper.doSync<SsssKeyCreationInfo> {
+            quadS.generateKey(TEST_KEY_ID, null, "Test Key", emptyKeySigner, it)
+        }
+
+        // Assert Account data is updated
+        val accountDataLock = CountDownLatch(1)
+        var accountData: UserAccountDataEvent? = null
+
+        val liveAccountData = runBlocking(Dispatchers.Main) {
+            aliceSession.getLiveAccountDataEvent("${DefaultSharedSecretStorageService.KEY_ID_BASE}.$TEST_KEY_ID")
+        }
+        val accountDataObserver = Observer<Optional<UserAccountDataEvent>?> { t ->
+            if (t?.getOrNull()?.type == "${DefaultSharedSecretStorageService.KEY_ID_BASE}.$TEST_KEY_ID") {
+                accountData = t.getOrNull()
+                accountDataLock.countDown()
+            }
+        }
+        GlobalScope.launch(Dispatchers.Main) { liveAccountData.observeForever(accountDataObserver) }
+
+        mTestHelper.await(accountDataLock)
+
+        assertNotNull("Key should be stored in account data", accountData)
+        val parsed = SecretStorageKeyContent.fromJson(accountData!!.content)
+        assertNotNull("Key Content cannot be parsed", parsed)
+        assertEquals("Unexpected Algorithm", SSSS_ALGORITHM_AES_HMAC_SHA2, parsed!!.algorithm)
+        assertEquals("Unexpected key name", "Test Key", parsed.name)
+        assertNull("Key was not generated from passphrase", parsed.passphrase)
+
+        // Set as default key
+        quadS.setDefaultKey(TEST_KEY_ID, object : MatrixCallback<Unit> {})
+
+        var defaultKeyAccountData: UserAccountDataEvent? = null
+        val defaultDataLock = CountDownLatch(1)
+
+        val liveDefAccountData = runBlocking(Dispatchers.Main) {
+            aliceSession.getLiveAccountDataEvent(DefaultSharedSecretStorageService.DEFAULT_KEY_ID)
+        }
+        val accountDefDataObserver = Observer<Optional<UserAccountDataEvent>?> { t ->
+            if (t?.getOrNull()?.type == DefaultSharedSecretStorageService.DEFAULT_KEY_ID) {
+                defaultKeyAccountData = t.getOrNull()!!
+                defaultDataLock.countDown()
+            }
+        }
+        GlobalScope.launch(Dispatchers.Main) { liveDefAccountData.observeForever(accountDefDataObserver) }
+
+        mTestHelper.await(defaultDataLock)
+
+        assertNotNull(defaultKeyAccountData?.content)
+        assertEquals("Unexpected default key ${defaultKeyAccountData?.content}", TEST_KEY_ID, defaultKeyAccountData?.content?.get("key"))
+
+        mTestHelper.signOutAndClose(aliceSession)
+    }
+
+    @Test
+    fun test_StoreSecret() {
+        val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true))
+        val keyId = "My.Key"
+        val info = generatedSecret(aliceSession, keyId, true)
+
+        val keySpec = RawBytesKeySpec.fromRecoveryKey(info.recoveryKey)
+
+        // Store a secret
+        val clearSecret = "42".toByteArray().toBase64NoPadding()
+        mTestHelper.doSync<Unit> {
+            aliceSession.sharedSecretStorageService.storeSecret(
+                    "secret.of.life",
+                    clearSecret,
+                    listOf(SharedSecretStorageService.KeyRef(null, keySpec)), // default key
+                    it
+            )
+        }
+
+        val secretAccountData = assertAccountData(aliceSession, "secret.of.life")
+
+        val encryptedContent = secretAccountData.content["encrypted"] as? Map<*, *>
+        assertNotNull("Element should be encrypted", encryptedContent)
+        assertNotNull("Secret should be encrypted with default key", encryptedContent?.get(keyId))
+
+        val secret = EncryptedSecretContent.fromJson(encryptedContent?.get(keyId))
+        assertNotNull(secret?.ciphertext)
+        assertNotNull(secret?.mac)
+        assertNotNull(secret?.initializationVector)
+
+        // Try to decrypt??
+
+        val decryptedSecret = mTestHelper.doSync<String> {
+            aliceSession.sharedSecretStorageService.getSecret(
+                    "secret.of.life",
+                    null, // default key
+                    keySpec!!,
+                    it
+            )
+        }
+
+        assertEquals("Secret mismatch", clearSecret, decryptedSecret)
+        mTestHelper.signOutAndClose(aliceSession)
+    }
+
+    @Test
+    fun test_SetDefaultLocalEcho() {
+        val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true))
+
+        val quadS = aliceSession.sharedSecretStorageService
+
+        val TEST_KEY_ID = "my.test.Key"
+
+        mTestHelper.doSync<SsssKeyCreationInfo> {
+            quadS.generateKey(TEST_KEY_ID, null, "Test Key", emptyKeySigner, it)
+        }
+
+        // Test that we don't need to wait for an account data sync to access directly the keyid from DB
+        mTestHelper.doSync<Unit> {
+            quadS.setDefaultKey(TEST_KEY_ID, it)
+        }
+
+        mTestHelper.signOutAndClose(aliceSession)
+    }
+
+    @Test
+    fun test_StoreSecretWithMultipleKey() {
+        val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true))
+        val keyId1 = "Key.1"
+        val key1Info = generatedSecret(aliceSession, keyId1, true)
+        val keyId2 = "Key2"
+        val key2Info = generatedSecret(aliceSession, keyId2, true)
+
+        val mySecretText = "Lorem ipsum dolor sit amet, consectetur adipiscing elit"
+
+        mTestHelper.doSync<Unit> {
+            aliceSession.sharedSecretStorageService.storeSecret(
+                    "my.secret",
+                    mySecretText.toByteArray().toBase64NoPadding(),
+                    listOf(
+                            SharedSecretStorageService.KeyRef(keyId1, RawBytesKeySpec.fromRecoveryKey(key1Info.recoveryKey)),
+                            SharedSecretStorageService.KeyRef(keyId2, RawBytesKeySpec.fromRecoveryKey(key2Info.recoveryKey))
+                    ),
+                    it
+            )
+        }
+
+        val accountDataEvent = aliceSession.getAccountDataEvent("my.secret")
+        val encryptedContent = accountDataEvent?.content?.get("encrypted") as? Map<*, *>
+
+        assertEquals("Content should contains two encryptions", 2, encryptedContent?.keys?.size ?: 0)
+
+        assertNotNull(encryptedContent?.get(keyId1))
+        assertNotNull(encryptedContent?.get(keyId2))
+
+        // Assert that can decrypt with both keys
+        mTestHelper.doSync<String> {
+            aliceSession.sharedSecretStorageService.getSecret("my.secret",
+                    keyId1,
+                    RawBytesKeySpec.fromRecoveryKey(key1Info.recoveryKey)!!,
+                    it
+            )
+        }
+
+        mTestHelper.doSync<String> {
+            aliceSession.sharedSecretStorageService.getSecret("my.secret",
+                    keyId2,
+                    RawBytesKeySpec.fromRecoveryKey(key2Info.recoveryKey)!!,
+                    it
+            )
+        }
+
+        mTestHelper.signOutAndClose(aliceSession)
+    }
+
+    @Test
+    fun test_GetSecretWithBadPassphrase() {
+        val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true))
+        val keyId1 = "Key.1"
+        val passphrase = "The good pass phrase"
+        val key1Info = generatedSecretFromPassphrase(aliceSession, passphrase, keyId1, true)
+
+        val mySecretText = "Lorem ipsum dolor sit amet, consectetur adipiscing elit"
+
+        mTestHelper.doSync<Unit> {
+            aliceSession.sharedSecretStorageService.storeSecret(
+                    "my.secret",
+                    mySecretText.toByteArray().toBase64NoPadding(),
+                    listOf(SharedSecretStorageService.KeyRef(keyId1, RawBytesKeySpec.fromRecoveryKey(key1Info.recoveryKey))),
+                    it
+            )
+        }
+
+        val decryptCountDownLatch = CountDownLatch(1)
+        var error = false
+        aliceSession.sharedSecretStorageService.getSecret("my.secret",
+                keyId1,
+                RawBytesKeySpec.fromPassphrase(
+                        "A bad passphrase",
+                        key1Info.content?.passphrase?.salt ?: "",
+                        key1Info.content?.passphrase?.iterations ?: 0,
+                        null),
+                object : MatrixCallback<String> {
+                    override fun onSuccess(data: String) {
+                        decryptCountDownLatch.countDown()
+                    }
+
+                    override fun onFailure(failure: Throwable) {
+                        error = true
+                        decryptCountDownLatch.countDown()
+                    }
+                }
+        )
+
+        mTestHelper.await(decryptCountDownLatch)
+
+        error shouldBe true
+
+        // Now try with correct key
+        mTestHelper.doSync<String> {
+            aliceSession.sharedSecretStorageService.getSecret("my.secret",
+                    keyId1,
+                    RawBytesKeySpec.fromPassphrase(
+                            passphrase,
+                            key1Info.content?.passphrase?.salt ?: "",
+                            key1Info.content?.passphrase?.iterations ?: 0,
+                            null),
+                    it
+            )
+        }
+
+        mTestHelper.signOutAndClose(aliceSession)
+    }
+
+    private fun assertAccountData(session: Session, type: String): UserAccountDataEvent {
+        val accountDataLock = CountDownLatch(1)
+        var accountData: UserAccountDataEvent? = null
+
+        val liveAccountData = runBlocking(Dispatchers.Main) {
+            session.getLiveAccountDataEvent(type)
+        }
+        val accountDataObserver = Observer<Optional<UserAccountDataEvent>?> { t ->
+            if (t?.getOrNull()?.type == type) {
+                accountData = t.getOrNull()
+                accountDataLock.countDown()
+            }
+        }
+        GlobalScope.launch(Dispatchers.Main) { liveAccountData.observeForever(accountDataObserver) }
+        mTestHelper.await(accountDataLock)
+
+        assertNotNull("Account Data type:$type should be found", accountData)
+
+        return accountData!!
+    }
+
+    private fun generatedSecret(session: Session, keyId: String, asDefault: Boolean = true): SsssKeyCreationInfo {
+        val quadS = session.sharedSecretStorageService
+
+        val creationInfo = mTestHelper.doSync<SsssKeyCreationInfo> {
+            quadS.generateKey(keyId, null, keyId, emptyKeySigner, it)
+        }
+
+        assertAccountData(session, "${DefaultSharedSecretStorageService.KEY_ID_BASE}.$keyId")
+
+        if (asDefault) {
+            mTestHelper.doSync<Unit> {
+                quadS.setDefaultKey(keyId, it)
+            }
+            assertAccountData(session, DefaultSharedSecretStorageService.DEFAULT_KEY_ID)
+        }
+
+        return creationInfo
+    }
+
+    private fun generatedSecretFromPassphrase(session: Session, passphrase: String, keyId: String, asDefault: Boolean = true): SsssKeyCreationInfo {
+        val quadS = session.sharedSecretStorageService
+
+        val creationInfo = mTestHelper.doSync<SsssKeyCreationInfo> {
+            quadS.generateKeyWithPassphrase(
+                    keyId,
+                    keyId,
+                    passphrase,
+                    emptyKeySigner,
+                    null,
+                    it)
+        }
+
+        assertAccountData(session, "${DefaultSharedSecretStorageService.KEY_ID_BASE}.$keyId")
+        if (asDefault) {
+            val setDefaultLatch = CountDownLatch(1)
+            quadS.setDefaultKey(keyId, TestMatrixCallback(setDefaultLatch))
+            mTestHelper.await(setDefaultLatch)
+            assertAccountData(session, DefaultSharedSecretStorageService.DEFAULT_KEY_ID)
+        }
+
+        return creationInfo
+    }
+}

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

@@ -0,0 +1,629 @@
+/*
+ * 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.internal.crypto.verification
+
+import android.util.Log
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import im.vector.matrix.android.InstrumentedTest
+import im.vector.matrix.android.api.session.Session
+import im.vector.matrix.android.api.session.crypto.verification.CancelCode
+import im.vector.matrix.android.api.session.crypto.verification.IncomingSasVerificationTransaction
+import im.vector.matrix.android.api.session.crypto.verification.OutgoingSasVerificationTransaction
+import im.vector.matrix.android.api.session.crypto.verification.SasMode
+import im.vector.matrix.android.api.session.crypto.verification.SasVerificationTransaction
+import im.vector.matrix.android.api.session.crypto.verification.VerificationMethod
+import im.vector.matrix.android.api.session.crypto.verification.VerificationService
+import im.vector.matrix.android.api.session.crypto.verification.VerificationTransaction
+import im.vector.matrix.android.api.session.crypto.verification.VerificationTxState
+import im.vector.matrix.android.api.session.events.model.Event
+import im.vector.matrix.android.api.session.events.model.toModel
+import im.vector.matrix.android.common.CommonTestHelper
+import im.vector.matrix.android.common.CryptoTestHelper
+import im.vector.matrix.android.internal.crypto.model.CryptoDeviceInfo
+import im.vector.matrix.android.internal.crypto.model.MXUsersDevicesMap
+import im.vector.matrix.android.internal.crypto.model.rest.KeyVerificationCancel
+import im.vector.matrix.android.internal.crypto.model.rest.KeyVerificationStart
+import im.vector.matrix.android.internal.crypto.model.rest.toValue
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+import java.util.concurrent.CountDownLatch
+
+@RunWith(AndroidJUnit4::class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+class SASTest : InstrumentedTest {
+    private val mTestHelper = CommonTestHelper(context())
+    private val mCryptoTestHelper = CryptoTestHelper(mTestHelper)
+
+    @Test
+    fun test_aliceStartThenAliceCancel() {
+        val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom()
+
+        val aliceSession = cryptoTestData.firstSession
+        val bobSession = cryptoTestData.secondSession
+
+        val aliceVerificationService = aliceSession.cryptoService().verificationService()
+        val bobVerificationService = bobSession!!.cryptoService().verificationService()
+
+        val bobTxCreatedLatch = CountDownLatch(1)
+        val bobListener = object : VerificationService.Listener {
+            override fun transactionUpdated(tx: VerificationTransaction) {
+                bobTxCreatedLatch.countDown()
+            }
+        }
+        bobVerificationService.addListener(bobListener)
+
+        val txID = aliceVerificationService.beginKeyVerification(VerificationMethod.SAS,
+                bobSession.myUserId,
+                bobSession.cryptoService().getMyDevice().deviceId,
+                null)
+        assertNotNull("Alice should have a started transaction", txID)
+
+        val aliceKeyTx = aliceVerificationService.getExistingTransaction(bobSession.myUserId, txID!!)
+        assertNotNull("Alice should have a started transaction", aliceKeyTx)
+
+        mTestHelper.await(bobTxCreatedLatch)
+        bobVerificationService.removeListener(bobListener)
+
+        val bobKeyTx = bobVerificationService.getExistingTransaction(aliceSession.myUserId, txID)
+
+        assertNotNull("Bob should have started verif transaction", bobKeyTx)
+        assertTrue(bobKeyTx is SASDefaultVerificationTransaction)
+        assertNotNull("Bob should have starting a SAS transaction", bobKeyTx)
+        assertTrue(aliceKeyTx is SASDefaultVerificationTransaction)
+        assertEquals("Alice and Bob have same transaction id", aliceKeyTx!!.transactionId, bobKeyTx!!.transactionId)
+
+        val aliceSasTx = aliceKeyTx as SASDefaultVerificationTransaction?
+        val bobSasTx = bobKeyTx as SASDefaultVerificationTransaction?
+
+        assertEquals("Alice state should be started", VerificationTxState.Started, aliceSasTx!!.state)
+        assertEquals("Bob state should be started by alice", VerificationTxState.OnStarted, bobSasTx!!.state)
+
+        // Let's cancel from alice side
+        val cancelLatch = CountDownLatch(1)
+
+        val bobListener2 = object : VerificationService.Listener {
+            override fun transactionUpdated(tx: VerificationTransaction) {
+                if (tx.transactionId == txID) {
+                    val immutableState = (tx as SASDefaultVerificationTransaction).state
+                    if (immutableState is VerificationTxState.Cancelled && !immutableState.byMe) {
+                        cancelLatch.countDown()
+                    }
+                }
+            }
+        }
+        bobVerificationService.addListener(bobListener2)
+
+        aliceSasTx.cancel(CancelCode.User)
+        mTestHelper.await(cancelLatch)
+
+        assertTrue("Should be cancelled on alice side", aliceSasTx.state is VerificationTxState.Cancelled)
+        assertTrue("Should be cancelled on bob side", bobSasTx.state is VerificationTxState.Cancelled)
+
+        val aliceCancelState = aliceSasTx.state as VerificationTxState.Cancelled
+        val bobCancelState = bobSasTx.state as VerificationTxState.Cancelled
+
+        assertTrue("Should be cancelled by me on alice side", aliceCancelState.byMe)
+        assertFalse("Should be cancelled by other on bob side", bobCancelState.byMe)
+
+        assertEquals("Should be User cancelled on alice side", CancelCode.User, aliceCancelState.cancelCode)
+        assertEquals("Should be User cancelled on bob side", CancelCode.User, bobCancelState.cancelCode)
+
+        assertNull(bobVerificationService.getExistingTransaction(aliceSession.myUserId, txID))
+        assertNull(aliceVerificationService.getExistingTransaction(bobSession.myUserId, txID))
+
+        cryptoTestData.cleanUp(mTestHelper)
+    }
+
+    @Test
+    fun test_key_agreement_protocols_must_include_curve25519() {
+        fail("Not passing for the moment")
+        val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom()
+
+        val bobSession = cryptoTestData.secondSession!!
+
+        val protocols = listOf("meh_dont_know")
+        val tid = "00000000"
+
+        // Bob should receive a cancel
+        var cancelReason: CancelCode? = null
+        val cancelLatch = CountDownLatch(1)
+
+        val bobListener = object : VerificationService.Listener {
+            override fun transactionUpdated(tx: VerificationTransaction) {
+                if (tx.transactionId == tid && tx.state is VerificationTxState.Cancelled) {
+                    cancelReason = (tx.state as VerificationTxState.Cancelled).cancelCode
+                    cancelLatch.countDown()
+                }
+            }
+        }
+        bobSession.cryptoService().verificationService().addListener(bobListener)
+
+        // TODO bobSession!!.dataHandler.addListener(object : MXEventListener() {
+        // TODO     override fun onToDeviceEvent(event: Event?) {
+        // TODO         if (event!!.getType() == CryptoEvent.EVENT_TYPE_KEY_VERIFICATION_CANCEL) {
+        // TODO             if (event.contentAsJsonObject?.get("transaction_id")?.asString == tid) {
+        // TODO                 canceledToDeviceEvent = event
+        // TODO                 cancelLatch.countDown()
+        // TODO             }
+        // TODO         }
+        // TODO     }
+        // TODO })
+
+        val aliceSession = cryptoTestData.firstSession
+        val aliceUserID = aliceSession.myUserId
+        val aliceDevice = aliceSession.cryptoService().getMyDevice().deviceId
+
+        val aliceListener = object : VerificationService.Listener {
+            override fun transactionUpdated(tx: VerificationTransaction) {
+                if ((tx as IncomingSasVerificationTransaction).uxState === IncomingSasVerificationTransaction.UxState.SHOW_ACCEPT) {
+                    (tx as IncomingSasVerificationTransaction).performAccept()
+                }
+            }
+        }
+        aliceSession.cryptoService().verificationService().addListener(aliceListener)
+
+        fakeBobStart(bobSession, aliceUserID, aliceDevice, tid, protocols = protocols)
+
+        mTestHelper.await(cancelLatch)
+
+        assertEquals("Request should be cancelled with m.unknown_method", CancelCode.UnknownMethod, cancelReason)
+
+        cryptoTestData.cleanUp(mTestHelper)
+    }
+
+    @Test
+    fun test_key_agreement_macs_Must_include_hmac_sha256() {
+        fail("Not passing for the moment")
+        val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom()
+
+        val bobSession = cryptoTestData.secondSession!!
+
+        val mac = listOf("shaBit")
+        val tid = "00000000"
+
+        // Bob should receive a cancel
+        var canceledToDeviceEvent: Event? = null
+        val cancelLatch = CountDownLatch(1)
+        // TODO bobSession!!.dataHandler.addListener(object : MXEventListener() {
+        // TODO     override fun onToDeviceEvent(event: Event?) {
+        // TODO         if (event!!.getType() == CryptoEvent.EVENT_TYPE_KEY_VERIFICATION_CANCEL) {
+        // TODO             if (event.contentAsJsonObject?.get("transaction_id")?.asString == tid) {
+        // TODO                 canceledToDeviceEvent = event
+        // TODO                 cancelLatch.countDown()
+        // TODO             }
+        // TODO         }
+        // TODO     }
+        // TODO })
+
+        val aliceSession = cryptoTestData.firstSession
+        val aliceUserID = aliceSession.myUserId
+        val aliceDevice = aliceSession.cryptoService().getMyDevice().deviceId
+
+        fakeBobStart(bobSession, aliceUserID, aliceDevice, tid, mac = mac)
+
+        mTestHelper.await(cancelLatch)
+
+        val cancelReq = canceledToDeviceEvent!!.content.toModel<KeyVerificationCancel>()!!
+        assertEquals("Request should be cancelled with m.unknown_method", CancelCode.UnknownMethod.value, cancelReq.code)
+
+        cryptoTestData.cleanUp(mTestHelper)
+    }
+
+    @Test
+    fun test_key_agreement_short_code_include_decimal() {
+        fail("Not passing for the moment")
+        val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom()
+
+        val bobSession = cryptoTestData.secondSession!!
+
+        val codes = listOf("bin", "foo", "bar")
+        val tid = "00000000"
+
+        // Bob should receive a cancel
+        var canceledToDeviceEvent: Event? = null
+        val cancelLatch = CountDownLatch(1)
+        // TODO bobSession!!.dataHandler.addListener(object : MXEventListener() {
+        // TODO     override fun onToDeviceEvent(event: Event?) {
+        // TODO         if (event!!.getType() == CryptoEvent.EVENT_TYPE_KEY_VERIFICATION_CANCEL) {
+        // TODO             if (event.contentAsJsonObject?.get("transaction_id")?.asString == tid) {
+        // TODO                 canceledToDeviceEvent = event
+        // TODO                 cancelLatch.countDown()
+        // TODO             }
+        // TODO         }
+        // TODO     }
+        // TODO })
+
+        val aliceSession = cryptoTestData.firstSession
+        val aliceUserID = aliceSession.myUserId
+        val aliceDevice = aliceSession.cryptoService().getMyDevice().deviceId
+
+        fakeBobStart(bobSession, aliceUserID, aliceDevice, tid, codes = codes)
+
+        mTestHelper.await(cancelLatch)
+
+        val cancelReq = canceledToDeviceEvent!!.content.toModel<KeyVerificationCancel>()!!
+        assertEquals("Request should be cancelled with m.unknown_method", CancelCode.UnknownMethod.value, cancelReq.code)
+
+        cryptoTestData.cleanUp(mTestHelper)
+    }
+
+    private fun fakeBobStart(bobSession: Session,
+                             aliceUserID: String?,
+                             aliceDevice: String?,
+                             tid: String,
+                             protocols: List<String> = SASDefaultVerificationTransaction.KNOWN_AGREEMENT_PROTOCOLS,
+                             hashes: List<String> = SASDefaultVerificationTransaction.KNOWN_HASHES,
+                             mac: List<String> = SASDefaultVerificationTransaction.KNOWN_MACS,
+                             codes: List<String> = SASDefaultVerificationTransaction.KNOWN_SHORT_CODES) {
+        val startMessage = KeyVerificationStart(
+                fromDevice = bobSession.cryptoService().getMyDevice().deviceId,
+                method = VerificationMethod.SAS.toValue(),
+                transactionId = tid,
+                keyAgreementProtocols = protocols,
+                hashes = hashes,
+                messageAuthenticationCodes = mac,
+                shortAuthenticationStrings = codes
+        )
+
+        val contentMap = MXUsersDevicesMap<Any>()
+        contentMap.setObject(aliceUserID, aliceDevice, startMessage)
+
+        // TODO val sendLatch = CountDownLatch(1)
+        // TODO bobSession.cryptoRestClient.sendToDevice(
+        // TODO         EventType.KEY_VERIFICATION_START,
+        // TODO         contentMap,
+        // TODO         tid,
+        // TODO         TestMatrixCallback<Void>(sendLatch)
+        // TODO )
+    }
+
+    // any two devices may only have at most one key verification in flight at a time.
+    // If a device has two verifications in progress with the same device, then it should cancel both verifications.
+    @Test
+    fun test_aliceStartTwoRequests() {
+        val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom()
+
+        val aliceSession = cryptoTestData.firstSession
+        val bobSession = cryptoTestData.secondSession
+
+        val aliceVerificationService = aliceSession.cryptoService().verificationService()
+
+        val aliceCreatedLatch = CountDownLatch(2)
+        val aliceCancelledLatch = CountDownLatch(2)
+        val createdTx = mutableListOf<SASDefaultVerificationTransaction>()
+        val aliceListener = object : VerificationService.Listener {
+            override fun transactionCreated(tx: VerificationTransaction) {
+                createdTx.add(tx as SASDefaultVerificationTransaction)
+                aliceCreatedLatch.countDown()
+            }
+
+            override fun transactionUpdated(tx: VerificationTransaction) {
+                if ((tx as SASDefaultVerificationTransaction).state is VerificationTxState.Cancelled && !(tx.state as VerificationTxState.Cancelled).byMe) {
+                    aliceCancelledLatch.countDown()
+                }
+            }
+        }
+        aliceVerificationService.addListener(aliceListener)
+
+        val bobUserId = bobSession!!.myUserId
+        val bobDeviceId = bobSession.cryptoService().getMyDevice().deviceId
+        aliceVerificationService.beginKeyVerification(VerificationMethod.SAS, bobUserId, bobDeviceId, null)
+        aliceVerificationService.beginKeyVerification(VerificationMethod.SAS, bobUserId, bobDeviceId, null)
+
+        mTestHelper.await(aliceCreatedLatch)
+        mTestHelper.await(aliceCancelledLatch)
+
+        cryptoTestData.cleanUp(mTestHelper)
+    }
+
+    /**
+     * Test that when alice starts a 'correct' request, bob agrees.
+     */
+    @Test
+    fun test_aliceAndBobAgreement() {
+        val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom()
+
+        val aliceSession = cryptoTestData.firstSession
+        val bobSession = cryptoTestData.secondSession
+
+        val aliceVerificationService = aliceSession.cryptoService().verificationService()
+        val bobVerificationService = bobSession!!.cryptoService().verificationService()
+
+        var accepted: ValidVerificationInfoAccept? = null
+        var startReq: ValidVerificationInfoStart.SasVerificationInfoStart? = null
+
+        val aliceAcceptedLatch = CountDownLatch(1)
+        val aliceListener = object : VerificationService.Listener {
+            override fun transactionUpdated(tx: VerificationTransaction) {
+                Log.v("TEST", "== aliceTx state ${tx.state} => ${(tx as? OutgoingSasVerificationTransaction)?.uxState}")
+                if ((tx as SASDefaultVerificationTransaction).state === VerificationTxState.OnAccepted) {
+                    val at = tx as SASDefaultVerificationTransaction
+                    accepted = at.accepted
+                    startReq = at.startReq
+                    aliceAcceptedLatch.countDown()
+                }
+            }
+        }
+        aliceVerificationService.addListener(aliceListener)
+
+        val bobListener = object : VerificationService.Listener {
+            override fun transactionUpdated(tx: VerificationTransaction) {
+                Log.v("TEST", "== bobTx state ${tx.state} => ${(tx as? IncomingSasVerificationTransaction)?.uxState}")
+                if ((tx as IncomingSasVerificationTransaction).uxState === IncomingSasVerificationTransaction.UxState.SHOW_ACCEPT) {
+                    bobVerificationService.removeListener(this)
+                    val at = tx as IncomingSasVerificationTransaction
+                    at.performAccept()
+                }
+            }
+        }
+        bobVerificationService.addListener(bobListener)
+
+        val bobUserId = bobSession.myUserId
+        val bobDeviceId = bobSession.cryptoService().getMyDevice().deviceId
+        aliceVerificationService.beginKeyVerification(VerificationMethod.SAS, bobUserId, bobDeviceId, null)
+        mTestHelper.await(aliceAcceptedLatch)
+
+        assertTrue("Should have receive a commitment", accepted!!.commitment?.trim()?.isEmpty() == false)
+
+        // check that agreement is valid
+        assertTrue("Agreed Protocol should be Valid", accepted != null)
+        assertTrue("Agreed Protocol should be known by alice", startReq!!.keyAgreementProtocols.contains(accepted!!.keyAgreementProtocol))
+        assertTrue("Hash should be known by alice", startReq!!.hashes.contains(accepted!!.hash))
+        assertTrue("Hash should be known by alice", startReq!!.messageAuthenticationCodes.contains(accepted!!.messageAuthenticationCode))
+
+        accepted!!.shortAuthenticationStrings.forEach {
+            assertTrue("all agreed Short Code should be known by alice", startReq!!.shortAuthenticationStrings.contains(it))
+        }
+
+        cryptoTestData.cleanUp(mTestHelper)
+    }
+
+    @Test
+    fun test_aliceAndBobSASCode() {
+        val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom()
+
+        val aliceSession = cryptoTestData.firstSession
+        val bobSession = cryptoTestData.secondSession
+
+        val aliceVerificationService = aliceSession.cryptoService().verificationService()
+        val bobVerificationService = bobSession!!.cryptoService().verificationService()
+
+        val aliceSASLatch = CountDownLatch(1)
+        val aliceListener = object : VerificationService.Listener {
+            override fun transactionUpdated(tx: VerificationTransaction) {
+                val uxState = (tx as OutgoingSasVerificationTransaction).uxState
+                when (uxState) {
+                    OutgoingSasVerificationTransaction.UxState.SHOW_SAS -> {
+                        aliceSASLatch.countDown()
+                    }
+                    else                                                -> Unit
+                }
+            }
+        }
+        aliceVerificationService.addListener(aliceListener)
+
+        val bobSASLatch = CountDownLatch(1)
+        val bobListener = object : VerificationService.Listener {
+            override fun transactionUpdated(tx: VerificationTransaction) {
+                val uxState = (tx as IncomingSasVerificationTransaction).uxState
+                when (uxState) {
+                    IncomingSasVerificationTransaction.UxState.SHOW_ACCEPT -> {
+                        tx.performAccept()
+                    }
+                    else                                                   -> Unit
+                }
+                if (uxState === IncomingSasVerificationTransaction.UxState.SHOW_SAS) {
+                    bobSASLatch.countDown()
+                }
+            }
+        }
+        bobVerificationService.addListener(bobListener)
+
+        val bobUserId = bobSession.myUserId
+        val bobDeviceId = bobSession.cryptoService().getMyDevice().deviceId
+        val verificationSAS = aliceVerificationService.beginKeyVerification(VerificationMethod.SAS, bobUserId, bobDeviceId, null)
+        mTestHelper.await(aliceSASLatch)
+        mTestHelper.await(bobSASLatch)
+
+        val aliceTx = aliceVerificationService.getExistingTransaction(bobUserId, verificationSAS!!) as SASDefaultVerificationTransaction
+        val bobTx = bobVerificationService.getExistingTransaction(aliceSession.myUserId, verificationSAS) as SASDefaultVerificationTransaction
+
+        assertEquals("Should have same SAS", aliceTx.getShortCodeRepresentation(SasMode.DECIMAL),
+                bobTx.getShortCodeRepresentation(SasMode.DECIMAL))
+
+        cryptoTestData.cleanUp(mTestHelper)
+    }
+
+    @Test
+    fun test_happyPath() {
+        val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom()
+
+        val aliceSession = cryptoTestData.firstSession
+        val bobSession = cryptoTestData.secondSession
+
+        val aliceVerificationService = aliceSession.cryptoService().verificationService()
+        val bobVerificationService = bobSession!!.cryptoService().verificationService()
+
+        val aliceSASLatch = CountDownLatch(1)
+        val aliceListener = object : VerificationService.Listener {
+            var matchOnce = true
+            override fun transactionUpdated(tx: VerificationTransaction) {
+                val uxState = (tx as OutgoingSasVerificationTransaction).uxState
+                Log.v("TEST", "== aliceState ${uxState.name}")
+                when (uxState) {
+                    OutgoingSasVerificationTransaction.UxState.SHOW_SAS -> {
+                        tx.userHasVerifiedShortCode()
+                    }
+                    OutgoingSasVerificationTransaction.UxState.VERIFIED -> {
+                        if (matchOnce) {
+                            matchOnce = false
+                            aliceSASLatch.countDown()
+                        }
+                    }
+                    else                                                -> Unit
+                }
+            }
+        }
+        aliceVerificationService.addListener(aliceListener)
+
+        val bobSASLatch = CountDownLatch(1)
+        val bobListener = object : VerificationService.Listener {
+            var acceptOnce = true
+            var matchOnce = true
+            override fun transactionUpdated(tx: VerificationTransaction) {
+                val uxState = (tx as IncomingSasVerificationTransaction).uxState
+                Log.v("TEST", "== bobState ${uxState.name}")
+                when (uxState) {
+                    IncomingSasVerificationTransaction.UxState.SHOW_ACCEPT -> {
+                        if (acceptOnce) {
+                            acceptOnce = false
+                            tx.performAccept()
+                        }
+                    }
+                    IncomingSasVerificationTransaction.UxState.SHOW_SAS    -> {
+                        if (matchOnce) {
+                            matchOnce = false
+                            tx.userHasVerifiedShortCode()
+                        }
+                    }
+                    IncomingSasVerificationTransaction.UxState.VERIFIED    -> {
+                        bobSASLatch.countDown()
+                    }
+                    else                                                   -> Unit
+                }
+            }
+        }
+        bobVerificationService.addListener(bobListener)
+
+        val bobUserId = bobSession.myUserId
+        val bobDeviceId = bobSession.cryptoService().getMyDevice().deviceId
+        aliceVerificationService.beginKeyVerification(VerificationMethod.SAS, bobUserId, bobDeviceId, null)
+        mTestHelper.await(aliceSASLatch)
+        mTestHelper.await(bobSASLatch)
+
+        // Assert that devices are verified
+        val bobDeviceInfoFromAlicePOV: CryptoDeviceInfo? = aliceSession.cryptoService().getDeviceInfo(bobUserId, bobDeviceId)
+        val aliceDeviceInfoFromBobPOV: CryptoDeviceInfo? = bobSession.cryptoService().getDeviceInfo(aliceSession.myUserId, aliceSession.cryptoService().getMyDevice().deviceId)
+
+        // latch wait a bit again
+        Thread.sleep(1000)
+
+        assertTrue("alice device should be verified from bob point of view", aliceDeviceInfoFromBobPOV!!.isVerified)
+        assertTrue("bob device should be verified from alice point of view", bobDeviceInfoFromAlicePOV!!.isVerified)
+        cryptoTestData.cleanUp(mTestHelper)
+    }
+
+    @Test
+    fun test_ConcurrentStart() {
+        val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom()
+
+        val aliceSession = cryptoTestData.firstSession
+        val bobSession = cryptoTestData.secondSession
+
+        val aliceVerificationService = aliceSession.cryptoService().verificationService()
+        val bobVerificationService = bobSession!!.cryptoService().verificationService()
+
+        val req = aliceVerificationService.requestKeyVerificationInDMs(
+                listOf(VerificationMethod.SAS, VerificationMethod.QR_CODE_SCAN, VerificationMethod.QR_CODE_SHOW),
+                bobSession.myUserId,
+                cryptoTestData.roomId
+        )
+
+        var requestID : String? = null
+
+        mTestHelper.waitWithLatch {
+            mTestHelper.retryPeriodicallyWithLatch(it) {
+                val prAlicePOV = aliceVerificationService.getExistingVerificationRequest(bobSession.myUserId)?.firstOrNull()
+                requestID = prAlicePOV?.transactionId
+                Log.v("TEST", "== alicePOV is $prAlicePOV")
+                prAlicePOV?.transactionId != null && prAlicePOV.localId == req.localId
+            }
+        }
+
+        Log.v("TEST", "== requestID is $requestID")
+
+        mTestHelper.waitWithLatch {
+            mTestHelper.retryPeriodicallyWithLatch(it) {
+                val prBobPOV = bobVerificationService.getExistingVerificationRequest(aliceSession.myUserId)?.firstOrNull()
+                Log.v("TEST", "== prBobPOV is $prBobPOV")
+                prBobPOV?.transactionId == requestID
+            }
+        }
+
+        bobVerificationService.readyPendingVerification(
+                listOf(VerificationMethod.SAS, VerificationMethod.QR_CODE_SCAN, VerificationMethod.QR_CODE_SHOW),
+                aliceSession.myUserId,
+                requestID!!
+        )
+
+        // wait for alice to get the ready
+        mTestHelper.waitWithLatch {
+            mTestHelper.retryPeriodicallyWithLatch(it) {
+                val prAlicePOV = aliceVerificationService.getExistingVerificationRequest(bobSession.myUserId)?.firstOrNull()
+                Log.v("TEST", "== prAlicePOV is $prAlicePOV")
+                prAlicePOV?.transactionId == requestID && prAlicePOV?.isReady != null
+            }
+        }
+
+        // Start concurrent!
+        aliceVerificationService.beginKeyVerificationInDMs(
+                VerificationMethod.SAS,
+                requestID!!,
+                cryptoTestData.roomId,
+                bobSession.myUserId,
+                bobSession.sessionParams.deviceId!!,
+                null)
+
+        bobVerificationService.beginKeyVerificationInDMs(
+                VerificationMethod.SAS,
+                requestID!!,
+                cryptoTestData.roomId,
+                aliceSession.myUserId,
+                aliceSession.sessionParams.deviceId!!,
+                null)
+
+        // we should reach SHOW SAS on both
+        var alicePovTx: SasVerificationTransaction?
+        var bobPovTx: SasVerificationTransaction?
+
+        mTestHelper.waitWithLatch {
+            mTestHelper.retryPeriodicallyWithLatch(it) {
+                alicePovTx = aliceVerificationService.getExistingTransaction(bobSession.myUserId, requestID!!) as? SasVerificationTransaction
+                Log.v("TEST", "== alicePovTx is $alicePovTx")
+                alicePovTx?.state == VerificationTxState.ShortCodeReady
+            }
+        }
+        // wait for alice to get the ready
+        mTestHelper.waitWithLatch {
+            mTestHelper.retryPeriodicallyWithLatch(it) {
+                bobPovTx = bobVerificationService.getExistingTransaction(aliceSession.myUserId, requestID!!) as? SasVerificationTransaction
+                Log.v("TEST", "== bobPovTx is $bobPovTx")
+                bobPovTx?.state == VerificationTxState.ShortCodeReady
+            }
+        }
+
+        cryptoTestData.cleanUp(mTestHelper)
+    }
+}

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/verification/qrcode/HexParser.kt

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2020 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.internal.crypto.verification.qrcode
+
+fun hexToByteArray(hex: String): ByteArray {
+    // Remove all spaces
+    return hex.replace(" ", "")
+            .let {
+                if (it.length % 2 != 0) "0$it" else it
+            }
+            .let {
+                ByteArray(it.length / 2)
+                        .apply {
+                            for (i in this.indices) {
+                                val index = i * 2
+                                val v = it.substring(index, index + 2).toInt(16)
+                                this[i] = v.toByte()
+                            }
+                        }
+            }
+}

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/verification/qrcode/QrCodeTest.kt

@@ -0,0 +1,249 @@
+/*
+ * Copyright (c) 2020 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.internal.crypto.verification.qrcode
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import im.vector.matrix.android.InstrumentedTest
+import org.amshove.kluent.shouldBeNull
+import org.amshove.kluent.shouldEqual
+import org.amshove.kluent.shouldEqualTo
+import org.amshove.kluent.shouldNotBeNull
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+
+@RunWith(AndroidJUnit4::class)
+@FixMethodOrder(MethodSorters.JVM)
+class QrCodeTest : InstrumentedTest {
+
+    private val qrCode1 = QrCodeData.VerifyingAnotherUser(
+            transactionId = "MaTransaction",
+            userMasterCrossSigningPublicKey = "ktEwcUP6su1xh+GuE+CYkQ3H6W/DIl+ybHFdaEOrolU",
+            otherUserMasterCrossSigningPublicKey = "TXluZKTZLvSRWOTPlOqLq534bA+/K4zLFKSu9cGLQaU",
+            sharedSecret = "MTIzNDU2Nzg"
+    )
+
+    private val value1 = "MATRIX\u0002\u0000\u0000\u000DMaTransaction\u0092Ñ0qCú²íq\u0087á®\u0013à\u0098\u0091\u000DÇéoÃ\"_²lq]hC«¢UMynd¤Ù.ô\u0091XäÏ\u0094ê\u008B«\u009Døl\u000F¿+\u008CË\u0014¤®õÁ\u008BA¥12345678"
+
+    private val qrCode2 = QrCodeData.SelfVerifyingMasterKeyTrusted(
+            transactionId = "MaTransaction",
+            userMasterCrossSigningPublicKey = "ktEwcUP6su1xh+GuE+CYkQ3H6W/DIl+ybHFdaEOrolU",
+            otherDeviceKey = "TXluZKTZLvSRWOTPlOqLq534bA+/K4zLFKSu9cGLQaU",
+            sharedSecret = "MTIzNDU2Nzg"
+    )
+
+    private val value2 = "MATRIX\u0002\u0001\u0000\u000DMaTransaction\u0092Ñ0qCú²íq\u0087á®\u0013à\u0098\u0091\u000DÇéoÃ\"_²lq]hC«¢UMynd¤Ù.ô\u0091XäÏ\u0094ê\u008B«\u009Døl\u000F¿+\u008CË\u0014¤®õÁ\u008BA¥12345678"
+
+    private val qrCode3 = QrCodeData.SelfVerifyingMasterKeyNotTrusted(
+            transactionId = "MaTransaction",
+            deviceKey = "TXluZKTZLvSRWOTPlOqLq534bA+/K4zLFKSu9cGLQaU",
+            userMasterCrossSigningPublicKey = "ktEwcUP6su1xh+GuE+CYkQ3H6W/DIl+ybHFdaEOrolU",
+            sharedSecret = "MTIzNDU2Nzg"
+    )
+
+    private val value3 = "MATRIX\u0002\u0002\u0000\u000DMaTransactionMynd¤Ù.ô\u0091XäÏ\u0094ê\u008B«\u009Døl\u000F¿+\u008CË\u0014¤®õÁ\u008BA¥\u0092Ñ0qCú²íq\u0087á®\u0013à\u0098\u0091\u000DÇéoÃ\"_²lq]hC«¢U12345678"
+
+    private val sharedSecretByteArray = "12345678".toByteArray(Charsets.ISO_8859_1)
+
+    private val tlx_byteArray = hexToByteArray("4d 79 6e 64 a4 d9 2e f4 91 58 e4 cf 94 ea 8b ab 9d f8 6c 0f bf 2b 8c cb 14 a4 ae f5 c1 8b 41 a5")
+
+    private val kte_byteArray = hexToByteArray("92 d1 30 71 43 fa b2 ed 71 87 e1 ae 13 e0 98 91 0d c7 e9 6f c3 22 5f b2 6c 71 5d 68 43 ab a2 55")
+
+    @Test
+    fun testEncoding1() {
+        qrCode1.toEncodedString() shouldEqual value1
+    }
+
+    @Test
+    fun testEncoding2() {
+        qrCode2.toEncodedString() shouldEqual value2
+    }
+
+    @Test
+    fun testEncoding3() {
+        qrCode3.toEncodedString() shouldEqual value3
+    }
+
+    @Test
+    fun testSymmetry1() {
+        qrCode1.toEncodedString().toQrCodeData() shouldEqual qrCode1
+    }
+
+    @Test
+    fun testSymmetry2() {
+        qrCode2.toEncodedString().toQrCodeData() shouldEqual qrCode2
+    }
+
+    @Test
+    fun testSymmetry3() {
+        qrCode3.toEncodedString().toQrCodeData() shouldEqual qrCode3
+    }
+
+    @Test
+    fun testCase1() {
+        val url = qrCode1.toEncodedString()
+
+        val byteArray = url.toByteArray(Charsets.ISO_8859_1)
+        checkHeader(byteArray)
+
+        // Mode
+        byteArray[7] shouldEqualTo 0
+
+        checkSizeAndTransaction(byteArray)
+
+        compareArray(byteArray.copyOfRange(23, 23 + 32), kte_byteArray)
+        compareArray(byteArray.copyOfRange(23 + 32, 23 + 64), tlx_byteArray)
+
+        compareArray(byteArray.copyOfRange(23 + 64, byteArray.size), sharedSecretByteArray)
+    }
+
+    @Test
+    fun testCase2() {
+        val url = qrCode2.toEncodedString()
+
+        val byteArray = url.toByteArray(Charsets.ISO_8859_1)
+        checkHeader(byteArray)
+
+        // Mode
+        byteArray[7] shouldEqualTo 1
+
+        checkSizeAndTransaction(byteArray)
+        compareArray(byteArray.copyOfRange(23, 23 + 32), kte_byteArray)
+        compareArray(byteArray.copyOfRange(23 + 32, 23 + 64), tlx_byteArray)
+
+        compareArray(byteArray.copyOfRange(23 + 64, byteArray.size), sharedSecretByteArray)
+    }
+
+    @Test
+    fun testCase3() {
+        val url = qrCode3.toEncodedString()
+
+        val byteArray = url.toByteArray(Charsets.ISO_8859_1)
+        checkHeader(byteArray)
+
+        // Mode
+        byteArray[7] shouldEqualTo 2
+
+        checkSizeAndTransaction(byteArray)
+        compareArray(byteArray.copyOfRange(23, 23 + 32), tlx_byteArray)
+        compareArray(byteArray.copyOfRange(23 + 32, 23 + 64), kte_byteArray)
+
+        compareArray(byteArray.copyOfRange(23 + 64, byteArray.size), sharedSecretByteArray)
+    }
+
+    @Test
+    fun testLongTransactionId() {
+        // Size on two bytes (2_000 = 0x07D0)
+        val longTransactionId = "PatternId_".repeat(200)
+
+        val qrCode = qrCode1.copy(transactionId = longTransactionId)
+
+        val result = qrCode.toEncodedString()
+        val expected = value1.replace("\u0000\u000DMaTransaction", "\u0007\u00D0$longTransactionId")
+
+        result shouldEqual expected
+
+        // Reverse operation
+        expected.toQrCodeData() shouldEqual qrCode
+    }
+
+    @Test
+    fun testAnyTransactionId() {
+        for (qty in 0 until 0x1FFF step 200) {
+            val longTransactionId = "a".repeat(qty)
+
+            val qrCode = qrCode1.copy(transactionId = longTransactionId)
+
+            // Symmetric operation
+            qrCode.toEncodedString().toQrCodeData() shouldEqual qrCode
+        }
+    }
+
+    // Error cases
+    @Test
+    fun testErrorHeader() {
+        value1.replace("MATRIX", "MOTRIX").toQrCodeData().shouldBeNull()
+        value1.replace("MATRIX", "MATRI").toQrCodeData().shouldBeNull()
+        value1.replace("MATRIX", "").toQrCodeData().shouldBeNull()
+    }
+
+    @Test
+    fun testErrorVersion() {
+        value1.replace("MATRIX\u0002", "MATRIX\u0000").toQrCodeData().shouldBeNull()
+        value1.replace("MATRIX\u0002", "MATRIX\u0001").toQrCodeData().shouldBeNull()
+        value1.replace("MATRIX\u0002", "MATRIX\u0003").toQrCodeData().shouldBeNull()
+        value1.replace("MATRIX\u0002", "MATRIX").toQrCodeData().shouldBeNull()
+    }
+
+    @Test
+    fun testErrorSecretTooShort() {
+        value1.replace("12345678", "1234567").toQrCodeData().shouldBeNull()
+    }
+
+    @Test
+    fun testErrorNoTransactionNoKeyNoSecret() {
+        // But keep transaction length
+        "MATRIX\u0002\u0000\u0000\u000D".toQrCodeData().shouldBeNull()
+    }
+
+    @Test
+    fun testErrorNoKeyNoSecret() {
+        "MATRIX\u0002\u0000\u0000\u000DMaTransaction".toQrCodeData().shouldBeNull()
+    }
+
+    @Test
+    fun testErrorTransactionLengthTooShort() {
+        // In this case, the secret will be longer, so this is not an error, but it will lead to keys mismatch
+        value1.replace("\u000DMaTransaction", "\u000CMaTransaction").toQrCodeData().shouldNotBeNull()
+    }
+
+    @Test
+    fun testErrorTransactionLengthTooBig() {
+        value1.replace("\u000DMaTransaction", "\u000EMaTransaction").toQrCodeData().shouldBeNull()
+    }
+
+    private fun compareArray(actual: ByteArray, expected: ByteArray) {
+        actual.size shouldEqual expected.size
+
+        for (i in actual.indices) {
+            actual[i] shouldEqualTo expected[i]
+        }
+    }
+
+    private fun checkHeader(byteArray: ByteArray) {
+        // MATRIX
+        byteArray[0] shouldEqualTo 'M'.toByte()
+        byteArray[1] shouldEqualTo 'A'.toByte()
+        byteArray[2] shouldEqualTo 'T'.toByte()
+        byteArray[3] shouldEqualTo 'R'.toByte()
+        byteArray[4] shouldEqualTo 'I'.toByte()
+        byteArray[5] shouldEqualTo 'X'.toByte()
+
+        // Version
+        byteArray[6] shouldEqualTo 2
+    }
+
+    private fun checkSizeAndTransaction(byteArray: ByteArray) {
+        // Size
+        byteArray[8] shouldEqualTo 0
+        byteArray[9] shouldEqualTo 13
+
+        // Transaction
+        byteArray.copyOfRange(10, 10 + "MaTransaction".length).toString(Charsets.ISO_8859_1) shouldEqual "MaTransaction"
+    }
+}

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/verification/qrcode/SharedSecretTest.kt

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 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.internal.crypto.verification.qrcode
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import im.vector.matrix.android.InstrumentedTest
+import org.amshove.kluent.shouldBe
+import org.amshove.kluent.shouldNotBeEqualTo
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+
+@RunWith(AndroidJUnit4::class)
+@FixMethodOrder(MethodSorters.JVM)
+class SharedSecretTest : InstrumentedTest {
+
+    @Test
+    fun testSharedSecretLengthCase() {
+        repeat(100) {
+            generateSharedSecretV2().length shouldBe 11
+        }
+    }
+
+    @Test
+    fun testSharedDiffCase() {
+        val sharedSecret1 = generateSharedSecretV2()
+        val sharedSecret2 = generateSharedSecretV2()
+
+        sharedSecret1 shouldNotBeEqualTo sharedSecret2
+    }
+}

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/verification/qrcode/VerificationTest.kt

@@ -0,0 +1,232 @@
+/*
+ * Copyright (c) 2020 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.internal.crypto.verification.qrcode
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import im.vector.matrix.android.InstrumentedTest
+import im.vector.matrix.android.api.session.crypto.verification.VerificationMethod
+import im.vector.matrix.android.api.session.crypto.verification.VerificationService
+import im.vector.matrix.android.common.CommonTestHelper
+import im.vector.matrix.android.common.CryptoTestHelper
+import im.vector.matrix.android.common.TestConstants
+import im.vector.matrix.android.internal.crypto.model.rest.UserPasswordAuth
+import im.vector.matrix.android.api.session.crypto.verification.PendingVerificationRequest
+import org.amshove.kluent.shouldBe
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+import java.util.concurrent.CountDownLatch
+
+@RunWith(AndroidJUnit4::class)
+@FixMethodOrder(MethodSorters.JVM)
+class VerificationTest : InstrumentedTest {
+    private val mTestHelper = CommonTestHelper(context())
+    private val mCryptoTestHelper = CryptoTestHelper(mTestHelper)
+
+    data class ExpectedResult(
+            val sasIsSupported: Boolean = false,
+            val otherCanScanQrCode: Boolean = false,
+            val otherCanShowQrCode: Boolean = false
+    )
+
+    private val sas = listOf(
+            VerificationMethod.SAS
+    )
+
+    private val sasShow = listOf(
+            VerificationMethod.SAS,
+            VerificationMethod.QR_CODE_SHOW
+    )
+
+    private val sasScan = listOf(
+            VerificationMethod.SAS,
+            VerificationMethod.QR_CODE_SCAN
+    )
+
+    private val sasShowScan = listOf(
+            VerificationMethod.SAS,
+            VerificationMethod.QR_CODE_SHOW,
+            VerificationMethod.QR_CODE_SCAN
+    )
+
+    @Test
+    fun test_aliceAndBob_sas_sas() = doTest(
+            sas,
+            sas,
+            ExpectedResult(sasIsSupported = true),
+            ExpectedResult(sasIsSupported = true)
+    )
+
+    @Test
+    fun test_aliceAndBob_sas_show() = doTest(
+            sas,
+            sasShow,
+            ExpectedResult(sasIsSupported = true),
+            ExpectedResult(sasIsSupported = true)
+    )
+
+    @Test
+    fun test_aliceAndBob_show_sas() = doTest(
+            sasShow,
+            sas,
+            ExpectedResult(sasIsSupported = true),
+            ExpectedResult(sasIsSupported = true)
+    )
+
+    @Test
+    fun test_aliceAndBob_sas_scan() = doTest(
+            sas,
+            sasScan,
+            ExpectedResult(sasIsSupported = true),
+            ExpectedResult(sasIsSupported = true)
+    )
+
+    @Test
+    fun test_aliceAndBob_scan_sas() = doTest(
+            sasScan,
+            sas,
+            ExpectedResult(sasIsSupported = true),
+            ExpectedResult(sasIsSupported = true)
+    )
+
+    @Test
+    fun test_aliceAndBob_scan_scan() = doTest(
+            sasScan,
+            sasScan,
+            ExpectedResult(sasIsSupported = true),
+            ExpectedResult(sasIsSupported = true)
+    )
+
+    @Test
+    fun test_aliceAndBob_show_show() = doTest(
+            sasShow,
+            sasShow,
+            ExpectedResult(sasIsSupported = true),
+            ExpectedResult(sasIsSupported = true)
+    )
+
+    @Test
+    fun test_aliceAndBob_show_scan() = doTest(
+            sasShow,
+            sasScan,
+            ExpectedResult(sasIsSupported = true, otherCanScanQrCode = true),
+            ExpectedResult(sasIsSupported = true, otherCanShowQrCode = true)
+    )
+
+    @Test
+    fun test_aliceAndBob_scan_show() = doTest(
+            sasScan,
+            sasShow,
+            ExpectedResult(sasIsSupported = true, otherCanShowQrCode = true),
+            ExpectedResult(sasIsSupported = true, otherCanScanQrCode = true)
+    )
+
+    @Test
+    fun test_aliceAndBob_all_all() = doTest(
+            sasShowScan,
+            sasShowScan,
+            ExpectedResult(sasIsSupported = true, otherCanShowQrCode = true, otherCanScanQrCode = true),
+            ExpectedResult(sasIsSupported = true, otherCanShowQrCode = true, otherCanScanQrCode = true)
+    )
+
+    // TODO Add tests without SAS
+
+    private fun doTest(aliceSupportedMethods: List<VerificationMethod>,
+                       bobSupportedMethods: List<VerificationMethod>,
+                       expectedResultForAlice: ExpectedResult,
+                       expectedResultForBob: ExpectedResult) {
+        val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom()
+
+        val aliceSession = cryptoTestData.firstSession
+        val bobSession = cryptoTestData.secondSession!!
+
+        mTestHelper.doSync<Unit> { callback ->
+            aliceSession.cryptoService().crossSigningService()
+                    .initializeCrossSigning(UserPasswordAuth(
+                            user = aliceSession.myUserId,
+                            password = TestConstants.PASSWORD
+                    ), callback)
+        }
+
+        mTestHelper.doSync<Unit> { callback ->
+            bobSession.cryptoService().crossSigningService()
+                    .initializeCrossSigning(UserPasswordAuth(
+                            user = bobSession.myUserId,
+                            password = TestConstants.PASSWORD
+                    ), callback)
+        }
+
+        val aliceVerificationService = aliceSession.cryptoService().verificationService()
+        val bobVerificationService = bobSession.cryptoService().verificationService()
+
+        var aliceReadyPendingVerificationRequest: PendingVerificationRequest? = null
+        var bobReadyPendingVerificationRequest: PendingVerificationRequest? = null
+
+        val latch = CountDownLatch(2)
+        val aliceListener = object : VerificationService.Listener {
+            override fun verificationRequestUpdated(pr: PendingVerificationRequest) {
+                // Step 4: Alice receive the ready request
+                if (pr.isReady) {
+                    aliceReadyPendingVerificationRequest = pr
+                    latch.countDown()
+                }
+            }
+        }
+        aliceVerificationService.addListener(aliceListener)
+
+        val bobListener = object : VerificationService.Listener {
+            override fun verificationRequestCreated(pr: PendingVerificationRequest) {
+                // Step 2: Bob accepts the verification request
+                bobVerificationService.readyPendingVerificationInDMs(
+                        bobSupportedMethods,
+                        aliceSession.myUserId,
+                        cryptoTestData.roomId,
+                        pr.transactionId!!
+                )
+            }
+
+            override fun verificationRequestUpdated(pr: PendingVerificationRequest) {
+                // Step 3: Bob is ready
+                if (pr.isReady) {
+                    bobReadyPendingVerificationRequest = pr
+                    latch.countDown()
+                }
+            }
+        }
+        bobVerificationService.addListener(bobListener)
+
+        val bobUserId = bobSession.myUserId
+        // Step 1: Alice starts a verification request
+        aliceVerificationService.requestKeyVerificationInDMs(aliceSupportedMethods, bobUserId, cryptoTestData.roomId)
+        mTestHelper.await(latch)
+
+        aliceReadyPendingVerificationRequest!!.let { pr ->
+            pr.isSasSupported() shouldBe expectedResultForAlice.sasIsSupported
+            pr.otherCanShowQrCode() shouldBe expectedResultForAlice.otherCanShowQrCode
+            pr.otherCanScanQrCode() shouldBe expectedResultForAlice.otherCanScanQrCode
+        }
+
+        bobReadyPendingVerificationRequest!!.let { pr ->
+            pr.isSasSupported() shouldBe expectedResultForBob.sasIsSupported
+            pr.otherCanShowQrCode() shouldBe expectedResultForBob.otherCanShowQrCode
+            pr.otherCanScanQrCode() shouldBe expectedResultForBob.otherCanScanQrCode
+        }
+
+        cryptoTestData.cleanUp(mTestHelper)
+    }
+}

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/session/room/send/MarkdownParserTest.kt

@@ -0,0 +1,278 @@
+/*
+ * Copyright (c) 2020 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.internal.session.room.send
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import im.vector.matrix.android.InstrumentedTest
+import org.commonmark.parser.Parser
+import org.commonmark.renderer.html.HtmlRenderer
+import org.commonmark.renderer.text.TextContentRenderer
+import org.junit.Assert.assertEquals
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+
+/**
+ * It will not be possible to test all combinations. For the moment I add a few tests, then, depending on the problem discovered in the wild,
+ * we can add more tests to cover the edge cases.
+ * Some tests are suffixed with `_not_passing`, maybe one day we will fix them...
+ * Riot-Web should be used as a reference for expected results, but not always. Especially Riot-Web add lots of `\n` in the
+ * formatted body, which is quite useless.
+ * Also Riot-Web does not provide plain text body when formatted text is provided. The body contains what the user has entered.
+ * See https://matrix.org/docs/spec/client_server/latest#m-room-message-msgtypes
+ */
+@Suppress("SpellCheckingInspection")
+@RunWith(AndroidJUnit4::class)
+@FixMethodOrder(MethodSorters.JVM)
+class MarkdownParserTest : InstrumentedTest {
+
+    /**
+     * Create the same parser than in the RoomModule
+     */
+    private val markdownParser = MarkdownParser(
+            Parser.builder().build(),
+            HtmlRenderer.builder().build(),
+            TextContentRenderer.builder().build()
+    )
+
+    @Test
+    fun parseNoMarkdown() {
+        testIdentity("")
+        testIdentity("a")
+        testIdentity("1")
+        testIdentity("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et " +
+                "dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea com" +
+                "modo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pari" +
+                "atur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.")
+    }
+
+    @Test
+    fun parseSpaces() {
+        testIdentity(" ")
+        testIdentity("  ")
+        testIdentity("\n")
+    }
+
+    @Test
+    fun parseNewLines() {
+        testIdentity("line1\nline2")
+        testIdentity("line1\nline2\nline3")
+    }
+
+    @Test
+    fun parseBold() {
+        testType(
+                name = "bold",
+                markdownPattern = "**",
+                htmlExpectedTag = "strong"
+        )
+    }
+
+    @Test
+    fun parseItalic() {
+        testType(
+                name = "italic",
+                markdownPattern = "*",
+                htmlExpectedTag = "em"
+        )
+    }
+
+    @Test
+    fun parseItalic2() {
+        // Riot-Web format
+        "_italic_".let { markdownParser.parse(it) }.expect("italic", "<em>italic</em>")
+    }
+
+    /**
+     * Note: the test is not passing, it does not work on Riot-Web neither
+     */
+    @Test
+    fun parseStrike_not_passing() {
+        testType(
+                name = "strike",
+                markdownPattern = "~~",
+                htmlExpectedTag = "del"
+        )
+    }
+
+    @Test
+    fun parseCode() {
+        testType(
+                name = "code",
+                markdownPattern = "`",
+                htmlExpectedTag = "code",
+                plainTextPrefix = "\"",
+                plainTextSuffix = "\""
+        )
+    }
+
+    @Test
+    fun parseCode2() {
+        testType(
+                name = "code",
+                markdownPattern = "``",
+                htmlExpectedTag = "code",
+                plainTextPrefix = "\"",
+                plainTextSuffix = "\""
+        )
+    }
+
+    @Test
+    fun parseCode3() {
+        testType(
+                name = "code",
+                markdownPattern = "```",
+                htmlExpectedTag = "code",
+                plainTextPrefix = "\"",
+                plainTextSuffix = "\""
+        )
+    }
+
+    @Test
+    fun parseUnorderedList() {
+        "- item1".let { markdownParser.parse(it).expect(it, "<ul><li>item1</li></ul>") }
+        "- item1\n- item2".let { markdownParser.parse(it).expect(it, "<ul><li>item1</li><li>item2</li></ul>") }
+    }
+
+    @Test
+    fun parseOrderedList() {
+        "1. item1".let { markdownParser.parse(it).expect(it, "<ol><li>item1</li></ol>") }
+        "1. item1\n2. item2".let { markdownParser.parse(it).expect(it, "<ol><li>item1</li><li>item2</li></ol>") }
+    }
+
+    @Test
+    fun parseHorizontalLine() {
+        "---".let { markdownParser.parse(it) }.expect("***", "<hr />")
+    }
+
+    @Test
+    fun parseH2AndContent() {
+        "a\n---\nb".let { markdownParser.parse(it) }.expect("a\nb", "<h2>a</h2><p>b</p>")
+    }
+
+    @Test
+    fun parseQuote() {
+        "> quoted".let { markdownParser.parse(it) }.expect("«quoted»", "<blockquote><p>quoted</p></blockquote>")
+    }
+
+    @Test
+    fun parseQuote_not_passing() {
+        "> quoted\nline2".let { markdownParser.parse(it) }.expect("«quoted\nline2»", "<blockquote><p>quoted<br/>line2</p></blockquote>")
+    }
+
+    @Test
+    fun parseBoldItalic() {
+        "*italic* **bold**".let { markdownParser.parse(it) }.expect("italic bold", "<em>italic</em> <strong>bold</strong>")
+        "**bold** *italic*".let { markdownParser.parse(it) }.expect("bold italic", "<strong>bold</strong> <em>italic</em>")
+    }
+
+    @Test
+    fun parseHead() {
+        "# head1".let { markdownParser.parse(it) }.expect("head1", "<h1>head1</h1>")
+        "## head2".let { markdownParser.parse(it) }.expect("head2", "<h2>head2</h2>")
+        "### head3".let { markdownParser.parse(it) }.expect("head3", "<h3>head3</h3>")
+        "#### head4".let { markdownParser.parse(it) }.expect("head4", "<h4>head4</h4>")
+        "##### head5".let { markdownParser.parse(it) }.expect("head5", "<h5>head5</h5>")
+        "###### head6".let { markdownParser.parse(it) }.expect("head6", "<h6>head6</h6>")
+    }
+
+    @Test
+    fun parseHeads() {
+        "# head1\n# head2".let { markdownParser.parse(it) }.expect("head1\nhead2", "<h1>head1</h1><h1>head2</h1>")
+    }
+
+    @Test
+    fun parseBoldNewLines_not_passing() {
+        "**bold**\nline2".let { markdownParser.parse(it) }.expect("bold\nline2", "<strong>bold</strong><br />line2")
+    }
+
+    @Test
+    fun parseLinks() {
+        "[link](target)".let { markdownParser.parse(it) }.expect(""""link" (target)""", """<a href="target">link</a>""")
+    }
+
+    @Test
+    fun parseParagraph() {
+        "# head\ncontent".let { markdownParser.parse(it) }.expect("head\ncontent", "<h1>head</h1><p>content</p>")
+    }
+
+    private fun testIdentity(text: String) {
+        markdownParser.parse(text).expect(text, null)
+    }
+
+    private fun testType(name: String,
+                         markdownPattern: String,
+                         htmlExpectedTag: String,
+                         plainTextPrefix: String = "",
+                         plainTextSuffix: String = "") {
+        // Test simple case
+        "$markdownPattern$name$markdownPattern"
+                .let { markdownParser.parse(it) }
+                .expect(expectedText = "$plainTextPrefix$name$plainTextSuffix",
+                        expectedFormattedText = "<$htmlExpectedTag>$name</$htmlExpectedTag>")
+
+        // Test twice the same tag
+        "$markdownPattern$name$markdownPattern and $markdownPattern$name bis$markdownPattern"
+                .let { markdownParser.parse(it) }
+                .expect(expectedText = "$plainTextPrefix$name$plainTextSuffix and $plainTextPrefix$name bis$plainTextSuffix",
+                        expectedFormattedText = "<$htmlExpectedTag>$name</$htmlExpectedTag> and <$htmlExpectedTag>$name bis</$htmlExpectedTag>")
+
+        val textBefore = "a"
+        val textAfter = "b"
+
+        // With sticked text before
+        "$textBefore$markdownPattern$name$markdownPattern"
+                .let { markdownParser.parse(it) }
+                .expect(expectedText = "$textBefore$plainTextPrefix$name$plainTextSuffix",
+                        expectedFormattedText = "$textBefore<$htmlExpectedTag>$name</$htmlExpectedTag>")
+
+        // With text before and space
+        "$textBefore $markdownPattern$name$markdownPattern"
+                .let { markdownParser.parse(it) }
+                .expect(expectedText = "$textBefore $plainTextPrefix$name$plainTextSuffix",
+                        expectedFormattedText = "$textBefore <$htmlExpectedTag>$name</$htmlExpectedTag>")
+
+        // With sticked text after
+        "$markdownPattern$name$markdownPattern$textAfter"
+                .let { markdownParser.parse(it) }
+                .expect(expectedText = "$plainTextPrefix$name$plainTextSuffix$textAfter",
+                        expectedFormattedText = "<$htmlExpectedTag>$name</$htmlExpectedTag>$textAfter")
+
+        // With space and text after
+        "$markdownPattern$name$markdownPattern $textAfter"
+                .let { markdownParser.parse(it) }
+                .expect(expectedText = "$plainTextPrefix$name$plainTextSuffix $textAfter",
+                        expectedFormattedText = "<$htmlExpectedTag>$name</$htmlExpectedTag> $textAfter")
+
+        // With sticked text before and text after
+        "$textBefore$markdownPattern$name$markdownPattern$textAfter"
+                .let { markdownParser.parse(it) }
+                .expect(expectedText = "$textBefore$plainTextPrefix$name$plainTextSuffix$textAfter",
+                        expectedFormattedText = "a<$htmlExpectedTag>$name</$htmlExpectedTag>$textAfter")
+
+        // With text before and after, with spaces
+        "$textBefore $markdownPattern$name$markdownPattern $textAfter"
+                .let { markdownParser.parse(it) }
+                .expect(expectedText = "$textBefore $plainTextPrefix$name$plainTextSuffix $textAfter",
+                        expectedFormattedText = "$textBefore <$htmlExpectedTag>$name</$htmlExpectedTag> $textAfter")
+    }
+
+    private fun TextContent.expect(expectedText: String, expectedFormattedText: String?) {
+        assertEquals("TextContent are not identical", TextContent(expectedText, expectedFormattedText), this)
+    }
+}

matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/util/JsonCanonicalizerTest.kt

@@ -62,8 +62,6 @@ internal class JsonCanonicalizerTest : InstrumentedTest {
                 JsonCanonicalizer.canonicalize("{\"a\":\"\\\"\"}"))
     }
 
-
-
     /* ==========================================================================================
      * Test from https://matrix.org/docs/spec/appendices.html#examples
      * ========================================================================================== */
@@ -74,7 +72,6 @@ internal class JsonCanonicalizerTest : InstrumentedTest {
                 JsonCanonicalizer.canonicalize("""{}"""))
     }
 
-
     @Test
     fun matrixOrg002Test() {
         assertEquals("""{"one":1,"two":"Two"}""",
@@ -84,7 +81,6 @@ internal class JsonCanonicalizerTest : InstrumentedTest {
 }"""))
     }
 
-
     @Test
     fun matrixOrg003Test() {
         assertEquals("""{"a":"1","b":"2"}""",
@@ -94,14 +90,12 @@ internal class JsonCanonicalizerTest : InstrumentedTest {
 }"""))
     }
 
-
     @Test
     fun matrixOrg004Test() {
         assertEquals("""{"a":"1","b":"2"}""",
                 JsonCanonicalizer.canonicalize("""{"b":"2","a":"1"}"""))
     }
 
-
     @Test
     fun matrixOrg005Test() {
         assertEquals("""{"auth":{"mxid":"@john.doe:example.com","profile":{"display_name":"John Doe","three_pids":[{"address":"john.doe@example.org","medium":"email"},{"address":"123456789","medium":"msisdn"}]},"success":true}}""",
@@ -126,7 +120,6 @@ internal class JsonCanonicalizerTest : InstrumentedTest {
 }"""))
     }
 
-
     @Test
     fun matrixOrg006Test() {
         assertEquals("""{"a":"日本語"}""",
@@ -135,7 +128,6 @@ internal class JsonCanonicalizerTest : InstrumentedTest {
 }"""))
     }
 
-
     @Test
     fun matrixOrg007Test() {
         assertEquals("""{"日":1,"本":2}""",
@@ -145,7 +137,6 @@ internal class JsonCanonicalizerTest : InstrumentedTest {
 }"""))
     }
 
-
     @Test
     fun matrixOrg008Test() {
         assertEquals("""{"a":"日"}""",
@@ -159,4 +150,4 @@ internal class JsonCanonicalizerTest : InstrumentedTest {
     "a": null
 }"""))
     }
-}
+}

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

@@ -19,23 +19,25 @@ 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.*
+import im.vector.matrix.android.api.session.events.model.Event
+import im.vector.matrix.android.api.session.room.send.SendState
+import im.vector.matrix.android.internal.database.helper.addTimelineEvent
+import im.vector.matrix.android.internal.database.helper.merge
+import im.vector.matrix.android.internal.database.mapper.toEntity
 import im.vector.matrix.android.internal.database.model.ChunkEntity
+import im.vector.matrix.android.internal.database.model.SessionRealmModule
 import im.vector.matrix.android.internal.session.room.timeline.PaginationDirection
 import im.vector.matrix.android.session.room.timeline.RoomDataHelper.createFakeListOfEvents
 import im.vector.matrix.android.session.room.timeline.RoomDataHelper.createFakeMessageEvent
-import im.vector.matrix.android.session.room.timeline.RoomDataHelper.createFakeRoomMemberEvent
 import io.realm.Realm
 import io.realm.RealmConfiguration
 import io.realm.kotlin.createObject
-import org.amshove.kluent.shouldBeFalse
 import org.amshove.kluent.shouldBeTrue
 import org.amshove.kluent.shouldEqual
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
 
-
 @RunWith(AndroidJUnit4::class)
 internal class ChunkEntityTest : InstrumentedTest {
 
@@ -44,17 +46,23 @@ internal class ChunkEntityTest : InstrumentedTest {
     @Before
     fun setup() {
         Realm.init(context())
-        val testConfig = RealmConfiguration.Builder().inMemory().name("test-realm").build()
+        val testConfig = RealmConfiguration.Builder()
+                .inMemory()
+                .name("test-realm")
+                .modules(SessionRealmModule())
+                .build()
         monarchy = Monarchy.Builder().setRealmConfiguration(testConfig).build()
     }
 
-
     @Test
     fun add_shouldAdd_whenNotAlreadyIncluded() {
         monarchy.runTransactionSync { realm ->
             val chunk: ChunkEntity = realm.createObject()
-            val fakeEvent = createFakeMessageEvent()
-            chunk.add("roomId", fakeEvent, PaginationDirection.FORWARDS)
+
+            val fakeEvent = createFakeMessageEvent().toEntity(ROOM_ID, SendState.SYNCED, System.currentTimeMillis()).let {
+                realm.copyToRealmOrUpdate(it)
+            }
+            chunk.addTimelineEvent(ROOM_ID, fakeEvent, PaginationDirection.FORWARDS, emptyMap())
             chunk.timelineEvents.size shouldEqual 1
         }
     }
@@ -63,65 +71,23 @@ internal class ChunkEntityTest : InstrumentedTest {
     fun add_shouldNotAdd_whenAlreadyIncluded() {
         monarchy.runTransactionSync { realm ->
             val chunk: ChunkEntity = realm.createObject()
-            val fakeEvent = createFakeMessageEvent()
-            chunk.add("roomId", fakeEvent, PaginationDirection.FORWARDS)
-            chunk.add("roomId", fakeEvent, PaginationDirection.FORWARDS)
+            val fakeEvent = createFakeMessageEvent().toEntity(ROOM_ID, SendState.SYNCED, System.currentTimeMillis()).let {
+                realm.copyToRealmOrUpdate(it)
+            }
+            chunk.addTimelineEvent(ROOM_ID, fakeEvent, PaginationDirection.FORWARDS, emptyMap())
+            chunk.addTimelineEvent(ROOM_ID, fakeEvent, PaginationDirection.FORWARDS, emptyMap())
             chunk.timelineEvents.size shouldEqual 1
         }
     }
 
-    @Test
-    fun add_shouldStateIndexIncremented_whenStateEventIsAddedForward() {
-        monarchy.runTransactionSync { realm ->
-            val chunk: ChunkEntity = realm.createObject()
-            val fakeEvent = createFakeRoomMemberEvent()
-            chunk.add("roomId", fakeEvent, PaginationDirection.FORWARDS)
-            chunk.lastStateIndex(PaginationDirection.FORWARDS) shouldEqual 1
-        }
-    }
-
-    @Test
-    fun add_shouldStateIndexNotIncremented_whenNoStateEventIsAdded() {
-        monarchy.runTransactionSync { realm ->
-            val chunk: ChunkEntity = realm.createObject()
-            val fakeEvent = createFakeMessageEvent()
-            chunk.add("roomId", fakeEvent, PaginationDirection.FORWARDS)
-            chunk.lastStateIndex(PaginationDirection.FORWARDS) shouldEqual 0
-        }
-    }
-
-    @Test
-    fun addAll_shouldStateIndexIncremented_whenStateEventsAreAddedForward() {
-        monarchy.runTransactionSync { realm ->
-            val chunk: ChunkEntity = realm.createObject()
-            val fakeEvents = createFakeListOfEvents(30)
-            val numberOfStateEvents = fakeEvents.filter { it.isStateEvent() }.size
-            chunk.addAll("roomId", fakeEvents, PaginationDirection.FORWARDS)
-            chunk.lastStateIndex(PaginationDirection.FORWARDS) shouldEqual numberOfStateEvents
-        }
-    }
-
-    @Test
-    fun addAll_shouldStateIndexDecremented_whenStateEventsAreAddedBackward() {
-        monarchy.runTransactionSync { realm ->
-            val chunk: ChunkEntity = realm.createObject()
-            val fakeEvents = createFakeListOfEvents(30)
-            val numberOfStateEvents = fakeEvents.filter { it.isStateEvent() }.size
-            val lastIsState = fakeEvents.last().isStateEvent()
-            val expectedStateIndex = if (lastIsState) -numberOfStateEvents + 1 else -numberOfStateEvents
-            chunk.addAll("roomId", fakeEvents, PaginationDirection.BACKWARDS)
-            chunk.lastStateIndex(PaginationDirection.BACKWARDS) shouldEqual expectedStateIndex
-        }
-    }
-
     @Test
     fun merge_shouldAddEvents_whenMergingBackward() {
         monarchy.runTransactionSync { realm ->
             val chunk1: ChunkEntity = realm.createObject()
             val chunk2: ChunkEntity = realm.createObject()
-            chunk1.addAll("roomId", createFakeListOfEvents(30), PaginationDirection.BACKWARDS)
-            chunk2.addAll("roomId", createFakeListOfEvents(30), PaginationDirection.BACKWARDS)
-            chunk1.merge("roomId", chunk2, PaginationDirection.BACKWARDS)
+            chunk1.addAll(ROOM_ID, createFakeListOfEvents(30), PaginationDirection.BACKWARDS)
+            chunk2.addAll(ROOM_ID, createFakeListOfEvents(30), PaginationDirection.BACKWARDS)
+            chunk1.merge(ROOM_ID, chunk2, PaginationDirection.BACKWARDS)
             chunk1.timelineEvents.size shouldEqual 60
         }
     }
@@ -135,38 +101,14 @@ internal class ChunkEntityTest : InstrumentedTest {
             val eventsForChunk2 = eventsForChunk1 + createFakeListOfEvents(10)
             chunk1.isLastForward = true
             chunk2.isLastForward = false
-            chunk1.addAll("roomId", eventsForChunk1, PaginationDirection.FORWARDS)
-            chunk2.addAll("roomId", eventsForChunk2, PaginationDirection.BACKWARDS)
-            chunk1.merge("roomId", chunk2, PaginationDirection.BACKWARDS)
+            chunk1.addAll(ROOM_ID, eventsForChunk1, PaginationDirection.FORWARDS)
+            chunk2.addAll(ROOM_ID, eventsForChunk2, PaginationDirection.BACKWARDS)
+            chunk1.merge(ROOM_ID, chunk2, PaginationDirection.BACKWARDS)
             chunk1.timelineEvents.size shouldEqual 40
             chunk1.isLastForward.shouldBeTrue()
         }
     }
 
-    @Test
-    fun merge_shouldEventsBeLinked_whenMergingLinkedWithUnlinked() {
-        monarchy.runTransactionSync { realm ->
-            val chunk1: ChunkEntity = realm.createObject()
-            val chunk2: ChunkEntity = realm.createObject()
-            chunk1.addAll("roomId", createFakeListOfEvents(30), PaginationDirection.BACKWARDS, isUnlinked = true)
-            chunk2.addAll("roomId", createFakeListOfEvents(30), PaginationDirection.BACKWARDS, isUnlinked = false)
-            chunk1.merge("roomId", chunk2, PaginationDirection.BACKWARDS)
-            chunk1.isUnlinked().shouldBeFalse()
-        }
-    }
-
-    @Test
-    fun merge_shouldEventsBeUnlinked_whenMergingUnlinkedWithUnlinked() {
-        monarchy.runTransactionSync { realm ->
-            val chunk1: ChunkEntity = realm.createObject()
-            val chunk2: ChunkEntity = realm.createObject()
-            chunk1.addAll("roomId", createFakeListOfEvents(30), PaginationDirection.BACKWARDS, isUnlinked = true)
-            chunk2.addAll("roomId", createFakeListOfEvents(30), PaginationDirection.BACKWARDS, isUnlinked = true)
-            chunk1.merge("roomId", chunk2, PaginationDirection.BACKWARDS)
-            chunk1.isUnlinked().shouldBeTrue()
-        }
-    }
-
     @Test
     fun merge_shouldPrevTokenMerged_whenMergingForwards() {
         monarchy.runTransactionSync { realm ->
@@ -174,9 +116,9 @@ internal class ChunkEntityTest : InstrumentedTest {
             val chunk2: ChunkEntity = realm.createObject()
             val prevToken = "prev_token"
             chunk1.prevToken = prevToken
-            chunk1.addAll("roomId", createFakeListOfEvents(30), PaginationDirection.BACKWARDS, isUnlinked = true)
-            chunk2.addAll("roomId", createFakeListOfEvents(30), PaginationDirection.BACKWARDS, isUnlinked = true)
-            chunk1.merge("roomId", chunk2, PaginationDirection.FORWARDS)
+            chunk1.addAll(ROOM_ID, createFakeListOfEvents(30), PaginationDirection.BACKWARDS)
+            chunk2.addAll(ROOM_ID, createFakeListOfEvents(30), PaginationDirection.BACKWARDS)
+            chunk1.merge(ROOM_ID, chunk2, PaginationDirection.FORWARDS)
             chunk1.prevToken shouldEqual prevToken
         }
     }
@@ -188,11 +130,25 @@ internal class ChunkEntityTest : InstrumentedTest {
             val chunk2: ChunkEntity = realm.createObject()
             val nextToken = "next_token"
             chunk1.nextToken = nextToken
-            chunk1.addAll("roomId", createFakeListOfEvents(30), PaginationDirection.BACKWARDS, isUnlinked = true)
-            chunk2.addAll("roomId", createFakeListOfEvents(30), PaginationDirection.BACKWARDS, isUnlinked = true)
-            chunk1.merge("roomId", chunk2, PaginationDirection.BACKWARDS)
+            chunk1.addAll(ROOM_ID, createFakeListOfEvents(30), PaginationDirection.BACKWARDS)
+            chunk2.addAll(ROOM_ID, createFakeListOfEvents(30), PaginationDirection.BACKWARDS)
+            chunk1.merge(ROOM_ID, chunk2, PaginationDirection.BACKWARDS)
             chunk1.nextToken shouldEqual nextToken
         }
     }
 
-}
+    private fun ChunkEntity.addAll(roomId: String,
+                                   events: List<Event>,
+                                   direction: PaginationDirection) {
+        events.forEach { event ->
+            val fakeEvent = event.toEntity(roomId, SendState.SYNCED, System.currentTimeMillis()).let {
+                realm.copyToRealmOrUpdate(it)
+            }
+            addTimelineEvent(roomId, fakeEvent, direction, emptyMap())
+        }
+    }
+
+    companion object {
+        private const val ROOM_ID = "roomId"
+    }
+}

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

@@ -32,6 +32,4 @@ internal class FakeGetContextOfEventTask constructor(private val tokenChunkEvent
         )
         return tokenChunkEventPersistor.insertInDb(tokenChunkEvent, params.roomId, PaginationDirection.BACKWARDS)
     }
-
-
-}
+}

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

@@ -28,6 +28,4 @@ internal class FakePaginationTask @Inject constructor(private val tokenChunkEven
         val tokenChunkEvent = FakeTokenChunkEvent(params.from, Random.nextLong(System.currentTimeMillis()).toString(), fakeEvents)
         return tokenChunkEventPersistor.insertInDb(tokenChunkEvent, params.roomId, params.direction)
     }
-
 }
-

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

@@ -23,4 +23,4 @@ internal data class FakeTokenChunkEvent(override val start: String?,
                                         override val end: String?,
                                         override val events: List<Event> = emptyList(),
                                         override val stateEvents: List<Event> = emptyList()
-) : TokenChunkEvent
+) : TokenChunkEvent

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

@@ -16,21 +16,14 @@
 
 package im.vector.matrix.android.session.room.timeline
 
-import com.zhuinden.monarchy.Monarchy
 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.api.session.events.model.EventType
 import im.vector.matrix.android.api.session.events.model.toContent
 import im.vector.matrix.android.api.session.room.model.Membership
-import im.vector.matrix.android.api.session.room.model.RoomMember
+import im.vector.matrix.android.api.session.room.model.RoomMemberSummary
 import im.vector.matrix.android.api.session.room.model.message.MessageTextContent
 import im.vector.matrix.android.api.session.room.model.message.MessageType
-import im.vector.matrix.android.internal.database.helper.addAll
-import im.vector.matrix.android.internal.database.helper.addOrUpdate
-import im.vector.matrix.android.internal.database.model.ChunkEntity
-import im.vector.matrix.android.internal.database.model.RoomEntity
-import im.vector.matrix.android.internal.session.room.timeline.PaginationDirection
-import io.realm.kotlin.createObject
 import kotlin.random.Random
 
 object RoomDataHelper {
@@ -70,24 +63,7 @@ object RoomDataHelper {
     }
 
     fun createFakeRoomMemberEvent(): Event {
-        val roomMember = RoomMember(Membership.JOIN, "Fake name #${Random.nextLong()}").toContent()
+        val roomMember = RoomMemberSummary(Membership.JOIN, "Fake name #${Random.nextLong()}").toContent()
         return createFakeEvent(EventType.STATE_ROOM_MEMBER, roomMember)
     }
-
-    fun fakeInitialSync(monarchy: Monarchy, roomId: String) {
-        monarchy.runTransactionSync { realm ->
-            val roomEntity = realm.createObject<RoomEntity>(roomId)
-            roomEntity.membership = Membership.JOIN
-            val eventList = createFakeListOfEvents(10)
-            val chunkEntity = realm.createObject<ChunkEntity>().apply {
-                nextToken = null
-                prevToken = Random.nextLong(System.currentTimeMillis()).toString()
-                isLastForward = true
-            }
-            chunkEntity.addAll(roomId, eventList, PaginationDirection.FORWARDS)
-            roomEntity.addOrUpdate(chunkEntity)
-        }
-    }
-
-
-}
+}

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

@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) 2020 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.session.room.timeline
+
+import im.vector.matrix.android.InstrumentedTest
+import im.vector.matrix.android.api.extensions.orFalse
+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.message.MessageContent
+import im.vector.matrix.android.api.session.room.timeline.Timeline
+import im.vector.matrix.android.api.session.room.timeline.TimelineSettings
+import im.vector.matrix.android.common.CommonTestHelper
+import im.vector.matrix.android.common.CryptoTestHelper
+import im.vector.matrix.android.common.checkSendOrder
+import org.amshove.kluent.shouldBeFalse
+import org.amshove.kluent.shouldBeTrue
+import org.junit.Assert.assertTrue
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import org.junit.runners.MethodSorters
+import timber.log.Timber
+import java.util.concurrent.CountDownLatch
+
+@RunWith(JUnit4::class)
+@FixMethodOrder(MethodSorters.JVM)
+class TimelineBackToPreviousLastForwardTest : InstrumentedTest {
+
+    private val commonTestHelper = CommonTestHelper(context())
+    private val cryptoTestHelper = CryptoTestHelper(commonTestHelper)
+
+    /**
+     * This test ensure that if we have a chunk in the timeline which is due to a sync, and we click to permalink of an
+     * even contained in a previous lastForward chunk, we will be able to go back to the live
+     */
+    @Test
+    fun backToPreviousLastForwardTest() {
+        val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoom(false)
+
+        val aliceSession = cryptoTestData.firstSession
+        val bobSession = cryptoTestData.secondSession!!
+        val aliceRoomId = cryptoTestData.roomId
+
+        aliceSession.cryptoService().setWarnOnUnknownDevices(false)
+        bobSession.cryptoService().setWarnOnUnknownDevices(false)
+
+        val roomFromAlicePOV = aliceSession.getRoom(aliceRoomId)!!
+        val roomFromBobPOV = bobSession.getRoom(aliceRoomId)!!
+
+        val bobTimeline = roomFromBobPOV.createTimeline(null, TimelineSettings(30))
+        bobTimeline.start()
+
+        var roomCreationEventId: String? = null
+
+        run {
+            val lock = CountDownLatch(1)
+            val eventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Bob timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root}")
+                }
+
+                roomCreationEventId = snapshot.lastOrNull()?.root?.eventId
+                // Ok, we have the 8 first messages of the initial sync (room creation and bob join event)
+                snapshot.size == 8
+            }
+
+            bobTimeline.addListener(eventsListener)
+            commonTestHelper.await(lock)
+            bobTimeline.removeAllListeners()
+
+            bobTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeFalse()
+            bobTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeFalse()
+        }
+
+        // Bob stop to sync
+        bobSession.stopSync()
+
+        val messageRoot = "First messages from Alice"
+
+        // Alice sends 30 messages
+        commonTestHelper.sendTextMessage(
+                roomFromAlicePOV,
+                messageRoot,
+                30)
+
+        // Bob start to sync
+        bobSession.startSync(true)
+
+        run {
+            val lock = CountDownLatch(1)
+            val eventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Bob timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root}")
+                }
+
+                // Ok, we have the 10 last messages from Alice.
+                snapshot.size == 10
+                        && snapshot.all { it.root.content.toModel<MessageContent>()?.body?.startsWith(messageRoot).orFalse() }
+            }
+
+            bobTimeline.addListener(eventsListener)
+            commonTestHelper.await(lock)
+            bobTimeline.removeAllListeners()
+
+            bobTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeTrue()
+            bobTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeFalse()
+        }
+
+        // Bob navigate to the first event (room creation event), so inside the previous last forward chunk
+        run {
+            val lock = CountDownLatch(1)
+            val eventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Bob timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root}")
+                }
+
+                // The event is in db, so it is fetch and auto pagination occurs, half of the number of events we have for this chunk (?)
+                snapshot.size == 4
+            }
+
+            bobTimeline.addListener(eventsListener)
+
+            // Restart the timeline to the first sent event, which is already in the database, so pagination should start automatically
+            assertTrue(roomFromBobPOV.getTimeLineEvent(roomCreationEventId!!) != null)
+
+            bobTimeline.restartWithEventId(roomCreationEventId)
+
+            commonTestHelper.await(lock)
+            bobTimeline.removeAllListeners()
+
+            bobTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeTrue()
+            bobTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeFalse()
+        }
+
+        // Bob scroll to the future
+        run {
+            val lock = CountDownLatch(1)
+            val eventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Bob timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root}")
+                }
+
+                // Bob can see the first event of the room (so Back pagination has worked)
+                snapshot.lastOrNull()?.root?.getClearType() == EventType.STATE_ROOM_CREATE
+                        // 8 for room creation item, and 30 for the forward pagination
+                        && snapshot.size == 38
+                        && snapshot.checkSendOrder(messageRoot, 30, 0)
+            }
+
+            bobTimeline.addListener(eventsListener)
+
+            bobTimeline.paginate(Timeline.Direction.FORWARDS, 50)
+
+            commonTestHelper.await(lock)
+            bobTimeline.removeAllListeners()
+
+            bobTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeFalse()
+            bobTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeFalse()
+        }
+        bobTimeline.dispose()
+
+        cryptoTestData.cleanUp(commonTestHelper)
+    }
+}

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

@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2020 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.session.room.timeline
+
+import im.vector.matrix.android.InstrumentedTest
+import im.vector.matrix.android.api.extensions.orFalse
+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.message.MessageContent
+import im.vector.matrix.android.api.session.room.timeline.Timeline
+import im.vector.matrix.android.api.session.room.timeline.TimelineSettings
+import im.vector.matrix.android.common.CommonTestHelper
+import im.vector.matrix.android.common.CryptoTestHelper
+import im.vector.matrix.android.common.checkSendOrder
+import org.amshove.kluent.shouldBeFalse
+import org.amshove.kluent.shouldBeTrue
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import org.junit.runners.MethodSorters
+import timber.log.Timber
+import java.util.concurrent.CountDownLatch
+
+@RunWith(JUnit4::class)
+@FixMethodOrder(MethodSorters.JVM)
+class TimelineForwardPaginationTest : InstrumentedTest {
+
+    private val commonTestHelper = CommonTestHelper(context())
+    private val cryptoTestHelper = CryptoTestHelper(commonTestHelper)
+
+    /**
+     * This test ensure that if we click to permalink, we will be able to go back to the live
+     */
+    @Test
+    fun forwardPaginationTest() {
+        val numberOfMessagesToSend = 90
+        val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceInARoom(false)
+
+        val aliceSession = cryptoTestData.firstSession
+        val aliceRoomId = cryptoTestData.roomId
+
+        aliceSession.cryptoService().setWarnOnUnknownDevices(false)
+
+        val roomFromAlicePOV = aliceSession.getRoom(aliceRoomId)!!
+
+        // Alice sends X messages
+        val message = "Message from Alice"
+        val sentMessages = commonTestHelper.sendTextMessage(
+                roomFromAlicePOV,
+                message,
+                numberOfMessagesToSend)
+
+        // Alice clear the cache
+        commonTestHelper.doSync<Unit> {
+            aliceSession.clearCache(it)
+        }
+
+        // And restarts the sync
+        aliceSession.startSync(true)
+
+        val aliceTimeline = roomFromAlicePOV.createTimeline(null, TimelineSettings(30))
+        aliceTimeline.start()
+
+        // Alice sees the 10 last message of the room, and can only navigate BACKWARD
+        run {
+            val lock = CountDownLatch(1)
+            val eventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Alice timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root.content}")
+                }
+
+                // Ok, we have the 10 last messages of the initial sync
+                snapshot.size == 10
+                        && snapshot.all { it.root.content.toModel<MessageContent>()?.body?.startsWith(message).orFalse() }
+            }
+
+            // Open the timeline at last sent message
+            aliceTimeline.addListener(eventsListener)
+            commonTestHelper.await(lock)
+            aliceTimeline.removeAllListeners()
+
+            aliceTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeTrue()
+            aliceTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeFalse()
+        }
+
+        // Alice navigates to the first message of the room, which is not in its database. A GET /context is performed
+        // Then she can paginate BACKWARD and FORWARD
+        run {
+            val lock = CountDownLatch(1)
+            val aliceEventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Alice timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root.content}")
+                }
+
+                // The event is not in db, so it is fetch alone
+                snapshot.size == 1
+                        && snapshot.all { it.root.content.toModel<MessageContent>()?.body?.startsWith("Message from Alice").orFalse() }
+            }
+
+            aliceTimeline.addListener(aliceEventsListener)
+
+            // Restart the timeline to the first sent event
+            aliceTimeline.restartWithEventId(sentMessages.last().eventId)
+
+            commonTestHelper.await(lock)
+            aliceTimeline.removeAllListeners()
+
+            aliceTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeTrue()
+            aliceTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeTrue()
+        }
+
+        // Alice paginates BACKWARD and FORWARD of 50 events each
+        // Then she can only navigate FORWARD
+        run {
+            val lock = CountDownLatch(1)
+            val aliceEventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Alice timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root.content}")
+                }
+
+                // Alice can see the first event of the room (so Back pagination has worked)
+                snapshot.lastOrNull()?.root?.getClearType() == EventType.STATE_ROOM_CREATE
+                        // 6 for room creation item (backward pagination), 1 for the context, and 50 for the forward pagination
+                        && snapshot.size == 6 + 1 + 50
+            }
+
+            aliceTimeline.addListener(aliceEventsListener)
+
+            // Restart the timeline to the first sent event
+            // We ask to load event backward and forward
+            aliceTimeline.paginate(Timeline.Direction.BACKWARDS, 50)
+            aliceTimeline.paginate(Timeline.Direction.FORWARDS, 50)
+
+            commonTestHelper.await(lock)
+            aliceTimeline.removeAllListeners()
+
+            aliceTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeTrue()
+            aliceTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeFalse()
+        }
+
+        // Alice paginates once again FORWARD for 50 events
+        // All the timeline is retrieved, she cannot paginate anymore in both direction
+        run {
+            val lock = CountDownLatch(1)
+            val aliceEventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Alice timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root.content}")
+                }
+                // 6 for room creation item (backward pagination),and numberOfMessagesToSend (all the message of the room)
+                snapshot.size == 6 + numberOfMessagesToSend
+                        && snapshot.checkSendOrder(message, numberOfMessagesToSend, 0)
+            }
+
+            aliceTimeline.addListener(aliceEventsListener)
+
+            // Ask for a forward pagination
+            aliceTimeline.paginate(Timeline.Direction.FORWARDS, 50)
+
+            commonTestHelper.await(lock)
+            aliceTimeline.removeAllListeners()
+
+            // The timeline is fully loaded
+            aliceTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeFalse()
+            aliceTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeFalse()
+        }
+
+        aliceTimeline.dispose()
+
+        cryptoTestData.cleanUp(commonTestHelper)
+    }
+}

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

@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) 2020 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.session.room.timeline
+
+import im.vector.matrix.android.InstrumentedTest
+import im.vector.matrix.android.api.extensions.orFalse
+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.message.MessageContent
+import im.vector.matrix.android.api.session.room.timeline.Timeline
+import im.vector.matrix.android.api.session.room.timeline.TimelineSettings
+import im.vector.matrix.android.common.CommonTestHelper
+import im.vector.matrix.android.common.CryptoTestHelper
+import im.vector.matrix.android.common.checkSendOrder
+import org.amshove.kluent.shouldBeFalse
+import org.amshove.kluent.shouldBeTrue
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import org.junit.runners.MethodSorters
+import timber.log.Timber
+import java.util.concurrent.CountDownLatch
+
+@RunWith(JUnit4::class)
+@FixMethodOrder(MethodSorters.JVM)
+class TimelinePreviousLastForwardTest : InstrumentedTest {
+
+    private val commonTestHelper = CommonTestHelper(context())
+    private val cryptoTestHelper = CryptoTestHelper(commonTestHelper)
+
+    /**
+     * This test ensure that if we have a chunk in the timeline which is due to a sync, and we click to permalink, we will be able to go back to the live
+     */
+    @Test
+    fun previousLastForwardTest() {
+        val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoom(false)
+
+        val aliceSession = cryptoTestData.firstSession
+        val bobSession = cryptoTestData.secondSession!!
+        val aliceRoomId = cryptoTestData.roomId
+
+        aliceSession.cryptoService().setWarnOnUnknownDevices(false)
+        bobSession.cryptoService().setWarnOnUnknownDevices(false)
+
+        val roomFromAlicePOV = aliceSession.getRoom(aliceRoomId)!!
+        val roomFromBobPOV = bobSession.getRoom(aliceRoomId)!!
+
+        val bobTimeline = roomFromBobPOV.createTimeline(null, TimelineSettings(30))
+        bobTimeline.start()
+
+        run {
+            val lock = CountDownLatch(1)
+            val eventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Bob timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root}")
+                }
+
+                // Ok, we have the 8 first messages of the initial sync (room creation and bob invite and join events)
+                snapshot.size == 8
+            }
+
+            bobTimeline.addListener(eventsListener)
+            commonTestHelper.await(lock)
+            bobTimeline.removeAllListeners()
+
+            bobTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeFalse()
+            bobTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeFalse()
+        }
+
+        // Bob stop to sync
+        bobSession.stopSync()
+
+        val firstMessage = "First messages from Alice"
+        // Alice sends 30 messages
+        val firstMessageFromAliceId = commonTestHelper.sendTextMessage(
+                roomFromAlicePOV,
+                firstMessage,
+                30)
+                .last()
+                .eventId
+
+        // Bob start to sync
+        bobSession.startSync(true)
+
+        run {
+            val lock = CountDownLatch(1)
+            val eventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Bob timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root}")
+                }
+
+                // Ok, we have the 10 last messages from Alice. This will be our future previous lastForward chunk
+                snapshot.size == 10
+                        && snapshot.all { it.root.content.toModel<MessageContent>()?.body?.startsWith(firstMessage).orFalse() }
+            }
+
+            bobTimeline.addListener(eventsListener)
+            commonTestHelper.await(lock)
+            bobTimeline.removeAllListeners()
+
+            bobTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeTrue()
+            bobTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeFalse()
+        }
+
+        // Bob stop to sync
+        bobSession.stopSync()
+
+        val secondMessage = "Second messages from Alice"
+        // Alice sends again 30 messages
+        commonTestHelper.sendTextMessage(
+                roomFromAlicePOV,
+                secondMessage,
+                30)
+
+        // Bob start to sync
+        bobSession.startSync(true)
+
+        run {
+            val lock = CountDownLatch(1)
+            val eventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Bob timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root}")
+                }
+
+                // Ok, we have the 10 last messages from Alice. This will be our future previous lastForward chunk
+                snapshot.size == 10
+                        && snapshot.all { it.root.content.toModel<MessageContent>()?.body?.startsWith(secondMessage).orFalse() }
+            }
+
+            bobTimeline.addListener(eventsListener)
+            commonTestHelper.await(lock)
+            bobTimeline.removeAllListeners()
+
+            bobTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeTrue()
+            bobTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeFalse()
+        }
+
+        // Bob navigate to the first message sent from Alice
+        run {
+            val lock = CountDownLatch(1)
+            val eventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Bob timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root}")
+                }
+
+                // The event is not in db, so it is fetch
+                snapshot.size == 1
+            }
+
+            bobTimeline.addListener(eventsListener)
+
+            // Restart the timeline to the first sent event, and paginate in both direction
+            bobTimeline.restartWithEventId(firstMessageFromAliceId)
+            bobTimeline.paginate(Timeline.Direction.BACKWARDS, 50)
+            bobTimeline.paginate(Timeline.Direction.FORWARDS, 50)
+
+            commonTestHelper.await(lock)
+            bobTimeline.removeAllListeners()
+
+            bobTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeTrue()
+            bobTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeTrue()
+        }
+
+        // Paginate in both direction
+        run {
+            val lock = CountDownLatch(1)
+            val eventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Bob timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root}")
+                }
+
+                snapshot.size == 8 + 1 + 35
+            }
+
+            bobTimeline.addListener(eventsListener)
+
+            // Paginate in both direction
+            bobTimeline.paginate(Timeline.Direction.BACKWARDS, 50)
+            // Ensure the chunk in the middle is included in the next pagination
+            bobTimeline.paginate(Timeline.Direction.FORWARDS, 35)
+
+            commonTestHelper.await(lock)
+            bobTimeline.removeAllListeners()
+
+            bobTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeTrue()
+            bobTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeFalse()
+        }
+
+        // Bob scroll to the future, till the live
+        run {
+            val lock = CountDownLatch(1)
+            val eventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Bob timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root}")
+                }
+
+                // Bob can see the first event of the room (so Back pagination has worked)
+                snapshot.lastOrNull()?.root?.getClearType() == EventType.STATE_ROOM_CREATE
+                        // 8 for room creation item 60 message from Alice
+                        && snapshot.size == 8 + 60
+                        && snapshot.checkSendOrder(secondMessage, 30, 0)
+                        && snapshot.checkSendOrder(firstMessage, 30, 30)
+            }
+
+            bobTimeline.addListener(eventsListener)
+
+            bobTimeline.paginate(Timeline.Direction.FORWARDS, 50)
+
+            commonTestHelper.await(lock)
+            bobTimeline.removeAllListeners()
+
+            bobTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeFalse()
+            bobTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeFalse()
+        }
+
+        bobTimeline.dispose()
+
+        cryptoTestData.cleanUp(commonTestHelper)
+    }
+}

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

@@ -66,7 +66,7 @@ internal class TimelineTest : InstrumentedTest {
 //        val latch = CountDownLatch(2)
 //        var timelineEvents: List<TimelineEvent> = emptyList()
 //        timeline.listener = object : Timeline.Listener {
-//            override fun onUpdated(snapshot: List<TimelineEvent>) {
+//            override fun onTimelineUpdated(snapshot: List<TimelineEvent>) {
 //                if (snapshot.isNotEmpty()) {
 //                    if (initialLoad == 0) {
 //                        initialLoad = snapshot.size
@@ -81,6 +81,4 @@ internal class TimelineTest : InstrumentedTest {
 //        timelineEvents.size shouldEqual initialLoad + paginationCount
 //        timeline.dispose()
 //    }
-
-
-}
+}

matrix-sdk-android/src/debug/java/im/vector/matrix/android/internal/database/RealmDebugTools.kt

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2020 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.internal.database
+
+import im.vector.matrix.android.internal.crypto.store.db.model.CrossSigningInfoEntity
+import im.vector.matrix.android.internal.crypto.store.db.model.CryptoMetadataEntity
+import im.vector.matrix.android.internal.crypto.store.db.model.CryptoRoomEntity
+import im.vector.matrix.android.internal.crypto.store.db.model.DeviceInfoEntity
+import im.vector.matrix.android.internal.crypto.store.db.model.GossipingEventEntity
+import im.vector.matrix.android.internal.crypto.store.db.model.IncomingGossipingRequestEntity
+import im.vector.matrix.android.internal.crypto.store.db.model.KeyInfoEntity
+import im.vector.matrix.android.internal.crypto.store.db.model.KeysBackupDataEntity
+import im.vector.matrix.android.internal.crypto.store.db.model.MyDeviceLastSeenInfoEntity
+import im.vector.matrix.android.internal.crypto.store.db.model.OlmInboundGroupSessionEntity
+import im.vector.matrix.android.internal.crypto.store.db.model.OlmSessionEntity
+import im.vector.matrix.android.internal.crypto.store.db.model.OutgoingGossipingRequestEntity
+import im.vector.matrix.android.internal.crypto.store.db.model.TrustLevelEntity
+import im.vector.matrix.android.internal.crypto.store.db.model.UserEntity
+import io.realm.Realm
+import io.realm.RealmConfiguration
+import io.realm.kotlin.where
+import timber.log.Timber
+
+object RealmDebugTools {
+    /**
+     * Log info about the crypto DB
+     */
+    fun dumpCryptoDb(realmConfiguration: RealmConfiguration) {
+        Realm.getInstance(realmConfiguration).use {
+            Timber.d("Realm located at : ${realmConfiguration.realmDirectory}/${realmConfiguration.realmFileName}")
+
+            val key = realmConfiguration.encryptionKey.joinToString("") { byte -> "%02x".format(byte) }
+            Timber.d("Realm encryption key : $key")
+
+            // Check if we have data
+            Timber.e("Realm is empty: ${it.isEmpty}")
+
+            Timber.d("Realm has CryptoMetadataEntity: ${it.where<CryptoMetadataEntity>().count()}")
+            Timber.d("Realm has CryptoRoomEntity: ${it.where<CryptoRoomEntity>().count()}")
+            Timber.d("Realm has DeviceInfoEntity: ${it.where<DeviceInfoEntity>().count()}")
+            Timber.d("Realm has KeysBackupDataEntity: ${it.where<KeysBackupDataEntity>().count()}")
+            Timber.d("Realm has OlmInboundGroupSessionEntity: ${it.where<OlmInboundGroupSessionEntity>().count()}")
+            Timber.d("Realm has OlmSessionEntity: ${it.where<OlmSessionEntity>().count()}")
+            Timber.d("Realm has UserEntity: ${it.where<UserEntity>().count()}")
+            Timber.d("Realm has KeyInfoEntity: ${it.where<KeyInfoEntity>().count()}")
+            Timber.d("Realm has CrossSigningInfoEntity: ${it.where<CrossSigningInfoEntity>().count()}")
+            Timber.d("Realm has TrustLevelEntity: ${it.where<TrustLevelEntity>().count()}")
+            Timber.d("Realm has GossipingEventEntity: ${it.where<GossipingEventEntity>().count()}")
+            Timber.d("Realm has IncomingGossipingRequestEntity: ${it.where<IncomingGossipingRequestEntity>().count()}")
+            Timber.d("Realm has OutgoingGossipingRequestEntity: ${it.where<OutgoingGossipingRequestEntity>().count()}")
+            Timber.d("Realm has MyDeviceLastSeenInfoEntity: ${it.where<MyDeviceLastSeenInfoEntity>().count()}")
+        }
+    }
+}

matrix-sdk-android/src/debug/java/im/vector/matrix/android/internal/network/interceptors/CurlLoggingInterceptor.kt

@@ -20,8 +20,8 @@ package im.vector.matrix.android.internal.network.interceptors
 import im.vector.matrix.android.internal.di.MatrixScope
 import okhttp3.Interceptor
 import okhttp3.Response
-import okhttp3.logging.HttpLoggingInterceptor
 import okio.Buffer
+import timber.log.Timber
 import java.io.IOException
 import java.nio.charset.Charset
 import javax.inject.Inject
@@ -36,7 +36,7 @@ import javax.inject.Inject
  * non-production environment.
  */
 @MatrixScope
-internal class CurlLoggingInterceptor @Inject constructor(private val logger: HttpLoggingInterceptor.Logger)
+internal class CurlLoggingInterceptor @Inject constructor()
     : Interceptor {
 
     /**
@@ -51,27 +51,33 @@ internal class CurlLoggingInterceptor @Inject constructor(private val logger: Ht
         var compressed = false
 
         var curlCmd = "curl"
-        if (curlOptions != null) {
-            curlCmd += " " + curlOptions!!
+        curlOptions?.let {
+            curlCmd += " $it"
         }
-        curlCmd += " -X " + request.method()
+        curlCmd += " -X " + request.method
 
-        val requestBody = request.body()
+        val requestBody = request.body
         if (requestBody != null) {
-            val buffer = Buffer()
-            requestBody.writeTo(buffer)
-            var charset: Charset? = UTF8
-            val contentType = requestBody.contentType()
-            if (contentType != null) {
-                charset = contentType.charset(UTF8)
+            if (requestBody.contentLength() > 100_000) {
+                Timber.w("Unable to log curl command data, size is too big (${requestBody.contentLength()})")
+                // Ensure the curl command will failed
+                curlCmd += "DATA IS TOO BIG"
+            } else {
+                val buffer = Buffer()
+                requestBody.writeTo(buffer)
+                var charset: Charset? = UTF8
+                val contentType = requestBody.contentType()
+                if (contentType != null) {
+                    charset = contentType.charset(UTF8)
+                }
+                // try to keep to a single line and use a subshell to preserve any line breaks
+                curlCmd += " --data $'" + buffer.readString(charset!!).replace("\n", "\\n") + "'"
             }
-            // try to keep to a single line and use a subshell to preserve any line breaks
-            curlCmd += " --data $'" + buffer.readString(charset!!).replace("\n", "\\n") + "'"
         }
 
-        val headers = request.headers()
+        val headers = request.headers
         var i = 0
-        val count = headers.size()
+        val count = headers.size
         while (i < count) {
             val name = headers.name(i)
             val value = headers.value(i)
@@ -82,7 +88,7 @@ internal class CurlLoggingInterceptor @Inject constructor(private val logger: Ht
             i++
         }
 
-        curlCmd += ((if (compressed) " --compressed " else " ") + "'" + request.url().toString()
+        curlCmd += ((if (compressed) " --compressed " else " ") + "'" + request.url.toString()
                 // Replace localhost for emulator by localhost for shell
                 .replace("://10.0.2.2:8080/".toRegex(), "://127.0.0.1:8080/")
                 + "'")
@@ -90,8 +96,8 @@ internal class CurlLoggingInterceptor @Inject constructor(private val logger: Ht
         // Add Json formatting
         curlCmd += " | python -m json.tool"
 
-        logger.log("--- cURL (" + request.url() + ")")
-        logger.log(curlCmd)
+        Timber.d("--- cURL (${request.url})")
+        Timber.d(curlCmd)
 
         return chain.proceed(request)
     }

matrix-sdk-android/src/debug/java/im/vector/matrix/android/internal/network/interceptors/FormattedJsonHttpLogger.kt

@@ -51,7 +51,6 @@ class FormattedJsonHttpLogger : HttpLoggingInterceptor.Logger {
                     // Finally this is not a JSON string...
                     Timber.e(e)
                 }
-
             } else if (message.startsWith("[")) {
                 // JSON Array detected
                 try {
@@ -61,7 +60,6 @@ class FormattedJsonHttpLogger : HttpLoggingInterceptor.Logger {
                     // Finally not JSON...
                     Timber.e(e)
                 }
-
             }
             // Else not a json string to log
         }
@@ -73,4 +71,4 @@ class FormattedJsonHttpLogger : HttpLoggingInterceptor.Logger {
             Timber.v(s)
         }
     }
-}
+}

matrix-sdk-android/src/main/AndroidManifest.xml

@@ -6,14 +6,27 @@
     <uses-permission android:name="android.permission.VIBRATE" />
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
 
-    <application>
+    <application android:networkSecurityConfig="@xml/network_security_config">
 
-        <provider android:name="androidx.work.impl.WorkManagerInitializer"
+        <provider
+            android:name="androidx.work.impl.WorkManagerInitializer"
             android:authorities="${applicationId}.workmanager-init"
             android:exported="false"
             tools:node="remove" />
-
+        <!--
+         The SDK offers a secured File provider to access downloaded files.
+         Access to these file will be given via the FileService, with a temporary
+         read access permission
+        -->
+        <provider
+            android:name="im.vector.matrix.android.api.session.file.MatrixSDKFileProvider"
+            android:authorities="${applicationId}.mx-sdk.fileprovider"
+            android:exported="false"
+            android:grantUriPermissions="true">
+            <meta-data
+                android:name="android.support.FILE_PROVIDER_PATHS"
+                android:resource="@xml/sdk_provider_paths" />
+        </provider>
     </application>
 
-
 </manifest>

matrix-sdk-android/src/main/assets/postMessageAPI.js

@@ -0,0 +1,54 @@
+var android_widget_events = {};
+
+var sendObjectMessageToRiotAndroid = function(parameters) {
+    Android.onWidgetEvent(JSON.stringify(parameters));
+};
+
+var onWidgetMessageToRiotAndroid = function(event) {
+    /* Use an internal "_id" field for matching onMessage events and requests
+       _id was originally used by the Modular API. Keep it */
+    if (!event.data._id) {
+        /* The Matrix Widget API v2 spec says:
+           "The requestId field should be unique and included in all requests" */
+        event.data._id = event.data.requestId;
+    }
+    /* Make sure to have one id */
+    if (!event.data._id) {
+        event.data._id = Date.now() + "-" + Math.random().toString(36);
+    }
+
+    console.log("onWidgetMessageToRiotAndroid " + event.data._id);
+
+    if (android_widget_events[event.data._id]) {
+        console.log("onWidgetMessageToRiotAndroid : already managed");
+        return;
+    }
+
+    if (!event.origin) {
+        event.origin = event.originalEvent.origin;
+    }
+
+    android_widget_events[event.data._id] = event;
+
+    console.log("onWidgetMessageToRiotAndroid : manage " + event.data);
+    sendObjectMessageToRiotAndroid({'event.data': event.data});
+};
+
+var sendResponseFromRiotAndroid = function(eventId, res) {
+    var event = android_widget_events[eventId];
+
+    console.log("sendResponseFromRiotAndroid to " + event.data.action + " for "+ eventId + ": " + JSON.stringify(res));
+
+    var data = JSON.parse(JSON.stringify(event.data));
+
+    data.response = res;
+
+    console.log("sendResponseFromRiotAndroid  ---> " + data);
+
+    event.source.postMessage(data, event.origin);
+    android_widget_events[eventId] = true;
+
+    console.log("sendResponseFromRiotAndroid to done");
+};
+
+window.addEventListener('message', onWidgetMessageToRiotAndroid, false);

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

@@ -22,32 +22,28 @@ import androidx.work.Configuration
 import androidx.work.WorkManager
 import com.zhuinden.monarchy.Monarchy
 import im.vector.matrix.android.BuildConfig
-import im.vector.matrix.android.api.auth.Authenticator
+import im.vector.matrix.android.api.auth.AuthenticationService
+import im.vector.matrix.android.api.legacy.LegacySessionImporter
 import im.vector.matrix.android.internal.SessionManager
+import im.vector.matrix.android.internal.crypto.attachments.ElementToDecrypt
+import im.vector.matrix.android.internal.crypto.attachments.MXEncryptedAttachments
 import im.vector.matrix.android.internal.di.DaggerMatrixComponent
 import im.vector.matrix.android.internal.network.UserAgentHolder
 import im.vector.matrix.android.internal.util.BackgroundDetectionObserver
 import org.matrix.olm.OlmManager
+import java.io.InputStream
+import java.util.concurrent.Executors
 import java.util.concurrent.atomic.AtomicBoolean
 import javax.inject.Inject
 
-data class MatrixConfiguration(
-        val applicationFlavor: String = "Default-application-flavor"
-) {
-
-    interface Provider {
-        fun providesMatrixConfiguration(): MatrixConfiguration
-    }
-
-}
-
 /**
  * This is the main entry point to the matrix sdk.
  * To get the singleton instance, use getInstance static method.
  */
 class Matrix private constructor(context: Context, matrixConfiguration: MatrixConfiguration) {
 
-    @Inject internal lateinit var authenticator: Authenticator
+    @Inject internal lateinit var legacySessionImporter: LegacySessionImporter
+    @Inject internal lateinit var authenticationService: AuthenticationService
     @Inject internal lateinit var userAgentHolder: UserAgentHolder
     @Inject internal lateinit var backgroundDetectionObserver: BackgroundDetectionObserver
     @Inject internal lateinit var olmManager: OlmManager
@@ -55,18 +51,21 @@ class Matrix private constructor(context: Context, matrixConfiguration: MatrixCo
 
     init {
         Monarchy.init(context)
-        DaggerMatrixComponent.factory().create(context).inject(this)
+        DaggerMatrixComponent.factory().create(context, matrixConfiguration).inject(this)
         if (context.applicationContext !is Configuration.Provider) {
-            WorkManager.initialize(context, Configuration.Builder().build())
+            WorkManager.initialize(context, Configuration.Builder().setExecutor(Executors.newCachedThreadPool()).build())
         }
         ProcessLifecycleOwner.get().lifecycle.addObserver(backgroundDetectionObserver)
-        userAgentHolder.setApplicationFlavor(matrixConfiguration.applicationFlavor)
     }
 
     fun getUserAgent() = userAgentHolder.userAgent
 
-    fun authenticator(): Authenticator {
-        return authenticator
+    fun authenticationService(): AuthenticationService {
+        return authenticationService
+    }
+
+    fun legacySessionImporter(): LegacySessionImporter {
+        return legacySessionImporter
     }
 
     companion object {
@@ -97,6 +96,9 @@ class Matrix private constructor(context: Context, matrixConfiguration: MatrixCo
         fun getSdkVersion(): String {
             return BuildConfig.VERSION_NAME + " (" + BuildConfig.GIT_SDK_REVISION + ")"
         }
-    }
 
+        fun decryptStream(inputStream: InputStream?, elementToDecrypt: ElementToDecrypt): InputStream? {
+            return MXEncryptedAttachments.decryptAttachment(inputStream, elementToDecrypt)
+        }
+    }
 }

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

@@ -27,7 +27,7 @@ interface MatrixCallback<in T> {
      * @param data the data successfully returned from the async function
      */
     fun onSuccess(data: T) {
-        //no-op
+        // no-op
     }
 
     /**
@@ -35,7 +35,11 @@ interface MatrixCallback<in T> {
      * @param failure the failure data returned from the async function
      */
     fun onFailure(failure: Throwable) {
-        //no-op
+        // no-op
     }
+}
 
-}
+/**
+ * Basic no op implementation
+ */
+class NoOpMatrixCallback<T>: MatrixCallback<T>

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

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2020 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
+
+import im.vector.matrix.android.api.crypto.MXCryptoConfig
+import java.net.Proxy
+
+data class MatrixConfiguration(
+        val applicationFlavor: String = "Default-application-flavor",
+        val cryptoConfig: MXCryptoConfig = MXCryptoConfig(),
+        val integrationUIUrl: String = "https://scalar.vector.im/",
+        val integrationRestUrl: String = "https://scalar.vector.im/api",
+        val integrationWidgetUrls: List<String> = listOf(
+                "https://scalar.vector.im/_matrix/integrations/v1",
+                "https://scalar.vector.im/api",
+                "https://scalar-staging.vector.im/_matrix/integrations/v1",
+                "https://scalar-staging.vector.im/api",
+                "https://scalar-staging.riot.im/scalar/api"
+        ),
+        /**
+         * Optional proxy to connect to the matrix servers
+         * You can create one using for instance Proxy(proxyType, InetSocketAddress(hostname, port)
+         */
+        val proxy: Proxy? = null
+) {
+
+    /**
+     * Can be implemented by your Application class
+     */
+    interface Provider {
+        fun providesMatrixConfiguration(): MatrixConfiguration
+    }
+}

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

@@ -16,7 +16,6 @@
 
 package im.vector.matrix.android.api
 
-
 /**
  * This class contains pattern to match the different Matrix ids
  */
@@ -123,9 +122,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_V3
-                   || str matches PATTERN_CONTAIN_MATRIX_EVENT_IDENTIFIER_V4)
+                && (str matches PATTERN_CONTAIN_MATRIX_EVENT_IDENTIFIER
+                || str matches PATTERN_CONTAIN_MATRIX_EVENT_IDENTIFIER_V3
+                || str matches PATTERN_CONTAIN_MATRIX_EVENT_IDENTIFIER_V4)
     }
 
     /**
@@ -145,15 +144,6 @@ object MatrixPatterns {
      * @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)
-
+        return matrixId?.substringAfter(":", missingDelimiterValue = "")?.takeIf { it.isNotEmpty() }
     }
 }

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

@@ -0,0 +1,104 @@
+/*
+ * 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.auth
+
+import im.vector.matrix.android.api.MatrixCallback
+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.LoginFlowResult
+import im.vector.matrix.android.api.auth.login.LoginWizard
+import im.vector.matrix.android.api.auth.registration.RegistrationWizard
+import im.vector.matrix.android.api.auth.wellknown.WellknownResult
+import im.vector.matrix.android.api.session.Session
+import im.vector.matrix.android.api.util.Cancelable
+
+/**
+ * This interface defines methods to authenticate or to create an account to a matrix server.
+ */
+interface AuthenticationService {
+    /**
+     * Request the supported login flows for this homeserver.
+     * This is the first method to call to be able to get a wizard to login or the create an account
+     */
+    fun getLoginFlow(homeServerConnectionConfig: HomeServerConnectionConfig, callback: MatrixCallback<LoginFlowResult>): Cancelable
+
+    /**
+     * Request the supported login flows for the corresponding sessionId.
+     */
+    fun getLoginFlowOfSession(sessionId: String, callback: MatrixCallback<LoginFlowResult>): Cancelable
+
+    /**
+     * Return a LoginWizard, to login to the homeserver. The login flow has to be retrieved first.
+     */
+    fun getLoginWizard(): LoginWizard
+
+    /**
+     * Return a RegistrationWizard, to create an matrix account on the homeserver. The login flow has to be retrieved first.
+     */
+    fun getRegistrationWizard(): RegistrationWizard
+
+    /**
+     * True when login and password has been sent with success to the homeserver
+     */
+    val isRegistrationStarted: Boolean
+
+    /**
+     * Cancel pending login or pending registration
+     */
+    fun cancelPendingLoginOrRegistration()
+
+    /**
+     * Reset all pending settings, including current HomeServerConnectionConfig
+     */
+    fun reset()
+
+    /**
+     * Check if there is an authenticated [Session].
+     * @return true if there is at least one active session.
+     */
+    fun hasAuthenticatedSessions(): Boolean
+
+    /**
+     * Get the last authenticated [Session], if there is an active session.
+     * @return the last active session if any, or null
+     */
+    fun getLastAuthenticatedSession(): Session?
+
+    /**
+     * Create a session after a SSO successful login
+     */
+    fun createSessionFromSso(homeServerConnectionConfig: HomeServerConnectionConfig,
+                             credentials: Credentials,
+                             callback: MatrixCallback<Session>): Cancelable
+
+    /**
+     * Perform a wellknown request, using the domain from the matrixId
+     */
+    fun getWellKnownData(matrixId: String,
+                         homeServerConnectionConfig: HomeServerConnectionConfig?,
+                         callback: MatrixCallback<WellknownResult>): Cancelable
+
+    /**
+     * Authenticate with a matrixId and a password
+     * Usually call this after a successful call to getWellKnownData()
+     */
+    fun directAuthentication(homeServerConnectionConfig: HomeServerConnectionConfig,
+                             matrixId: String,
+                             password: String,
+                             initialDeviceName: String,
+                             callback: MatrixCallback<Session>): Cancelable
+}

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

@@ -1,59 +0,0 @@
-/*
- * 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.auth
-
-import im.vector.matrix.android.api.MatrixCallback
-import im.vector.matrix.android.api.auth.data.HomeServerConnectionConfig
-import im.vector.matrix.android.api.auth.data.SessionParams
-import im.vector.matrix.android.api.session.Session
-import im.vector.matrix.android.api.util.Cancelable
-
-/**
- * This interface defines methods to authenticate to a matrix server.
- */
-interface Authenticator {
-
-    /**
-     * @param homeServerConnectionConfig this param is used to configure the Homeserver
-     * @param login the login field
-     * @param password the password field
-     * @param callback  the matrix callback on which you'll receive the result of authentication.
-     * @return return a [Cancelable]
-     */
-    fun authenticate(homeServerConnectionConfig: HomeServerConnectionConfig, login: String, password: String, callback: MatrixCallback<Session>): Cancelable
-
-    /**
-     * Check if there is an authenticated [Session].
-     * @return true if there is at least one active session.
-     */
-    fun hasAuthenticatedSessions(): Boolean
-
-    /**
-     * Get the last authenticated [Session], if there is an active session.
-     * @return the last active session if any, or null
-     */
-    fun getLastAuthenticatedSession(): Session?
-
-    /**
-     * Get an authenticated session. You should at least call authenticate one time before.
-     * If you logout, this session will no longer be valid.
-     *
-     * @param sessionParams the sessionParams to open with.
-     * @return the associated session if any, or null
-     */
-    fun getSession(sessionParams: SessionParams): Session?
-}

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

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2020 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.auth
+
+/**
+ * Path to use when the client does not supported any or all login flows
+ * Ref: https://matrix.org/docs/spec/client_server/latest#login-fallback
+ * */
+const val LOGIN_FALLBACK_PATH = "/_matrix/static/client/login/"
+
+/**
+ * Path to use when the client does not supported any or all registration flows
+ * Not documented
+ */
+const val REGISTER_FALLBACK_PATH = "/_matrix/static/client/register/"
+
+/**
+ * Path to use when the client want to connect using SSO
+ * Ref: https://matrix.org/docs/spec/client_server/latest#sso-client-login
+ */
+const val SSO_REDIRECT_PATH = "/_matrix/client/r0/login/sso/redirect"
+
+const val SSO_REDIRECT_URL_PARAM = "redirectUrl"

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

@@ -18,16 +18,46 @@ package im.vector.matrix.android.api.auth.data
 
 import com.squareup.moshi.Json
 import com.squareup.moshi.JsonClass
+import im.vector.matrix.android.internal.util.md5
 
 /**
  * This data class hold credentials user data.
  * You shouldn't have to instantiate it.
  * The access token should be use to authenticate user in all server requests.
+ * Ref: https://matrix.org/docs/spec/client_server/latest#post-matrix-client-r0-login
  */
 @JsonClass(generateAdapter = true)
 data class Credentials(
+        /**
+         * The fully-qualified Matrix ID that has been registered.
+         */
         @Json(name = "user_id") val userId: String,
-        @Json(name = "home_server") val homeServer: String,
+        /**
+         * An access token for the account. This access token can then be used to authorize other requests.
+         */
         @Json(name = "access_token") val accessToken: String,
+        /**
+         * Not documented
+         */
         @Json(name = "refresh_token") val refreshToken: String?,
-        @Json(name = "device_id") val deviceId: String?)
+        /**
+         * The server_name of the homeserver on which the account has been registered.
+         * @Deprecated. Clients should extract the server_name from user_id (by splitting at the first colon)
+         * if they require it. Note also that homeserver is not spelt this way.
+         */
+        @Json(name = "home_server") val homeServer: String?,
+        /**
+         * ID of the logged-in device. Will be the same as the corresponding parameter in the request, if one was specified.
+         */
+        @Json(name = "device_id") val deviceId: String?,
+        /**
+         * Optional client configuration provided by the server. If present, clients SHOULD use the provided object to
+         * reconfigure themselves, optionally validating the URLs within.
+         * This object takes the same form as the one returned from .well-known autodiscovery.
+         */
+        @Json(name = "well_known") val discoveryInformation: DiscoveryInformation? = null
+)
+
+internal fun Credentials.sessionId(): String {
+    return (if (deviceId.isNullOrBlank()) userId else "$userId|$deviceId").md5()
+}