Merge branch 'hotfix/fix_crash_invite_user'

Fix IllegalArgumentException reported from store on HomeActivity aunch

.buildkite/pipeline.yml

@@ -1,88 +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
-# We propagate the environment to the container (sse https://github.com/buildkite-plugins/docker-buildkite-plugin#propagate-environment-optional-boolean)
-
-steps:
-  - label: "Compile and run Unit tests"
-    agents:
-      # We use a medium sized instance instead of the normal small ones because
-      # gradle build can be memory hungry
-      queue: "medium"
-    commands:
-      - "./gradlew clean test --stacktrace"
-    plugins:
-      - docker#v3.1.0:
-          image: "runmymind/docker-android-sdk"
-          propagate-environment: true
-
-  - label: "Compile Android tests"
-    agents:
-      # We use a medium sized instance instead of the normal small ones because
-      # gradle build can be memory hungry
-      queue: "medium"
-    commands:
-      - "./gradlew clean assembleAndroidTest --stacktrace"
-    plugins:
-      - docker#v3.1.0:
-          image: "runmymind/docker-android-sdk"
-          propagate-environment: true
-
-  - label: "Assemble GPlay Debug version"
-    agents:
-      # We use a xlarge sized instance instead of the normal small ones because
-      # gradle build can be memory hungry
-      queue: "xlarge"
-    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"
-          propagate-environment: true
-
-  - label: "Assemble FDroid Debug version"
-    agents:
-      # We use a xlarge sized instance instead of the normal small ones because
-      # gradle build can be memory hungry
-      queue: "xlarge"
-    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"
-          propagate-environment: true
-
-  - label: "Build Google Play unsigned APK"
-    agents:
-      # We use a xlarge sized instance instead of the normal small ones because
-      # gradle build can be memory hungry
-      queue: "xlarge"
-    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"
-          propagate-environment: true
-
-  # Code quality
-
-  - label: "Code quality"
-    command:
-      - "./tools/check/check_code_quality.sh"
-
-  - label: "ktlint"
-    command:
-      - "curl -sSLO https://github.com/pinterest/ktlint/releases/download/0.34.2/ktlint && chmod a+x ktlint"
-      - "./ktlint --android --experimental -v"
-    plugins:
-      - docker#v3.1.0:
-          image: "openjdk"

.editorconfig

@@ -12,7 +12,7 @@ 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-wildcard-imports,no-multi-spaces,colon-spacing,chain-wrapping,import-ordering,experimental:annotation
+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
@@ -30,3 +30,4 @@ disabled_rules=no-wildcard-imports,no-multi-spaces,colon-spacing,chain-wrapping,
 # no-empty-class-body
 # experimental:multiline-if-else
 # experimental:no-empty-first-line-in-method-block
+# no-wildcard-imports

.gitignore

@@ -4,6 +4,7 @@
 # idea files: exclude everything except dictionnaries
 .idea/caches
 .idea/libraries
+.idea/inspectionProfiles
 .idea/*.xml
 .DS_Store
 /build
@@ -13,7 +14,3 @@
 /tmp
 
 ktlint
-.idea/copyright/New_vector.xml
-.idea/copyright/profiles_settings.xml
-
-.idea/copyright/New_Vector_Ltd.xml

.idea/codeStyles/Project.xml

@@ -1,8 +1,6 @@
 <component name="ProjectCodeStyleConfiguration">
   <code_scheme name="Project" version="173">
-    <AndroidXmlCodeStyleSettings>
-      <option name="ARRANGEMENT_SETTINGS_MIGRATED_TO_191" value="true" />
-    </AndroidXmlCodeStyleSettings>
+    <option name="RIGHT_MARGIN" value="160" />
     <JetCodeStyleSettings>
       <option name="PACKAGES_TO_USE_STAR_IMPORTS">
         <value>

.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

@@ -7,22 +7,29 @@
       <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

@@ -28,8 +28,8 @@ Even if we try to be able to work on all the functionalities, we have more knowl
 
 # 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.
+First of all, we thank all contributors who use Element 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.
+We do not forget all translators, for their work of translating Element into many languages. They are also the authors of Element.
 
 Feel free to add your name below, when you contribute to the project!

CHANGES.md

@@ -1,3 +1,415 @@
+Changes in Element 1.0.4 (2020-08-03)
+===================================================
+
+Bugfix 🐛:
+ - Fix Crash when opening invite to room user screen
+
+Changes in Element 1.0.3 (2020-07-31)
+===================================================
+
+Features ✨:
+ - Support server admin option to disable E2EE for DMs / private rooms [users can still enable] (#1794)
+
+Bugfix 🐛:
+ - Crash reported on playstore for HomeActivity launch (151 reports)
+
+Changes in Element 1.0.2 (2020-07-29)
+===================================================
+
+Improvements 🙌:
+ - Added Session Database migration to avoid unneeded initial syncs
+
+Changes in Element 1.0.1 (2020-07-28)
+===================================================
+
+Improvements 🙌:
+ - Sending events is now retried only 3 times, so we avoid blocking the sending queue too long.
+ - Display warning when fail to send events in room list
+ - Improve UI of edit role action in member profile
+ - Moderation | New screen to display list of banned users in room settings, with unban action
+
+Bugfix 🐛:
+ - Fix theme issue on Room directory screen (#1613)
+ - Fix notification not dismissing when entering a room
+ - Fix uploads don't work with Room v6 (#1558)
+ - Fix Requesting avatar thumbnails in Element uses wrong http "user-agent" string (#1725)
+ - Fix 404 on EMS (#1761)
+ - Fix Infinite loop at startup when migrating account from Riot (#1699)
+ - Fix Element crashes in loop after initial sync (#1709)
+ - Remove inner mx-reply tags before replying
+ - Fix timeline items not loading when there are only filtered events
+ - Fix "Voice & Video" grayed out in Settings (#1733)
+ - Fix Allow VOIP call in all rooms with 2 participants (even if not DM)
+ - Migration from old client does not enable notifications (#1723)
+
+Other changes:
+ - i18n deactivated account error
+
+Changes in Element 1.0.0 (2020-07-15)
+===================================================
+
+Features ✨:
+ - Re-branding: The app is now called Element. New name, new themes, new icons, etc. More details here: https://element.io/blog/welcome-to-element/ (#1691)
+
+Bugfix 🐛:
+ - Video calls are shown as a voice ones in the timeline (#1676)
+ - Fix regression: not able to create a room without IS configured (#1679)
+
+Changes in Riot.imX 0.91.5 (2020-07-11)
+===================================================
+
+Features ✨:
+ - 3pid invite: it is now possible to invite people by email. An Identity Server has to be configured (#548)
+
+Improvements 🙌:
+ - Cleaning chunks with lots of events as long as a threshold has been exceeded (35_000 events in DB) (#1634)
+ - Creating and listening to EventInsertEntity. (#1634)
+ - Handling (almost) properly the groups fetching (#1634)
+ - Improve fullscreen media display (#327)
+ - Setup server recovery banner (#1648)
+ - Set up SSSS from security settings (#1567)
+ - New lab setting to add 'unread notifications' tab to main screen
+ - Render third party invite event (#548)
+ - Display three pid invites in the room members list (#548)
+
+Bugfix 🐛:
+ - Integration Manager: Wrong URL to review terms if URL in config contains path (#1606)
+ - Regression Composer does not grow, crops out text (#1650)
+ - Bug / Unwanted draft (#698)
+ - All users seems to be able to see the enable encryption option in room settings (#1341)
+ - Leave room only leaves the current version (#1656)
+ - Regression |  Share action menu do not work (#1647)
+ - verification issues on transition (#1555)
+ - Fix issue when restoring keys backup using recovery key
+
+SDK API changes ⚠️:
+ - CreateRoomParams has been updated
+
+Build 🧱:
+ - Upgrade some dependencies
+ - Revert to build-tools 3.5.3
+
+Other changes:
+ - Use Intent.ACTION_CREATE_DOCUMENT to save megolm key or recovery key in a txt file
+ - Use `Context#withStyledAttributes` extension function (#1546)
+
+Changes in Riot.imX 0.91.4 (2020-07-06)
+===================================================
+
+Features ✨:
+ - Re-activate Wellknown support with updated UI (#1614)
+
+Improvements 🙌:
+ - Upload device keys only once to the homeserver and fix crash when no network (#1629)
+
+Bugfix 🐛:
+ - Fix crash when coming from a notification (#1601)
+ - Fix Exception when importing keys (#1576)
+ - File isn't downloaded when another file with the same name already exists (#1578)
+ - saved images don't show up in gallery (#1324)
+ - Fix reply fallback leaking sender locale (#429)
+
+Build 🧱:
+ - Fix lint false-positive about WorkManager (#1012)
+ - Upgrade build-tools from 3.5.3 to 3.6.3
+ - Upgrade gradle from 5.4.1 to 5.6.4
+
+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)
 ===================================================
 
@@ -297,6 +709,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%
@@ -340,7 +753,7 @@ Mode details here: https://medium.com/@RiotChat/introducing-the-riotx-beta-for-a
 =======================================================
 
 
-Changes in RiotX 0.X.0 (2020-XX-XX)
+Changes in Element 1.X.X (2020-XX-XX)
 ===================================================
 
 Features ✨:
@@ -349,15 +762,17 @@ Features ✨:
 Improvements 🙌:
  -
 
-Other changes:
- -
-
 Bugfix 🐛:
  -
 
 Translations 🗣:
  -
 
+SDK API changes ⚠️:
+ - 
+
 Build 🧱:
  -
 
+Other changes:
+ -

CONTRIBUTING.md

@@ -2,9 +2,7 @@
 
 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.
-
-Dedicated room for RiotX: [![RiotX Android Matrix room #riot-android:matrix.org](https://img.shields.io/matrix/riotx:matrix.org.svg?label=%23RiotX:matrix.org&logo=matrix&server_fqdn=matrix.org)](https://matrix.to/#/#riotx:matrix.org)
+Android support can be found in this [![Element Android Matrix room #element-android:matrix.org](https://img.shields.io/matrix/element-android:matrix.org.svg?label=%23element-android:matrix.org&logo=matrix&server_fqdn=matrix.org)](https://matrix.to/#/#element-android:matrix.org) room.
 
 # Specific rules for Matrix Android projects
 
@@ -13,17 +11,37 @@ Dedicated room for RiotX: [![RiotX Android Matrix room #riot-android:matrix.org]
 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
 
-For now, the Matrix SDK and the RiotX application are in the same project. So there is no specific thing to do, this project should compile without any special action.
+For now, the Matrix SDK and the Element application are in the same project. So there is no specific thing to do, this project should compile without any special action.
 
-## I want to help translating RiotX
+## I want to help translating Element
 
 If you want to fix an issue with an English string, please submit a PR.
 If you want to fix an issue in other languages, or add a missing translation, or even add a new language, please use [Weblate](https://translate.riot.im/projects/riot-android/).
 
-For the moment, Strings from Riot will be used, there is no dedicated project in Weblate for RiotX.
-
 ## I want to submit a PR to fix an issue
 
 Please check if a corresponding issue exists. If yes, please let us know in a comment that you're working on it.
@@ -79,9 +97,11 @@ Make sure the following commands execute without any error:
 
 ### Tests
 
-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.
+Element is currently supported on Android Lollipop (API 21+): please test your change on an Android device (or Android emulator) running with API 21. 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/).
@@ -96,7 +116,7 @@ Please consider accessibility as an important point. As a minimum requirement, i
 When adding or editing layouts, make sure the layout will render correctly if device uses a RTL (Right To Left) language.
 You can check this in the layout editor preview by selecting any RTL language (ex: Arabic).
 
-Also please check that the colors are ok for all the current themes of RiotX. Please use `?attr` instead of `@color` to reference colors in the layout. You can check this in the layout editor preview by selecting all the main themes (`AppTheme.Status`, `AppTheme.Dark`, etc.).
+Also please check that the colors are ok for all the current themes of Element. Please use `?attr` instead of `@color` to reference colors in the layout. You can check this in the layout editor preview by selecting all the main themes (`AppTheme.Status`, `AppTheme.Dark`, etc.).
 
 ### Authors
 

README.md

@@ -1,38 +1,32 @@
 [![Buildkite](https://badge.buildkite.com/657d3db27364448d69d54f66c690f7788bc6aa80a7628e37f3.svg?branch=develop)](https://buildkite.com/matrix-dot-org/riotx-android/builds?branch=develop)
 [![Weblate](https://translate.riot.im/widgets/riot-android/-/svg-badge.svg)](https://translate.riot.im/engage/riot-android/?utm_source=widget)
-[![RiotX Android Matrix room #riot-android:matrix.org](https://img.shields.io/matrix/riotx:matrix.org.svg?label=%23RiotX:matrix.org&logo=matrix&server_fqdn=matrix.org)](https://matrix.to/#/#riotx:matrix.org)
+[![Element Android Matrix room #element-android:matrix.org](https://img.shields.io/matrix/element-android:matrix.org.svg?label=%23element-android:matrix.org&logo=matrix&server_fqdn=matrix.org)](https://matrix.to/#/#element-android:matrix.org)
 [![Quality Gate](https://sonarcloud.io/api/project_badges/measure?project=vector.android.riotx&metric=alert_status)](https://sonarcloud.io/dashboard?id=vector.android.riotx)
 [![Vulnerabilities](https://sonarcloud.io/api/project_badges/measure?project=vector.android.riotx&metric=vulnerabilities)](https://sonarcloud.io/dashboard?id=vector.android.riotx)
 [![Bugs](https://sonarcloud.io/api/project_badges/measure?project=vector.android.riotx&metric=bugs)](https://sonarcloud.io/dashboard?id=vector.android.riotx)
 
-# RiotX Android
+# Element Android
 
-RiotX is an Android Matrix Client currently in beta but in active development.
+Element Android is an Android Matrix Client provided by [Element](https://element.io/).
 
-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.
+It is a total rewrite of [Riot-Android](https://github.com/vector-im/riot-android) with a new user experience.
 
-[<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="https://f-droid.org/badge/get-it-on.png" alt="Get it on F-Droid" height="60">](https://f-droid.org/app/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.app)
+[<img src="resources/img/f-droid-badge.png" alt="Get it on F-Droid" height="60">](https://f-droid.org/app/im.vector.app)
 
 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 SDK is stable enough.
-
+Element is based on a new Android SDK fully written in Kotlin (like Element). In order to make the early development as fast as possible, Element and the new SDK currently share the same git repository. We will make separate repos once the SDK is stable enough.
 
 # Roadmap
 
-The current target is to release an application out of beta with the same level of features (and even more) as Riot.
-The roadmap has 3 phases:
-
-- [phase 0](https://github.com/vector-im/riotX-android/labels/phase0): Prototyping / Project setup
-- [phase 1](https://github.com/vector-im/riotX-android/labels/phase1): Beta release to the Play Store
-- [phase 2](https://github.com/vector-im/riotX-android/labels/phase2): Out of beta
-
+The version 1.0.0 of Element still misses some features which was previously included in Riot-Android.
+The team will work to add them on a regular basis.
 
 ## Contributing
 
 Please refer to [CONTRIBUTING.md](https://github.com/vector-im/riotX-android/blob/develop/CONTRIBUTING.md) if you want to contribute on Matrix Android projects!
 
-Come chat with the community in the dedicated Matrix [room](https://matrix.to/#/#riotx:matrix.org).
+Come chat with the community in the dedicated Matrix [room](https://matrix.to/#/#element-android:matrix.org).

attachment-viewer/.gitignore

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

attachment-viewer/build.gradle

@@ -0,0 +1,78 @@
+/*
+ * 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.
+ */
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+apply plugin: 'kotlin-android-extensions'
+
+buildscript {
+    repositories {
+        maven {
+            url 'https://jitpack.io'
+            content {
+                // PhotoView
+                includeGroupByRegex 'com\\.github\\.chrisbanes'
+            }
+        }
+        jcenter()
+    }
+
+}
+
+android {
+    compileSdkVersion 29
+
+    defaultConfig {
+        minSdkVersion 21
+        targetSdkVersion 29
+        versionCode 1
+        versionName "1.0"
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    kotlinOptions {
+        jvmTarget = '1.8'
+    }
+}
+
+dependencies {
+    implementation 'com.github.chrisbanes:PhotoView:2.0.0'
+
+    implementation 'io.reactivex.rxjava2:rxkotlin:2.3.0'
+    implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
+
+    implementation fileTree(dir: "libs", include: ["*.jar"])
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+    implementation 'androidx.core:core-ktx:1.3.0'
+    implementation 'androidx.appcompat:appcompat:1.1.0'
+    implementation 'com.google.android.material:material:1.1.0'
+    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
+    implementation 'androidx.navigation:navigation-fragment-ktx:2.1.0'
+    implementation 'androidx.navigation:navigation-ui-ktx:2.1.0'
+    testImplementation 'junit:junit:4.12'
+    androidTestImplementation 'androidx.test.ext:junit:1.1.1'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
+
+}

attachment-viewer/proguard-rules.pro

@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile

attachment-viewer/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest package="im.vector.riotx.attachmentviewer" />

attachment-viewer/src/main/java/im/vector/riotx/attachmentviewer/AnimatedImageViewHolder.kt

@@ -0,0 +1,30 @@
+/*
+ * 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.riotx.attachmentviewer
+
+import android.view.View
+import android.widget.ImageView
+import android.widget.ProgressBar
+
+class AnimatedImageViewHolder constructor(itemView: View) :
+        BaseViewHolder(itemView) {
+
+    val touchImageView: ImageView = itemView.findViewById(R.id.imageView)
+    val imageLoaderProgress: ProgressBar = itemView.findViewById(R.id.imageLoaderProgress)
+
+    internal val target = DefaultImageLoaderTarget(this, this.touchImageView)
+}

attachment-viewer/src/main/java/im/vector/riotx/attachmentviewer/AttachmentEvents.kt

@@ -0,0 +1,31 @@
+/*
+ * 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.riotx.attachmentviewer
+
+sealed class AttachmentEvents {
+    data class VideoEvent(val isPlaying: Boolean, val progress: Int, val duration: Int) : AttachmentEvents()
+}
+
+interface AttachmentEventListener {
+    fun onEvent(event: AttachmentEvents)
+}
+
+sealed class AttachmentCommands {
+    object PauseVideo : AttachmentCommands()
+    object StartVideo : AttachmentCommands()
+    data class SeekTo(val percentProgress: Int) : AttachmentCommands()
+}

attachment-viewer/src/main/java/im/vector/riotx/attachmentviewer/AttachmentSourceProvider.kt

@@ -0,0 +1,45 @@
+/*
+ * 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.riotx.attachmentviewer
+
+import android.content.Context
+import android.view.View
+
+sealed class AttachmentInfo(open val uid: String) {
+    data class Image(override val uid: String, val url: String, val data: Any?) : AttachmentInfo(uid)
+    data class AnimatedImage(override val uid: String, val url: String, val data: Any?) : AttachmentInfo(uid)
+    data class Video(override val uid: String, val url: String, val data: Any, val thumbnail: Image?) : AttachmentInfo(uid)
+//    data class Audio(override val uid: String, val url: String, val data: Any) : AttachmentInfo(uid)
+//    data class File(override val uid: String, val url: String, val data: Any) : AttachmentInfo(uid)
+}
+
+interface AttachmentSourceProvider {
+
+    fun getItemCount(): Int
+
+    fun getAttachmentInfoAt(position: Int): AttachmentInfo
+
+    fun loadImage(target: ImageLoaderTarget, info: AttachmentInfo.Image)
+
+    fun loadImage(target: ImageLoaderTarget, info: AttachmentInfo.AnimatedImage)
+
+    fun loadVideo(target: VideoLoaderTarget, info: AttachmentInfo.Video)
+
+    fun overlayViewAtPosition(context: Context, position: Int): View?
+
+    fun clear(id: String)
+}

attachment-viewer/src/main/java/im/vector/riotx/attachmentviewer/AttachmentViewerActivity.kt

@@ -0,0 +1,335 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ * Copyright (C) 2018 stfalcon.com
+ *
+ * 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.riotx.attachmentviewer
+
+import android.graphics.Color
+import android.os.Bundle
+import android.view.GestureDetector
+import android.view.MotionEvent
+import android.view.ScaleGestureDetector
+import android.view.View
+import android.view.ViewGroup
+import android.view.WindowManager
+import android.widget.ImageView
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.view.GestureDetectorCompat
+import androidx.core.view.ViewCompat
+import androidx.core.view.isVisible
+import androidx.core.view.updatePadding
+import androidx.transition.TransitionManager
+import androidx.viewpager2.widget.ViewPager2
+import kotlinx.android.synthetic.main.activity_attachment_viewer.*
+import java.lang.ref.WeakReference
+import kotlin.math.abs
+
+abstract class AttachmentViewerActivity : AppCompatActivity(), AttachmentEventListener {
+
+    lateinit var pager2: ViewPager2
+    lateinit var imageTransitionView: ImageView
+    lateinit var transitionImageContainer: ViewGroup
+
+    var topInset = 0
+    var bottomInset = 0
+    var systemUiVisibility = true
+
+    private var overlayView: View? = null
+        set(value) {
+            if (value == overlayView) return
+            overlayView?.let { rootContainer.removeView(it) }
+            rootContainer.addView(value)
+            value?.updatePadding(top = topInset, bottom = bottomInset)
+            field = value
+        }
+
+    private lateinit var swipeDismissHandler: SwipeToDismissHandler
+    private lateinit var directionDetector: SwipeDirectionDetector
+    private lateinit var scaleDetector: ScaleGestureDetector
+    private lateinit var gestureDetector: GestureDetectorCompat
+
+    var currentPosition = 0
+
+    private var swipeDirection: SwipeDirection? = null
+
+    private fun isScaled() = attachmentsAdapter.isScaled(currentPosition)
+
+    private var wasScaled: Boolean = false
+    private var isSwipeToDismissAllowed: Boolean = true
+    private lateinit var attachmentsAdapter: AttachmentsAdapter
+    private var isOverlayWasClicked = false
+
+//    private val shouldDismissToBottom: Boolean
+//        get() = e == null
+//                || !externalTransitionImageView.isRectVisible
+//                || !isAtStartPosition
+
+    private var isImagePagerIdle = true
+
+    fun setSourceProvider(sourceProvider: AttachmentSourceProvider) {
+        attachmentsAdapter.attachmentSourceProvider = sourceProvider
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        // This is important for the dispatchTouchEvent, if not we must correct
+        // the touch coordinates
+        window.decorView.systemUiVisibility = (
+                View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+                        or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
+                        or View.SYSTEM_UI_FLAG_IMMERSIVE)
+        window.setFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS, WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS)
+        window.setFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION, WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION)
+
+        setContentView(R.layout.activity_attachment_viewer)
+        attachmentPager.orientation = ViewPager2.ORIENTATION_HORIZONTAL
+        attachmentsAdapter = AttachmentsAdapter()
+        attachmentPager.adapter = attachmentsAdapter
+        imageTransitionView = transitionImageView
+        transitionImageContainer = findViewById(R.id.transitionImageContainer)
+        pager2 = attachmentPager
+        directionDetector = createSwipeDirectionDetector()
+        gestureDetector = createGestureDetector()
+
+        attachmentPager.registerOnPageChangeCallback(object : ViewPager2.OnPageChangeCallback() {
+            override fun onPageScrollStateChanged(state: Int) {
+                isImagePagerIdle = state == ViewPager2.SCROLL_STATE_IDLE
+            }
+
+            override fun onPageSelected(position: Int) {
+                onSelectedPositionChanged(position)
+            }
+        })
+
+        swipeDismissHandler = createSwipeToDismissHandler()
+        rootContainer.setOnTouchListener(swipeDismissHandler)
+        rootContainer.viewTreeObserver.addOnGlobalLayoutListener { swipeDismissHandler.translationLimit = dismissContainer.height / 4 }
+
+        scaleDetector = createScaleGestureDetector()
+
+        ViewCompat.setOnApplyWindowInsetsListener(rootContainer) { _, insets ->
+            overlayView?.updatePadding(top = insets.systemWindowInsetTop, bottom = insets.systemWindowInsetBottom)
+            topInset = insets.systemWindowInsetTop
+            bottomInset = insets.systemWindowInsetBottom
+            insets
+        }
+    }
+
+    fun onSelectedPositionChanged(position: Int) {
+        attachmentsAdapter.recyclerView?.findViewHolderForAdapterPosition(currentPosition)?.let {
+            (it as? BaseViewHolder)?.onSelected(false)
+        }
+        attachmentsAdapter.recyclerView?.findViewHolderForAdapterPosition(position)?.let {
+            (it as? BaseViewHolder)?.onSelected(true)
+            if (it is VideoViewHolder) {
+                it.eventListener = WeakReference(this)
+            }
+        }
+        currentPosition = position
+        overlayView = attachmentsAdapter.attachmentSourceProvider?.overlayViewAtPosition(this@AttachmentViewerActivity, position)
+    }
+
+    override fun onPause() {
+        attachmentsAdapter.onPause(currentPosition)
+        super.onPause()
+    }
+
+    override fun onResume() {
+        super.onResume()
+        attachmentsAdapter.onResume(currentPosition)
+    }
+
+    override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
+        // The zoomable view is configured to disallow interception when image is zoomed
+
+        // Check if the overlay is visible, and wants to handle the click
+        if (overlayView?.isVisible == true && overlayView?.dispatchTouchEvent(ev) == true) {
+            return true
+        }
+
+        // Log.v("ATTACHEMENTS", "================\ndispatchTouchEvent $ev")
+        handleUpDownEvent(ev)
+
+        // Log.v("ATTACHEMENTS", "scaleDetector is in progress ${scaleDetector.isInProgress}")
+        // Log.v("ATTACHEMENTS", "pointerCount ${ev.pointerCount}")
+        // Log.v("ATTACHEMENTS", "wasScaled $wasScaled")
+        if (swipeDirection == null && (scaleDetector.isInProgress || ev.pointerCount > 1 || wasScaled)) {
+            wasScaled = true
+//            Log.v("ATTACHEMENTS", "dispatch to pager")
+            return attachmentPager.dispatchTouchEvent(ev)
+        }
+
+        // Log.v("ATTACHEMENTS", "is current item scaled ${isScaled()}")
+        return (if (isScaled()) super.dispatchTouchEvent(ev) else handleTouchIfNotScaled(ev)).also {
+//            Log.v("ATTACHEMENTS", "\n================")
+        }
+    }
+
+    private fun handleUpDownEvent(event: MotionEvent) {
+        // Log.v("ATTACHEMENTS", "handleUpDownEvent $event")
+        if (event.action == MotionEvent.ACTION_UP) {
+            handleEventActionUp(event)
+        }
+
+        if (event.action == MotionEvent.ACTION_DOWN) {
+            handleEventActionDown(event)
+        }
+
+        scaleDetector.onTouchEvent(event)
+        gestureDetector.onTouchEvent(event)
+    }
+
+    private fun handleEventActionDown(event: MotionEvent) {
+        swipeDirection = null
+        wasScaled = false
+        attachmentPager.dispatchTouchEvent(event)
+
+        swipeDismissHandler.onTouch(rootContainer, event)
+        isOverlayWasClicked = dispatchOverlayTouch(event)
+    }
+
+    private fun handleEventActionUp(event: MotionEvent) {
+//        wasDoubleTapped = false
+        swipeDismissHandler.onTouch(rootContainer, event)
+        attachmentPager.dispatchTouchEvent(event)
+        isOverlayWasClicked = dispatchOverlayTouch(event)
+    }
+
+    private fun handleSingleTap(event: MotionEvent, isOverlayWasClicked: Boolean) {
+        // TODO if there is no overlay, we should at least toggle system bars?
+        if (overlayView != null && !isOverlayWasClicked) {
+            toggleOverlayViewVisibility()
+            super.dispatchTouchEvent(event)
+        }
+    }
+
+    private fun toggleOverlayViewVisibility() {
+        if (systemUiVisibility) {
+            // we hide
+            TransitionManager.beginDelayedTransition(rootContainer)
+            hideSystemUI()
+            overlayView?.isVisible = false
+        } else {
+            // we show
+            TransitionManager.beginDelayedTransition(rootContainer)
+            showSystemUI()
+            overlayView?.isVisible = true
+        }
+    }
+
+    private fun handleTouchIfNotScaled(event: MotionEvent): Boolean {
+//        Log.v("ATTACHEMENTS", "handleTouchIfNotScaled $event")
+        directionDetector.handleTouchEvent(event)
+
+        return when (swipeDirection) {
+            SwipeDirection.Up, SwipeDirection.Down    -> {
+                if (isSwipeToDismissAllowed && !wasScaled && isImagePagerIdle) {
+                    swipeDismissHandler.onTouch(rootContainer, event)
+                } else true
+            }
+            SwipeDirection.Left, SwipeDirection.Right -> {
+                attachmentPager.dispatchTouchEvent(event)
+            }
+            else                                      -> true
+        }
+    }
+
+    private fun handleSwipeViewMove(translationY: Float, translationLimit: Int) {
+        val alpha = calculateTranslationAlpha(translationY, translationLimit)
+        backgroundView.alpha = alpha
+        dismissContainer.alpha = alpha
+        overlayView?.alpha = alpha
+    }
+
+    private fun dispatchOverlayTouch(event: MotionEvent): Boolean =
+            overlayView
+                    ?.let { it.isVisible && it.dispatchTouchEvent(event) }
+                    ?: false
+
+    private fun calculateTranslationAlpha(translationY: Float, translationLimit: Int): Float =
+            1.0f - 1.0f / translationLimit.toFloat() / 4f * abs(translationY)
+
+    private fun createSwipeToDismissHandler()
+            : SwipeToDismissHandler = SwipeToDismissHandler(
+            swipeView = dismissContainer,
+            shouldAnimateDismiss = { shouldAnimateDismiss() },
+            onDismiss = { animateClose() },
+            onSwipeViewMove = ::handleSwipeViewMove)
+
+    private fun createSwipeDirectionDetector() =
+            SwipeDirectionDetector(this) { swipeDirection = it }
+
+    private fun createScaleGestureDetector() =
+            ScaleGestureDetector(this, ScaleGestureDetector.SimpleOnScaleGestureListener())
+
+    private fun createGestureDetector() =
+            GestureDetectorCompat(this, object : GestureDetector.SimpleOnGestureListener() {
+                override fun onSingleTapConfirmed(e: MotionEvent): Boolean {
+                    if (isImagePagerIdle) {
+                        handleSingleTap(e, isOverlayWasClicked)
+                    }
+                    return false
+                }
+
+                override fun onDoubleTap(e: MotionEvent?): Boolean {
+                    return super.onDoubleTap(e)
+                }
+            })
+
+    override fun onEvent(event: AttachmentEvents) {
+        if (overlayView is AttachmentEventListener) {
+            (overlayView as? AttachmentEventListener)?.onEvent(event)
+        }
+    }
+
+    protected open fun shouldAnimateDismiss(): Boolean = true
+
+    protected open fun animateClose() {
+        window.statusBarColor = Color.TRANSPARENT
+        finish()
+    }
+
+    fun handle(commands: AttachmentCommands) {
+        (attachmentsAdapter.recyclerView?.findViewHolderForAdapterPosition(currentPosition) as? BaseViewHolder)
+                ?.handleCommand(commands)
+    }
+
+    private fun hideSystemUI() {
+        systemUiVisibility = false
+        // Enables regular immersive mode.
+        // For "lean back" mode, remove SYSTEM_UI_FLAG_IMMERSIVE.
+        // Or for "sticky immersive," replace it with SYSTEM_UI_FLAG_IMMERSIVE_STICKY
+        window.decorView.systemUiVisibility = (View.SYSTEM_UI_FLAG_IMMERSIVE
+                // Set the content to appear under the system bars so that the
+                // content doesn't resize when the system bars hide and show.
+                or View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+                or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
+                or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
+                // Hide the nav bar and status bar
+                or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
+                or View.SYSTEM_UI_FLAG_FULLSCREEN)
+    }
+
+    // Shows the system bars by removing all the flags
+// except for the ones that make the content appear under the system bars.
+    private fun showSystemUI() {
+        systemUiVisibility = true
+        window.decorView.systemUiVisibility = (View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+                or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
+                or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN)
+    }
+}

attachment-viewer/src/main/java/im/vector/riotx/attachmentviewer/AttachmentsAdapter.kt

@@ -0,0 +1,115 @@
+/*
+ * 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.riotx.attachmentviewer
+
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.recyclerview.widget.RecyclerView
+
+class AttachmentsAdapter : RecyclerView.Adapter<BaseViewHolder>() {
+
+    var attachmentSourceProvider: AttachmentSourceProvider? = null
+        set(value) {
+            field = value
+            notifyDataSetChanged()
+        }
+
+    var recyclerView: RecyclerView? = null
+
+    override fun onAttachedToRecyclerView(recyclerView: RecyclerView) {
+        this.recyclerView = recyclerView
+    }
+
+    override fun onDetachedFromRecyclerView(recyclerView: RecyclerView) {
+        this.recyclerView = null
+    }
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): BaseViewHolder {
+        val inflater = LayoutInflater.from(parent.context)
+        val itemView = inflater.inflate(viewType, parent, false)
+        return when (viewType) {
+            R.layout.item_image_attachment          -> ZoomableImageViewHolder(itemView)
+            R.layout.item_animated_image_attachment -> AnimatedImageViewHolder(itemView)
+            R.layout.item_video_attachment          -> VideoViewHolder(itemView)
+            else                                    -> UnsupportedViewHolder(itemView)
+        }
+    }
+
+    override fun getItemViewType(position: Int): Int {
+        val info = attachmentSourceProvider!!.getAttachmentInfoAt(position)
+        return when (info) {
+            is AttachmentInfo.Image         -> R.layout.item_image_attachment
+            is AttachmentInfo.Video         -> R.layout.item_video_attachment
+            is AttachmentInfo.AnimatedImage -> R.layout.item_animated_image_attachment
+//            is AttachmentInfo.Audio         -> TODO()
+//            is AttachmentInfo.File          -> TODO()
+        }
+    }
+
+    override fun getItemCount(): Int {
+        return attachmentSourceProvider?.getItemCount() ?: 0
+    }
+
+    override fun onBindViewHolder(holder: BaseViewHolder, position: Int) {
+        attachmentSourceProvider?.getAttachmentInfoAt(position)?.let {
+            holder.bind(it)
+            when (it) {
+                is AttachmentInfo.Image         -> {
+                    attachmentSourceProvider?.loadImage((holder as ZoomableImageViewHolder).target, it)
+                }
+                is AttachmentInfo.AnimatedImage -> {
+                    attachmentSourceProvider?.loadImage((holder as AnimatedImageViewHolder).target, it)
+                }
+                is AttachmentInfo.Video         -> {
+                    attachmentSourceProvider?.loadVideo((holder as VideoViewHolder).target, it)
+                }
+//                else                            -> {
+// //                }
+            }
+        }
+    }
+
+    override fun onViewAttachedToWindow(holder: BaseViewHolder) {
+        holder.onAttached()
+    }
+
+    override fun onViewRecycled(holder: BaseViewHolder) {
+        holder.onRecycled()
+    }
+
+    override fun onViewDetachedFromWindow(holder: BaseViewHolder) {
+        holder.onDetached()
+    }
+
+    fun isScaled(position: Int): Boolean {
+        val holder = recyclerView?.findViewHolderForAdapterPosition(position)
+        if (holder is ZoomableImageViewHolder) {
+            return holder.touchImageView.attacher.scale > 1f
+        }
+        return false
+    }
+
+    fun onPause(position: Int) {
+        val holder = recyclerView?.findViewHolderForAdapterPosition(position) as? BaseViewHolder
+        holder?.entersBackground()
+    }
+
+    fun onResume(position: Int) {
+        val holder = recyclerView?.findViewHolderForAdapterPosition(position) as? BaseViewHolder
+        holder?.entersForeground()
+    }
+}

attachment-viewer/src/main/java/im/vector/riotx/attachmentviewer/BaseViewHolder.kt

@@ -0,0 +1,45 @@
+/*
+ * 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.riotx.attachmentviewer
+
+import android.view.View
+import androidx.recyclerview.widget.RecyclerView
+
+abstract class BaseViewHolder constructor(itemView: View) :
+        RecyclerView.ViewHolder(itemView) {
+
+    open fun onRecycled() {
+        boundResourceUid = null
+    }
+
+    open fun onAttached() {}
+    open fun onDetached() {}
+    open fun entersBackground() {}
+    open fun entersForeground() {}
+    open fun onSelected(selected: Boolean) {}
+
+    open fun handleCommand(commands: AttachmentCommands) {}
+
+    var boundResourceUid: String? = null
+
+    open fun bind(attachmentInfo: AttachmentInfo) {
+        boundResourceUid = attachmentInfo.uid
+    }
+}
+
+class UnsupportedViewHolder constructor(itemView: View) :
+        BaseViewHolder(itemView)

attachment-viewer/src/main/java/im/vector/riotx/attachmentviewer/ImageLoaderTarget.kt

@@ -0,0 +1,103 @@
+/*
+ * 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.riotx.attachmentviewer
+
+import android.graphics.drawable.Animatable
+import android.graphics.drawable.Drawable
+import android.widget.ImageView
+import android.widget.LinearLayout
+import androidx.core.view.isVisible
+import androidx.core.view.updateLayoutParams
+
+interface ImageLoaderTarget {
+
+    fun contextView(): ImageView
+
+    fun onResourceLoading(uid: String, placeholder: Drawable?)
+
+    fun onLoadFailed(uid: String, errorDrawable: Drawable?)
+
+    fun onResourceCleared(uid: String, placeholder: Drawable?)
+
+    fun onResourceReady(uid: String, resource: Drawable)
+}
+
+internal class DefaultImageLoaderTarget(val holder: AnimatedImageViewHolder, private val contextView: ImageView)
+    : ImageLoaderTarget {
+    override fun contextView(): ImageView {
+        return contextView
+    }
+
+    override fun onResourceLoading(uid: String, placeholder: Drawable?) {
+        if (holder.boundResourceUid != uid) return
+        holder.imageLoaderProgress.isVisible = true
+    }
+
+    override fun onLoadFailed(uid: String, errorDrawable: Drawable?) {
+        if (holder.boundResourceUid != uid) return
+        holder.imageLoaderProgress.isVisible = false
+    }
+
+    override fun onResourceCleared(uid: String, placeholder: Drawable?) {
+        if (holder.boundResourceUid != uid) return
+        holder.touchImageView.setImageDrawable(placeholder)
+    }
+
+    override fun onResourceReady(uid: String, resource: Drawable) {
+        if (holder.boundResourceUid != uid) return
+        holder.imageLoaderProgress.isVisible = false
+        // Glide mess up the view size :/
+        holder.touchImageView.updateLayoutParams {
+            width = LinearLayout.LayoutParams.MATCH_PARENT
+            height = LinearLayout.LayoutParams.MATCH_PARENT
+        }
+        holder.touchImageView.setImageDrawable(resource)
+        if (resource is Animatable) {
+            resource.start()
+        }
+    }
+
+    internal class ZoomableImageTarget(val holder: ZoomableImageViewHolder, private val contextView: ImageView) : ImageLoaderTarget {
+        override fun contextView() = contextView
+
+        override fun onResourceLoading(uid: String, placeholder: Drawable?) {
+            if (holder.boundResourceUid != uid) return
+            holder.imageLoaderProgress.isVisible = true
+        }
+
+        override fun onLoadFailed(uid: String, errorDrawable: Drawable?) {
+            if (holder.boundResourceUid != uid) return
+            holder.imageLoaderProgress.isVisible = false
+        }
+
+        override fun onResourceCleared(uid: String, placeholder: Drawable?) {
+            if (holder.boundResourceUid != uid) return
+            holder.touchImageView.setImageDrawable(placeholder)
+        }
+
+        override fun onResourceReady(uid: String, resource: Drawable) {
+            if (holder.boundResourceUid != uid) return
+            holder.imageLoaderProgress.isVisible = false
+            // Glide mess up the view size :/
+            holder.touchImageView.updateLayoutParams {
+                width = LinearLayout.LayoutParams.MATCH_PARENT
+                height = LinearLayout.LayoutParams.MATCH_PARENT
+            }
+            holder.touchImageView.setImageDrawable(resource)
+        }
+    }
+}

attachment-viewer/src/main/java/im/vector/riotx/attachmentviewer/SwipeDirection.kt

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ * Copyright (C) 2018 stfalcon.com
+ *
+ * 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.riotx.attachmentviewer
+
+sealed class SwipeDirection {
+    object NotDetected : SwipeDirection()
+    object Up : SwipeDirection()
+    object Down : SwipeDirection()
+    object Left : SwipeDirection()
+    object Right : SwipeDirection()
+
+    companion object {
+        fun fromAngle(angle: Double): SwipeDirection {
+            return when (angle) {
+                in 0.0..45.0    -> Right
+                in 45.0..135.0  -> Up
+                in 135.0..225.0 -> Left
+                in 225.0..315.0 -> Down
+                in 315.0..360.0 -> Right
+                else            -> NotDetected
+            }
+        }
+    }
+}

attachment-viewer/src/main/java/im/vector/riotx/attachmentviewer/SwipeDirectionDetector.kt

@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ * Copyright (C) 2018 stfalcon.com
+ *
+ * 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.riotx.attachmentviewer
+
+import android.content.Context
+import android.view.MotionEvent
+import kotlin.math.sqrt
+
+class SwipeDirectionDetector(
+        context: Context,
+        private val onDirectionDetected: (SwipeDirection) -> Unit
+) {
+
+    private val touchSlop: Int = android.view.ViewConfiguration.get(context).scaledTouchSlop
+    private var startX: Float = 0f
+    private var startY: Float = 0f
+    private var isDetected: Boolean = false
+
+    fun handleTouchEvent(event: MotionEvent) {
+        when (event.action) {
+            MotionEvent.ACTION_DOWN                          -> {
+                startX = event.x
+                startY = event.y
+            }
+            MotionEvent.ACTION_CANCEL, MotionEvent.ACTION_UP -> {
+                if (!isDetected) {
+                    onDirectionDetected(SwipeDirection.NotDetected)
+                }
+                startY = 0.0f
+                startX = startY
+                isDetected = false
+            }
+            MotionEvent.ACTION_MOVE                          -> if (!isDetected && getEventDistance(event) > touchSlop) {
+                isDetected = true
+                onDirectionDetected(getDirection(startX, startY, event.x, event.y))
+            }
+        }
+    }
+
+    /**
+     * Given two points in the plane p1=(x1, x2) and p2=(y1, y1), this method
+     * returns the direction that an arrow pointing from p1 to p2 would have.
+     *
+     * @param x1 the x position of the first point
+     * @param y1 the y position of the first point
+     * @param x2 the x position of the second point
+     * @param y2 the y position of the second point
+     * @return the direction
+     */
+    private fun getDirection(x1: Float, y1: Float, x2: Float, y2: Float): SwipeDirection {
+        val angle = getAngle(x1, y1, x2, y2)
+        return SwipeDirection.fromAngle(angle)
+    }
+
+    /**
+     * Finds the angle between two points in the plane (x1,y1) and (x2, y2)
+     * The angle is measured with 0/360 being the X-axis to the right, angles
+     * increase counter clockwise.
+     *
+     * @param x1 the x position of the first point
+     * @param y1 the y position of the first point
+     * @param x2 the x position of the second point
+     * @param y2 the y position of the second point
+     * @return the angle between two points
+     */
+    private fun getAngle(x1: Float, y1: Float, x2: Float, y2: Float): Double {
+        val rad = Math.atan2((y1 - y2).toDouble(), (x2 - x1).toDouble()) + Math.PI
+        return (rad * 180 / Math.PI + 180) % 360
+    }
+
+    private fun getEventDistance(ev: MotionEvent): Float {
+        val dx = ev.getX(0) - startX
+        val dy = ev.getY(0) - startY
+        return sqrt((dx * dx + dy * dy).toDouble()).toFloat()
+    }
+}

attachment-viewer/src/main/java/im/vector/riotx/attachmentviewer/SwipeToDismissHandler.kt

@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ * Copyright (C) 2018 stfalcon.com
+ *
+ * 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.riotx.attachmentviewer
+
+import android.animation.Animator
+import android.animation.AnimatorListenerAdapter
+import android.annotation.SuppressLint
+import android.graphics.Rect
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewPropertyAnimator
+import android.view.animation.AccelerateInterpolator
+
+class SwipeToDismissHandler(
+        private val swipeView: View,
+        private val onDismiss: () -> Unit,
+        private val onSwipeViewMove: (translationY: Float, translationLimit: Int) -> Unit,
+        private val shouldAnimateDismiss: () -> Boolean
+) : View.OnTouchListener {
+
+    companion object {
+        private const val ANIMATION_DURATION = 200L
+    }
+
+    var translationLimit: Int = swipeView.height / 4
+    private var isTracking = false
+    private var startY: Float = 0f
+
+    @SuppressLint("ClickableViewAccessibility")
+    override fun onTouch(v: View, event: MotionEvent): Boolean {
+        when (event.action) {
+            MotionEvent.ACTION_DOWN                          -> {
+                if (swipeView.hitRect.contains(event.x.toInt(), event.y.toInt())) {
+                    isTracking = true
+                }
+                startY = event.y
+                return true
+            }
+            MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
+                if (isTracking) {
+                    isTracking = false
+                    onTrackingEnd(v.height)
+                }
+                return true
+            }
+            MotionEvent.ACTION_MOVE                          -> {
+                if (isTracking) {
+                    val translationY = event.y - startY
+                    swipeView.translationY = translationY
+                    onSwipeViewMove(translationY, translationLimit)
+                }
+                return true
+            }
+            else                                             -> {
+                return false
+            }
+        }
+    }
+
+    internal fun initiateDismissToBottom() {
+        animateTranslation(swipeView.height.toFloat())
+    }
+
+    private fun onTrackingEnd(parentHeight: Int) {
+        val animateTo = when {
+            swipeView.translationY < -translationLimit -> -parentHeight.toFloat()
+            swipeView.translationY > translationLimit  -> parentHeight.toFloat()
+            else                                       -> 0f
+        }
+
+        if (animateTo != 0f && !shouldAnimateDismiss()) {
+            onDismiss()
+        } else {
+            animateTranslation(animateTo)
+        }
+    }
+
+    private fun animateTranslation(translationTo: Float) {
+        swipeView.animate()
+                .translationY(translationTo)
+                .setDuration(ANIMATION_DURATION)
+                .setInterpolator(AccelerateInterpolator())
+                .setUpdateListener { onSwipeViewMove(swipeView.translationY, translationLimit) }
+                .setAnimatorListener(onAnimationEnd = {
+                    if (translationTo != 0f) {
+                        onDismiss()
+                    }
+
+                    // remove the update listener, otherwise it will be saved on the next animation execution:
+                    swipeView.animate().setUpdateListener(null)
+                })
+                .start()
+    }
+}
+
+internal fun ViewPropertyAnimator.setAnimatorListener(
+        onAnimationEnd: ((Animator?) -> Unit)? = null,
+        onAnimationStart: ((Animator?) -> Unit)? = null
+) = this.setListener(
+        object : AnimatorListenerAdapter() {
+            override fun onAnimationEnd(animation: Animator?) {
+                onAnimationEnd?.invoke(animation)
+            }
+
+            override fun onAnimationStart(animation: Animator?) {
+                onAnimationStart?.invoke(animation)
+            }
+        })
+
+internal val View?.hitRect: Rect
+    get() = Rect().also { this?.getHitRect(it) }

attachment-viewer/src/main/java/im/vector/riotx/attachmentviewer/VideoLoaderTarget.kt

@@ -0,0 +1,76 @@
+/*
+ * 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.riotx.attachmentviewer
+
+import android.graphics.drawable.Drawable
+import android.widget.ImageView
+import androidx.core.view.isVisible
+import java.io.File
+
+interface VideoLoaderTarget {
+    fun contextView(): ImageView
+
+    fun onThumbnailResourceLoading(uid: String, placeholder: Drawable?)
+
+    fun onThumbnailLoadFailed(uid: String, errorDrawable: Drawable?)
+
+    fun onThumbnailResourceCleared(uid: String, placeholder: Drawable?)
+
+    fun onThumbnailResourceReady(uid: String, resource: Drawable)
+
+    fun onVideoFileLoading(uid: String)
+    fun onVideoFileLoadFailed(uid: String)
+    fun onVideoFileReady(uid: String, file: File)
+}
+
+internal class DefaultVideoLoaderTarget(val holder: VideoViewHolder, private val contextView: ImageView) : VideoLoaderTarget {
+    override fun contextView(): ImageView = contextView
+
+    override fun onThumbnailResourceLoading(uid: String, placeholder: Drawable?) {
+    }
+
+    override fun onThumbnailLoadFailed(uid: String, errorDrawable: Drawable?) {
+    }
+
+    override fun onThumbnailResourceCleared(uid: String, placeholder: Drawable?) {
+    }
+
+    override fun onThumbnailResourceReady(uid: String, resource: Drawable) {
+        if (holder.boundResourceUid != uid) return
+        holder.thumbnailImage.setImageDrawable(resource)
+    }
+
+    override fun onVideoFileLoading(uid: String) {
+        if (holder.boundResourceUid != uid) return
+        holder.thumbnailImage.isVisible = true
+        holder.loaderProgressBar.isVisible = true
+        holder.videoView.isVisible = false
+    }
+
+    override fun onVideoFileLoadFailed(uid: String) {
+        if (holder.boundResourceUid != uid) return
+        holder.videoFileLoadError()
+    }
+
+    override fun onVideoFileReady(uid: String, file: File) {
+        if (holder.boundResourceUid != uid) return
+        holder.thumbnailImage.isVisible = false
+        holder.loaderProgressBar.isVisible = false
+        holder.videoView.isVisible = true
+        holder.videoReady(file)
+    }
+}

attachment-viewer/src/main/java/im/vector/riotx/attachmentviewer/VideoViewHolder.kt

@@ -0,0 +1,157 @@
+/*
+ * 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.riotx.attachmentviewer
+
+import android.view.View
+import android.widget.ImageView
+import android.widget.ProgressBar
+import android.widget.TextView
+import android.widget.VideoView
+import androidx.core.view.isVisible
+import io.reactivex.Observable
+import io.reactivex.android.schedulers.AndroidSchedulers
+import io.reactivex.disposables.Disposable
+import java.io.File
+import java.lang.ref.WeakReference
+import java.util.concurrent.TimeUnit
+
+// TODO, it would be probably better to use a unique media player
+// for better customization and control
+// But for now VideoView is enough, it released player when detached, we use a timer to update progress
+class VideoViewHolder constructor(itemView: View) :
+        BaseViewHolder(itemView) {
+
+    private var isSelected = false
+    private var mVideoPath: String? = null
+    private var progressDisposable: Disposable? = null
+    private var progress: Int = 0
+    private var wasPaused = false
+
+    var eventListener: WeakReference<AttachmentEventListener>? = null
+
+    val thumbnailImage: ImageView = itemView.findViewById(R.id.videoThumbnailImage)
+    val videoView: VideoView = itemView.findViewById(R.id.videoView)
+    val loaderProgressBar: ProgressBar = itemView.findViewById(R.id.videoLoaderProgress)
+    val videoControlIcon: ImageView = itemView.findViewById(R.id.videoControlIcon)
+    val errorTextView: TextView = itemView.findViewById(R.id.videoMediaViewerErrorView)
+
+    internal val target = DefaultVideoLoaderTarget(this, thumbnailImage)
+
+    override fun onRecycled() {
+        super.onRecycled()
+        progressDisposable?.dispose()
+        progressDisposable = null
+        mVideoPath = null
+    }
+
+    fun videoReady(file: File) {
+        mVideoPath = file.path
+        if (isSelected) {
+            startPlaying()
+        }
+    }
+
+    fun videoFileLoadError() {
+    }
+
+    override fun entersBackground() {
+        if (videoView.isPlaying) {
+            progress = videoView.currentPosition
+            progressDisposable?.dispose()
+            progressDisposable = null
+            videoView.stopPlayback()
+            videoView.pause()
+        }
+    }
+
+    override fun entersForeground() {
+        onSelected(isSelected)
+    }
+
+    override fun onSelected(selected: Boolean) {
+        if (!selected) {
+            if (videoView.isPlaying) {
+                progress = videoView.currentPosition
+                videoView.stopPlayback()
+            } else {
+                progress = 0
+            }
+            progressDisposable?.dispose()
+            progressDisposable = null
+        } else {
+            if (mVideoPath != null) {
+                startPlaying()
+            }
+        }
+        isSelected = true
+    }
+
+    private fun startPlaying() {
+        thumbnailImage.isVisible = false
+        loaderProgressBar.isVisible = false
+        videoView.isVisible = true
+
+        videoView.setOnPreparedListener {
+            progressDisposable?.dispose()
+            progressDisposable = Observable.interval(100, TimeUnit.MILLISECONDS)
+                    .timeInterval()
+                    .observeOn(AndroidSchedulers.mainThread())
+                    .subscribe {
+                        val duration = videoView.duration
+                        val progress = videoView.currentPosition
+                        val isPlaying = videoView.isPlaying
+//                        Log.v("FOO", "isPlaying $isPlaying $progress/$duration")
+                        eventListener?.get()?.onEvent(AttachmentEvents.VideoEvent(isPlaying, progress, duration))
+                    }
+        }
+
+        videoView.setVideoPath(mVideoPath)
+        if (!wasPaused) {
+            videoView.start()
+            if (progress > 0) {
+                videoView.seekTo(progress)
+            }
+        }
+    }
+
+    override fun handleCommand(commands: AttachmentCommands) {
+        if (!isSelected) return
+        when (commands) {
+            AttachmentCommands.StartVideo -> {
+                wasPaused = false
+                videoView.start()
+            }
+            AttachmentCommands.PauseVideo -> {
+                wasPaused = true
+                videoView.pause()
+            }
+            is AttachmentCommands.SeekTo  -> {
+                val duration = videoView.duration
+                if (duration > 0) {
+                    val seekDuration = duration * (commands.percentProgress / 100f)
+                    videoView.seekTo(seekDuration.toInt())
+                }
+            }
+        }
+    }
+
+    override fun bind(attachmentInfo: AttachmentInfo) {
+        super.bind(attachmentInfo)
+        progress = 0
+        wasPaused = false
+    }
+}

attachment-viewer/src/main/java/im/vector/riotx/attachmentviewer/ZoomableImageViewHolder.kt

@@ -0,0 +1,42 @@
+/*
+ * 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.riotx.attachmentviewer
+
+import android.view.View
+import android.widget.ProgressBar
+import com.github.chrisbanes.photoview.PhotoView
+
+class ZoomableImageViewHolder constructor(itemView: View) :
+        BaseViewHolder(itemView) {
+
+    val touchImageView: PhotoView = itemView.findViewById(R.id.touchImageView)
+    val imageLoaderProgress: ProgressBar = itemView.findViewById(R.id.imageLoaderProgress)
+
+    init {
+        touchImageView.setAllowParentInterceptOnEdge(false)
+        touchImageView.setOnScaleChangeListener { scaleFactor, _, _ ->
+            // Log.v("ATTACHEMENTS", "scaleFactor $scaleFactor")
+            // It's a bit annoying but when you pitch down the scaling
+            // is not exactly one :/
+            touchImageView.setAllowParentInterceptOnEdge(scaleFactor <= 1.0008f)
+        }
+        touchImageView.setScale(1.0f, true)
+        touchImageView.setAllowParentInterceptOnEdge(true)
+    }
+
+    internal val target = DefaultImageLoaderTarget.ZoomableImageTarget(this, touchImageView)
+}

attachment-viewer/src/main/res/layout/activity_attachment_viewer.xml

@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="utf-8"?>
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:id="@+id/rootContainer"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context=".AttachmentViewerActivity">
+
+    <View
+        android:id="@+id/backgroundView"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:alpha="1"
+        android:background="@android:color/black" />
+
+    <FrameLayout
+        android:id="@+id/dismissContainer"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent">
+
+        <FrameLayout
+            android:id="@+id/transitionImageContainer"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            tools:ignore="UselessParent"
+            tools:visibility="invisible">
+
+            <ImageView
+                android:id="@+id/transitionImageView"
+                android:layout_width="match_parent"
+                android:layout_height="match_parent"
+                tools:ignore="ContentDescription" />
+
+        </FrameLayout>
+
+        <androidx.viewpager2.widget.ViewPager2
+            android:id="@+id/attachmentPager"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:background="@android:color/transparent"
+            android:orientation="horizontal"
+            android:visibility="visible" />
+
+    </FrameLayout>
+
+</FrameLayout>

attachment-viewer/src/main/res/layout/item_animated_image_attachment.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <ImageView
+        android:id="@+id/imageView"
+        android:visibility="visible"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"/>
+
+    <ProgressBar
+        android:layout_centerInParent="true"
+        android:id="@+id/imageLoaderProgress"
+        style="?android:attr/progressBarStyle"
+        android:layout_width="40dp"
+        android:layout_height="40dp"
+        android:visibility="visible"
+        tools:visibility="gone" />
+
+</RelativeLayout>

attachment-viewer/src/main/res/layout/item_image_attachment.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <com.github.chrisbanes.photoview.PhotoView
+        android:id="@+id/touchImageView"
+        android:visibility="visible"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"/>
+
+    <ProgressBar
+        android:layout_centerInParent="true"
+        android:id="@+id/imageLoaderProgress"
+        style="?android:attr/progressBarStyle"
+        android:layout_width="40dp"
+        android:layout_height="40dp"
+        android:visibility="visible"
+        tools:visibility="gone" />
+
+</RelativeLayout>

attachment-viewer/src/main/res/layout/item_video_attachment.xml

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <ImageView
+        android:id="@+id/videoThumbnailImage"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:layout_gravity="center"
+        android:scaleType="centerInside" />
+
+    <VideoView
+        android:id="@+id/videoView"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:layout_centerInParent="true" />
+
+    <ImageView
+        android:id="@+id/videoControlIcon"
+        android:layout_centerInParent="true"
+        android:visibility="gone"
+        tools:visibility="visible"
+        android:layout_width="44dp"
+        android:layout_height="44dp"
+        />
+
+    <ProgressBar
+        android:layout_centerInParent="true"
+        android:id="@+id/videoLoaderProgress"
+        style="?android:attr/progressBarStyle"
+        android:layout_width="40dp"
+        android:layout_height="40dp"
+        android:visibility="invisible"
+        tools:visibility="visible" />
+
+    <TextView
+        android:id="@+id/videoMediaViewerErrorView"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_centerInParent="true"
+        android:layout_margin="16dp"
+        android:textSize="16sp"
+        android:visibility="gone"
+        tools:text="Error"
+        tools:visibility="visible" />
+
+</RelativeLayout>

attachment-viewer/src/main/res/layout/view_image_attachment.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:background="@color/design_default_color_primary">
+
+    <TextView
+        android:id="@+id/testPage"
+        android:layout_centerInParent="true"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="1"
+        android:textSize="80sp"
+        android:textStyle="bold" />
+
+
+</RelativeLayout>

build.gradle

@@ -1,7 +1,7 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 
 buildscript {
-    ext.kotlin_version = '1.3.50'
+    ext.kotlin_version = '1.3.72'
     repositories {
         google()
         jcenter()
@@ -10,12 +10,13 @@ buildscript {
         }
     }
     dependencies {
+        // Warning: 3.6.3 leads to infinite gradle builds. Stick to 3.5.3 for the moment
         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.7.1'
-        classpath 'com.google.android.gms:oss-licenses-plugin:0.9.5'
+        classpath 'com.google.android.gms:oss-licenses-plugin:0.10.2'
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files
@@ -34,6 +35,12 @@ allprojects {
                 includeGroupByRegex "com\\.github\\.jaiselrahman"
                 // And monarchy
                 includeGroupByRegex "com\\.github\\.Zhuinden"
+                // And ucrop
+                includeGroupByRegex "com\\.github\\.yalantis"
+                // JsonViewer
+                includeGroupByRegex 'com\\.github\\.BillCarsonFr'
+                // PhotoView
+                includeGroupByRegex 'com\\.github\\.chrisbanes'
             }
         }
         maven {
@@ -47,23 +54,11 @@ allprojects {
         jcenter()
     }
 
-    tasks.withType(JavaCompile).all {
-        options.compilerArgs += [
-                '-Adagger.gradle.incremental=enabled'
-        ]
-    }
-
     tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
         // Warnings are potential errors, so stop ignoring them
         kotlinOptions.allWarningsAsErrors = true
     }
 
-    afterEvaluate {
-        extensions.findByName("kapt")?.arguments {
-            arg("dagger.gradle.incremental", "enabled")
-        }
-    }
-
 }
 
 task clean(type: Delete) {

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 Element)
+- 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 Element-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) Element 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

@@ -1,4 +1,4 @@
-This document aims to describe how RiotX android displays notifications to the end user. It also clarifies notifications and background settings in the app.
+This document aims to describe how Element android displays notifications to the end user. It also clarifies notifications and background settings in the app.
 
 # Table of Contents
 1. [Prerequisites Knowledge](#prerequisites-knowledge)
@@ -9,7 +9,7 @@ This document aims to describe how RiotX android displays notifications to the e
     * [How does the Home Server knows when to notify a client?](#how-does-the-home-server-knows-when-to-notify-a-client)
     * [Push vs privacy, and mitigation](#push-vs-privacy-and-mitigation)
     * [Background processing limitations](#background-processing-limitations)
-2. [RiotX Notification implementations](#riotx-notification-implementations)
+2. [Element Notification implementations](#element-notification-implementations)
     * [Requirements](#requirements) 
     * [Foreground sync mode (Gplay & F-Droid)](#foreground-sync-mode-gplay-f-droid)
     * [Push (FCM) received in background](#push-fcm-received-in-background)
@@ -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.
@@ -50,7 +50,7 @@ By default, this is 0, so the server will return immediately even if the respons
 
 **delay** is a client preference. When the server responds to a sync request, the client waits for `delay`before calling a new sync.
 
-When the RiotX Android app is open (i.e in foreground state), the default timeout is 30 seconds, and delay is 0.
+When the Element Android app is open (i.e in foreground state), the default timeout is 30 seconds, and delay is 0.
 
 ## How does a mobile app receives push notification
 
@@ -86,7 +86,7 @@ This need some disambiguation, because it is the source of common confusion:
 In order to send a push to a mobile, App developers need to have a server that will use the FCM APIs, and these APIs requires authentication!
 This server is called a **Push Gateway** in the matrix world
 
-That means that RiotX Android, a matrix client created by New Vector, is using a **Push Gateway** with the needed credentials (FCM API secret Key) in order to send push to the New Vector client.
+That means that Element Android, a matrix client created by New Vector, is using a **Push Gateway** with the needed credentials (FCM API secret Key) in order to send push to the New Vector client.
 
 If you create your own matrix client, you will also need to deploy an instance of a **Push Gateway** with the credentials needed to use FCM for your app.
 
@@ -132,7 +132,7 @@ A Home Server can be configured with default rules (for Direct messages, group m
 
 There are different kind of push rules, it can be per room (each new message on this room should be notified), it can also define a pattern that a message should match (when you are mentioned, or key word based).
 
-Notifications have 2 'levels' (`highlighted = true/false sound = default/custom`). In RiotX these notifications level are reflected as Noisy/Silent. 
+Notifications have 2 'levels' (`highlighted = true/false sound = default/custom`). In Element these notifications level are reflected as Noisy/Silent. 
 
 **What about encrypted messages?**
 
@@ -158,7 +158,7 @@ In a nutshell, apps can't do much in background now.
 
 If the devices is not plugged and stays IDLE for a certain amount of time, radio (mobile connectivity) and CPU can/will be turned off.
 
-For an application like RiotX, where users can receive important information at anytime, the best option is to rely on a push system (Google's Firebase Message a.k.a FCM). FCM high priority push can wake up the device and whitelist an application to perform background task (for a limited but unspecified amount of time). 
+For an application like Element, where users can receive important information at anytime, the best option is to rely on a push system (Google's Firebase Message a.k.a FCM). FCM high priority push can wake up the device and whitelist an application to perform background task (for a limited but unspecified amount of time). 
 
 Notice that this is still evolving, and in future versions application that has been 'background restricted' by users won't be able to wake up even when a high priority push is received. Also high priority notifications could be rate limited (not defined anywhere)
 
@@ -167,41 +167,41 @@ The documentation on this subject is vague, and as per our experiments not alway
 
 It is getting more and more complex to have reliable notifications when FCM is not used.
 
-# RiotX Notification implementations
+# Element Notification implementations
 
 ## Requirements
 
-RiotX Android must work with and without FCM.
-* The RiotX android app published on F-Droid do not rely on FCM (all related dependencies are not present)
-* The RiotX android app published on google play rely on FCM, with a fallback mode when FCM registration has failed (e.g outdated or missing Google Play Services)
+Element Android must work with and without FCM.
+* The Element android app published on F-Droid do not rely on FCM (all related dependencies are not present)
+* The Element android app published on google play rely on FCM, with a fallback mode when FCM registration has failed (e.g outdated or missing Google Play Services)
 
 ## Foreground sync mode (Gplay & F-Droid)
 
-When in foreground, RiotX performs sync continuously with a timeout value set to 10 seconds (see HttpPooling).
+When in foreground, Element performs sync continuously with a timeout value set to 10 seconds (see HttpPooling).
 
-As this mode does not need to live beyond the scope of the application, and as per Google recommendation, RiotX uses the internal app resources (Thread and Timers) to perform the syncs. 
+As this mode does not need to live beyond the scope of the application, and as per Google recommendation, Element uses the internal app resources (Thread and Timers) to perform the syncs. 
 
 This mode is turned on when the app enters foreground, and off when enters background.
 
-In background, and depending on wether push is available or not, RiotX will use different methods to perform the syncs (Workers / Alarms / Service)
+In background, and depending on wether push is available or not, Element will use different methods to perform the syncs (Workers / Alarms / Service)
 
 ## Push (FCM) received in background 
 
-In order to enable Push, RiotX must first get a push token from the firebase SDK, then register a pusher with this token on the HomeServer.
+In order to enable Push, Element must first get a push token from the firebase SDK, then register a pusher with this token on the HomeServer.
 
-When a message should be notified to a user,  the user's homeserver notifies the registered `push gateway` for RiotX, that is [sygnal](https://github.com/matrix-org/sygnal) _- The reference implementation for push gateways -_ hosted by matrix.org. 
+When a message should be notified to a user,  the user's homeserver notifies the registered `push gateway` for Element, that is [sygnal](https://github.com/matrix-org/sygnal) _- The reference implementation for push gateways -_ hosted by matrix.org. 
 
-This sygnal instance is configured with the required FCM API authentication token, and will then use the FCM API in order to notify the user's device running riotX.
+This sygnal instance is configured with the required FCM API authentication token, and will then use the FCM API in order to notify the user's device running Element.
 
 ```
-Homeserver ----> Sygnal (configured for RiotX) ----> FCM ----> RiotX
+Homeserver ----> Sygnal (configured for Element) ----> FCM ----> Element
 ```
 
 The push gateway is configured to only send  `(eventId,roomId)` in the push payload (for better [privacy](#push-vs-privacy-and-mitigation)).
 
-RiotX needs then to synchronise with the user's HomeServer, in order to resolve the event and create a notification.
+Element needs then to synchronise with the user's HomeServer, in order to resolve the event and create a notification.
 
-As per [Google recommendation](https://android-developers.googleblog.com/2018/09/notifying-your-users-with-fcm.html), RiotX will then use the WorkManager API in order to trigger a background sync. 
+As per [Google recommendation](https://android-developers.googleblog.com/2018/09/notifying-your-users-with-fcm.html), Element will then use the WorkManager API in order to trigger a background sync. 
 
 **Google recommendations:** 
 >  We recommend using FCM messages in combination with the WorkManager 1 or JobScheduler API
@@ -209,7 +209,7 @@ As per [Google recommendation](https://android-developers.googleblog.com/2018/09
 >  Avoid background services. One common pitfall is using a background service to fetch data in the FCM message handler, since background service will be stopped by the system per recent changes to Google Play Policy
 
 ```
-Homeserver ----> Sygnal ----> FCM ----> RiotX
+Homeserver ----> Sygnal ----> FCM ----> Element
                                         (Sync) ----> Homeserver
                                                <----
                                         Display notification
@@ -217,24 +217,24 @@ Homeserver ----> Sygnal ----> FCM ----> RiotX
 
 **Possible outcomes**
 
-Upon reception of the FCM push, RiotX will perform a sync call to the Home Server, during this process it is possible that:
+Upon reception of the FCM push, Element will perform a sync call to the Home Server, during this process it is possible that:
   * Happy path, the sync is performed, the message resolved and displayed in the notification drawer
   * The notified message is not in the sync. Can happen if a lot of things did happen since the push (`gappy sync`)
   * The sync generates additional notifications (e.g an encrypted message where the user is mentioned detected locally)
   * The sync takes too long and the process is killed before completion, or network is not reliable and the sync fails.
 
-RiotX implements several strategies in these cases (TODO document)
+Element implements several strategies in these cases (TODO document)
 
 ## FCM Fallback mode
 
-It is possible that RiotX is not able to get a FCM push token.
+It is possible that Element is not able to get a FCM push token.
 Common errors (amoung several others) that can cause that:
 * Google Play Services is outdated
 * Google Play Service fails in someways with FCM servers (infamous `SERVICE_NOT_AVAILABLE`)
 
-If RiotX is able to detect one of this cases, it will notifies it to the users and when possible help him fix it via a dedicated troubleshoot screen.
+If Element is able to detect one of this cases, it will notifies it to the users and when possible help him fix it via a dedicated troubleshoot screen.
 
-Meanwhile, in order to offer a minimal service, and as per Google's recommendation for background activities, RiotX will launch periodic background sync in order to stays in sync with servers.
+Meanwhile, in order to offer a minimal service, and as per Google's recommendation for background activities, Element will launch periodic background sync in order to stays in sync with servers.
 
 The fallback mode is impacted by all the battery life saving mechanism implemented by android. Meaning that if the app is not used for a certain amount of time (`App-Standby`), or the device stays still and unplugged (`Light Doze`) , the sync will become less frequent.
 
@@ -248,7 +248,7 @@ The fallback mode is supposed to be a temporary state waiting for the user to fi
 
 ## F-Droid background Mode
 
-The F-Droid RiotX flavor has no dependencies to FCM, therefore cannot relies on Push.
+The F-Droid Element flavor has no dependencies to FCM, therefore cannot relies on Push.
 
 Also Google's recommended background processing method cannot be applied. This is because all of these methods are affected by IDLE modes, and will result on the user not being notified at all when the app is in a Doze mode (only in maintenance windows that could happens only after hours).
 
@@ -262,7 +262,7 @@ F-Droid version will schedule alarms that will then trigger a Broadcast Receiver
 
 Depending on the system status (or device make),  it is still possible that the app is not given enough time to launch the service, or that the radio is still turned off thus preventing the sync to success (that's why Alarms are not recommended for network related tasks).
 
-That is why on RiotX F-Droid, the broadcast receiver will acquire a temporary WAKE_LOCK for several seconds (thus securing cpu/network), and launch the service in foreground. The service performs the sync.
+That is why on Element F-Droid, the broadcast receiver will acquire a temporary WAKE_LOCK for several seconds (thus securing cpu/network), and launch the service in foreground. The service performs the sync.
 
 Note that foreground services require to put a notification informing the user that the app is doing something even if not launched).
 

docs/signin.md

@@ -2,7 +2,7 @@
 
 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 up flows
+## Sign in flows
 
 ### Get the flow
 
@@ -57,8 +57,8 @@ We get credential (200)
 
 ```json
 {
-  "user_id": "@benoit0816:matrix.org",
-  "access_token": "MDAxOGxvY2F0aW9uIG1hdHREDACTEDb2l0MDgxNjptYXRyaXgub3JnCjAwMTZjaWQgdHlwZSA9IGFjY2VzcwowMDIxY2lkIG5vbmNlID0gfnYrSypfdTtkNXIuNWx1KgowMDJmc2lnbmF0dXJlIOsh1XqeAkXexh4qcofl_aR4kHJoSOWYGOhE7-ubX-DZCg",
+  "user_id": "@alice:matrix.org",
+  "access_token": "MDAxOGxvY2F0aW9uIG1hdHREDACTEDb2l0MDgxNjptYXRyaXgub3JnCjAwMTZjaWQgdHlwZSA9IGFjY2VzcwowMDIxY2lr",
   "home_server": "matrix.org",
   "device_id": "GTVREDALBF",
   "well_known": {
@@ -117,7 +117,7 @@ We get the credentials (200)
 ```json
 {
   "user_id": "@alice:matrix.org",
-  "access_token": "MDAxOGxvY2F0aW9uIG1hdHJpeC5vcmREDACTEDZXJfaWQgPSBAYmVub2l0MDgxNjptYXRyaXgub3JnCjAwMTZjaWQgdHlwZSA9IGFjY2VzcwowMDIxY2lkIG5vbmNlID0gNjtDY0MwRlNPSFFoOC5wOgowMDJmc2lnbmF0dXJlIGiTRm1mYLLxQywxOh3qzQVT8HoEorSokEP2u-bAwtnYCg",
+  "access_token": "MDAxOGxvY2F0aW9uIG1hdHJpeC5vcmREDACTEDZXJfaWQgPSBAYmVub2l0MDgxNjptYXRyaXgub3Jnfrfdegfszsefddvf",
   "home_server": "matrix.org",
   "device_id": "WBSREDASND",
   "well_known": {
@@ -128,9 +128,11 @@ We get the credentials (200)
 }
 ```
 
+It's worth noting that the response from the homeserver contains the userId of Alice.
+
 ### Login with Msisdn
 
-Not supported yet in RiotX
+Not supported yet in Element
 
 ### Login with SSO
 
@@ -143,12 +145,59 @@ Not supported yet in RiotX
   "flows": [
     {
       "type": "m.login.sso"
+    },
+    {
+      "type": "m.login.token"
     }
   ]
 }
 ```
 
-In this case, the user can click on "Sign in with SSO" and the web screen will be displayed on the page `https://homeserver.with.sso/_matrix/static/client/login/` and the credentials will be passed back to the native code through the JS bridge
+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=element%3A%2F%element
+
+The parameter `redirectUrl` is set to `element://element`.
+
+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`
+
+> element://element?loginToken=MDAxOWxvY2F0aW9uIG1vemlsbGEub3JnCjAwMTNpZGVudGlmaWVy
+
+This navigation is intercepted by Element 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
 

docs/voip_signaling.md

@@ -0,0 +1,425 @@
+Useful links:
+- https://codelabs.developers.google.com/codelabs/webrtc-web/#0
+- http://webrtc.github.io/webrtc-org/native-code/android/
+
+
+   ╔════════════════════════════════════════════════╗
+   ║                                                ║
+   ║A] Placing a call offer                         ║
+   ║                                                ║
+   ╚════════════════════════════════════════════════╝
+
+
+
+                                                    ┌───────────────┐
+                                                    │    Matrix     │
+                                                    ├───────────────┴ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
+                                                                                                                     │
+                                                    │
+                                                                                                                     │
+              ┌─────────────────┐                   │                  ┌───────────────────────────┐                                      ┌─────────────────┐
+              │     Caller      │                                      │      Signaling Room       │                 │                    │     Callee      │
+              └─────────────────┘                   │                  ├───────────────────────────┤                                      └─────────────────┘
+                                       ┌────┐                          │                           │                 │
+                                       │ 3  │       │                  │  ┌────────────────────┐   │
+              ┌─────────────────┐──────┴────┴──────────────────────────┼─▶│   m.call.invite    │   │                 │                    ┌─────────────────┐
+              │                 │                   │                  │  │      mx event      │   │                                      │                 │
+              │                 │                                      │  └────────────────────┘   │                 │                    │                 │
+              │                 │                   │                  │                           │                                      │                 │
+              │     Element     │                                      │                           │                 │                    │     Element     │
+           ┌──│       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  │   │                                      │                 │
+             │     Element     │                                      │  │      mx event      │   │                 │                    │     Element     │
+             │       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  │    │                 │
+              │                 │                   │                  │  └────────────────────┘   │                            └────┘    │                 │
+              │                 │                                      │  ┌────────────────────┐   │                 │                    │     Element     │
+              │                 │                   │                  │  │ m.call.candidates  │   │                                      │       App       │
+              │     Element     │                                      │  │      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  │   │                                      │                 │
+              │     Element     │                                      │  │      mx event      │   │                 │                    │     Element     │
+              │       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      │
+               └─────────────────┘                                                                                  │                      └─────────────────┘
+                                                   │
+                                                                                                                    │
+               ┌─────────────────┐                 │                                                                                       ┌─────────────────┐
+               │                 │                                                                                  │                      │                 │
+               │                 │                 │                                                                                       │                 │
+               │                 │                                                                                  │                      │                 │
+               │     Element     │                 └ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─                       │     Element     │
+               │       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=-Xmx2048m
 # 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 @@
-#Fri Sep 27 10:10:35 CEST 2019
+#Thu Jul 02 12:33:07 CEST 2020
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-5.4.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.6.4-all.zip

matrix-sdk-android-rx/build.gradle

@@ -3,11 +3,11 @@ 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"
 
@@ -39,7 +39,7 @@ dependencies {
     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"
+    implementation "androidx.paging:paging-runtime-ktx:2.1.2"
 
     // Logging
     implementation 'com.jakewharton.timber:timber:4.7.1'

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

@@ -20,6 +20,7 @@ import androidx.lifecycle.LiveData
 import androidx.lifecycle.Observer
 import io.reactivex.Observable
 import io.reactivex.android.MainThreadDisposable
+import io.reactivex.android.schedulers.AndroidSchedulers
 import io.reactivex.schedulers.Schedulers
 
 private class LiveDataObservable<T>(
@@ -60,3 +61,11 @@ 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/RxRoom.kt

@@ -16,13 +16,15 @@
 
 package im.vector.matrix.rx
 
-import im.vector.matrix.android.api.crypto.RoomEncryptionTrustLevel
-import im.vector.matrix.android.api.session.Session
+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.identity.ThreePid
 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
@@ -30,114 +32,51 @@ 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 im.vector.matrix.android.internal.crypto.model.CryptoDeviceInfo
+import io.reactivex.Completable
 import io.reactivex.Observable
 import io.reactivex.Single
-import io.reactivex.functions.BiFunction
-import timber.log.Timber
 
-class RxRoom(private val room: Room, private val session: Session) {
+class RxRoom(private val room: Room) {
 
     fun liveRoomSummary(): Observable<Optional<RoomSummary>> {
-        val summaryObservable = room.getRoomSummaryLive()
+        return room.getRoomSummaryLive()
                 .asObservable()
-                .startWith(room.roomSummary().toOptional())
-                .doOnNext { Timber.v("RX: summary emitted for: ${it.getOrNull()?.roomId}") }
-
-        val memberIdsChangeObservable = summaryObservable
-                .map {
-                    it.getOrNull()?.let { roomSummary ->
-                        if (roomSummary.isEncrypted) {
-                            // Return the list of other users
-                            roomSummary.otherMemberIds + listOf(session.myUserId)
-                        } else {
-                            // Return an empty list, the room is not encrypted
-                            emptyList()
-                        }
-                    }.orEmpty()
-                }.distinctUntilChanged()
-                .doOnNext { Timber.v("RX: memberIds emitted. Size: ${it.size}") }
-
-        // Observe the device info of the users in the room
-        val cryptoDeviceInfoObservable = memberIdsChangeObservable
-                .switchMap { membersIds ->
-                    session.getLiveCryptoDeviceInfo(membersIds)
-                            .asObservable()
-                            .map {
-                                // If any key change, emit the userIds list
-                                membersIds
-                            }
-                            .startWith(membersIds)
-                            .doOnNext { Timber.v("RX: CryptoDeviceInfo emitted. Size: ${it.size}") }
-                }
-                .doOnNext { Timber.v("RX: cryptoDeviceInfo emitted 2. Size: ${it.size}") }
-
-        val roomEncryptionTrustLevelObservable = cryptoDeviceInfoObservable
-                .map { userIds ->
-                    if (userIds.isEmpty()) {
-                        Optional<RoomEncryptionTrustLevel>(null)
-                    } else {
-                        session.getCrossSigningService().getTrustLevelForUsers(userIds).toOptional()
-                    }
-                }
-                .doOnNext { Timber.v("RX: roomEncryptionTrustLevel emitted: ${it.getOrNull()?.name}") }
-
-        return Observable
-                .combineLatest<Optional<RoomSummary>, Optional<RoomEncryptionTrustLevel>, Optional<RoomSummary>>(
-                        summaryObservable,
-                        roomEncryptionTrustLevelObservable,
-                        BiFunction { summary, level ->
-                            summary.getOrNull()?.copy(
-                                    roomEncryptionTrustLevel = level.getOrNull()
-                            ).toOptional()
-                        }
-                )
-                .doOnNext { Timber.v("RX: final room summary emitted for ${it.getOrNull()?.roomId}") }
+                .startWithCallable { room.roomSummary().toOptional() }
     }
 
     fun liveRoomMembers(queryParams: RoomMemberQueryParams): Observable<List<RoomMemberSummary>> {
-        val roomMembersObservable = room.getRoomMembersLive(queryParams).asObservable()
-                .startWith(room.getRoomMembers(queryParams))
-                .doOnNext { Timber.v("RX: room members emitted. Size: ${it.size}") }
-
-        // TODO Do it only for room members of the room (switchMap)
-        val cryptoDeviceInfoObservable = session.getLiveCryptoDeviceInfo().asObservable()
-                .startWith(emptyList<CryptoDeviceInfo>())
-                .doOnNext { Timber.v("RX: cryptoDeviceInfo emitted. Size: ${it.size}") }
-
-        return Observable
-                .combineLatest<List<RoomMemberSummary>, List<CryptoDeviceInfo>, List<RoomMemberSummary>>(
-                        roomMembersObservable,
-                        cryptoDeviceInfoObservable,
-                        BiFunction { summaries, _ ->
-                            summaries.map {
-                                if (room.isEncrypted()) {
-                                    it.copy(
-                                            // Get the trust level of a virtual room with only this user
-                                            userEncryptionTrustLevel = session.getCrossSigningService().getTrustLevelForUsers(listOf(it.userId))
-                                    )
-                                } else {
-                                    it
-                                }
-                            }
-                        }
-                )
-                .doOnNext { Timber.v("RX: final room members emitted. Size: ${it.size}") }
+        return room.getRoomMembersLive(queryParams).asObservable()
+                .startWithCallable {
+                    room.getRoomMembers(queryParams)
+                }
     }
 
     fun liveAnnotationSummary(eventId: String): Observable<Optional<EventAnnotationsSummary>> {
         return room.getEventAnnotationsSummaryLive(eventId).asObservable()
-                .startWith(room.getEventAnnotationsSummary(eventId).toOptional())
+                .startWithCallable {
+                    room.getEventAnnotationsSummary(eventId).toOptional()
+                }
     }
 
     fun liveTimelineEvent(eventId: String): Observable<Optional<TimelineEvent>> {
         return room.getTimeLineEventLive(eventId).asObservable()
-                .startWith(room.getTimeLineEvent(eventId).toOptional())
+                .startWithCallable {
+                    room.getTimeLineEvent(eventId).toOptional()
+                }
     }
 
-    fun liveStateEvent(eventType: String): Observable<Optional<Event>> {
-        return room.getStateEventLive(eventType).asObservable()
-                .startWith(room.getStateEvent(eventType).toOptional())
+    fun liveStateEvent(eventType: String, stateKey: QueryStringValue): Observable<Optional<Event>> {
+        return room.getStateEventLive(eventType, stateKey).asObservable()
+                .startWithCallable {
+                    room.getStateEvent(eventType, stateKey).toOptional()
+                }
+    }
+
+    fun liveStateEvents(eventTypes: Set<String>): Observable<List<Event>> {
+        return room.getStateEventsLive(eventTypes).asObservable()
+                .startWithCallable {
+                    room.getStateEvents(eventTypes)
+                }
     }
 
     fun liveReadMarker(): Observable<Optional<String>> {
@@ -168,8 +107,40 @@ class RxRoom(private val room: Room, private val session: Session) {
     fun liveNotificationState(): Observable<RoomNotificationState> {
         return room.getLiveRoomNotificationState().asObservable()
     }
+
+    fun invite(userId: String, reason: String? = null): Completable = completableBuilder<Unit> {
+        room.invite(userId, reason, it)
+    }
+
+    fun invite3pid(threePid: ThreePid): Completable = completableBuilder<Unit> {
+        room.invite3pid(threePid, 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(session: Session): RxRoom {
-    return RxRoom(this, session)
+fun Room.rx(): RxRoom {
+    return RxRoom(this)
 }

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

@@ -17,64 +17,64 @@
 package im.vector.matrix.rx
 
 import androidx.paging.PagedList
+import im.vector.matrix.android.api.extensions.orFalse
+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.KEYBACKUP_SECRET_SSSS_NAME
+import im.vector.matrix.android.api.session.crypto.crosssigning.MASTER_KEY_SSSS_NAME
 import im.vector.matrix.android.api.session.crypto.crosssigning.MXCrossSigningInfo
+import im.vector.matrix.android.api.session.crypto.crosssigning.SELF_SIGNING_KEY_SSSS_NAME
+import im.vector.matrix.android.api.session.crypto.crosssigning.USER_SIGNING_KEY_SSSS_NAME
 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.members.ChangeMembershipState
 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.api.session.accountdata.UserAccountDataEvent
 import io.reactivex.Observable
 import io.reactivex.Single
-import io.reactivex.functions.BiFunction
-import timber.log.Timber
+import io.reactivex.functions.Function3
 
 class RxSession(private val session: Session) {
 
     fun liveRoomSummaries(queryParams: RoomSummaryQueryParams): Observable<List<RoomSummary>> {
-        val summariesObservable = session.getRoomSummariesLive(queryParams).asObservable()
-                .startWith(session.getRoomSummaries(queryParams))
-                .doOnNext { Timber.v("RX: summaries emitted: size: ${it.size}") }
-
-        val cryptoDeviceInfoObservable = session.getLiveCryptoDeviceInfo().asObservable()
-                .startWith(emptyList<CryptoDeviceInfo>())
-                .doOnNext { Timber.v("RX: crypto device info emitted: size: ${it.size}") }
-
-        return Observable
-                .combineLatest<List<RoomSummary>, List<CryptoDeviceInfo>, List<RoomSummary>>(
-                        summariesObservable,
-                        cryptoDeviceInfoObservable,
-                        BiFunction { summaries, _ ->
-                            summaries.map {
-                                if (it.isEncrypted) {
-                                    it.copy(
-                                            roomEncryptionTrustLevel = session.getCrossSigningService()
-                                                    .getTrustLevelForUsers(it.otherMemberIds + session.myUserId)
-                                    )
-                                } else {
-                                    it
-                                }
-                            }
-                        }
-                )
-                .doOnNext { Timber.d("RX: final summaries emitted: size: ${it.size}") }
+        return session.getRoomSummariesLive(queryParams).asObservable()
+                .startWithCallable {
+                    session.getRoomSummaries(queryParams)
+                }
     }
 
     fun liveGroupSummaries(queryParams: GroupSummaryQueryParams): Observable<List<GroupSummary>> {
         return session.getGroupSummariesLive(queryParams).asObservable()
-                .startWith(session.getGroupSummaries(queryParams))
+                .startWithCallable {
+                    session.getGroupSummaries(queryParams)
+                }
     }
 
-    fun liveBreadcrumbs(): Observable<List<RoomSummary>> {
-        return session.getBreadcrumbsLive().asObservable()
-                .startWith(session.getBreadcrumbs())
+    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> {
@@ -87,7 +87,9 @@ class RxSession(private val session: Session) {
 
     fun liveUser(userId: String): Observable<Optional<User>> {
         return session.getUserLive(userId).asObservable()
-                .startWith(session.getUser(userId).toOptional())
+                .startWithCallable {
+                    session.getUser(userId).toOptional()
+                }
     }
 
     fun liveUsers(): Observable<List<User>> {
@@ -98,8 +100,13 @@ class RxSession(private val session: Session) {
         return session.getIgnoredUsersLive().asObservable()
     }
 
-    fun livePagedUsers(filter: String? = null): Observable<PagedList<User>> {
-        return session.getPagedUsersLive(filter).asObservable()
+    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 {
@@ -112,10 +119,10 @@ class RxSession(private val session: Session) {
         session.searchUsersDirectory(search, limit, excludedUserIds, it)
     }
 
-    fun joinRoom(roomId: String,
+    fun joinRoom(roomIdOrAlias: String,
                  reason: String? = null,
                  viaServers: List<String> = emptyList()): Single<Unit> = singleBuilder {
-        session.joinRoom(roomId, reason, viaServers, it)
+        session.joinRoom(roomIdOrAlias, reason, viaServers, it)
     }
 
     fun getRoomIdByAlias(roomAlias: String,
@@ -128,12 +135,78 @@ class RxSession(private val session: Session) {
     }
 
     fun liveUserCryptoDevices(userId: String): Observable<List<CryptoDeviceInfo>> {
-        return session.getLiveCryptoDeviceInfo(userId).asObservable()
+        return session.cryptoService().getLiveCryptoDeviceInfo(userId).asObservable().startWithCallable {
+            session.cryptoService().getCryptoDeviceInfo(userId)
+        }
     }
 
     fun liveCrossSigningInfo(userId: String): Observable<Optional<MXCrossSigningInfo>> {
-        return session.getCrossSigningService().getLiveCrossSigningKeys(userId).asObservable()
-                .startWith(session.getCrossSigningService().getUserCrossSigningKeys(userId).toOptional())
+        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 liveRoomChangeMembershipState(): Observable<Map<String, ChangeMembershipState>> {
+        return session.getChangeMembershipsLive().asObservable()
+    }
+
+    fun liveSecretSynchronisationInfo(): Observable<SecretsSynchronisationInfo> {
+        return Observable.combineLatest<List<UserAccountDataEvent>, Optional<MXCrossSigningInfo>, Optional<PrivateKeysInfo>, SecretsSynchronisationInfo>(
+                liveAccountData(setOf(MASTER_KEY_SSSS_NAME, USER_SIGNING_KEY_SSSS_NAME, SELF_SIGNING_KEY_SSSS_NAME, KEYBACKUP_SECRET_SSSS_NAME)),
+                liveCrossSigningInfo(session.myUserId),
+                liveCrossSigningPrivateKeys(),
+                Function3 { _, crossSigningInfo, pInfo ->
+                    // first check if 4S is already setup
+                    val is4SSetup = session.sharedSecretStorageService.isRecoverySetup()
+                    val isCrossSigningEnabled = crossSigningInfo.getOrNull() != null
+                    val isCrossSigningTrusted = crossSigningInfo.getOrNull()?.isTrusted() == true
+                    val allPrivateKeysKnown = pInfo.getOrNull()?.allKnown().orFalse()
+
+                    val keysBackupService = session.cryptoService().keysBackupService()
+                    val currentBackupVersion = keysBackupService.currentBackupVersion
+                    val megolmBackupAvailable = currentBackupVersion != null
+                    val savedBackupKey = keysBackupService.getKeyBackupRecoveryKeyInfo()
+
+                    val megolmKeyKnown = savedBackupKey?.version == currentBackupVersion
+                    SecretsSynchronisationInfo(
+                            isBackupSetup = is4SSetup,
+                            isCrossSigningEnabled = isCrossSigningEnabled,
+                            isCrossSigningTrusted = isCrossSigningTrusted,
+                            allPrivateKeysKnown = allPrivateKeysKnown,
+                            megolmBackupAvailable = megolmBackupAvailable,
+                            megolmSecretKnown = megolmKeyKnown,
+                            isMegolmKeyIn4S = session.sharedSecretStorageService.isMegolmKeyInBackup()
+                    )
+                }
+        )
+                .distinctUntilChanged()
     }
 }
 

matrix-sdk-android-rx/src/main/java/im/vector/matrix/rx/SecretsSynchronisationInfo.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.rx
+
+data class SecretsSynchronisationInfo(
+        val isBackupSetup: Boolean,
+        val isCrossSigningEnabled: Boolean,
+        val isCrossSigningTrusted: Boolean,
+        val allPrivateKeysKnown: Boolean,
+        val megolmBackupAvailable: Boolean,
+        val megolmSecretKnown: Boolean,
+        val isMegolmKeyIn4S: Boolean
+)

matrix-sdk-android/build.gradle

@@ -19,26 +19,38 @@ 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 {
-
         debug {
             // Set to true to log privacy or sensible data, such as token
             buildConfigField "boolean", "LOG_PRIVATE_DATA", project.property("vector.debugPrivateData")
@@ -49,9 +61,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'
         }
     }
 
@@ -71,6 +80,15 @@ android {
     kotlinOptions {
         jvmTarget = "1.8"
     }
+
+    sourceSets {
+        androidTest {
+            java.srcDirs += "src/sharedTest/java"
+        }
+        test {
+            java.srcDirs += "src/sharedTest/java"
+        }
+    }
 }
 
 static def gitRevision() {
@@ -92,40 +110,45 @@ dependencies {
 
     def arrow_version = "0.8.2"
     def moshi_version = '1.8.0'
-    def lifecycle_version = '2.1.0'
+    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.24'
+    def daggerVersion = '2.25.4'
+    def work_version = '2.3.3'
+    def retrofit_version = '2.6.2'
 
     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"
+    implementation "androidx.core:core-ktx:1.3.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.2'
-    implementation 'com.squareup.retrofit2:converter-moshi:2.6.2'
+    implementation "com.squareup.retrofit2:retrofit:$retrofit_version"
+    implementation "com.squareup.retrofit2:converter-moshi:$retrofit_version"
+    implementation "com.squareup.retrofit2:converter-scalars:$retrofit_version"
     implementation 'com.squareup.okhttp3:okhttp:4.2.2'
     implementation 'com.squareup.okhttp3:logging-interceptor:4.2.2'
-    implementation 'com.novoda:merlin:1.2.0'
     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.1.0'
+    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.3.0-beta02"
+    implementation "androidx.work:work-runtime-ktx:$work_version"
 
     // FP
     implementation "io.arrow-kt:arrow-core:$arrow_version"
@@ -147,6 +170,13 @@ dependencies {
     // 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'
@@ -158,7 +188,10 @@ dependencies {
     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'
@@ -167,7 +200,10 @@ dependencies {
     androidTestImplementation 'org.amshove.kluent:kluent-android:1.44'
     // 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:$lifecycle_version"
+    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,64 @@
 # 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.** { *; }
+
+### Serializable persisted classes
+# https://www.guardsquare.com/en/products/proguard/manual/examples#serializable
+-keepnames class * implements java.io.Serializable
+
+-keepclassmembers class * implements java.io.Serializable {
+    static final long serialVersionUID;
+    private static final java.io.ObjectStreamField[] serialPersistentFields;
+    !static !transient <fields>;
+    !private <fields>;
+    !private <methods>;
+    private void writeObject(java.io.ObjectOutputStream);
+    private void readObject(java.io.ObjectInputStream);
+    java.lang.Object writeReplace();
+    java.lang.Object readResolve();
+}

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

@@ -18,10 +18,15 @@ package im.vector.matrix.android
 
 import android.content.Context
 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 ApplicationProvider.getApplicationContext()
     }

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

@@ -38,9 +38,7 @@ class AccountCreationTest : InstrumentedTest {
     fun createAccountTest() {
         val session = commonTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(withInitialSync = true))
 
-        commonTestHelper.signout(session)
-
-        session.close()
+        commonTestHelper.signOutAndClose(session)
     }
 
     @Test
@@ -50,14 +48,14 @@ class AccountCreationTest : InstrumentedTest {
         // Log again to the same account
         val session2 = commonTestHelper.logIntoAccount(session.myUserId, SessionTestParams(withInitialSync = true))
 
-        session.close()
-        session2.close()
+        commonTestHelper.signOutAndClose(session)
+        commonTestHelper.signOutAndClose(session2)
     }
 
     @Test
     fun simpleE2eTest() {
         val res = cryptoTestHelper.doE2ETestWithAliceInARoom()
 
-        res.close()
+        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/common/CommonTestHelper.kt

@@ -28,13 +28,17 @@ 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
@@ -53,9 +57,10 @@ 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)
     }
 
@@ -84,7 +89,8 @@ class CommonTestHelper(context: Context) {
     fun syncSession(session: Session) {
         val lock = CountDownLatch(1)
 
-        session.open()
+        GlobalScope.launch(Dispatchers.Main) { session.open() }
+
         session.startSync(true)
 
         val syncLiveData = runBlocking(Dispatchers.Main) {
@@ -111,30 +117,42 @@ class CommonTestHelper(context: Context) {
      * @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(nbOfMessages)
-        val onEventSentListener = object : Timeline.Listener {
+        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>) {
-                // TODO Count only new messages?
-                if (snapshot.count { it.root.type == EventType.MESSAGE } == nbOfMessages) {
-                    sentEvents.addAll(snapshot.filter { it.root.type == EventType.MESSAGE })
+                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()
                 }
             }
         }
-        val timeline = room.createTimeline(null, TimelineSettings(10))
-        timeline.addListener(onEventSentListener)
+        timeline.start()
+        timeline.addListener(timelineListener)
         for (i in 0 until nbOfMessages) {
             room.sendTextMessage(message + " #" + (i + 1))
         }
-        await(latch)
-        timeline.removeListener(onEventSentListener)
+        // Wait 3 second more per message
+        await(latch, timeout = TestConstants.timeOutMillis + 3_000L * nbOfMessages)
+        timeline.dispose()
 
         // Check that all events has been created
-        assertEquals(nbOfMessages.toLong(), sentEvents.size.toLong())
+        assertEquals("Message number do not match $sentEvents", nbOfMessages.toLong(), sentEvents.size.toLong())
 
         return sentEvents
     }
@@ -169,9 +187,9 @@ class CommonTestHelper(context: Context) {
      * @param testParams test params about the session
      * @return the session associated with the existing account
      */
-    private fun logIntoAccount(userId: String,
-                               password: String,
-                               testParams: SessionTestParams): Session {
+    fun logIntoAccount(userId: String,
+                       password: String,
+                       testParams: SessionTestParams): Session {
         val session = logAccountAndSync(userId, password, testParams)
         assertNotNull(session)
         return session
@@ -246,14 +264,81 @@ class CommonTestHelper(context: Context) {
         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) {
-        assertTrue(latch.await(TestConstants.timeOutMillis, TimeUnit.MILLISECONDS))
+    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
@@ -279,11 +364,20 @@ class CommonTestHelper(context: Context) {
     /**
      * Clear all provided sessions
      */
-    fun Iterable<Session>.close() = forEach { it.close() }
+    fun Iterable<Session>.signOutAndClose() = forEach { signOutAndClose(it) }
 
-    fun signout(session: Session) {
-        val lock = CountDownLatch(1)
-        session.signOut(true, TestMatrixCallback(lock))
-        await(lock)
+    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

@@ -23,9 +23,9 @@ data class CryptoTestData(val firstSession: Session,
                           val secondSession: Session? = null,
                           val thirdSession: Session? = null) {
 
-    fun close() {
-        firstSession.close()
-        secondSession?.close()
-        secondSession?.close()
+    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

@@ -17,11 +17,17 @@
 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
@@ -33,6 +39,7 @@ 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
@@ -41,52 +48,42 @@ import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNotNull
 import org.junit.Assert.assertNull
 import org.junit.Assert.assertTrue
-import java.util.Arrays
-import java.util.HashMap
+import java.util.UUID
 import java.util.concurrent.CountDownLatch
 
-class CryptoTestHelper(val mTestHelper: CommonTestHelper) {
+class CryptoTestHelper(private val mTestHelper: CommonTestHelper) {
 
-    val messagesFromAlice: List<String> = Arrays.asList("0 - Hello I'm Alice!", "4 - Go!")
-    val messagesFromBob: List<String> = Arrays.asList("1 - Hello I'm Bob!", "2 - Isn't life grand?", "3 - Let's go to the opera.")
+    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.")
 
-    val defaultSessionParams = SessionTestParams(true)
+    private val defaultSessionParams = SessionTestParams(true)
 
     /**
      * @return alice session
      */
-    fun doE2ETestWithAliceInARoom(): CryptoTestData {
+    fun doE2ETestWithAliceInARoom(encryptedRoom: Boolean = true): CryptoTestData {
         val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, defaultSessionParams)
 
-        var roomId: String? = null
-        val lock1 = CountDownLatch(1)
+        val roomId = mTestHelper.doSync<String> {
+            aliceSession.createRoom(CreateRoomParams().apply { name = "MyRoom" }, it)
+        }
 
-        aliceSession.createRoom(CreateRoomParams(name = "MyRoom"), object : TestMatrixCallback<String>(lock1) {
-            override fun onSuccess(data: String) {
-                roomId = data
-                super.onSuccess(data)
+        if (encryptedRoom) {
+            val room = aliceSession.getRoom(roomId)!!
+
+            mTestHelper.doSync<Unit> {
+                room.enableEncryption(callback = it)
             }
-        })
+        }
 
-        mTestHelper.await(lock1)
-        assertNotNull(roomId)
-
-        val room = aliceSession.getRoom(roomId!!)!!
-
-        val lock2 = CountDownLatch(1)
-        room.enableEncryptionWithAlgorithm(MXCRYPTO_ALGORITHM_MEGOLM, object : TestMatrixCallback<Unit>(lock2) {})
-        mTestHelper.await(lock2)
-
-        return CryptoTestData(aliceSession, roomId!!)
+        return CryptoTestData(aliceSession, roomId)
     }
 
     /**
      * @return alice and bob sessions
      */
-    fun doE2ETestWithAliceAndBobInARoom(): CryptoTestData {
-        val statuses = HashMap<String, String>()
-
-        val cryptoTestData = doE2ETestWithAliceInARoom()
+    fun doE2ETestWithAliceAndBobInARoom(encryptedRoom: Boolean = true): CryptoTestData {
+        val cryptoTestData = doE2ETestWithAliceInARoom(encryptedRoom)
         val aliceSession = cryptoTestData.firstSession
         val aliceRoomId = cryptoTestData.roomId
 
@@ -94,7 +91,7 @@ class CryptoTestHelper(val mTestHelper: CommonTestHelper) {
 
         val bobSession = mTestHelper.createAccount(TestConstants.USER_BOB, defaultSessionParams)
 
-        val lock1 = CountDownLatch(2)
+        val lock1 = CountDownLatch(1)
 
         val bobRoomSummariesLive = runBlocking(Dispatchers.Main) {
             bobSession.getRoomSummariesLive(roomSummaryQueryParams { })
@@ -103,7 +100,6 @@ class CryptoTestHelper(val mTestHelper: CommonTestHelper) {
         val newRoomObserver = object : Observer<List<RoomSummary>> {
             override fun onChanged(t: List<RoomSummary>?) {
                 if (t?.isNotEmpty() == true) {
-                    statuses["onNewRoom"] = "onNewRoom"
                     lock1.countDown()
                     bobRoomSummariesLive.removeObserver(this)
                 }
@@ -114,26 +110,20 @@ class CryptoTestHelper(val mTestHelper: CommonTestHelper) {
             bobRoomSummariesLive.observeForever(newRoomObserver)
         }
 
-        aliceRoom.invite(bobSession.myUserId, callback = object : TestMatrixCallback<Unit>(lock1) {
-            override fun onSuccess(data: Unit) {
-                statuses["invite"] = "invite"
-                super.onSuccess(data)
-            }
-        })
+        mTestHelper.doSync<Unit> {
+            aliceRoom.invite(bobSession.myUserId, callback = it)
+        }
 
         mTestHelper.await(lock1)
 
-        assertTrue(statuses.containsKey("invite") && statuses.containsKey("onNewRoom"))
-
-        val lock2 = CountDownLatch(2)
+        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) {
-                    statuses["AliceJoin"] = "AliceJoin"
-                    lock2.countDown()
+                    lock.countDown()
                     bobRoomSummariesLive.removeObserver(this)
                 }
             }
@@ -143,19 +133,15 @@ class CryptoTestHelper(val mTestHelper: CommonTestHelper) {
             bobRoomSummariesLive.observeForever(roomJoinedObserver)
         }
 
-        bobSession.joinRoom(aliceRoomId, callback = TestMatrixCallback(lock2))
+        mTestHelper.doSync<Unit> { bobSession.joinRoom(aliceRoomId, callback = it) }
 
-        mTestHelper.await(lock2)
+        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))
 
-        assertTrue(statuses.toString() + "", statuses.containsKey("AliceJoin"))
-
-//        bobSession.dataHandler.removeListener(bobEventListener)
-
         return CryptoTestData(aliceSession, aliceRoomId, bobSession)
     }
 
@@ -163,64 +149,38 @@ class CryptoTestHelper(val mTestHelper: CommonTestHelper) {
      * @return Alice, Bob and Sam session
      */
     fun doE2ETestWithAliceAndBobAndSamInARoom(): CryptoTestData {
-        val statuses = HashMap<String, String>()
-
         val cryptoTestData = doE2ETestWithAliceAndBobInARoom()
         val aliceSession = cryptoTestData.firstSession
         val aliceRoomId = cryptoTestData.roomId
 
         val room = aliceSession.getRoom(aliceRoomId)!!
 
-        val samSession = mTestHelper.createAccount(TestConstants.USER_SAM, defaultSessionParams)
-
-        val lock1 = CountDownLatch(2)
-
-//        val samEventListener = object : MXEventListener() {
-//            override fun onNewRoom(roomId: String) {
-//                if (TextUtils.equals(roomId, aliceRoomId)) {
-//                    if (!statuses.containsKey("onNewRoom")) {
-//                        statuses["onNewRoom"] = "onNewRoom"
-//                        lock1.countDown()
-//                    }
-//                }
-//            }
-//        }
-//
-//        samSession.dataHandler.addListener(samEventListener)
-
-        room.invite(samSession.myUserId, null, object : TestMatrixCallback<Unit>(lock1) {
-            override fun onSuccess(data: Unit) {
-                statuses["invite"] = "invite"
-                super.onSuccess(data)
-            }
-        })
-
-        mTestHelper.await(lock1)
-
-        assertTrue(statuses.containsKey("invite") && statuses.containsKey("onNewRoom"))
-
-//        samSession.dataHandler.removeListener(samEventListener)
-
-        val lock2 = CountDownLatch(1)
-
-        samSession.joinRoom(aliceRoomId, null, object : TestMatrixCallback<Unit>(lock2) {
-            override fun onSuccess(data: Unit) {
-                statuses["joinRoom"] = "joinRoom"
-                super.onSuccess(data)
-            }
-        })
-
-        mTestHelper.await(lock2)
-        assertTrue(statuses.containsKey("joinRoom"))
+        val samSession = createSamAccountAndInviteToTheRoom(room)
 
         // wait the initial sync
         SystemClock.sleep(1000)
 
-//        samSession.dataHandler.removeListener(samEventListener)
-
         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, emptyList(), it)
+        }
+
+        return samSession
+    }
+
     /**
      * @return Alice and Bob sessions
      */
@@ -230,77 +190,54 @@ class CryptoTestHelper(val mTestHelper: CommonTestHelper) {
         val aliceRoomId = cryptoTestData.roomId
         val bobSession = cryptoTestData.secondSession!!
 
-        bobSession.setWarnOnUnknownDevices(false)
+        bobSession.cryptoService().setWarnOnUnknownDevices(false)
 
-        aliceSession.setWarnOnUnknownDevices(false)
+        aliceSession.cryptoService().setWarnOnUnknownDevices(false)
 
         val roomFromBobPOV = bobSession.getRoom(aliceRoomId)!!
         val roomFromAlicePOV = aliceSession.getRoom(aliceRoomId)!!
 
-        var lock = CountDownLatch(1)
+        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 size = snapshot.filter { it.root.senderId != bobSession.myUserId && it.root.getClearType() == EventType.MESSAGE }
-                        .size
+                val messages = snapshot.filter { it.root.getClearType() == EventType.MESSAGE }
+                        .groupBy { it.root.senderId!! }
 
-                if (size == 3) {
+                // 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(10))
+        val bobTimeline = roomFromBobPOV.createTimeline(null, TimelineSettings(20))
+        bobTimeline.start()
         bobTimeline.addListener(bobEventsListener)
 
-        val results = HashMap<String, Any>()
-
-        // bobSession.dataHandler.addListener(object : MXEventListener() {
-        //     override fun onToDeviceEvent(event: Event) {
-        //         results["onToDeviceEvent"] = event
-        //         lock.countDown()
-        //     }
-        // })
-
         // Alice sends a message
         roomFromAlicePOV.sendTextMessage(messagesFromAlice[0])
-        assertTrue(results.containsKey("onToDeviceEvent"))
-//        assertEquals(1, messagesReceivedByBobCount)
 
-        // Bob send a message
-        lock = CountDownLatch(1)
+        // Bob send 3 messages
         roomFromBobPOV.sendTextMessage(messagesFromBob[0])
-        // android does not echo the messages sent from itself
-//        messagesReceivedByBobCount++
-        mTestHelper.await(lock)
-//        assertEquals(2, messagesReceivedByBobCount)
-
-        // Bob send a message
-        lock = CountDownLatch(1)
         roomFromBobPOV.sendTextMessage(messagesFromBob[1])
-        // android does not echo the messages sent from itself
-//        messagesReceivedByBobCount++
-        mTestHelper.await(lock)
-//        assertEquals(3, messagesReceivedByBobCount)
-
-        // Bob send a message
-        lock = CountDownLatch(1)
         roomFromBobPOV.sendTextMessage(messagesFromBob[2])
-        // android does not echo the messages sent from itself
-//        messagesReceivedByBobCount++
-        mTestHelper.await(lock)
-//        assertEquals(4, messagesReceivedByBobCount)
 
         // Alice sends a message
-        lock = CountDownLatch(2)
         roomFromAlicePOV.sendTextMessage(messagesFromAlice[1])
+
         mTestHelper.await(lock)
-//        assertEquals(5, messagesReceivedByBobCount)
 
         bobTimeline.removeListener(bobEventsListener)
+        bobTimeline.dispose()
 
         return cryptoTestData
     }
@@ -312,14 +249,14 @@ class CryptoTestHelper(val mTestHelper: CommonTestHelper) {
         val eventWireContent = event.content.toContent()
         assertNotNull(eventWireContent)
 
-        assertNull(eventWireContent.get("body"))
-        assertEquals(MXCRYPTO_ALGORITHM_MEGOLM, eventWireContent.get("algorithm"))
+        assertNull(eventWireContent["body"])
+        assertEquals(MXCRYPTO_ALGORITHM_MEGOLM, eventWireContent["algorithm"])
 
-        assertNotNull(eventWireContent.get("ciphertext"))
-        assertNotNull(eventWireContent.get("session_id"))
-        assertNotNull(eventWireContent.get("sender_key"))
+        assertNotNull(eventWireContent["ciphertext"])
+        assertNotNull(eventWireContent["session_id"])
+        assertNotNull(eventWireContent["sender_key"])
 
-        assertEquals(senderSession.sessionParams.credentials.deviceId, eventWireContent.get("device_id"))
+        assertEquals(senderSession.sessionParams.deviceId, eventWireContent["device_id"])
 
         assertNotNull(event.eventId)
         assertEquals(roomId, event.roomId)
@@ -328,25 +265,160 @@ class CryptoTestHelper(val mTestHelper: CommonTestHelper) {
 
         val eventContent = event.toContent()
         assertNotNull(eventContent)
-        assertEquals(clearMessage, eventContent.get("body"))
+        assertEquals(clearMessage, eventContent["body"])
         assertEquals(senderSession.myUserId, event.senderId)
     }
 
     fun createFakeMegolmBackupAuthData(): MegolmBackupAuthData {
         return MegolmBackupAuthData(
                 publicKey = "abcdefg",
-                signatures = HashMap<String, Map<String, String>>().apply {
-                    this["something"] = HashMap<String, String>().apply {
-                        this["ed25519:something"] = "hijklmnop"
-                    }
-                }
+                signatures = mapOf("something" to mapOf("ed25519:something" to "hijklmnop"))
         )
     }
 
     fun createFakeMegolmBackupCreationInfo(): MegolmBackupCreationInfo {
-        return MegolmBackupCreationInfo().apply {
-            algorithm = MXCRYPTO_ALGORITHM_MEGOLM_BACKUP
-            authData = createFakeMegolmBackupAuthData()
+        return MegolmBackupCreationInfo(
+                algorithm = MXCRYPTO_ALGORITHM_MEGOLM_BACKUP,
+                authData = createFakeMegolmBackupAuthData()
+        )
+    }
+
+    fun createDM(alice: Session, bob: Session): String {
+        val roomId = mTestHelper.doSync<String> {
+            alice.createRoom(
+                    CreateRoomParams().apply {
+                        invitedUserIds.add(bob.myUserId)
+                        setDirectMessage()
+                        enableEncryptionIfInvitedUsersSupportIt = true
+                    },
+                    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

@@ -15,6 +15,7 @@
  */
 package im.vector.matrix.android.common
 
+import im.vector.matrix.android.internal.session.TestInterceptor
 import okhttp3.Interceptor
 import okhttp3.Protocol
 import okhttp3.Request
@@ -37,7 +38,7 @@ import javax.net.ssl.HttpsURLConnection
  *      AutoDiscovery().findClientConfig("matrix.org", <callback>)
  * </code>
  */
-class MockOkHttpInterceptor : Interceptor {
+class MockOkHttpInterceptor : TestInterceptor {
 
     private var rules: ArrayList<Rule> = ArrayList()
 
@@ -45,6 +46,12 @@ class MockOkHttpInterceptor : Interceptor {
         rules.add(rule)
     }
 
+    fun clearRules() {
+        rules.clear()
+    }
+
+    override var sessionId: String? = null
+
     override fun intercept(chain: Interceptor.Chain): Response {
         val originalRequest = chain.request()
 

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

@@ -16,7 +16,10 @@
 
 package im.vector.matrix.android.common
 
-import org.junit.Assert.*
+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

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

@@ -22,11 +22,11 @@ object TestConstants {
 
     const val TESTS_HOME_SERVER_URL = "http://10.0.2.2:8080"
 
-    // Time out to use when waiting for server response. 60s
-    private const val AWAIT_TIME_OUT_MILLIS = 60000
+    // 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 * 60000
+    private const val AWAIT_TIME_OUT_WITH_DEBUGGER_MILLIS = 10 * 60_000
 
     const val USER_ALICE = "Alice"
     const val USER_BOB = "Bob"

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

@@ -22,7 +22,9 @@ 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.*
+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

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

@@ -20,6 +20,8 @@ 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 kotlin.random.Random
 
@@ -31,6 +33,7 @@ internal class CryptoStoreHelper {
                         .name("test.realm")
                         .modules(RealmCryptoStoreModule())
                         .build(),
+                crossSigningKeysMapper = CrossSigningKeysMapper(MoshiProvider.providesMoshi()),
                 credentials = createCredential())
     }
 

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

@@ -21,7 +21,9 @@ 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 io.realm.Realm
-import org.junit.Assert.*
+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
@@ -41,22 +43,22 @@ class CryptoStoreTest : InstrumentedTest {
         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_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() {

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

@@ -17,7 +17,9 @@
 package im.vector.matrix.android.internal.crypto
 
 import androidx.test.ext.junit.runners.AndroidJUnit4
-import org.junit.Assert.*
+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

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

@@ -2,12 +2,10 @@ 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.api.MatrixCallback
 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.common.TestMatrixCallback
 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
@@ -21,7 +19,6 @@ 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)
@@ -34,16 +31,15 @@ class XSigningTest : InstrumentedTest {
     fun test_InitializeAndStoreKeys() {
         val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true))
 
-        val aliceLatch = CountDownLatch(1)
-        aliceSession.getCrossSigningService()
-                .initializeCrossSigning(UserPasswordAuth(
-                        user = aliceSession.myUserId,
-                        password = TestConstants.PASSWORD
-                ), TestMatrixCallback(aliceLatch))
+        mTestHelper.doSync<Unit> {
+            aliceSession.cryptoService().crossSigningService()
+                    .initializeCrossSigning(UserPasswordAuth(
+                            user = aliceSession.myUserId,
+                            password = TestConstants.PASSWORD
+                    ), it)
+        }
 
-        mTestHelper.await(aliceLatch)
-
-        val myCrossSigningKeys = aliceSession.getCrossSigningService().getMyCrossSigningKeys()
+        val myCrossSigningKeys = aliceSession.cryptoService().crossSigningService().getMyCrossSigningKeys()
         val masterPubKey = myCrossSigningKeys?.masterKey()
         assertNotNull("Master key should be stored", masterPubKey?.unpaddedBase64PublicKey)
         val selfSigningKey = myCrossSigningKeys?.selfSigningKey()
@@ -53,9 +49,9 @@ class XSigningTest : InstrumentedTest {
 
         assertTrue("Signing Keys should be trusted", myCrossSigningKeys?.isTrusted() == true)
 
-        assertTrue("Signing Keys should be trusted", aliceSession.getCrossSigningService().checkUserTrust(aliceSession.myUserId).isVerified())
+        assertTrue("Signing Keys should be trusted", aliceSession.cryptoService().crossSigningService().checkUserTrust(aliceSession.myUserId).isVerified())
 
-        mTestHelper.signout(aliceSession)
+        mTestHelper.signOutAndClose(aliceSession)
     }
 
     @Test
@@ -74,30 +70,24 @@ class XSigningTest : InstrumentedTest {
                 password = TestConstants.PASSWORD
         )
 
-        val latch = CountDownLatch(2)
-
-        aliceSession.getCrossSigningService().initializeCrossSigning(aliceAuthParams, TestMatrixCallback(latch))
-        bobSession.getCrossSigningService().initializeCrossSigning(bobAuthParams, TestMatrixCallback(latch))
-
-        mTestHelper.await(latch)
+        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 downloadLatch = CountDownLatch(1)
-        aliceSession.downloadKeys(listOf(bobSession.myUserId), true, TestMatrixCallback(downloadLatch))
-        mTestHelper.await(downloadLatch)
+        mTestHelper.doSync<MXUsersDevicesMap<CryptoDeviceInfo>> { aliceSession.cryptoService().downloadKeys(listOf(bobSession.myUserId), true, it) }
 
-        val bobKeysFromAlicePOV = aliceSession.getCrossSigningService().getUserCrossSigningKeys(bobSession.myUserId)
+        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.getCrossSigningService().getMyCrossSigningKeys()?.masterKey()?.unpaddedBase64PublicKey)
-        assertEquals("Bob keys from alice pov should match", bobKeysFromAlicePOV.selfSigningKey()?.unpaddedBase64PublicKey, bobSession.getCrossSigningService().getMyCrossSigningKeys()?.selfSigningKey()?.unpaddedBase64PublicKey)
+        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.signout(aliceSession)
-        mTestHelper.signout(bobSession)
+        mTestHelper.signOutAndClose(aliceSession)
+        mTestHelper.signOutAndClose(bobSession)
     }
 
     @Test
@@ -116,94 +106,56 @@ class XSigningTest : InstrumentedTest {
                 password = TestConstants.PASSWORD
         )
 
-        val latch = CountDownLatch(2)
-
-        aliceSession.getCrossSigningService().initializeCrossSigning(aliceAuthParams, TestMatrixCallback(latch))
-        bobSession.getCrossSigningService().initializeCrossSigning(bobAuthParams, TestMatrixCallback(latch))
-
-        mTestHelper.await(latch)
+        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 downloadLatch = CountDownLatch(1)
         val bobUserId = bobSession.myUserId
-        aliceSession.downloadKeys(listOf(bobUserId), true, TestMatrixCallback(downloadLatch))
-        mTestHelper.await(downloadLatch)
+        mTestHelper.doSync<MXUsersDevicesMap<CryptoDeviceInfo>> { aliceSession.cryptoService().downloadKeys(listOf(bobUserId), true, it) }
 
-        val bobKeysFromAlicePOV = aliceSession.getCrossSigningService().getUserCrossSigningKeys(bobUserId)
+        val bobKeysFromAlicePOV = aliceSession.cryptoService().crossSigningService().getUserCrossSigningKeys(bobUserId)
         assertTrue("Bob keys from alice pov should not be trusted", bobKeysFromAlicePOV?.isTrusted() == false)
 
-        val trustLatch = CountDownLatch(1)
-        aliceSession.getCrossSigningService().trustUser(bobUserId, object : MatrixCallback<Unit> {
-            override fun onSuccess(data: Unit) {
-                trustLatch.countDown()
-            }
-
-            override fun onFailure(failure: Throwable) {
-                fail("Failed to trust bob")
-            }
-        })
-        mTestHelper.await(trustLatch)
+        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.credentials.deviceId
+        val bobSecondDeviceId = bobSession2.sessionParams.deviceId!!
 
         // Check that bob first session sees the new login
-        val bobKeysLatch = CountDownLatch(1)
-        bobSession.downloadKeys(listOf(bobUserId), true, object : MatrixCallback<MXUsersDevicesMap<CryptoDeviceInfo>> {
-            override fun onFailure(failure: Throwable) {
-                fail("Failed to get device")
-            }
+        val data = mTestHelper.doSync<MXUsersDevicesMap<CryptoDeviceInfo>> {
+            bobSession.cryptoService().downloadKeys(listOf(bobUserId), true, it)
+        }
 
-            override fun onSuccess(data: MXUsersDevicesMap<CryptoDeviceInfo>) {
-                if (data.getUserDeviceIds(bobUserId)?.contains(bobSecondDeviceId!!) == false) {
-                    fail("Bob should see the new device")
-                }
-                bobKeysLatch.countDown()
-            }
-        })
-        mTestHelper.await(bobKeysLatch)
+        if (data.getUserDeviceIds(bobUserId)?.contains(bobSecondDeviceId) == false) {
+            fail("Bob should see the new device")
+        }
 
-        val bobSecondDevicePOVFirstDevice = bobSession.getDeviceInfo(bobUserId, bobSecondDeviceId)
+        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
-        val bobSignLatch = CountDownLatch(1)
-        bobSession.getCrossSigningService().signDevice(bobSecondDeviceId!!, object : MatrixCallback<Unit> {
-            override fun onSuccess(data: Unit) {
-                bobSignLatch.countDown()
-            }
-
-            override fun onFailure(failure: Throwable) {
-                fail("Failed to trust bob ${failure.localizedMessage}")
-            }
-        })
-        mTestHelper.await(bobSignLatch)
+        mTestHelper.doSync<Unit> {
+            bobSession.cryptoService().crossSigningService().trustDevice(bobSecondDeviceId, it)
+        }
 
         // Now alice should cross trust bob's second device
-        val aliceKeysLatch = CountDownLatch(1)
-        aliceSession.downloadKeys(listOf(bobUserId), true, object : MatrixCallback<MXUsersDevicesMap<CryptoDeviceInfo>> {
-            override fun onFailure(failure: Throwable) {
-                fail("Failed to get device")
-            }
+        val data2 = mTestHelper.doSync<MXUsersDevicesMap<CryptoDeviceInfo>> {
+            aliceSession.cryptoService().downloadKeys(listOf(bobUserId), true, it)
+        }
 
-            override fun onSuccess(data: MXUsersDevicesMap<CryptoDeviceInfo>) {
-                // check that the device is seen
-                if (data.getUserDeviceIds(bobUserId)?.contains(bobSecondDeviceId) == false) {
-                    fail("Alice should see the new device")
-                }
-                aliceKeysLatch.countDown()
-            }
-        })
-        mTestHelper.await(aliceKeysLatch)
+        // check that the device is seen
+        if (data2.getUserDeviceIds(bobUserId)?.contains(bobSecondDeviceId) == false) {
+            fail("Alice should see the new device")
+        }
 
-        val result = aliceSession.getCrossSigningService().checkDeviceTrust(bobUserId, bobSecondDeviceId, null)
+        val result = aliceSession.cryptoService().crossSigningService().checkDeviceTrust(bobUserId, bobSecondDeviceId, null)
         assertTrue("Bob second device should be trusted from alice POV", result.isCrossSignedVerified())
 
-        mTestHelper.signout(aliceSession)
-        mTestHelper.signout(bobSession)
-        mTestHelper.signout(bobSession2)
+        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,299 @@
+/*
+ * 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().apply {
+                        visibility = RoomDirectoryVisibility.PRIVATE
+                        enableEncryption()
+                    },
+                    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

@@ -20,7 +20,9 @@ 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.*
+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

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/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.api.session.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

@@ -16,24 +16,25 @@
 
 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.sas.CancelCode
-import im.vector.matrix.android.api.session.crypto.sas.IncomingSasVerificationTransaction
-import im.vector.matrix.android.api.session.crypto.sas.OutgoingSasVerificationTransaction
-import im.vector.matrix.android.api.session.crypto.sas.SasMode
-import im.vector.matrix.android.api.session.crypto.sas.VerificationMethod
-import im.vector.matrix.android.api.session.crypto.sas.VerificationService
-import im.vector.matrix.android.api.session.crypto.sas.VerificationTransaction
-import im.vector.matrix.android.api.session.crypto.sas.VerificationTxState
+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.KeyVerificationAccept
 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
@@ -62,24 +63,20 @@ class SASTest : InstrumentedTest {
         val aliceSession = cryptoTestData.firstSession
         val bobSession = cryptoTestData.secondSession
 
-        val aliceVerificationService = aliceSession.getVerificationService()
-        val bobVerificationService = bobSession!!.getVerificationService()
+        val aliceVerificationService = aliceSession.cryptoService().verificationService()
+        val bobVerificationService = bobSession!!.cryptoService().verificationService()
 
         val bobTxCreatedLatch = CountDownLatch(1)
-        val bobListener = object : VerificationService.VerificationListener {
-            override fun transactionCreated(tx: VerificationTransaction) {}
-
+        val bobListener = object : VerificationService.Listener {
             override fun transactionUpdated(tx: VerificationTransaction) {
                 bobTxCreatedLatch.countDown()
             }
-
-            override fun markedAsManuallyVerified(userId: String, deviceId: String) {}
         }
         bobVerificationService.addListener(bobListener)
 
         val txID = aliceVerificationService.beginKeyVerification(VerificationMethod.SAS,
                 bobSession.myUserId,
-                bobSession.getMyDevice().deviceId,
+                bobSession.cryptoService().getMyDevice().deviceId,
                 null)
         assertNotNull("Alice should have a started transaction", txID)
 
@@ -106,9 +103,7 @@ class SASTest : InstrumentedTest {
         // Let's cancel from alice side
         val cancelLatch = CountDownLatch(1)
 
-        val bobListener2 = object : VerificationService.VerificationListener {
-            override fun transactionCreated(tx: VerificationTransaction) {}
-
+        val bobListener2 = object : VerificationService.Listener {
             override fun transactionUpdated(tx: VerificationTransaction) {
                 if (tx.transactionId == txID) {
                     val immutableState = (tx as SASDefaultVerificationTransaction).state
@@ -117,8 +112,6 @@ class SASTest : InstrumentedTest {
                     }
                 }
             }
-
-            override fun markedAsManuallyVerified(userId: String, deviceId: String) {}
         }
         bobVerificationService.addListener(bobListener2)
 
@@ -140,7 +133,7 @@ class SASTest : InstrumentedTest {
         assertNull(bobVerificationService.getExistingTransaction(aliceSession.myUserId, txID))
         assertNull(aliceVerificationService.getExistingTransaction(bobSession.myUserId, txID))
 
-        cryptoTestData.close()
+        cryptoTestData.cleanUp(mTestHelper)
     }
 
     @Test
@@ -157,19 +150,15 @@ class SASTest : InstrumentedTest {
         var cancelReason: CancelCode? = null
         val cancelLatch = CountDownLatch(1)
 
-        val bobListener = object : VerificationService.VerificationListener {
-            override fun transactionCreated(tx: VerificationTransaction) {}
-
+        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()
                 }
             }
-
-            override fun markedAsManuallyVerified(userId: String, deviceId: String) {}
         }
-        bobSession.getVerificationService().addListener(bobListener)
+        bobSession.cryptoService().verificationService().addListener(bobListener)
 
         // TODO bobSession!!.dataHandler.addListener(object : MXEventListener() {
         // TODO     override fun onToDeviceEvent(event: Event?) {
@@ -184,20 +173,16 @@ class SASTest : InstrumentedTest {
 
         val aliceSession = cryptoTestData.firstSession
         val aliceUserID = aliceSession.myUserId
-        val aliceDevice = aliceSession.getMyDevice().deviceId
-
-        val aliceListener = object : VerificationService.VerificationListener {
-            override fun transactionCreated(tx: VerificationTransaction) {}
+        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()
                 }
             }
-
-            override fun markedAsManuallyVerified(userId: String, deviceId: String) {}
         }
-        aliceSession.getVerificationService().addListener(aliceListener)
+        aliceSession.cryptoService().verificationService().addListener(aliceListener)
 
         fakeBobStart(bobSession, aliceUserID, aliceDevice, tid, protocols = protocols)
 
@@ -205,7 +190,7 @@ class SASTest : InstrumentedTest {
 
         assertEquals("Request should be cancelled with m.unknown_method", CancelCode.UnknownMethod, cancelReason)
 
-        cryptoTestData.close()
+        cryptoTestData.cleanUp(mTestHelper)
     }
 
     @Test
@@ -234,7 +219,7 @@ class SASTest : InstrumentedTest {
 
         val aliceSession = cryptoTestData.firstSession
         val aliceUserID = aliceSession.myUserId
-        val aliceDevice = aliceSession.getMyDevice().deviceId
+        val aliceDevice = aliceSession.cryptoService().getMyDevice().deviceId
 
         fakeBobStart(bobSession, aliceUserID, aliceDevice, tid, mac = mac)
 
@@ -243,7 +228,7 @@ class SASTest : InstrumentedTest {
         val cancelReq = canceledToDeviceEvent!!.content.toModel<KeyVerificationCancel>()!!
         assertEquals("Request should be cancelled with m.unknown_method", CancelCode.UnknownMethod.value, cancelReq.code)
 
-        cryptoTestData.close()
+        cryptoTestData.cleanUp(mTestHelper)
     }
 
     @Test
@@ -272,7 +257,7 @@ class SASTest : InstrumentedTest {
 
         val aliceSession = cryptoTestData.firstSession
         val aliceUserID = aliceSession.myUserId
-        val aliceDevice = aliceSession.getMyDevice().deviceId
+        val aliceDevice = aliceSession.cryptoService().getMyDevice().deviceId
 
         fakeBobStart(bobSession, aliceUserID, aliceDevice, tid, codes = codes)
 
@@ -281,7 +266,7 @@ class SASTest : InstrumentedTest {
         val cancelReq = canceledToDeviceEvent!!.content.toModel<KeyVerificationCancel>()!!
         assertEquals("Request should be cancelled with m.unknown_method", CancelCode.UnknownMethod.value, cancelReq.code)
 
-        cryptoTestData.close()
+        cryptoTestData.cleanUp(mTestHelper)
     }
 
     private fun fakeBobStart(bobSession: Session,
@@ -293,9 +278,9 @@ class SASTest : InstrumentedTest {
                              mac: List<String> = SASDefaultVerificationTransaction.KNOWN_MACS,
                              codes: List<String> = SASDefaultVerificationTransaction.KNOWN_SHORT_CODES) {
         val startMessage = KeyVerificationStart(
-                fromDevice = bobSession.getMyDevice().deviceId,
+                fromDevice = bobSession.cryptoService().getMyDevice().deviceId,
                 method = VerificationMethod.SAS.toValue(),
-                transactionID = tid,
+                transactionId = tid,
                 keyAgreementProtocols = protocols,
                 hashes = hashes,
                 messageAuthenticationCodes = mac,
@@ -323,12 +308,12 @@ class SASTest : InstrumentedTest {
         val aliceSession = cryptoTestData.firstSession
         val bobSession = cryptoTestData.secondSession
 
-        val aliceVerificationService = aliceSession.getVerificationService()
+        val aliceVerificationService = aliceSession.cryptoService().verificationService()
 
         val aliceCreatedLatch = CountDownLatch(2)
         val aliceCancelledLatch = CountDownLatch(2)
         val createdTx = mutableListOf<SASDefaultVerificationTransaction>()
-        val aliceListener = object : VerificationService.VerificationListener {
+        val aliceListener = object : VerificationService.Listener {
             override fun transactionCreated(tx: VerificationTransaction) {
                 createdTx.add(tx as SASDefaultVerificationTransaction)
                 aliceCreatedLatch.countDown()
@@ -339,20 +324,18 @@ class SASTest : InstrumentedTest {
                     aliceCancelledLatch.countDown()
                 }
             }
-
-            override fun markedAsManuallyVerified(userId: String, deviceId: String) {}
         }
         aliceVerificationService.addListener(aliceListener)
 
         val bobUserId = bobSession!!.myUserId
-        val bobDeviceId = bobSession.getMyDevice().deviceId
+        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.close()
+        cryptoTestData.cleanUp(mTestHelper)
     }
 
     /**
@@ -365,61 +348,56 @@ class SASTest : InstrumentedTest {
         val aliceSession = cryptoTestData.firstSession
         val bobSession = cryptoTestData.secondSession
 
-        val aliceVerificationService = aliceSession.getVerificationService()
-        val bobVerificationService = bobSession!!.getVerificationService()
+        val aliceVerificationService = aliceSession.cryptoService().verificationService()
+        val bobVerificationService = bobSession!!.cryptoService().verificationService()
 
-        var accepted: KeyVerificationAccept? = null
-        var startReq: KeyVerificationStart? = null
+        var accepted: ValidVerificationInfoAccept? = null
+        var startReq: ValidVerificationInfoStart.SasVerificationInfoStart? = null
 
         val aliceAcceptedLatch = CountDownLatch(1)
-        val aliceListener = object : VerificationService.VerificationListener {
-            override fun markedAsManuallyVerified(userId: String, deviceId: String) {}
-
-            override fun transactionCreated(tx: VerificationTransaction) {}
-
+        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 as? KeyVerificationAccept
-                    startReq = at.startReq as? KeyVerificationStart
+                    accepted = at.accepted
+                    startReq = at.startReq
                     aliceAcceptedLatch.countDown()
                 }
             }
         }
         aliceVerificationService.addListener(aliceListener)
 
-        val bobListener = object : VerificationService.VerificationListener {
-            override fun transactionCreated(tx: VerificationTransaction) {}
-
+        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()
                 }
             }
-
-            override fun markedAsManuallyVerified(userId: String, deviceId: String) {}
         }
         bobVerificationService.addListener(bobListener)
 
         val bobUserId = bobSession.myUserId
-        val bobDeviceId = bobSession.getMyDevice().deviceId
+        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!!.isValid())
-        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))
+        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))
+        accepted!!.shortAuthenticationStrings.forEach {
+            assertTrue("all agreed Short Code should be known by alice", startReq!!.shortAuthenticationStrings.contains(it))
         }
 
-        cryptoTestData.close()
+        cryptoTestData.cleanUp(mTestHelper)
     }
 
     @Test
@@ -429,13 +407,11 @@ class SASTest : InstrumentedTest {
         val aliceSession = cryptoTestData.firstSession
         val bobSession = cryptoTestData.secondSession
 
-        val aliceVerificationService = aliceSession.getVerificationService()
-        val bobVerificationService = bobSession!!.getVerificationService()
+        val aliceVerificationService = aliceSession.cryptoService().verificationService()
+        val bobVerificationService = bobSession!!.cryptoService().verificationService()
 
         val aliceSASLatch = CountDownLatch(1)
-        val aliceListener = object : VerificationService.VerificationListener {
-            override fun transactionCreated(tx: VerificationTransaction) {}
-
+        val aliceListener = object : VerificationService.Listener {
             override fun transactionUpdated(tx: VerificationTransaction) {
                 val uxState = (tx as OutgoingSasVerificationTransaction).uxState
                 when (uxState) {
@@ -445,15 +421,11 @@ class SASTest : InstrumentedTest {
                     else                                                -> Unit
                 }
             }
-
-            override fun markedAsManuallyVerified(userId: String, deviceId: String) {}
         }
         aliceVerificationService.addListener(aliceListener)
 
         val bobSASLatch = CountDownLatch(1)
-        val bobListener = object : VerificationService.VerificationListener {
-            override fun transactionCreated(tx: VerificationTransaction) {}
-
+        val bobListener = object : VerificationService.Listener {
             override fun transactionUpdated(tx: VerificationTransaction) {
                 val uxState = (tx as IncomingSasVerificationTransaction).uxState
                 when (uxState) {
@@ -466,13 +438,11 @@ class SASTest : InstrumentedTest {
                     bobSASLatch.countDown()
                 }
             }
-
-            override fun markedAsManuallyVerified(userId: String, deviceId: String) {}
         }
         bobVerificationService.addListener(bobListener)
 
         val bobUserId = bobSession.myUserId
-        val bobDeviceId = bobSession.getMyDevice().deviceId
+        val bobDeviceId = bobSession.cryptoService().getMyDevice().deviceId
         val verificationSAS = aliceVerificationService.beginKeyVerification(VerificationMethod.SAS, bobUserId, bobDeviceId, null)
         mTestHelper.await(aliceSASLatch)
         mTestHelper.await(bobSASLatch)
@@ -483,7 +453,7 @@ class SASTest : InstrumentedTest {
         assertEquals("Should have same SAS", aliceTx.getShortCodeRepresentation(SasMode.DECIMAL),
                 bobTx.getShortCodeRepresentation(SasMode.DECIMAL))
 
-        cryptoTestData.close()
+        cryptoTestData.cleanUp(mTestHelper)
     }
 
     @Test
@@ -493,42 +463,50 @@ class SASTest : InstrumentedTest {
         val aliceSession = cryptoTestData.firstSession
         val bobSession = cryptoTestData.secondSession
 
-        val aliceVerificationService = aliceSession.getVerificationService()
-        val bobVerificationService = bobSession!!.getVerificationService()
+        val aliceVerificationService = aliceSession.cryptoService().verificationService()
+        val bobVerificationService = bobSession!!.cryptoService().verificationService()
 
         val aliceSASLatch = CountDownLatch(1)
-        val aliceListener = object : VerificationService.VerificationListener {
-            override fun transactionCreated(tx: VerificationTransaction) {}
-
+        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 -> {
-                        aliceSASLatch.countDown()
+                        if (matchOnce) {
+                            matchOnce = false
+                            aliceSASLatch.countDown()
+                        }
                     }
                     else                                                -> Unit
                 }
             }
-
-            override fun markedAsManuallyVerified(userId: String, deviceId: String) {}
         }
         aliceVerificationService.addListener(aliceListener)
 
         val bobSASLatch = CountDownLatch(1)
-        val bobListener = object : VerificationService.VerificationListener {
-            override fun transactionCreated(tx: VerificationTransaction) {}
-
+        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 -> {
-                        tx.performAccept()
+                        if (acceptOnce) {
+                            acceptOnce = false
+                            tx.performAccept()
+                        }
                     }
                     IncomingSasVerificationTransaction.UxState.SHOW_SAS    -> {
-                        tx.userHasVerifiedShortCode()
+                        if (matchOnce) {
+                            matchOnce = false
+                            tx.userHasVerifiedShortCode()
+                        }
                     }
                     IncomingSasVerificationTransaction.UxState.VERIFIED    -> {
                         bobSASLatch.countDown()
@@ -536,26 +514,116 @@ class SASTest : InstrumentedTest {
                     else                                                   -> Unit
                 }
             }
-
-            override fun markedAsManuallyVerified(userId: String, deviceId: String) {}
         }
         bobVerificationService.addListener(bobListener)
 
         val bobUserId = bobSession.myUserId
-        val bobDeviceId = bobSession.getMyDevice().deviceId
+        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.getDeviceInfo(bobUserId, bobDeviceId)
-        val aliceDeviceInfoFromBobPOV: CryptoDeviceInfo? = bobSession.getDeviceInfo(aliceSession.myUserId, aliceSession.getMyDevice().deviceId)
+        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.close()
+        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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 New Vector Ltd
+ * 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.
@@ -32,14 +32,14 @@ class SharedSecretTest : InstrumentedTest {
     @Test
     fun testSharedSecretLengthCase() {
         repeat(100) {
-            generateSharedSecret().length shouldBe 43
+            generateSharedSecretV2().length shouldBe 11
         }
     }
 
     @Test
     fun testSharedDiffCase() {
-        val sharedSecret1 = generateSharedSecret()
-        val sharedSecret2 = generateSharedSecret()
+        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/session/room/timeline/ChunkEntityTest.kt

@@ -20,15 +20,15 @@ import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.zhuinden.monarchy.Monarchy
 import im.vector.matrix.android.InstrumentedTest
 import im.vector.matrix.android.api.session.events.model.Event
-import im.vector.matrix.android.internal.database.helper.add
-import im.vector.matrix.android.internal.database.helper.lastStateIndex
+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
@@ -58,8 +58,11 @@ internal class ChunkEntityTest : InstrumentedTest {
     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
         }
     }
@@ -68,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
         }
     }
@@ -140,9 +101,9 @@ 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()
         }
@@ -155,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)
-            chunk2.addAll("roomId", createFakeListOfEvents(30), PaginationDirection.BACKWARDS)
-            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
         }
     }
@@ -169,19 +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)
-            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.nextToken shouldEqual nextToken
         }
     }
 
     private fun ChunkEntity.addAll(roomId: String,
                                    events: List<Event>,
-                                   direction: PaginationDirection,
-                                   stateIndexOffset: Int = 0) {
+                                   direction: PaginationDirection) {
         events.forEach { event ->
-            add(roomId, event, direction, stateIndexOffset)
+            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/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/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,7 +20,6 @@ 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
@@ -37,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 {
 
     /**
@@ -97,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/main/AndroidManifest.xml

@@ -1,5 +1,4 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:tools="http://schemas.android.com/tools"
     package="im.vector.matrix.android">
 
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
@@ -8,13 +7,20 @@
 
     <application android:networkSecurityConfig="@xml/network_security_config">
 
+        <!--
+         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="androidx.work.impl.WorkManagerInitializer"
-            android:authorities="${applicationId}.workmanager-init"
+            android:name="im.vector.matrix.android.api.session.file.MatrixSDKFileProvider"
+            android:authorities="${applicationId}.mx-sdk.fileprovider"
             android:exported="false"
-            tools:node="remove" />
-
+            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

@@ -23,6 +23,7 @@ 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.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
@@ -31,24 +32,17 @@ 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 legacySessionImporter: LegacySessionImporter
     @Inject internal lateinit var authenticationService: AuthenticationService
     @Inject internal lateinit var userAgentHolder: UserAgentHolder
     @Inject internal lateinit var backgroundDetectionObserver: BackgroundDetectionObserver
@@ -57,12 +51,11 @@ 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
@@ -71,6 +64,10 @@ class Matrix private constructor(context: Context, matrixConfiguration: MatrixCo
         return authenticationService
     }
 
+    fun legacySessionImporter(): LegacySessionImporter {
+        return legacySessionImporter
+    }
+
     companion object {
 
         private lateinit var instance: Matrix

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

@@ -38,3 +38,8 @@ interface MatrixCallback<in T> {
         // 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.createUnresolved(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

@@ -122,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)
     }
 
     /**
@@ -144,14 +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

@@ -20,9 +20,9 @@ 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.data.SessionParams
 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
 
@@ -30,13 +30,17 @@ 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.
      */
@@ -74,19 +78,27 @@ interface AuthenticationService {
      */
     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?
-
     /**
      * 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/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"