Merge branch 'release/0.18.0'

Fix / Self verification mode 1 was not working

.buildkite/pipeline.yml

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

.editorconfig

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

.github/PULL_REQUEST_TEMPLATE.md

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

.gitignore

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

.idea/codeStyles/Project.xml

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

.idea/codeStyles/codeStyleConfig.xml

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

.idea/copyright/NewVector.xml

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

.idea/copyright/profiles_settings.xml

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

.idea/dictionaries/bmarty.xml

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

.travis.yml

@@ -49,12 +49,12 @@ script:
   # Build Android test (assembleAndroidTest) (disabled for now)
   # Code quality (lintGplayRelease lintFdroidRelease)
   # Split into two steps because if a task contain Fdroid, PlayService will be disabled
-  - ./gradlew clean assembleGplayRelease lintGplayRelease --stacktrace
-  - ./gradlew clean assembleFdroidRelease lintFdroidRelease --stacktrace
+  # Done by Buildkite now: - ./gradlew clean assembleGplayRelease lintGplayRelease --stacktrace
+  # Done by Buildkite now: - ./gradlew clean assembleFdroidRelease lintFdroidRelease --stacktrace
   # Run unitary test (Disable for now, see https://travis-ci.org/vector-im/riot-android/builds/502504370)
   # - ./gradlew testGplayReleaseUnitTest --stacktrace
   # Other code quality check
-  - ./tools/check/check_code_quality.sh
+  # Done by Buildkite now: - ./tools/check/check_code_quality.sh
   - ./tools/travis/check_pr.sh
   # Check that indonesians file are identical. Due to Android issue, the resource folder must be value-in/, and Weblate export data into value-id/.
-  - diff ./vector/src/main/res/values-id/strings.xml ./vector/src/main/res/values-in/strings.xml
+  # Done by Buildkite now: - diff ./vector/src/main/res/values-id/strings.xml ./vector/src/main/res/values-in/strings.xml

AUTHORS.md

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

CHANGES.md

@@ -1,25 +1,369 @@
-Changes in RiotX 0.4.0 (2019-XX-XX)
+Changes in RiotX 0.18.0 (2020-03-11)
+===================================================
+
+Improvements 🙌:
+ - Share image and other media from e2e rooms (#677)
+ - Add support for `/plain` command (#12)
+ - Detect spaces in password if user fail to login (#1038)
+ - FTUE: do not display a different color when encrypting message when not in developer mode.
+ - Open room member profile from avatar of the room member state event (#935)
+ - Restore the push rules configuration in the settings
+
+Bugfix 🐛:
+ - Fix crash on attachment preview screen (#1088)
+ - "Share" option is not appearing in encrypted rooms for images (#1031)
+ - Set "image/jpeg" as MIME type of images instead of "image/jpg" (#1075)
+ - Self verification via QR code is failing (#1130)
+
+SDK API changes ⚠️:
+ - PushRuleService.getPushRules() now returns a RuleSet. Use getAllRules() on this object to get all the rules.
+
+Build 🧱:
+ - Upgrade ktlint to version 0.36.0
+ - Pipeline file for Buildkite is now hosted on another Github repository: https://github.com/matrix-org/pipelines/blob/master/riotx-android/pipeline.yml
+
+Other changes:
+ - Restore availability to Chromebooks (#932)
+ - Add a [documentation](./docs/integration_tests.md) to run integration tests
+
+Changes in RiotX 0.17.0 (2020-02-27)
+===================================================
+
+Features ✨:
+ - Secured Shared Storage Support (#984, #936)
+ - It's now possible to select several rooms (with a possible mix of clear/encrypted rooms) when sharing elements to RiotX (#1010)
+ - Media preview: media are previewed before being sent to a room (#1010)
+ - Image edition: it's now possible to edit image before sending: crop, rotate, and delete actions are supported (#1010)
+ - Sending image: image are sent to rooms with a reduced size. It's still possible to send original image file (#1010)
+
+Improvements 🙌:
+ - Migrate to binary QR code verification (#994)
+ - Share action is added to room profile and room member profile (#858)
+ - Display avatar in fullscreen (#861)
+ - Fix some performance issues with crypto
+
+Bugfix 🐛:
+ - Account creation: wrongly hints that an email can be used to create an account (#941)
+ - Fix crash in the room directory, when public room has no name (#1023)
+ - Fix restoring keys backup with passphrase (#526)
+ - Fix rotation of full-size image (#647)
+ - Fix joining rooms from directory via federation isn't working. (#808)
+ - Leaving a room creates a stuck "leaving room" loading screen. (#1041)
+ - Fix some invitation handling issues (#1013)
+ - New direct chat: selecting a participant sometimes results in two breadcrumbs (#1022)
+ - New direct chat: selecting several participants was not adding the room to the direct chats list
+ - Room overview shows deleted messages as “Encrypted message” (#758)
+
+SDK API changes ⚠️:
+ - Get crypto methods through Session.cryptoService()
+ - ProgressListener.onProgress() function will be invoked on the background thread instead of UI thread
+ - Improve CreateRoomParams API (#1070)
+
+Changes in RiotX 0.16.0 (2020-02-14)
+===================================================
+
+Features ✨:
+ - Polls and Bot Buttons (MSC 2192 matrix-org/matrix-doc#2192)
+
+Improvements 🙌:
+ - Show confirmation dialog before deleting a message (#967, #1003)
+ - Open room member profile from reactions list and read receipts list (#875)
+
+Bugfix 🐛:
+ - Fix crash by removing all notifications after clearing cache (#878)
+ - Fix issue with verification when other client declares it can only show QR code (#988)
+ - Fix too errors in the code (1941862499c9ec5268cc80882512ced379cafcfd, a250a895fe0a4acf08c671e03434edcd29ccd84f)
+
+SDK API changes ⚠️:
+ - Javadoc improved for PushersService
+ - PushersService.pushers() has been renamed to PushersService.getPushers()
+
+Changes in RiotX 0.15.0 (2020-02-10)
+===================================================
+
+Improvements 🙌:
+ - Improve navigation to the timeline (#789, #862)
+ - Improve network detection. It is now based on the sync request status (#873, #882)
+
+Other changes:
+ - Support SSO login with Firefox account (#606)
+
+Bugfix 🐛:
+ - Ask for permission before opening the camera (#934)
+ - Encrypt for invited users by default, if the room state allows it (#803)
+
+Changes in RiotX 0.14.3 (2020-02-03)
+===================================================
+
+Bugfix 🐛:
+ - Fix Exception in DeviceListManager
+
+Changes in RiotX 0.14.2 (2020-02-02)
+===================================================
+
+Bugfix 🐛:
+ - Fix RiotX not starting issue
+
+Changes in RiotX 0.14.1 (2020-02-02)
+===================================================
+
+Bugfix 🐛:
+ - Cross-signing: fix UX issue when closing the bottom sheet verification (#813)
+ - Room and room member profile: fix issues on dark and black themes
+
+Changes in RiotX 0.14.0 (2020-02-01)
+===================================================
+
+Features ✨:
+ - First implementation of Cross-signing
+ - Enable encryption in unencrypted rooms, from the room settings (#212)
+ - Negotiate E2E by default for DMs (#907)
+
+Improvements 🙌:
+ - Sharing things to RiotX: sort list by recent room first (#771)
+ - Hide the algorithm when turning on e2e (#897)
+ - Sort room members by display names
+
+Other changes:
+ - Add support for /rainbow and /rainbowme commands (#879)
+
+Build 🧱:
+ - Ensure builds are reproducible (#842)
+ - F-Droid: fix the "-dev" issue in version name (#815)
+
+Changes in RiotX 0.13.0 (2020-01-17)
+===================================================
+
+Features ✨:
+ - Send and render typing events (#564)
+ - Create Room Profile screen (#54)
+ - Create Room Member Profile screen (#59)
+
+Improvements 🙌:
+ - Render events m.room.encryption and m.room.guest_access in the timeline
+
+Bugfix 🐛:
+ - Fix broken background sync in F-Droid version
+ - Fix issue with downloaded file on encrypted rooms. The file was not properly decrypted
+
+Build 🧱:
+ - Change the way versionCode is computed (#827)
+
+Changes in RiotX 0.12.0 (2020-01-09)
+===================================================
+
+Improvements 🙌:
+ - The initial sync is now handled by a foreground service
+ - Render aliases and canonical alias change in the timeline
+ - Introduce developer mode in the settings (#745, #796)
+ - Improve devices list screen
+ - Add settings for rageshake sensibility
+ - Fix autocompletion issues and add support for rooms, groups, and emoji (#780)
+ - Show skip to bottom FAB while scrolling down (#752)
+ - Enable encryption on a room, SDK part (#212)
+
+Other changes:
+ - Change the way RiotX identifies a session to allow the SDK to support several sessions with the same user (#800)
+ - Exclude play-services-oss-licenses library from F-Droid build (#814)
+ - Email domain can be limited on some homeservers, i18n of the displayed error (#754)
+
+Bugfix 🐛:
+ - Fix crash when opening room creation screen from the room filtering screen
+ - Fix avatar image disappearing (#777)
+ - Fix read marker banner when permalink
+ - Fix joining upgraded rooms (#697)
+ - Fix matrix.org room directory not being browsable (#807)
+ - Hide non working settings (#751)
+
+Changes in RiotX 0.11.0 (2019-12-19)
+===================================================
+
+Features ✨:
+ - Implement soft logout (#281)
+
+Improvements 🙌:
+ - Handle navigation to room via room alias (#201)
+ - Open matrix.to link in RiotX (#57)
+ - Limit sticker size in the timeline
+
+Other changes:
+ - Use same default room colors than Riot-Web
+
+Bugfix 🐛:
+ - Scroll breadcrumbs to top when opened
+ - Render default room name when it starts with an emoji (#477)
+ - Do not display " (IRC)" in display names https://github.com/vector-im/riot-android/issues/444
+ - Fix rendering issue with HTML formatted body
+ - Disable click on Stickers (#703)
+
+Build 🧱:
+ - Include diff-match-patch sources as dependency
+
+Changes in RiotX 0.10.0 (2019-12-10)
+===================================================
+
+Features ✨:
+ - Breadcrumbs: switch from one room to another quickly (#571)
+
+Improvements 🙌:
+ - Support entering a RiotWeb client URL instead of the homeserver URL during connection (#744)
+
+Other changes:
+ - Add reason for all membership events (https://github.com/matrix-org/matrix-doc/pull/2367)
+
+Bugfix 🐛:
+ - When automardown is ON, pills are sent as MD in body (#739)
+ - "ban" event are not rendered correctly (#716)
+ - Fix crash when rotating screen in Room timeline
+
+Changes in RiotX 0.9.1 (2019-12-05)
+===================================================
+
+Bugfix 🐛:
+ - Fix an issue with DB transaction (#740)
+
+Changes in RiotX 0.9.0 (2019-12-05)
+===================================================
+
+Features ✨:
+ - Account creation. It's now possible to create account on any homeserver with RiotX (#34)
+ - Iteration of the login flow (#613)
+ - [SDK] MSC2241 / verification in DMs (#707)
+
+Improvements 🙌:
+ - Send mention Pills from composer
+ - Links in message preview in the bottom sheet are now active. 
+ - Rework the read marker to make it more usable
+
+Other changes:
+ - Fix a small grammatical error when an empty room list is shown.
+
+Bugfix 🐛:
+ - Do not show long click help if only invitation are displayed
+ - Fix emoji filtering not working
+ - Fix issue of closing Realm in another thread (#725)
+ - Attempt to properly cancel the crypto module when user signs out (#724)
+
+Changes in RiotX 0.8.0 (2019-11-19)
+===================================================
+
+Features ✨:
+ - Handle long click on room in the room list (#395)
+ - Ignore/UnIgnore users, and display list of ignored users (#542, #617)
+
+Improvements 🙌:
+ - Search reaction by name or keyword in emoji picker
+ - Handle code tags (#567)
+ - Support spoiler messages
+ - Support m.sticker and m.room.join_rules events in timeline
+
+Other changes:
+ - Markdown set to off by default (#412)
+ - Accessibility improvements to the attachment file type chooser
+
+Bugfix 🐛:
+ - Fix issues with some member events rendering (#498)
+ - Passphrase does not match (Export room keys) (#644)
+ - Ask for permission to write external storage when uri comes from the keyboard (#658)
+ - Fix issue with english US/GB translation (#671)
+
+Changes in RiotX 0.7.0 (2019-10-24)
+===================================================
+
+Features:
+ - Share elements from other app to RiotX (#58)
+ - Read marker (#84)
+ - Add ability to report content (#515)
+
+Improvements:
+ - Persist active tab between sessions (#503)
+ - Do not upload file too big for the homeserver (#587)
+ - Attachments: start using system pickers (#52)
+ - Mark all messages as read (#396)
+
+
+Other changes:
+ - Accessibility improvements to read receipts in the room timeline and reactions emoji chooser
+
+Bugfix:
+ - Fix issue on upload error in loop (#587)
+ - Fix opening a permalink: the targeted event is displayed twice (#556)
+ - Fix opening a permalink paginates all the history up to the last event (#282)
+ - after login, the icon in the top left is a green 'A' for (all communities) rather than my avatar (#267)
+ - Picture uploads are unreliable, pictures are shown in wrong aspect ratio on desktop client (#517)
+ - Invitation notifications are not dismissed automatically if room is joined from another client (#347)
+ - Opening links from RiotX reuses browser tab (#599)
+
+Changes in RiotX 0.6.1 (2019-09-24)
+===================================================
+
+Bugfix:
+ - Fix crash: MergedHeaderItem was missing dimensionConverter
+
+Changes in RiotX 0.6.0 (2019-09-24)
+===================================================
+
+Features:
+ - Save draft of a message when exiting a room with non empty composer (#329)
+
+Improvements:
+ - Add unread indent on room list (#485)
+ - Message Editing: Update notifications (#128)
+ - Remove any notification of a redacted event (#563)
+
+Other changes:
+ - Fix a few accessibility issues
+
+Bugfix:
+ - Fix characters erased from the Search field when the result are coming (#545)
+ - "No connection" banner was displayed by mistake
+ - Leaving community (from another client) has no effect on RiotX (#497)
+ - Push rules was not retrieved after a clear cache
+ - m.notice messages trigger push notifications (#238)
+ - Embiggen messages with multiple emojis also for edited messages (#458)
+
+Build:
+ - Fix (again) issue with bad versionCode generated by Buildkite (#553)
+
+Changes in RiotX 0.5.0 (2019-09-17)
+===================================================
+
+Features:
+ - Implementation of login to homeserver with SSO (#557)
+ - Handle M_CONSENT_NOT_GIVEN error (#64)
+ - Auto configure homeserver and identity server URLs of LoginActivity with a magic link
+
+Improvements:
+ - Reduce default release build log level, and lab option to enable more logs.
+ - Display a no network indicator when there is no network (#559)
+
+Bugfix:
+ - Fix crash due to missing informationData (#535)
+ - Progress in initial sync dialog is decreasing for a step and should not (#532)
+ - Fix rendering issue of accepted third party invitation event
+ - All current notifications were dismissed by mistake when the app is launched from the launcher
+
+Build:
+ - Fix issue with version name (#533)
+ - Fix issue with bad versionCode generated by Buildkite (#553)
+
+Changes in RiotX 0.4.0 (2019-08-30)
 ===================================================
 
 Features:
  - Display read receipts in timeline (#81)
 
 Improvements:
- -
-
-Other changes:
- -
+ - Reactions: Reinstate the ability to react with non-unicode keys (#307)
 
 Bugfix:
  - Fix text diff linebreak display (#441)
  - Date change message repeats for each redaction until a normal message (#358)
  - Slide-in reply icon is distorted (#423)
-
-Translations:
- -
-
-Build:
- -
+ - Regression / e2e replies not encrypted
+ - Some video won't play
+ - Privacy: remove log of notifiable event (#519)
+ - Fix crash with EmojiCompat (#530)
 
 Changes in RiotX 0.3.0 (2019-08-08)
 ===================================================
@@ -90,24 +434,26 @@ Mode details here: https://medium.com/@RiotChat/introducing-the-riotx-beta-for-a
 =======================================================
 
 
-Changes in RiotX 0.0.0 (2019-XX-XX)
+Changes in RiotX 0.X.0 (2020-XX-XX)
 ===================================================
 
-Features:
+Features ✨:
  -
 
-Improvements:
+Improvements 🙌:
+ -
+
+Bugfix 🐛:
+ -
+
+Translations 🗣:
+ -
+
+SDK API changes ⚠️:
+ - 
+
+Build 🧱:
  -
 
 Other changes:
  -
-
-Bugfix:
- -
-
-Translations:
- -
-
-Build:
- -
-

CONTRIBUTING.md

@@ -1,6 +1,6 @@
 # Contributing code to Matrix
 
-Please read https://github.com/matrix-org/synapse/blob/master/CONTRIBUTING.rst
+Please read https://github.com/matrix-org/synapse/blob/master/CONTRIBUTING.md
 
 Android support can be found in this [![Riot Android Matrix room #riot-android:matrix.org](https://img.shields.io/matrix/riot-android:matrix.org.svg?label=%23riot-android:matrix.org&logo=matrix&server_fqdn=matrix.org)](https://matrix.to/#/#riot-android:matrix.org) room.
 
@@ -11,6 +11,7 @@ Dedicated room for RiotX: [![RiotX Android Matrix room #riot-android:matrix.org]
 ## Android Studio settings
 
 Please set the "hard wrap" setting of Android Studio to 160 chars, this is the setting we use internally to format the source code (Menu `Settings/Editor/Code Style` then `Hard wrap at`).
+Please ensure that your using the project formatting rules (which are in the project at .idea/codeStyles/), and format the file before committing them.
 
 ## Compilation
 
@@ -40,26 +41,58 @@ Please add a line to the top of the file `CHANGES.md` describing your change.
 
 Make sure the following commands execute without any error:
 
-> ./tools/check/check_code_quality.sh
+#### Internal tool
 
-> ./gradlew lintGplayRelease
+<pre>
+./tools/check/check_code_quality.sh
+</pre>
+
+#### ktlint
+
+<pre>
+curl -sSLO https://github.com/pinterest/ktlint/releases/download/0.34.2/ktlint && chmod a+x ktlint
+./ktlint --android --experimental -v
+</pre>
+
+Note that you can run
+
+<pre>
+./ktlint --android --experimental -v -F
+</pre>
+
+For ktlint to fix some detected errors for you (you still have to check and commit the fix of course)
+
+#### lint
+
+<pre>
+./gradlew lintGplayRelease
+./gradlew lintFdroidRelease
+</pre>
 
 ### Unit tests
 
 Make sure the following commands execute without any error:
 
-> ./gradlew testGplayReleaseUnitTest
+<pre>
+./gradlew testGplayReleaseUnitTest
+</pre>
 
 ### Tests
 
-RiotX is currently supported on Android Jelly Bean (API 16+): please test your change on an Android device (or Android emulator) running with API 16. Many issues can happen (including crashes) on older devices.
+RiotX is currently supported on Android KitKat (API 19+): please test your change on an Android device (or Android emulator) running with API 19. Many issues can happen (including crashes) on older devices.
 Also, if possible, please test your change on a real device. Testing on Android emulator may not be sufficient.
 
+You should consider adding Unit tests with your PR, and also integration tests (AndroidTest). Please refer to [this document](./docs/integration_tests.md) to install and run the integration test environment.
+
 ### Internationalisation
 
 When adding new string resources, please only add new entries in file `value/strings.xml`. Translations will be added later by the community of translators with a specific tool named [Weblate](https://translate.riot.im/projects/riot-android/).
 Do not hesitate to use plurals when appropriate.
 
+### Accessibility
+
+Please consider accessibility as an important point. As a minimum requirement, in layout XML files please use attributes such as `android:contentDescription` and `android:importantForAccessibility`, and test with a screen reader if it's working well. You can add new string resources, dedicated to accessibility, in this case, please prefix theirs id with `a11y_`.
+
 ### Layout
 
 When adding or editing layouts, make sure the layout will render correctly if device uses a RTL (Right To Left) language.

README.md

@@ -12,12 +12,13 @@ RiotX is an Android Matrix Client currently in beta but in active development.
 It is a total rewrite of [Riot-Android](https://github.com/vector-im/riot-android) with a new user experience. RiotX will become the official replacement as soon as all features are implemented.
 
 [<img src="https://play.google.com/intl/en_us/badges/images/generic/en_badge_web_generic.png" alt="Get it on Google Play" height="60">](https://play.google.com/store/apps/details?id=im.vector.riotx)
+[<img src="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)
 
 Nightly build: [![Buildkite](https://badge.buildkite.com/657d3db27364448d69d54f66c690f7788bc6aa80a7628e37f3.svg?branch=develop)](https://buildkite.com/matrix-dot-org/riotx-android/builds?branch=develop)
 
 # New Android SDK
 
-RiotX is based on a new Android SDK fully written in Kotlin (like RiotX). In order to make the early development as fast as possible, RiotX and the new SDK currently share the same git repository. We will make separate repos once the API is stable enough.
+RiotX is based on a new Android SDK fully written in Kotlin (like RiotX). In order to make the early development as fast as possible, RiotX and the new SDK currently share the same git repository. We will make separate repos once the SDK is stable enough.
 
 
 # Roadmap

build.gradle

@@ -1,9 +1,7 @@
-import javax.tools.JavaCompiler
-
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 
 buildscript {
-    ext.kotlin_version = '1.3.21'
+    ext.kotlin_version = '1.3.50'
     repositories {
         google()
         jcenter()
@@ -12,11 +10,11 @@ buildscript {
         }
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.4.1'
-        classpath 'com.google.gms:google-services:4.2.0'
-        classpath "com.airbnb.okreplay:gradle-plugin:1.4.0"
+        classpath 'com.android.tools.build:gradle:3.5.3'
+        classpath 'com.google.gms:google-services:4.3.2'
+        classpath "com.airbnb.okreplay:gradle-plugin:1.5.0"
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-        classpath 'org.sonarsource.scanner.gradle:sonarqube-gradle-plugin:2.6.2'
+        classpath 'org.sonarsource.scanner.gradle:sonarqube-gradle-plugin:2.7.1'
         classpath 'com.google.android.gms:oss-licenses-plugin:0.9.5'
 
         // NOTE: Do not place your application dependencies here; they belong
@@ -36,6 +34,10 @@ allprojects {
                 includeGroupByRegex "com\\.github\\.jaiselrahman"
                 // And monarchy
                 includeGroupByRegex "com\\.github\\.Zhuinden"
+                // And ucrop
+                includeGroupByRegex "com\\.github\\.yalantis"
+                // JsonViewer
+                includeGroupByRegex 'com\\.github\\.BillCarsonFr'
             }
         }
         maven {
@@ -47,24 +49,11 @@ allprojects {
         maven { url 'https://oss.sonatype.org/content/repositories/snapshots/' }
         google()
         jcenter()
-        maven {
-            url 'https://repo.adobe.com/nexus/content/repositories/public/'
-            content {
-                includeGroupByRegex "diff_match_patch"
-            }
-        }
     }
 
-    tasks.withType(JavaCompile).all {
-        options.compilerArgs += [
-                '-Adagger.gradle.incremental=enabled'
-        ]
-    }
-
-    afterEvaluate {
-        extensions.findByName("kapt")?.arguments {
-            arg("dagger.gradle.incremental", "enabled")
-        }
+    tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
+        // Warnings are potential errors, so stop ignoring them
+        kotlinOptions.allWarningsAsErrors = true
     }
 
 }

diff-match-patch/.gitignore

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

diff-match-patch/build.gradle

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

docs/integration_tests.md

@@ -0,0 +1,97 @@
+# 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.
+
+## 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/signin.md

@@ -0,0 +1,260 @@
+# Sign in to a homeserver
+
+This document describes the flow of signin to a homeserver, and also the flow when user want to reset his password. Examples come from the `matrix.org` homeserver.
+
+## Sign up flows
+
+### Get the flow
+
+Client request the sign-in flows, once the homeserver is chosen by the user and its url is known (in the example it's `https://matrix.org`)
+
+> curl -X GET 'https://matrix.org/_matrix/client/r0/login'
+
+200
+
+```json
+{
+  "flows": [
+    {
+      "type": "m.login.password"
+    }
+  ]
+}
+```
+
+### Login with username
+
+The user is able to connect using `m.login.password`
+
+> curl -X POST --data $'{"identifier":{"type":"m.id.user","user":"alice"},"password":"weak_password","type":"m.login.password","initial_device_display_name":"Portable"}' 'https://matrix.org/_matrix/client/r0/login'
+
+```json
+{
+  "identifier": {
+    "type": "m.id.user",
+    "user": "alice"
+  },
+  "password": "weak_password",
+  "type": "m.login.password",
+  "initial_device_display_name": "Portable"
+}
+```
+
+#### Incorrect password
+
+403
+
+```json
+{
+  "errcode": "M_FORBIDDEN",
+  "error": "Invalid password"
+}
+```
+
+#### Correct password:
+
+We get credential (200)
+
+```json
+{
+  "user_id": "@benoit0816:matrix.org",
+  "access_token": "MDAxOGxvY2F0aW9uIG1hdHREDACTEDb2l0MDgxNjptYXRyaXgub3JnCjAwMTZjaWQgdHlwZSA9IGFjY2VzcwowMDIxY2lkIG5vbmNlID0gfnYrSypfdTtkNXIuNWx1KgowMDJmc2lnbmF0dXJlIOsh1XqeAkXexh4qcofl_aR4kHJoSOWYGOhE7-ubX-DZCg",
+  "home_server": "matrix.org",
+  "device_id": "GTVREDALBF",
+  "well_known": {
+    "m.homeserver": {
+      "base_url": "https:\/\/matrix.org\/"
+    }
+  }
+}
+```
+
+### Login with email
+
+If the user has associated an email with its account, he can signin using the email.
+
+> curl -X POST --data $'{"identifier":{"type":"m.id.thirdparty","medium":"email","address":"alice@yopmail.com"},"password":"weak_password","type":"m.login.password","initial_device_display_name":"Portable"}' 'https://matrix.org/_matrix/client/r0/login'
+
+```json
+{
+  "identifier": {
+    "type": "m.id.thirdparty",
+    "medium": "email",
+    "address": "alice@yopmail.com"
+  },
+  "password": "weak_password",
+  "type": "m.login.password",
+  "initial_device_display_name": "Portable"
+}
+```
+
+#### Unknown email
+
+403
+
+```json
+{
+  "errcode": "M_FORBIDDEN",
+  "error": ""
+}
+```
+
+#### Known email, wrong password
+
+403
+
+```json
+{
+  "errcode": "M_FORBIDDEN",
+  "error": "Invalid password"
+}
+```
+
+##### Known email, correct password
+
+We get the credentials (200)
+
+```json
+{
+  "user_id": "@alice:matrix.org",
+  "access_token": "MDAxOGxvY2F0aW9uIG1hdHJpeC5vcmREDACTEDZXJfaWQgPSBAYmVub2l0MDgxNjptYXRyaXgub3JnCjAwMTZjaWQgdHlwZSA9IGFjY2VzcwowMDIxY2lkIG5vbmNlID0gNjtDY0MwRlNPSFFoOC5wOgowMDJmc2lnbmF0dXJlIGiTRm1mYLLxQywxOh3qzQVT8HoEorSokEP2u-bAwtnYCg",
+  "home_server": "matrix.org",
+  "device_id": "WBSREDASND",
+  "well_known": {
+    "m.homeserver": {
+      "base_url": "https:\/\/matrix.org\/"
+    }
+  }
+}
+```
+
+### Login with Msisdn
+
+Not supported yet in RiotX
+
+### Login with SSO
+
+> curl -X GET 'https://homeserver.with.sso/_matrix/client/r0/login'
+
+200
+
+```json
+{
+  "flows": [
+    {
+      "type": "m.login.sso"
+    }
+  ]
+}
+```
+
+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
+
+## Reset password
+
+Ref: `https://matrix.org/docs/spec/client_server/latest#post-matrix-client-r0-account-password-email-requesttoken`
+
+When the user has forgotten his password, he can reset it by providing an email and a new password.
+
+Here is the flow:
+
+### Send email
+
+User is asked to enter the email linked to his account and a new password.
+We display a warning regarding e2e.
+
+At the first step, we do not send the password, only the email and a client secret, generated by the application
+
+> curl -X POST --data $'{"client_secret":"6c57f284-85e2-421b-8270-fb1795a120a7","send_attempt":0,"email":"user@domain.com"}' 'https://matrix.org/_matrix/client/r0/account/password/email/requestToken'
+
+```json
+{
+  "client_secret": "6c57f284-85e2-421b-8270-fb1795a120a7",
+  "send_attempt": 0,
+  "email": "user@domain.com"
+}
+```
+
+#### When the email is not known
+
+We get a 400
+
+```json
+{
+  "errcode": "M_THREEPID_NOT_FOUND",
+  "error": "Email not found"
+}
+```
+
+#### When the email is known
+
+We get a 200 with a `sid`
+
+```json
+{
+  "sid": "tQNbrREDACTEDldA"
+}
+```
+
+Then the user is asked to click on the link in the email he just received, and to confirm when it's done.
+
+During this step, the new password is sent to the homeserver.
+
+If the user confirms before the link is clicked, we get an error:
+
+> curl -X POST --data $'{"auth":{"type":"m.login.email.identity","threepid_creds":{"client_secret":"6c57f284-85e2-421b-8270-fb1795a120a7","sid":"tQNbrREDACTEDldA"}},"new_password":"weak_password"}' 'https://matrix.org/_matrix/client/r0/account/password'
+
+```json
+{
+  "auth": {
+    "type": "m.login.email.identity",
+    "threepid_creds": {
+      "client_secret": "6c57f284-85e2-421b-8270-fb1795a120a7",
+      "sid": "tQNbrREDACTEDldA"
+    }
+  },
+  "new_password": "weak_password"
+}
+```
+
+401
+
+```json
+{
+  "errcode": "M_UNAUTHORIZED",
+  "error": ""
+}
+```
+
+### User clicks on the link
+
+The link has the form:
+
+https://matrix.org/_matrix/client/unstable/password_reset/email/submit_token?token=fzZLBlcqhTKeaFQFSRbsQnQCkzbwtGAD&client_secret=6c57f284-85e2-421b-8270-fb1795a120a7&sid=tQNbrREDACTEDldA
+
+It contains the client secret, a token and the sid
+
+When the user click the link, if validate his ownership and the new password can now be ent by the application (on user demand):
+
+> curl -X POST --data $'{"auth":{"type":"m.login.email.identity","threepid_creds":{"client_secret":"6c57f284-85e2-421b-8270-fb1795a120a7","sid":"tQNbrREDACTEDldA"}},"new_password":"weak_password"}' 'https://matrix.org/_matrix/client/r0/account/password'
+
+```json
+{
+  "auth": {
+    "type": "m.login.email.identity",
+    "threepid_creds": {
+      "client_secret": "6c57f284-85e2-421b-8270-fb1795a120a7",
+      "sid": "tQNbrREDACTEDldA"
+    }
+  },
+  "new_password": "weak_password"
+}
+```
+
+200
+
+```json
+{}
+```
+
+The password has been changed, and all the existing token are invalidated. User can now login with the new password.

docs/signup.md

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

gradle/wrapper/gradle-wrapper.properties

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

matrix-sdk-android-rx/build.gradle

@@ -5,16 +5,15 @@ apply plugin: 'kotlin-kapt'
 android {
     compileSdkVersion 28
 
-
-
     defaultConfig {
         minSdkVersion 16
         targetSdkVersion 28
         versionCode 1
         versionName "1.0"
 
+        // Multidex is useful for tests
+        multiDexEnabled true
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
-
     }
 
     buildTypes {
@@ -29,17 +28,22 @@ android {
         targetCompatibility JavaVersion.VERSION_1_8
     }
 
-
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
 }
 
 dependencies {
     implementation project(":matrix-sdk-android")
-    implementation 'androidx.appcompat:appcompat:1.1.0-beta01'
+    implementation 'androidx.appcompat:appcompat:1.1.0'
     implementation 'io.reactivex.rxjava2:rxkotlin:2.3.0'
     implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
     // Paging
     implementation "androidx.paging:paging-runtime-ktx:2.1.0"
 
+    // Logging
+    implementation 'com.jakewharton.timber:timber:4.7.1'
+
     testImplementation 'junit:junit:4.12'
     androidTestImplementation 'androidx.test:runner:1.2.0'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'

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

@@ -1,42 +0,0 @@
-/*
- * Copyright 2019 New Vector Ltd
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package im.vector.matrix.rx;
-
-import android.content.Context;
-import androidx.test.InstrumentationRegistry;
-import androidx.test.runner.AndroidJUnit4;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import static org.junit.Assert.*;
-
-/**
- * Instrumented test, which will execute on an Android device.
- *
- * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
- */
-@RunWith(AndroidJUnit4.class)
-public class ExampleInstrumentedTest {
-    @Test
-    public void useAppContext() {
-        // Context of the app under test.
-        Context appContext = InstrumentationRegistry.getTargetContext();
-
-        assertEquals("im.vector.matrix.rx.test", appContext.getPackageName());
-    }
-}

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

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

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

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.rx
+
+import im.vector.matrix.android.api.util.Optional
+import io.reactivex.Observable
+
+fun <T : Any> Observable<Optional<T>>.unwrap(): Observable<T> {
+    return filter { it.hasValue() }.map { it.get() }
+}
+
+fun <T : Any, U : Any> Observable<Optional<T>>.mapOptional(fn: (T) -> U?): Observable<Optional<U>> {
+    return map {
+        it.map(fn)
+    }
+}

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

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.rx
+
+import im.vector.matrix.android.api.MatrixCallback
+import im.vector.matrix.android.api.util.Cancelable
+import io.reactivex.Completable
+import io.reactivex.Single
+
+fun <T> singleBuilder(builder: (callback: MatrixCallback<T>) -> Cancelable): Single<T> = Single.create {
+    val callback: MatrixCallback<T> = object : MatrixCallback<T> {
+        override fun onSuccess(data: T) {
+            it.onSuccess(data)
+        }
+
+        override fun onFailure(failure: Throwable) {
+            it.tryOnError(failure)
+        }
+    }
+    val cancelable = builder(callback)
+    it.setCancellable {
+        cancelable.cancel()
+    }
+}
+
+fun <T> completableBuilder(builder: (callback: MatrixCallback<T>) -> Cancelable): Completable = Completable.create {
+    val callback: MatrixCallback<T> = object : MatrixCallback<T> {
+        override fun onSuccess(data: T) {
+            it.onComplete()
+        }
+
+        override fun onFailure(failure: Throwable) {
+            it.tryOnError(failure)
+        }
+    }
+    val cancelable = builder(callback)
+    it.setCancellable {
+        cancelable.cancel()
+    }
+}

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

@@ -16,46 +16,87 @@
 
 package im.vector.matrix.rx
 
+import im.vector.matrix.android.api.session.events.model.Event
 import im.vector.matrix.android.api.session.room.Room
+import im.vector.matrix.android.api.session.room.members.RoomMemberQueryParams
 import im.vector.matrix.android.api.session.room.model.EventAnnotationsSummary
 import im.vector.matrix.android.api.session.room.model.ReadReceipt
+import im.vector.matrix.android.api.session.room.model.RoomMemberSummary
 import im.vector.matrix.android.api.session.room.model.RoomSummary
+import im.vector.matrix.android.api.session.room.notification.RoomNotificationState
+import im.vector.matrix.android.api.session.room.send.UserDraft
 import im.vector.matrix.android.api.session.room.timeline.TimelineEvent
+import im.vector.matrix.android.api.util.Optional
+import im.vector.matrix.android.api.util.toOptional
 import io.reactivex.Observable
 import io.reactivex.Single
 
 class RxRoom(private val room: Room) {
 
-    fun liveRoomSummary(): Observable<RoomSummary> {
-        return room.liveRoomSummary().asObservable()
+    fun liveRoomSummary(): Observable<Optional<RoomSummary>> {
+        return room.getRoomSummaryLive()
+                .asObservable()
+                .startWithCallable { room.roomSummary().toOptional() }
     }
 
-    fun liveRoomMemberIds(): Observable<List<String>> {
-        return room.getRoomMemberIdsLive().asObservable()
+    fun liveRoomMembers(queryParams: RoomMemberQueryParams): Observable<List<RoomMemberSummary>> {
+        return room.getRoomMembersLive(queryParams).asObservable()
+                .startWithCallable {
+                    room.getRoomMembers(queryParams)
+                }
     }
 
-    fun liveAnnotationSummary(eventId: String): Observable<EventAnnotationsSummary> {
-        return room.getEventSummaryLive(eventId).asObservable()
+    fun liveAnnotationSummary(eventId: String): Observable<Optional<EventAnnotationsSummary>> {
+        return room.getEventAnnotationsSummaryLive(eventId).asObservable()
+                .startWithCallable {
+                    room.getEventAnnotationsSummary(eventId).toOptional()
+                }
     }
 
-    fun liveTimelineEvent(eventId: String): Observable<TimelineEvent> {
-        return room.liveTimeLineEvent(eventId).asObservable()
+    fun liveTimelineEvent(eventId: String): Observable<Optional<TimelineEvent>> {
+        return room.getTimeLineEventLive(eventId).asObservable()
+                .startWithCallable {
+                    room.getTimeLineEvent(eventId).toOptional()
+                }
     }
 
-    fun loadRoomMembersIfNeeded(): Single<Unit> = Single.create {
-        room.loadRoomMembersIfNeeded(MatrixCallbackSingle(it)).toSingle(it)
+    fun liveStateEvent(eventType: String, stateKey: String): Observable<Optional<Event>> {
+        return room.getStateEventLive(eventType, stateKey).asObservable()
+                .startWithCallable {
+                    room.getStateEvent(eventType, stateKey).toOptional()
+                }
     }
 
-    fun joinRoom(viaServers: List<String> = emptyList()): Single<Unit> = Single.create {
-        room.join(viaServers, MatrixCallbackSingle(it)).toSingle(it)
+    fun liveReadMarker(): Observable<Optional<String>> {
+        return room.getReadMarkerLive().asObservable()
+    }
+
+    fun liveReadReceipt(): Observable<Optional<String>> {
+        return room.getMyReadReceiptLive().asObservable()
+    }
+
+    fun loadRoomMembersIfNeeded(): Single<Unit> = singleBuilder {
+        room.loadRoomMembersIfNeeded(it)
+    }
+
+    fun joinRoom(reason: String? = null,
+                 viaServers: List<String> = emptyList()): Single<Unit> = singleBuilder {
+        room.join(reason, viaServers, it)
     }
 
     fun liveEventReadReceipts(eventId: String): Observable<List<ReadReceipt>> {
         return room.getEventReadReceiptsLive(eventId).asObservable()
     }
 
+    fun liveDrafts(): Observable<List<UserDraft>> {
+        return room.getDraftsLive().asObservable()
+    }
+
+    fun liveNotificationState(): Observable<RoomNotificationState> {
+        return room.getLiveRoomNotificationState().asObservable()
+    }
 }
 
 fun Room.rx(): RxRoom {
     return RxRoom(this)
-}
+}

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

@@ -18,57 +18,119 @@ package im.vector.matrix.rx
 
 import androidx.paging.PagedList
 import im.vector.matrix.android.api.session.Session
+import im.vector.matrix.android.api.session.crypto.crosssigning.MXCrossSigningInfo
+import im.vector.matrix.android.api.session.group.GroupSummaryQueryParams
 import im.vector.matrix.android.api.session.group.model.GroupSummary
 import im.vector.matrix.android.api.session.pushers.Pusher
+import im.vector.matrix.android.api.session.room.RoomSummaryQueryParams
 import im.vector.matrix.android.api.session.room.model.RoomSummary
 import im.vector.matrix.android.api.session.room.model.create.CreateRoomParams
 import im.vector.matrix.android.api.session.sync.SyncState
 import im.vector.matrix.android.api.session.user.model.User
+import im.vector.matrix.android.api.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.session.sync.model.accountdata.UserAccountDataEvent
 import io.reactivex.Observable
 import io.reactivex.Single
 
 class RxSession(private val session: Session) {
 
-    fun liveRoomSummaries(): Observable<List<RoomSummary>> {
-        return session.liveRoomSummaries().asObservable()
+    fun liveRoomSummaries(queryParams: RoomSummaryQueryParams): Observable<List<RoomSummary>> {
+        return session.getRoomSummariesLive(queryParams).asObservable()
+                .startWithCallable {
+                    session.getRoomSummaries(queryParams)
+                }
     }
 
-    fun liveGroupSummaries(): Observable<List<GroupSummary>> {
-        return session.liveGroupSummaries().asObservable()
+    fun liveGroupSummaries(queryParams: GroupSummaryQueryParams): Observable<List<GroupSummary>> {
+        return session.getGroupSummariesLive(queryParams).asObservable()
+                .startWithCallable {
+                    session.getGroupSummaries(queryParams)
+                }
+    }
+
+    fun liveBreadcrumbs(): Observable<List<RoomSummary>> {
+        return session.getBreadcrumbsLive().asObservable()
+                .startWithCallable {
+                    session.getBreadcrumbs()
+                }
     }
 
     fun liveSyncState(): Observable<SyncState> {
-        return session.syncState().asObservable()
+        return session.getSyncStateLive().asObservable()
     }
 
     fun livePushers(): Observable<List<Pusher>> {
-        return session.livePushers().asObservable()
+        return session.getPushersLive().asObservable()
+    }
+
+    fun liveUser(userId: String): Observable<Optional<User>> {
+        return session.getUserLive(userId).asObservable()
+                .startWithCallable {
+                    session.getUser(userId).toOptional()
+                }
     }
 
     fun liveUsers(): Observable<List<User>> {
-        return session.liveUsers().asObservable()
+        return session.getUsersLive().asObservable()
+    }
+
+    fun liveIgnoredUsers(): Observable<List<User>> {
+        return session.getIgnoredUsersLive().asObservable()
     }
 
     fun livePagedUsers(filter: String? = null): Observable<PagedList<User>> {
-        return session.livePagedUsers(filter).asObservable()
+        return session.getPagedUsersLive(filter).asObservable()
     }
 
-    fun createRoom(roomParams: CreateRoomParams): Single<String> = Single.create {
-        session.createRoom(roomParams, MatrixCallbackSingle(it)).toSingle(it)
+    fun createRoom(roomParams: CreateRoomParams): Single<String> = singleBuilder {
+        session.createRoom(roomParams, it)
     }
 
     fun searchUsersDirectory(search: String,
                              limit: Int,
-                             excludedUserIds: Set<String>): Single<List<User>> = Single.create {
-        session.searchUsersDirectory(search, limit, excludedUserIds, MatrixCallbackSingle(it)).toSingle(it)
+                             excludedUserIds: Set<String>): Single<List<User>> = singleBuilder {
+        session.searchUsersDirectory(search, limit, excludedUserIds, it)
     }
 
-    fun joinRoom(roomId: String, viaServers: List<String> = emptyList()): Single<Unit> = Single.create {
-        session.joinRoom(roomId, viaServers, MatrixCallbackSingle(it)).toSingle(it)
+    fun joinRoom(roomIdOrAlias: String,
+                 reason: String? = null,
+                 viaServers: List<String> = emptyList()): Single<Unit> = singleBuilder {
+        session.joinRoom(roomIdOrAlias, reason, viaServers, it)
     }
 
+    fun getRoomIdByAlias(roomAlias: String,
+                         searchOnServer: Boolean): Single<Optional<String>> = singleBuilder {
+        session.getRoomIdByAlias(roomAlias, searchOnServer, it)
+    }
+
+    fun getProfileInfo(userId: String): Single<JsonDict> = singleBuilder {
+        session.getProfile(userId, it)
+    }
+
+    fun liveUserCryptoDevices(userId: String): Observable<List<CryptoDeviceInfo>> {
+        return session.cryptoService().getLiveCryptoDeviceInfo(userId).asObservable().startWithCallable {
+            session.cryptoService().getCryptoDeviceInfo(userId)
+        }
+    }
+
+    fun liveCrossSigningInfo(userId: String): Observable<Optional<MXCrossSigningInfo>> {
+        return session.cryptoService().crossSigningService().getLiveCrossSigningKeys(userId).asObservable()
+                .startWithCallable {
+                    session.cryptoService().crossSigningService().getUserCrossSigningKeys(userId).toOptional()
+                }
+    }
+
+    fun liveAccountData(types: Set<String>): Observable<List<UserAccountDataEvent>> {
+        return session.getLiveAccountDataEvents(types).asObservable()
+                .startWithCallable {
+                    session.getAccountDataEvents(types)
+                }
+    }
 }
 
 fun Session.rx(): RxSession {
     return RxSession(this)
-}
+}

matrix-sdk-android/build.gradle

@@ -10,7 +10,7 @@ buildscript {
         jcenter()
     }
     dependencies {
-        classpath "io.realm:realm-gradle-plugin:5.12.0"
+        classpath "io.realm:realm-gradle-plugin:6.1.0"
     }
 }
 
@@ -67,10 +67,14 @@ android {
         sourceCompatibility JavaVersion.VERSION_1_8
         targetCompatibility JavaVersion.VERSION_1_8
     }
+
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
 }
 
 static def gitRevision() {
-    def cmd = "git rev-parse --short HEAD"
+    def cmd = "git rev-parse --short=8 HEAD"
     return cmd.execute().text.trim()
 }
 
@@ -86,41 +90,43 @@ static def gitRevisionDate() {
 
 dependencies {
 
-    def arrow_version = "0.8.0"
-    def support_version = '1.1.0-beta01'
+    def arrow_version = "0.8.2"
     def moshi_version = '1.8.0'
-    def lifecycle_version = '2.0.0'
-    def coroutines_version = "1.0.1"
-    def markwon_version = '3.0.0'
-    def daggerVersion = '2.23.1'
+    def lifecycle_version = '2.2.0'
+    def arch_version = '2.1.0'
+    def coroutines_version = "1.3.2"
+    def markwon_version = '3.1.0'
+    def daggerVersion = '2.25.4'
 
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutines_version"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$coroutines_version"
 
-    implementation "androidx.appcompat:appcompat:1.1.0-rc01"
-    implementation "androidx.recyclerview:recyclerview:1.1.0-beta01"
+    implementation "androidx.appcompat:appcompat:1.1.0"
 
     implementation "androidx.lifecycle:lifecycle-extensions:$lifecycle_version"
-    kapt "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
+    implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"
 
     // Network
-    implementation 'com.squareup.retrofit2:retrofit:2.6.0'
-    implementation 'com.squareup.retrofit2:converter-moshi:2.4.0'
-    implementation 'com.squareup.okhttp3:okhttp:3.14.1'
-    implementation 'com.squareup.okhttp3:logging-interceptor:3.10.0'
-    implementation 'com.novoda:merlin:1.2.0'
+    implementation 'com.squareup.retrofit2:retrofit:2.6.2'
+    implementation 'com.squareup.retrofit2:converter-moshi:2.6.2'
+    implementation 'com.squareup.okhttp3:okhttp:4.2.2'
+    implementation 'com.squareup.okhttp3:logging-interceptor:4.2.2'
     implementation "com.squareup.moshi:moshi-adapters:$moshi_version"
     kapt "com.squareup.moshi:moshi-kotlin-codegen:$moshi_version"
 
     implementation "ru.noties.markwon:core:$markwon_version"
 
+    // Image
+    implementation 'androidx.exifinterface:exifinterface:1.1.0'
+    implementation 'id.zelory:compressor:3.0.0'
+
     // Database
     implementation 'com.github.Zhuinden:realm-monarchy:0.5.1'
     kapt 'dk.ilios:realmfieldnameshelper:1.1.1'
 
     // Work
-    implementation "androidx.work:work-runtime-ktx:2.1.0-rc01"
+    implementation "androidx.work:work-runtime-ktx:2.3.3"
 
     // FP
     implementation "io.arrow-kt:arrow-core:$arrow_version"
@@ -132,21 +138,25 @@ dependencies {
     // DI
     implementation "com.google.dagger:dagger:$daggerVersion"
     kapt "com.google.dagger:dagger-compiler:$daggerVersion"
-    compileOnly 'com.squareup.inject:assisted-inject-annotations-dagger2:0.4.0'
-    kapt 'com.squareup.inject:assisted-inject-processor-dagger2:0.4.0'
+    compileOnly 'com.squareup.inject:assisted-inject-annotations-dagger2:0.5.0'
+    kapt 'com.squareup.inject:assisted-inject-processor-dagger2:0.5.0'
 
     // Logging
     implementation 'com.jakewharton.timber:timber:4.7.1'
-    implementation 'com.facebook.stetho:stetho-okhttp3:1.5.0'
+    implementation 'com.facebook.stetho:stetho-okhttp3:1.5.1'
 
-    debugImplementation 'com.airbnb.okreplay:okreplay:1.4.0'
-    releaseImplementation 'com.airbnb.okreplay:noop:1.4.0'
-    androidTestImplementation 'com.airbnb.okreplay:espresso:1.4.0'
+    // Bus
+    implementation 'org.greenrobot:eventbus:3.1.1'
+
+    debugImplementation 'com.airbnb.okreplay:okreplay:1.5.0'
+    releaseImplementation 'com.airbnb.okreplay:noop:1.5.0'
+    androidTestImplementation 'com.airbnb.okreplay:espresso:1.5.0'
 
     testImplementation 'junit:junit:4.12'
-    testImplementation 'org.robolectric:robolectric:4.0.2'
+    testImplementation 'org.robolectric:robolectric:4.3'
     //testImplementation 'org.robolectric:shadows-support-v4:3.0'
-    testImplementation "io.mockk:mockk:1.8.13.kotlin13"
+    // Note: version sticks to 1.9.2 due to https://github.com/mockk/mockk/issues/281
+    testImplementation 'io.mockk:mockk:1.9.2.kotlin12'
     testImplementation 'org.amshove.kluent:kluent-android:1.44'
     testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$coroutines_version"
 
@@ -156,8 +166,9 @@ dependencies {
     androidTestImplementation 'androidx.test.ext:junit:1.1.1'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
     androidTestImplementation 'org.amshove.kluent:kluent-android:1.44'
-    androidTestImplementation "io.mockk:mockk-android:1.8.13.kotlin13"
-    androidTestImplementation "androidx.arch.core:core-testing:$lifecycle_version"
+    // Note: version sticks to 1.9.2 due to https://github.com/mockk/mockk/issues/281
+    androidTestImplementation 'io.mockk:mockk-android:1.9.2.kotlin12'
+    androidTestImplementation "androidx.arch.core:core-testing:$arch_version"
     androidTestImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$coroutines_version"
 
 }

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

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

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

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

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

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

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

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.account
+
+import im.vector.matrix.android.InstrumentedTest
+import im.vector.matrix.android.common.CommonTestHelper
+import im.vector.matrix.android.common.CryptoTestHelper
+import im.vector.matrix.android.common.SessionTestParams
+import im.vector.matrix.android.common.TestConstants
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import org.junit.runners.MethodSorters
+
+@RunWith(JUnit4::class)
+@FixMethodOrder(MethodSorters.JVM)
+class AccountCreationTest : InstrumentedTest {
+
+    private val commonTestHelper = CommonTestHelper(context())
+    private val cryptoTestHelper = CryptoTestHelper(commonTestHelper)
+
+    @Test
+    fun createAccountTest() {
+        val session = commonTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(withInitialSync = true))
+
+        commonTestHelper.signOutAndClose(session)
+    }
+
+    @Test
+    fun createAccountAndLoginAgainTest() {
+        val session = commonTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(withInitialSync = true))
+
+        // Log again to the same account
+        val session2 = commonTestHelper.logIntoAccount(session.myUserId, SessionTestParams(withInitialSync = true))
+
+        commonTestHelper.signOutAndClose(session)
+        commonTestHelper.signOutAndClose(session2)
+    }
+
+    @Test
+    fun simpleE2eTest() {
+        val res = cryptoTestHelper.doE2ETestWithAliceInARoom()
+
+        res.cleanUp(commonTestHelper)
+    }
+}

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

@@ -1,64 +0,0 @@
-/*
- * Copyright 2019 New Vector Ltd
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package im.vector.matrix.android.auth
-
-import androidx.test.annotation.UiThreadTest
-import androidx.test.rule.GrantPermissionRule
-import androidx.test.runner.AndroidJUnit4
-import im.vector.matrix.android.InstrumentedTest
-import im.vector.matrix.android.OkReplayRuleChainNoActivity
-import im.vector.matrix.android.api.auth.Authenticator
-import okreplay.*
-import org.junit.ClassRule
-import org.junit.Rule
-import org.junit.Test
-import org.junit.runner.RunWith
-
-
-@RunWith(AndroidJUnit4::class)
-internal class AuthenticatorTest : InstrumentedTest {
-
-    lateinit var authenticator: Authenticator
-    lateinit var okReplayInterceptor: OkReplayInterceptor
-
-    private val okReplayConfig = OkReplayConfig.Builder()
-            .tapeRoot(AndroidTapeRoot(
-                    context(), javaClass))
-            .defaultMode(TapeMode.READ_WRITE) // or TapeMode.READ_ONLY
-            .sslEnabled(true)
-            .interceptor(okReplayInterceptor)
-            .build()
-
-    @get:Rule
-    val testRule = OkReplayRuleChainNoActivity(okReplayConfig).get()
-
-    @Test
-    @UiThreadTest
-    @OkReplay(tape = "auth", mode = TapeMode.READ_WRITE)
-    fun auth() {
-
-    }
-
-    companion object {
-        @ClassRule
-        @JvmField
-        val grantExternalStoragePermissionRule: GrantPermissionRule =
-                GrantPermissionRule.grant(android.Manifest.permission.WRITE_EXTERNAL_STORAGE)
-    }
-
-
-}

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

@@ -0,0 +1,301 @@
+/*
+ * Copyright 2016 OpenMarket Ltd
+ * Copyright 2018 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.common
+
+import android.content.Context
+import android.net.Uri
+import androidx.lifecycle.Observer
+import im.vector.matrix.android.api.Matrix
+import im.vector.matrix.android.api.MatrixCallback
+import im.vector.matrix.android.api.MatrixConfiguration
+import im.vector.matrix.android.api.auth.data.HomeServerConnectionConfig
+import im.vector.matrix.android.api.auth.data.LoginFlowResult
+import im.vector.matrix.android.api.auth.registration.RegistrationResult
+import im.vector.matrix.android.api.session.Session
+import im.vector.matrix.android.api.session.events.model.EventType
+import im.vector.matrix.android.api.session.events.model.LocalEcho
+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.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.launch
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import java.util.ArrayList
+import java.util.UUID
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+
+/**
+ * This class exposes methods to be used in common cases
+ * Registration, login, Sync, Sending messages...
+ */
+class CommonTestHelper(context: Context) {
+
+    val matrix: Matrix
+
+    init {
+        Matrix.initialize(context, MatrixConfiguration("TestFlavor"))
+
+        matrix = Matrix.getInstance(context)
+    }
+
+    fun createAccount(userNamePrefix: String, testParams: SessionTestParams): Session {
+        return createAccount(userNamePrefix, TestConstants.PASSWORD, testParams)
+    }
+
+    fun logIntoAccount(userId: String, testParams: SessionTestParams): Session {
+        return logIntoAccount(userId, TestConstants.PASSWORD, testParams)
+    }
+
+    /**
+     * Create a Home server configuration, with Http connection allowed for test
+     */
+    fun createHomeServerConfig(): HomeServerConnectionConfig {
+        return HomeServerConnectionConfig.Builder()
+                .withHomeServerUri(Uri.parse(TestConstants.TESTS_HOME_SERVER_URL))
+                .build()
+    }
+
+    /**
+     * This methods init the event stream and check for initial sync
+     *
+     * @param session    the session to sync
+     */
+    fun syncSession(session: Session) {
+        val lock = CountDownLatch(1)
+
+        session.open()
+        session.startSync(true)
+
+        val syncLiveData = runBlocking(Dispatchers.Main) {
+            session.getSyncStateLive()
+        }
+        val syncObserver = object : Observer<SyncState> {
+            override fun onChanged(t: SyncState?) {
+                if (session.hasAlreadySynced()) {
+                    lock.countDown()
+                    syncLiveData.removeObserver(this)
+                }
+            }
+        }
+        GlobalScope.launch(Dispatchers.Main) { syncLiveData.observeForever(syncObserver) }
+
+        await(lock)
+    }
+
+    /**
+     * Sends text messages in a room
+     *
+     * @param room         the room where to send the messages
+     * @param message      the message to send
+     * @param nbOfMessages the number of time the message will be sent
+     */
+    fun sendTextMessage(room: Room, message: String, nbOfMessages: Int): List<TimelineEvent> {
+        val sentEvents = ArrayList<TimelineEvent>(nbOfMessages)
+        val latch = CountDownLatch(nbOfMessages)
+        val timelineListener = object : Timeline.Listener {
+            override fun onTimelineFailure(throwable: Throwable) {
+            }
+
+            override fun onNewTimelineEvents(eventIds: List<String>) {
+                // noop
+            }
+
+            override fun onTimelineUpdated(snapshot: List<TimelineEvent>) {
+                val newMessages = snapshot
+                        .filter { LocalEcho.isLocalEchoId(it.eventId).not() }
+                        .filter { it.root.getClearType() == EventType.MESSAGE }
+                        .filter { it.root.getClearContent().toModel<MessageContent>()?.body?.startsWith(message) == true }
+
+                if (newMessages.size == nbOfMessages) {
+                    sentEvents.addAll(newMessages)
+                    latch.countDown()
+                }
+            }
+        }
+        val timeline = room.createTimeline(null, TimelineSettings(10))
+        timeline.start()
+        timeline.addListener(timelineListener)
+        for (i in 0 until nbOfMessages) {
+            room.sendTextMessage(message + " #" + (i + 1))
+        }
+        await(latch)
+        timeline.removeListener(timelineListener)
+        timeline.dispose()
+
+        // Check that all events has been created
+        assertEquals(nbOfMessages.toLong(), sentEvents.size.toLong())
+
+        return sentEvents
+    }
+
+    // PRIVATE METHODS *****************************************************************************
+
+    /**
+     * Creates a unique account
+     *
+     * @param userNamePrefix the user name prefix
+     * @param password       the password
+     * @param testParams     test params about the session
+     * @return the session associated with the newly created account
+     */
+    private fun createAccount(userNamePrefix: String,
+                              password: String,
+                              testParams: SessionTestParams): Session {
+        val session = createAccountAndSync(
+                userNamePrefix + "_" + System.currentTimeMillis() + UUID.randomUUID(),
+                password,
+                testParams
+        )
+        assertNotNull(session)
+        return session
+    }
+
+    /**
+     * Logs into an existing account
+     *
+     * @param userId     the userId to log in
+     * @param password   the password to log in
+     * @param testParams test params about the session
+     * @return the session associated with the existing account
+     */
+    private fun logIntoAccount(userId: String,
+                               password: String,
+                               testParams: SessionTestParams): Session {
+        val session = logAccountAndSync(userId, password, testParams)
+        assertNotNull(session)
+        return session
+    }
+
+    /**
+     * Create an account and a dedicated session
+     *
+     * @param userName          the account username
+     * @param password          the password
+     * @param sessionTestParams parameters for the test
+     */
+    private fun createAccountAndSync(userName: String,
+                                     password: String,
+                                     sessionTestParams: SessionTestParams): Session {
+        val hs = createHomeServerConfig()
+
+        doSync<LoginFlowResult> {
+            matrix.authenticationService
+                    .getLoginFlow(hs, it)
+        }
+
+        doSync<RegistrationResult> {
+            matrix.authenticationService
+                    .getRegistrationWizard()
+                    .createAccount(userName, password, null, it)
+        }
+
+        // Preform dummy step
+        val registrationResult = doSync<RegistrationResult> {
+            matrix.authenticationService
+                    .getRegistrationWizard()
+                    .dummy(it)
+        }
+
+        assertTrue(registrationResult is RegistrationResult.Success)
+        val session = (registrationResult as RegistrationResult.Success).session
+        if (sessionTestParams.withInitialSync) {
+            syncSession(session)
+        }
+
+        return session
+    }
+
+    /**
+     * Start an account login
+     *
+     * @param userName          the account username
+     * @param password          the password
+     * @param sessionTestParams session test params
+     */
+    private fun logAccountAndSync(userName: String,
+                                  password: String,
+                                  sessionTestParams: SessionTestParams): Session {
+        val hs = createHomeServerConfig()
+
+        doSync<LoginFlowResult> {
+            matrix.authenticationService
+                    .getLoginFlow(hs, it)
+        }
+
+        val session = doSync<Session> {
+            matrix.authenticationService
+                    .getLoginWizard()
+                    .login(userName, password, "myDevice", it)
+        }
+
+        if (sessionTestParams.withInitialSync) {
+            syncSession(session)
+        }
+
+        return session
+    }
+
+    /**
+     * 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))
+    }
+
+    // Transform a method with a MatrixCallback to a synchronous method
+    inline fun <reified T> doSync(block: (MatrixCallback<T>) -> Unit): T {
+        val lock = CountDownLatch(1)
+        var result: T? = null
+
+        val callback = object : TestMatrixCallback<T>(lock) {
+            override fun onSuccess(data: T) {
+                result = data
+                super.onSuccess(data)
+            }
+        }
+
+        block.invoke(callback)
+
+        await(lock)
+
+        assertNotNull(result)
+        return result!!
+    }
+
+    /**
+     * Clear all provided sessions
+     */
+    fun Iterable<Session>.signOutAndClose() = forEach { signOutAndClose(it) }
+
+    fun signOutAndClose(session: Session) {
+        doSync<Unit> { session.signOut(true, it) }
+        session.close()
+    }
+}

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

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2018 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.common
+
+import im.vector.matrix.android.api.session.Session
+
+data class CryptoTestData(val firstSession: Session,
+                          val roomId: String,
+                          val secondSession: Session? = null,
+                          val thirdSession: Session? = null) {
+
+    fun cleanUp(testHelper: CommonTestHelper) {
+        testHelper.signOutAndClose(firstSession)
+        secondSession?.let { testHelper.signOutAndClose(it) }
+        thirdSession?.let { testHelper.signOutAndClose(it) }
+    }
+}

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

@@ -0,0 +1,302 @@
+/*
+ * Copyright 2018 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.common
+
+import android.os.SystemClock
+import androidx.lifecycle.Observer
+import im.vector.matrix.android.api.session.Session
+import im.vector.matrix.android.api.session.events.model.Event
+import im.vector.matrix.android.api.session.events.model.EventType
+import im.vector.matrix.android.api.session.events.model.toContent
+import im.vector.matrix.android.api.session.room.model.Membership
+import im.vector.matrix.android.api.session.room.model.RoomSummary
+import im.vector.matrix.android.api.session.room.model.create.CreateRoomParams
+import im.vector.matrix.android.api.session.room.roomSummaryQueryParams
+import im.vector.matrix.android.api.session.room.timeline.Timeline
+import im.vector.matrix.android.api.session.room.timeline.TimelineEvent
+import im.vector.matrix.android.api.session.room.timeline.TimelineSettings
+import im.vector.matrix.android.internal.crypto.MXCRYPTO_ALGORITHM_MEGOLM
+import im.vector.matrix.android.internal.crypto.MXCRYPTO_ALGORITHM_MEGOLM_BACKUP
+import im.vector.matrix.android.internal.crypto.keysbackup.model.MegolmBackupAuthData
+import im.vector.matrix.android.internal.crypto.keysbackup.model.MegolmBackupCreationInfo
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import java.util.HashMap
+import java.util.concurrent.CountDownLatch
+
+class CryptoTestHelper(private val mTestHelper: CommonTestHelper) {
+
+    private val messagesFromAlice: List<String> = listOf("0 - Hello I'm Alice!", "4 - Go!")
+    private val messagesFromBob: List<String> = listOf("1 - Hello I'm Bob!", "2 - Isn't life grand?", "3 - Let's go to the opera.")
+
+    private val defaultSessionParams = SessionTestParams(true)
+
+    /**
+     * @return alice session
+     */
+    fun doE2ETestWithAliceInARoom(): CryptoTestData {
+        val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, defaultSessionParams)
+
+        val roomId = mTestHelper.doSync<String> {
+            aliceSession.createRoom(CreateRoomParams(name = "MyRoom"), it)
+        }
+
+        val room = aliceSession.getRoom(roomId)!!
+
+        mTestHelper.doSync<Unit> {
+            room.enableEncryption(callback = it)
+        }
+
+        return CryptoTestData(aliceSession, roomId)
+    }
+
+    /**
+     * @return alice and bob sessions
+     */
+    fun doE2ETestWithAliceAndBobInARoom(): CryptoTestData {
+        val cryptoTestData = doE2ETestWithAliceInARoom()
+        val aliceSession = cryptoTestData.firstSession
+        val aliceRoomId = cryptoTestData.roomId
+
+        val aliceRoom = aliceSession.getRoom(aliceRoomId)!!
+
+        val bobSession = mTestHelper.createAccount(TestConstants.USER_BOB, defaultSessionParams)
+
+        val lock1 = CountDownLatch(1)
+
+        val bobRoomSummariesLive = runBlocking(Dispatchers.Main) {
+            bobSession.getRoomSummariesLive(roomSummaryQueryParams { })
+        }
+
+        val newRoomObserver = object : Observer<List<RoomSummary>> {
+            override fun onChanged(t: List<RoomSummary>?) {
+                if (t?.isNotEmpty() == true) {
+                    lock1.countDown()
+                    bobRoomSummariesLive.removeObserver(this)
+                }
+            }
+        }
+
+        GlobalScope.launch(Dispatchers.Main) {
+            bobRoomSummariesLive.observeForever(newRoomObserver)
+        }
+
+        mTestHelper.doSync<Unit> {
+            aliceRoom.invite(bobSession.myUserId, callback = it)
+        }
+
+        mTestHelper.await(lock1)
+
+        val lock = CountDownLatch(1)
+
+        val roomJoinedObserver = object : Observer<List<RoomSummary>> {
+            override fun onChanged(t: List<RoomSummary>?) {
+                if (bobSession.getRoom(aliceRoomId)
+                                ?.getRoomMember(aliceSession.myUserId)
+                                ?.membership == Membership.JOIN) {
+                    lock.countDown()
+                    bobRoomSummariesLive.removeObserver(this)
+                }
+            }
+        }
+
+        GlobalScope.launch(Dispatchers.Main) {
+            bobRoomSummariesLive.observeForever(roomJoinedObserver)
+        }
+
+        mTestHelper.doSync<Unit> { bobSession.joinRoom(aliceRoomId, callback = it) }
+
+        mTestHelper.await(lock)
+
+        // Ensure bob can send messages to the room
+//        val roomFromBobPOV = bobSession.getRoom(aliceRoomId)!!
+//        assertNotNull(roomFromBobPOV.powerLevels)
+//        assertTrue(roomFromBobPOV.powerLevels.maySendMessage(bobSession.myUserId))
+
+        return CryptoTestData(aliceSession, aliceRoomId, bobSession)
+    }
+
+    /**
+     * @return Alice, Bob and Sam session
+     */
+    fun doE2ETestWithAliceAndBobAndSamInARoom(): CryptoTestData {
+        val 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"))
+
+        // wait the initial sync
+        SystemClock.sleep(1000)
+
+//        samSession.dataHandler.removeListener(samEventListener)
+
+        return CryptoTestData(aliceSession, aliceRoomId, cryptoTestData.secondSession, samSession)
+    }
+
+    /**
+     * @return Alice and Bob sessions
+     */
+    fun doE2ETestWithAliceAndBobInARoomWithEncryptedMessages(): CryptoTestData {
+        val cryptoTestData = doE2ETestWithAliceAndBobInARoom()
+        val aliceSession = cryptoTestData.firstSession
+        val aliceRoomId = cryptoTestData.roomId
+        val bobSession = cryptoTestData.secondSession!!
+
+        bobSession.cryptoService().setWarnOnUnknownDevices(false)
+
+        aliceSession.cryptoService().setWarnOnUnknownDevices(false)
+
+        val roomFromBobPOV = bobSession.getRoom(aliceRoomId)!!
+        val roomFromAlicePOV = aliceSession.getRoom(aliceRoomId)!!
+
+        val lock = CountDownLatch(1)
+
+        val bobEventsListener = object : Timeline.Listener {
+            override fun onTimelineFailure(throwable: Throwable) {
+                // noop
+            }
+
+            override fun onNewTimelineEvents(eventIds: List<String>) {
+                // noop
+            }
+
+            override fun onTimelineUpdated(snapshot: List<TimelineEvent>) {
+                val messages = snapshot.filter { it.root.getClearType() == EventType.MESSAGE }
+                        .groupBy { it.root.senderId!! }
+
+                // Alice has sent 2 messages and Bob has sent 3 messages
+                if (messages[aliceSession.myUserId]?.size == 2 && messages[bobSession.myUserId]?.size == 3) {
+                    lock.countDown()
+                }
+            }
+        }
+
+        val bobTimeline = roomFromBobPOV.createTimeline(null, TimelineSettings(20))
+        bobTimeline.start()
+        bobTimeline.addListener(bobEventsListener)
+
+        // Alice sends a message
+        roomFromAlicePOV.sendTextMessage(messagesFromAlice[0])
+
+        // Bob send 3 messages
+        roomFromBobPOV.sendTextMessage(messagesFromBob[0])
+        roomFromBobPOV.sendTextMessage(messagesFromBob[1])
+        roomFromBobPOV.sendTextMessage(messagesFromBob[2])
+
+        // Alice sends a message
+        roomFromAlicePOV.sendTextMessage(messagesFromAlice[1])
+
+        mTestHelper.await(lock)
+
+        bobTimeline.removeListener(bobEventsListener)
+        bobTimeline.dispose()
+
+        return cryptoTestData
+    }
+
+    fun checkEncryptedEvent(event: Event, roomId: String, clearMessage: String, senderSession: Session) {
+        assertEquals(EventType.ENCRYPTED, event.type)
+        assertNotNull(event.content)
+
+        val eventWireContent = event.content.toContent()
+        assertNotNull(eventWireContent)
+
+        assertNull(eventWireContent.get("body"))
+        assertEquals(MXCRYPTO_ALGORITHM_MEGOLM, eventWireContent.get("algorithm"))
+
+        assertNotNull(eventWireContent.get("ciphertext"))
+        assertNotNull(eventWireContent.get("session_id"))
+        assertNotNull(eventWireContent.get("sender_key"))
+
+        assertEquals(senderSession.sessionParams.credentials.deviceId, eventWireContent.get("device_id"))
+
+        assertNotNull(event.eventId)
+        assertEquals(roomId, event.roomId)
+        assertEquals(EventType.MESSAGE, event.getClearType())
+        // TODO assertTrue(event.getAge() < 10000)
+
+        val eventContent = event.toContent()
+        assertNotNull(eventContent)
+        assertEquals(clearMessage, eventContent.get("body"))
+        assertEquals(senderSession.myUserId, event.senderId)
+    }
+
+    fun createFakeMegolmBackupAuthData(): MegolmBackupAuthData {
+        return MegolmBackupAuthData(
+                publicKey = "abcdefg",
+                signatures = mapOf("something" to mapOf("ed25519:something" to "hijklmnop"))
+        )
+    }
+
+    fun createFakeMegolmBackupCreationInfo(): MegolmBackupCreationInfo {
+        return MegolmBackupCreationInfo(
+                algorithm = MXCRYPTO_ALGORITHM_MEGOLM_BACKUP,
+                authData = createFakeMegolmBackupAuthData()
+        )
+    }
+}

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

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package im.vector.matrix.android.common
+
+import okhttp3.Interceptor
+import okhttp3.Protocol
+import okhttp3.Request
+import okhttp3.Response
+import okhttp3.ResponseBody.Companion.toResponseBody
+import javax.net.ssl.HttpsURLConnection
+
+/**
+ * Allows to intercept network requests for test purpose by
+ *   - re-writing the response
+ *   - changing the response code (200/404/etc..).
+ *   - Test delays..
+ *
+ * Basic usage:
+ * <code>
+ *     val mockInterceptor = MockOkHttpInterceptor()
+ *      mockInterceptor.addRule(MockOkHttpInterceptor.SimpleRule(".well-known/matrix/client", 200, "{}"))
+ *
+ *      RestHttpClientFactoryProvider.defaultProvider = RestClientHttpClientFactory(mockInterceptor)
+ *      AutoDiscovery().findClientConfig("matrix.org", <callback>)
+ * </code>
+ */
+class MockOkHttpInterceptor : Interceptor {
+
+    private var rules: ArrayList<Rule> = ArrayList()
+
+    fun addRule(rule: Rule) {
+        rules.add(rule)
+    }
+
+    override fun intercept(chain: Interceptor.Chain): Response {
+        val originalRequest = chain.request()
+
+        rules.forEach { rule ->
+            if (originalRequest.url.toString().contains(rule.match)) {
+                rule.process(originalRequest)?.let {
+                    return it
+                }
+            }
+        }
+
+        return chain.proceed(originalRequest)
+    }
+
+    abstract class Rule(val match: String) {
+        abstract fun process(originalRequest: Request): Response?
+    }
+
+    /**
+     * Simple rule that reply with the given body for any request that matches the match param
+     */
+    class SimpleRule(match: String,
+                     private val code: Int = HttpsURLConnection.HTTP_OK,
+                     private val body: String = "{}") : Rule(match) {
+
+        override fun process(originalRequest: Request): Response? {
+            return Response.Builder()
+                    .protocol(Protocol.HTTP_1_1)
+                    .request(originalRequest)
+                    .message("mocked answer")
+                    .body(body.toResponseBody(null))
+                    .code(code)
+                    .build()
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2018 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.common
+
+data class SessionTestParams @JvmOverloads constructor(val withInitialSync: Boolean = false)

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

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2018 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.common
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.fail
+
+/**
+ * Compare two lists and their content
+ */
+fun assertListEquals(list1: List<Any>?, list2: List<Any>?) {
+    if (list1 == null) {
+        assertNull(list2)
+    } else {
+        assertNotNull(list2)
+
+        assertEquals("List sizes must match", list1.size, list2!!.size)
+
+        for (i in list1.indices) {
+            assertEquals("Elements at index $i are not equal", list1[i], list2[i])
+        }
+    }
+}
+
+/**
+ * Compare two maps and their content
+ */
+fun assertDictEquals(dict1: Map<String, Any>?, dict2: Map<String, Any>?) {
+    if (dict1 == null) {
+        assertNull(dict2)
+    } else {
+        assertNotNull(dict2)
+
+        assertEquals("Map sizes must match", dict1.size, dict2!!.size)
+
+        for (i in dict1.keys) {
+            assertEquals("Values for key $i are not equal", dict1[i], dict2[i])
+        }
+    }
+}
+
+/**
+ * Compare two byte arrays content.
+ * Note that if the arrays have not the same size, it also fails.
+ */
+fun assertByteArrayNotEqual(a1: ByteArray, a2: ByteArray) {
+    if (a1.size != a2.size) {
+        fail("Arrays have not the same size.")
+    }
+
+    for (index in a1.indices) {
+        if (a1[index] != a2[index]) {
+            // Difference found!
+            return
+        }
+    }
+
+    fail("Arrays are equals.")
+}

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

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2018 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.common
+
+import android.os.Debug
+
+object TestConstants {
+
+    const val TESTS_HOME_SERVER_URL = "http://10.0.2.2:8080"
+
+    // Time out to use when waiting for server response. 10s
+    private const val AWAIT_TIME_OUT_MILLIS = 10_000
+
+    // Time out to use when waiting for server response, when the debugger is connected. 10 minutes
+    private const val AWAIT_TIME_OUT_WITH_DEBUGGER_MILLIS = 10 * 60_000
+
+    const val USER_ALICE = "Alice"
+    const val USER_BOB = "Bob"
+    const val USER_SAM = "Sam"
+
+    const val PASSWORD = "password"
+
+    val timeOutMillis: Long
+        get() = if (Debug.isDebuggerConnected()) {
+            // Wait more
+            AWAIT_TIME_OUT_WITH_DEBUGGER_MILLIS.toLong()
+        } else {
+            AWAIT_TIME_OUT_MILLIS.toLong()
+        }
+}

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

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2018 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.common
+
+import androidx.annotation.CallSuper
+import im.vector.matrix.android.api.MatrixCallback
+import org.junit.Assert.fail
+import timber.log.Timber
+import java.util.concurrent.CountDownLatch
+
+/**
+ * Simple implementation of MatrixCallback, which count down the CountDownLatch on each API callback
+ * @param onlySuccessful true to fail if an error occurs. This is the default behavior
+ * @param <T>
+ */
+open class TestMatrixCallback<T>(private val countDownLatch: CountDownLatch,
+                                 private val onlySuccessful: Boolean = true) : MatrixCallback<T> {
+
+    @CallSuper
+    override fun onSuccess(data: T) {
+        countDownLatch.countDown()
+    }
+
+    @CallSuper
+    override fun onFailure(failure: Throwable) {
+        Timber.e(failure, "TestApiCallback")
+
+        if (onlySuccessful) {
+            fail("onFailure " + failure.localizedMessage)
+        }
+
+        countDownLatch.countDown()
+    }
+}

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

@@ -0,0 +1,148 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.internal.crypto
+
+import android.os.MemoryFile
+import android.util.Base64
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import im.vector.matrix.android.internal.crypto.attachments.MXEncryptedAttachments
+import im.vector.matrix.android.internal.crypto.model.rest.EncryptedFileInfo
+import im.vector.matrix.android.internal.crypto.model.rest.EncryptedFileKey
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertNotNull
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+import java.io.ByteArrayInputStream
+import java.io.InputStream
+
+/**
+ * Unit tests AttachmentEncryptionTest.
+ */
+@Suppress("SpellCheckingInspection")
+@RunWith(AndroidJUnit4::class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+class AttachmentEncryptionTest {
+
+    private fun checkDecryption(input: String, encryptedFileInfo: EncryptedFileInfo): String {
+        val `in` = Base64.decode(input, Base64.DEFAULT)
+
+        val inputStream: InputStream
+
+        inputStream = if (`in`.isEmpty()) {
+            ByteArrayInputStream(`in`)
+        } else {
+            val memoryFile = MemoryFile("file" + System.currentTimeMillis(), `in`.size)
+            memoryFile.outputStream.write(`in`)
+            memoryFile.inputStream
+        }
+
+        val decryptedStream = MXEncryptedAttachments.decryptAttachment(inputStream, encryptedFileInfo)
+
+        assertNotNull(decryptedStream)
+
+        val buffer = ByteArray(100)
+
+        val len = decryptedStream!!.read(buffer)
+
+        decryptedStream.close()
+
+        return Base64.encodeToString(buffer, 0, len, Base64.DEFAULT).replace("\n".toRegex(), "").replace("=".toRegex(), "")
+    }
+
+    @Test
+    fun checkDecrypt1() {
+        val encryptedFileInfo = EncryptedFileInfo(
+                v = "v2",
+                hashes = mapOf("sha256" to "47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU"),
+                key = EncryptedFileKey(
+                        alg = "A256CTR",
+                        k = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+                        key_ops = listOf("encrypt", "decrypt"),
+                        kty = "oct",
+                        ext = true
+                ),
+                iv = "AAAAAAAAAAAAAAAAAAAAAA",
+                url = "dummyUrl"
+        )
+
+        assertEquals("", checkDecryption("", encryptedFileInfo))
+    }
+
+    @Test
+    fun checkDecrypt2() {
+        val encryptedFileInfo = EncryptedFileInfo(
+                v = "v2",
+                hashes = mapOf("sha256" to "YzF08lARDdOCzJpzuSwsjTNlQc4pHxpdHcXiD/wpK6k"),
+                key = EncryptedFileKey(
+                        alg = "A256CTR",
+                        k = "__________________________________________8",
+                        key_ops = listOf("encrypt", "decrypt"),
+                        kty = "oct",
+                        ext = true
+                ),
+                iv = "//////////8AAAAAAAAAAA",
+                url = "dummyUrl"
+        )
+
+        assertEquals("SGVsbG8sIFdvcmxk", checkDecryption("5xJZTt5cQicm+9f4", encryptedFileInfo))
+    }
+
+    @Test
+    fun checkDecrypt3() {
+        val encryptedFileInfo = EncryptedFileInfo(
+                v = "v2",
+                hashes = mapOf("sha256" to "IOq7/dHHB+mfHfxlRY5XMeCWEwTPmlf4cJcgrkf6fVU"),
+                key = EncryptedFileKey(
+                        alg = "A256CTR",
+                        k = "__________________________________________8",
+                        key_ops = listOf("encrypt", "decrypt"),
+                        kty = "oct",
+                        ext = true
+                ),
+                iv = "//////////8AAAAAAAAAAA",
+                url = "dummyUrl"
+        )
+
+        assertEquals("YWxwaGFudW1lcmljYWxseWFscGhhbnVtZXJpY2FsbHlhbHBoYW51bWVyaWNhbGx5YWxwaGFudW1lcmljYWxseQ",
+                checkDecryption("zhtFStAeFx0s+9L/sSQO+WQMtldqYEHqTxMduJrCIpnkyer09kxJJuA4K+adQE4w+7jZe/vR9kIcqj9rOhDR8Q",
+                        encryptedFileInfo))
+    }
+
+    @Test
+    fun checkDecrypt4() {
+        val encryptedFileInfo = EncryptedFileInfo(
+                v = "v2",
+                hashes = mapOf("sha256" to "LYG/orOViuFwovJpv2YMLSsmVKwLt7pY3f8SYM7KU5E"),
+                key = EncryptedFileKey(
+                        alg = "A256CTR",
+                        k = "__________________________________________8",
+                        key_ops = listOf("encrypt", "decrypt"),
+                        kty = "oct",
+                        ext = true
+                ),
+                iv = "/////////////////////w",
+                url = "dummyUrl"
+        )
+
+        assertNotEquals("YWxwaGFudW1lcmljYWxseWFscGhhbnVtZXJpY2FsbHlhbHBoYW51bWVyaWNhbGx5YWxwaGFudW1lcmljYWxseQ",
+                checkDecryption("tJVNBVJ/vl36UQt4Y5e5m84bRUrQHhcdLPvS/7EkDvlkDLZXamBB6k8THbiawiKZ5Mnq9PZMSSbgOCvmnUBOMA",
+                        encryptedFileInfo))
+    }
+}

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

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

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

@@ -16,20 +16,35 @@
 
 package im.vector.matrix.android.internal.crypto
 
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import im.vector.matrix.android.InstrumentedTest
 import im.vector.matrix.android.internal.crypto.model.OlmSessionWrapper
 import im.vector.matrix.android.internal.crypto.store.IMXCryptoStore
-import org.junit.Assert.*
+import io.realm.Realm
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
 import org.junit.Test
+import org.junit.runner.RunWith
 import org.matrix.olm.OlmAccount
 import org.matrix.olm.OlmManager
 import org.matrix.olm.OlmSession
 
 private const val DUMMY_DEVICE_KEY = "DeviceKey"
 
-class CryptoStoreTest {
+@RunWith(AndroidJUnit4::class)
+class CryptoStoreTest : InstrumentedTest {
 
     private val cryptoStoreHelper = CryptoStoreHelper()
 
+    @Before
+    fun setup() {
+        Realm.init(context())
+    }
+
     @Test
     fun test_metadata_realm_ok() {
         val cryptoStore: IMXCryptoStore = cryptoStoreHelper.createStore()
@@ -114,4 +129,4 @@ class CryptoStoreTest {
         olmAccount1.releaseAccount()
         olmAccount2.releaseAccount()
     }
-}
+}

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

@@ -0,0 +1,208 @@
+/*
+ * Copyright 2018 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.internal.crypto
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+
+/**
+ * Unit tests ExportEncryptionTest.
+ */
+@RunWith(AndroidJUnit4::class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+class ExportEncryptionTest {
+
+    @Test
+    fun checkExportError1() {
+        val password = "password"
+        val input = "-----"
+        var failed = false
+
+        try {
+            MXMegolmExportEncryption.decryptMegolmKeyFile(input.toByteArray(charset("UTF-8")), password)
+        } catch (e: Exception) {
+            failed = true
+        }
+
+        assertTrue(failed)
+    }
+
+    @Test
+    fun checkExportError2() {
+        val password = "password"
+        val input = "-----BEGIN MEGOLM SESSION DATA-----\n" + "-----"
+        var failed = false
+
+        try {
+            MXMegolmExportEncryption.decryptMegolmKeyFile(input.toByteArray(charset("UTF-8")), password)
+        } catch (e: Exception) {
+            failed = true
+        }
+
+        assertTrue(failed)
+    }
+
+    @Test
+    fun checkExportError3() {
+        val password = "password"
+        val input = "-----BEGIN MEGOLM SESSION DATA-----\n" +
+                " AXNhbHRzYWx0c2FsdHNhbHSIiIiIiIiIiIiIiIiIiIiIAAAACmIRUW2OjZ3L2l6j9h0lHlV3M2dx\n" +
+                " cissyYBxjsfsAn\n" +
+                " -----END MEGOLM SESSION DATA-----"
+        var failed = false
+
+        try {
+            MXMegolmExportEncryption.decryptMegolmKeyFile(input.toByteArray(charset("UTF-8")), password)
+        } catch (e: Exception) {
+            failed = true
+        }
+
+        assertTrue(failed)
+    }
+
+    @Test
+    fun checkExportDecrypt1() {
+        val password = "password"
+        val input = "-----BEGIN MEGOLM SESSION DATA-----\nAXNhbHRzYWx0c2FsdHNhbHSIiIiIiIiIiIiIiIiIiIiIAAAACmIRUW2OjZ3L2l6j9h0lHlV3M2dx\n" + "cissyYBxjsfsAndErh065A8=\n-----END MEGOLM SESSION DATA-----"
+        val expectedString = "plain"
+
+        var decodedString: String? = null
+        try {
+            decodedString = MXMegolmExportEncryption.decryptMegolmKeyFile(input.toByteArray(charset("UTF-8")), password)
+        } catch (e: Exception) {
+            fail("## checkExportDecrypt1() failed : " + e.message)
+        }
+
+        assertEquals("## checkExportDecrypt1() : expectedString $expectedString -- decodedString $decodedString",
+                expectedString,
+                decodedString)
+    }
+
+    @Test
+    fun checkExportDecrypt2() {
+        val password = "betterpassword"
+        val input = "-----BEGIN MEGOLM SESSION DATA-----\nAW1vcmVzYWx0bW9yZXNhbHT//////////wAAAAAAAAAAAAAD6KyBpe1Niv5M5NPm4ZATsJo5nghk\n" + "KYu63a0YQ5DRhUWEKk7CcMkrKnAUiZny\n-----END MEGOLM SESSION DATA-----"
+        val expectedString = "Hello, World"
+
+        var decodedString: String? = null
+        try {
+            decodedString = MXMegolmExportEncryption.decryptMegolmKeyFile(input.toByteArray(charset("UTF-8")), password)
+        } catch (e: Exception) {
+            fail("## checkExportDecrypt2() failed : " + e.message)
+        }
+
+        assertEquals("## checkExportDecrypt2() : expectedString $expectedString -- decodedString $decodedString",
+                expectedString,
+                decodedString)
+    }
+
+    @Test
+    fun checkExportDecrypt3() {
+        val password = "SWORDFISH"
+        val input = "-----BEGIN MEGOLM SESSION DATA-----\nAXllc3NhbHR5Z29vZG5lc3P//////////wAAAAAAAAAAAAAD6OIW+Je7gwvjd4kYrb+49gKCfExw\n" + "MgJBMD4mrhLkmgAngwR1pHjbWXaoGybtiAYr0moQ93GrBQsCzPbvl82rZhaXO3iH5uHo/RCEpOqp\nPgg29363BGR+/Ripq/VCLKGNbw==\n-----END MEGOLM SESSION DATA-----"
+        val expectedString = "alphanumericallyalphanumericallyalphanumericallyalphanumerically"
+
+        var decodedString: String? = null
+        try {
+            decodedString = MXMegolmExportEncryption.decryptMegolmKeyFile(input.toByteArray(charset("UTF-8")), password)
+        } catch (e: Exception) {
+            fail("## checkExportDecrypt3() failed : " + e.message)
+        }
+
+        assertEquals("## checkExportDecrypt3() : expectedString $expectedString -- decodedString $decodedString",
+                expectedString,
+                decodedString)
+    }
+
+    @Test
+    fun checkExportEncrypt1() {
+        val password = "password"
+        val expectedString = "plain"
+        var decodedString: String? = null
+
+        try {
+            decodedString = MXMegolmExportEncryption
+                    .decryptMegolmKeyFile(MXMegolmExportEncryption.encryptMegolmKeyFile(expectedString, password, 1000), password)
+        } catch (e: Exception) {
+            fail("## checkExportEncrypt1() failed : " + e.message)
+        }
+
+        assertEquals("## checkExportEncrypt1() : expectedString $expectedString -- decodedString $decodedString",
+                expectedString,
+                decodedString)
+    }
+
+    @Test
+    fun checkExportEncrypt2() {
+        val password = "betterpassword"
+        val expectedString = "Hello, World"
+        var decodedString: String? = null
+
+        try {
+            decodedString = MXMegolmExportEncryption
+                    .decryptMegolmKeyFile(MXMegolmExportEncryption.encryptMegolmKeyFile(expectedString, password, 1000), password)
+        } catch (e: Exception) {
+            fail("## checkExportEncrypt2() failed : " + e.message)
+        }
+
+        assertEquals("## checkExportEncrypt2() : expectedString $expectedString -- decodedString $decodedString",
+                expectedString,
+                decodedString)
+    }
+
+    @Test
+    fun checkExportEncrypt3() {
+        val password = "SWORDFISH"
+        val expectedString = "alphanumericallyalphanumericallyalphanumericallyalphanumerically"
+        var decodedString: String? = null
+
+        try {
+            decodedString = MXMegolmExportEncryption
+                    .decryptMegolmKeyFile(MXMegolmExportEncryption.encryptMegolmKeyFile(expectedString, password, 1000), password)
+        } catch (e: Exception) {
+            fail("## checkExportEncrypt3() failed : " + e.message)
+        }
+
+        assertEquals("## checkExportEncrypt3() : expectedString $expectedString -- decodedString $decodedString",
+                expectedString,
+                decodedString)
+    }
+
+    @Test
+    fun checkExportEncrypt4() {
+        val password = "passwordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpassword" + "passwordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpasswordpassword"
+        val expectedString = "alphanumericallyalphanumericallyalphanumericallyalphanumerically"
+        var decodedString: String? = null
+
+        try {
+            decodedString = MXMegolmExportEncryption
+                    .decryptMegolmKeyFile(MXMegolmExportEncryption.encryptMegolmKeyFile(expectedString, password, 1000), password)
+        } catch (e: Exception) {
+            fail("## checkExportEncrypt4() failed : " + e.message)
+        }
+
+        assertEquals("## checkExportEncrypt4() : expectedString $expectedString -- decodedString $decodedString",
+                expectedString,
+                decodedString)
+    }
+}

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

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.internal.crypto.crosssigning
+
+import org.amshove.kluent.shouldBeNull
+import org.amshove.kluent.shouldBeTrue
+import org.junit.Test
+
+@Suppress("SpellCheckingInspection")
+class ExtensionsKtTest {
+
+    @Test
+    fun testComparingBase64StringWithOrWithoutPadding() {
+        // Without padding
+        "NMJyumnhMic".fromBase64().contentEquals("NMJyumnhMic".fromBase64()).shouldBeTrue()
+        // With padding
+        "NMJyumnhMic".fromBase64().contentEquals("NMJyumnhMic=".fromBase64()).shouldBeTrue()
+    }
+
+    @Test
+    fun testBadBase64() {
+        "===".fromBase64Safe().shouldBeNull()
+    }
+}

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

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

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

@@ -0,0 +1,180 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.internal.crypto.keysbackup
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import im.vector.matrix.android.InstrumentedTest
+import im.vector.matrix.android.api.listeners.ProgressListener
+import im.vector.matrix.android.common.assertByteArrayNotEqual
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+import org.matrix.olm.OlmManager
+import org.matrix.olm.OlmPkDecryption
+
+@RunWith(AndroidJUnit4::class)
+@FixMethodOrder(MethodSorters.JVM)
+class KeysBackupPasswordTest : InstrumentedTest {
+
+    @Before
+    fun ensureLibLoaded() {
+        OlmManager()
+    }
+
+    /**
+     * Check KeysBackupPassword utilities
+     */
+    @Test
+    fun passwordConverter_ok() {
+        val generatePrivateKeyResult = generatePrivateKeyWithPassword(PASSWORD, null)
+
+        assertEquals(32, generatePrivateKeyResult.salt.length)
+        assertEquals(500_000, generatePrivateKeyResult.iterations)
+        assertEquals(OlmPkDecryption.privateKeyLength(), generatePrivateKeyResult.privateKey.size)
+
+        // Reverse operation
+        val retrievedPrivateKey = retrievePrivateKeyWithPassword(PASSWORD,
+                generatePrivateKeyResult.salt,
+                generatePrivateKeyResult.iterations)
+
+        assertEquals(OlmPkDecryption.privateKeyLength(), retrievedPrivateKey.size)
+        assertArrayEquals(generatePrivateKeyResult.privateKey, retrievedPrivateKey)
+    }
+
+    /**
+     * Check generatePrivateKeyWithPassword progress listener behavior
+     */
+    @Test
+    fun passwordConverter_progress_ok() {
+        val progressValues = ArrayList<Int>(101)
+        var lastTotal = 0
+
+        generatePrivateKeyWithPassword(PASSWORD, object : ProgressListener {
+            override fun onProgress(progress: Int, total: Int) {
+                if (!progressValues.contains(progress)) {
+                    progressValues.add(progress)
+                }
+
+                lastTotal = total
+            }
+        })
+
+        assertEquals(100, lastTotal)
+
+        // Ensure all values are here
+        assertEquals(101, progressValues.size)
+
+        for (i in 0..100) {
+            assertTrue(progressValues[i] == i)
+        }
+    }
+
+    /**
+     * Check KeysBackupPassword utilities, with bad password
+     */
+    @Test
+    fun passwordConverter_badPassword_ok() {
+        val generatePrivateKeyResult = generatePrivateKeyWithPassword(PASSWORD, null)
+
+        assertEquals(32, generatePrivateKeyResult.salt.length)
+        assertEquals(500_000, generatePrivateKeyResult.iterations)
+        assertEquals(OlmPkDecryption.privateKeyLength(), generatePrivateKeyResult.privateKey.size)
+
+        // Reverse operation, with bad password
+        val retrievedPrivateKey = retrievePrivateKeyWithPassword(BAD_PASSWORD,
+                generatePrivateKeyResult.salt,
+                generatePrivateKeyResult.iterations)
+
+        assertEquals(OlmPkDecryption.privateKeyLength(), retrievedPrivateKey.size)
+        assertByteArrayNotEqual(generatePrivateKeyResult.privateKey, retrievedPrivateKey)
+    }
+
+    /**
+     * Check KeysBackupPassword utilities, with bad password
+     */
+    @Test
+    fun passwordConverter_badIteration_ok() {
+        val generatePrivateKeyResult = generatePrivateKeyWithPassword(PASSWORD, null)
+
+        assertEquals(32, generatePrivateKeyResult.salt.length)
+        assertEquals(500_000, generatePrivateKeyResult.iterations)
+        assertEquals(OlmPkDecryption.privateKeyLength(), generatePrivateKeyResult.privateKey.size)
+
+        // Reverse operation, with bad iteration
+        val retrievedPrivateKey = retrievePrivateKeyWithPassword(PASSWORD,
+                generatePrivateKeyResult.salt,
+                500_001)
+
+        assertEquals(OlmPkDecryption.privateKeyLength(), retrievedPrivateKey.size)
+        assertByteArrayNotEqual(generatePrivateKeyResult.privateKey, retrievedPrivateKey)
+    }
+
+    /**
+     * Check KeysBackupPassword utilities, with bad salt
+     */
+    @Test
+    fun passwordConverter_badSalt_ok() {
+        val generatePrivateKeyResult = generatePrivateKeyWithPassword(PASSWORD, null)
+
+        assertEquals(32, generatePrivateKeyResult.salt.length)
+        assertEquals(500_000, generatePrivateKeyResult.iterations)
+        assertEquals(OlmPkDecryption.privateKeyLength(), generatePrivateKeyResult.privateKey.size)
+
+        // Reverse operation, with bad iteration
+        val retrievedPrivateKey = retrievePrivateKeyWithPassword(PASSWORD,
+                BAD_SALT,
+                generatePrivateKeyResult.iterations)
+
+        assertEquals(OlmPkDecryption.privateKeyLength(), retrievedPrivateKey.size)
+        assertByteArrayNotEqual(generatePrivateKeyResult.privateKey, retrievedPrivateKey)
+    }
+
+    /**
+     * Check [retrievePrivateKeyWithPassword] with data coming from another platform (RiotWeb).
+     */
+    @Test
+    fun passwordConverter_crossPlatform_ok() {
+        val password = "This is a passphrase!"
+        val salt = "TO0lxhQ9aYgGfMsclVWPIAublg8h9Nlu"
+        val iteration = 500_000
+
+        val retrievedPrivateKey = retrievePrivateKeyWithPassword(password, salt, iteration)
+
+        assertEquals(OlmPkDecryption.privateKeyLength(), retrievedPrivateKey.size)
+
+        // Data from RiotWeb
+        val privateKeyBytes = byteArrayOf(
+                116.toByte(), 224.toByte(), 229.toByte(), 224.toByte(), 9.toByte(), 3.toByte(), 178.toByte(), 162.toByte(),
+                120.toByte(), 23.toByte(), 108.toByte(), 218.toByte(), 22.toByte(), 61.toByte(), 241.toByte(), 200.toByte(),
+                235.toByte(), 173.toByte(), 236.toByte(), 100.toByte(), 115.toByte(), 247.toByte(), 33.toByte(), 132.toByte(),
+                195.toByte(), 154.toByte(), 64.toByte(), 158.toByte(), 184.toByte(), 148.toByte(), 20.toByte(), 85.toByte())
+
+        assertArrayEquals(privateKeyBytes, retrievedPrivateKey)
+    }
+
+    companion object {
+        private const val PASSWORD = "password"
+        private const val BAD_PASSWORD = "passw0rd"
+
+        private const val BAD_SALT = "AA0lxhQ9aYgGfMsclVWPIAublg8h9Nlu"
+    }
+}

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

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.internal.crypto.keysbackup
+
+import im.vector.matrix.android.api.session.crypto.keysbackup.KeysBackupService
+import im.vector.matrix.android.api.session.crypto.keysbackup.KeysBackupState
+import im.vector.matrix.android.api.session.crypto.keysbackup.KeysBackupStateListener
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import java.util.concurrent.CountDownLatch
+
+/**
+ * This class observe the state change of a KeysBackup object and provide a method to check the several state change
+ * It checks all state transitions and detected forbidden transition
+ */
+internal class StateObserver(private val keysBackup: KeysBackupService,
+                             private val latch: CountDownLatch? = null,
+                             private val expectedStateChange: Int = -1) : KeysBackupStateListener {
+
+    private val allowedStateTransitions = listOf(
+            KeysBackupState.BackingUp to KeysBackupState.ReadyToBackUp,
+            KeysBackupState.BackingUp to KeysBackupState.WrongBackUpVersion,
+
+            KeysBackupState.CheckingBackUpOnHomeserver to KeysBackupState.Disabled,
+            KeysBackupState.CheckingBackUpOnHomeserver to KeysBackupState.NotTrusted,
+            KeysBackupState.CheckingBackUpOnHomeserver to KeysBackupState.ReadyToBackUp,
+            KeysBackupState.CheckingBackUpOnHomeserver to KeysBackupState.Unknown,
+            KeysBackupState.CheckingBackUpOnHomeserver to KeysBackupState.WrongBackUpVersion,
+
+            KeysBackupState.Disabled to KeysBackupState.Enabling,
+
+            KeysBackupState.Enabling to KeysBackupState.Disabled,
+            KeysBackupState.Enabling to KeysBackupState.ReadyToBackUp,
+
+            KeysBackupState.NotTrusted to KeysBackupState.CheckingBackUpOnHomeserver,
+            // This transition happens when we trust the device
+            KeysBackupState.NotTrusted to KeysBackupState.ReadyToBackUp,
+
+            KeysBackupState.ReadyToBackUp to KeysBackupState.WillBackUp,
+
+            KeysBackupState.Unknown to KeysBackupState.CheckingBackUpOnHomeserver,
+
+            KeysBackupState.WillBackUp to KeysBackupState.BackingUp,
+
+            KeysBackupState.WrongBackUpVersion to KeysBackupState.CheckingBackUpOnHomeserver,
+
+            // FIXME These transitions are observed during test, and I'm not sure they should occur. Don't have time to investigate now
+            KeysBackupState.ReadyToBackUp to KeysBackupState.BackingUp,
+            KeysBackupState.ReadyToBackUp to KeysBackupState.ReadyToBackUp,
+            KeysBackupState.WillBackUp to KeysBackupState.ReadyToBackUp,
+            KeysBackupState.WillBackUp to KeysBackupState.Unknown
+    )
+
+    private val stateList = ArrayList<KeysBackupState>()
+    private var lastTransitionError: String? = null
+
+    init {
+        keysBackup.addListener(this)
+    }
+
+    // TODO Make expectedStates mandatory to enforce test
+    fun stopAndCheckStates(expectedStates: List<KeysBackupState>?) {
+        keysBackup.removeListener(this)
+
+        expectedStates?.let {
+            assertEquals(it.size, stateList.size)
+
+            for (i in it.indices) {
+                assertEquals("The state $i is not correct. states: " + stateList.joinToString(separator = " "), it[i], stateList[i])
+            }
+        }
+
+        assertNull("states: " + stateList.joinToString(separator = " "), lastTransitionError)
+    }
+
+    override fun onStateChange(newState: KeysBackupState) {
+        stateList.add(newState)
+
+        // Check that state transition is valid
+        if (stateList.size >= 2
+                && !allowedStateTransitions.contains(stateList[stateList.size - 2] to newState)) {
+            // Forbidden transition detected
+            lastTransitionError = "Forbidden transition detected from " + stateList[stateList.size - 2] + " to " + newState
+        }
+
+        if (expectedStateChange == stateList.size) {
+            latch?.countDown()
+        }
+    }
+}

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

@@ -0,0 +1,363 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.internal.crypto.ssss
+
+import androidx.lifecycle.Observer
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import im.vector.matrix.android.InstrumentedTest
+import im.vector.matrix.android.api.MatrixCallback
+import im.vector.matrix.android.api.session.Session
+import im.vector.matrix.android.api.session.securestorage.EncryptedSecretContent
+import im.vector.matrix.android.api.session.securestorage.KeySigner
+import im.vector.matrix.android.api.session.securestorage.RawBytesKeySpec
+import im.vector.matrix.android.api.session.securestorage.SecretStorageKeyContent
+import im.vector.matrix.android.api.session.securestorage.SharedSecretStorageService
+import im.vector.matrix.android.api.session.securestorage.SsssKeyCreationInfo
+import im.vector.matrix.android.api.util.Optional
+import im.vector.matrix.android.common.CommonTestHelper
+import im.vector.matrix.android.common.SessionTestParams
+import im.vector.matrix.android.common.TestConstants
+import im.vector.matrix.android.common.TestMatrixCallback
+import im.vector.matrix.android.internal.crypto.SSSS_ALGORITHM_AES_HMAC_SHA2
+import im.vector.matrix.android.internal.crypto.crosssigning.toBase64NoPadding
+import im.vector.matrix.android.internal.crypto.secrets.DefaultSharedSecretStorageService
+import im.vector.matrix.android.internal.session.sync.model.accountdata.UserAccountDataEvent
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import org.amshove.kluent.shouldBe
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+import java.util.concurrent.CountDownLatch
+
+@RunWith(AndroidJUnit4::class)
+@FixMethodOrder(MethodSorters.JVM)
+class QuadSTests : InstrumentedTest {
+
+    private val mTestHelper = CommonTestHelper(context())
+
+    private val emptyKeySigner = object : KeySigner {
+        override fun sign(canonicalJson: String): Map<String, Map<String, String>>? {
+            return null
+        }
+    }
+
+    @Test
+    fun test_Generate4SKey() {
+        val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true))
+
+        val quadS = aliceSession.sharedSecretStorageService
+
+        val TEST_KEY_ID = "my.test.Key"
+
+        mTestHelper.doSync<SsssKeyCreationInfo> {
+            quadS.generateKey(TEST_KEY_ID, "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.get("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, "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, keyId, emptyKeySigner, it)
+        }
+
+        assertAccountData(session, "${DefaultSharedSecretStorageService.KEY_ID_BASE}.$keyId")
+
+        if (asDefault) {
+            mTestHelper.doSync<Unit> {
+                quadS.setDefaultKey(keyId, it)
+            }
+            assertAccountData(session, DefaultSharedSecretStorageService.DEFAULT_KEY_ID)
+        }
+
+        return creationInfo
+    }
+
+    private fun generatedSecretFromPassphrase(session: Session, passphrase: String, keyId: String, asDefault: Boolean = true): SsssKeyCreationInfo {
+        val quadS = session.sharedSecretStorageService
+
+        val creationInfo = mTestHelper.doSync<SsssKeyCreationInfo> {
+            quadS.generateKeyWithPassphrase(
+                    keyId,
+                    keyId,
+                    passphrase,
+                    emptyKeySigner,
+                    null,
+                    it)
+        }
+
+        assertAccountData(session, "${DefaultSharedSecretStorageService.KEY_ID_BASE}.$keyId")
+        if (asDefault) {
+            val setDefaultLatch = CountDownLatch(1)
+            quadS.setDefaultKey(keyId, TestMatrixCallback(setDefaultLatch))
+            mTestHelper.await(setDefaultLatch)
+            assertAccountData(session, DefaultSharedSecretStorageService.DEFAULT_KEY_ID)
+        }
+
+        return creationInfo
+    }
+}

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

@@ -0,0 +1,518 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.internal.crypto.verification
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import im.vector.matrix.android.InstrumentedTest
+import im.vector.matrix.android.api.session.Session
+import im.vector.matrix.android.api.session.crypto.verification.CancelCode
+import im.vector.matrix.android.api.session.crypto.verification.IncomingSasVerificationTransaction
+import im.vector.matrix.android.api.session.crypto.verification.OutgoingSasVerificationTransaction
+import im.vector.matrix.android.api.session.crypto.verification.SasMode
+import im.vector.matrix.android.api.session.crypto.verification.VerificationMethod
+import im.vector.matrix.android.api.session.crypto.verification.VerificationService
+import im.vector.matrix.android.api.session.crypto.verification.VerificationTransaction
+import im.vector.matrix.android.api.session.crypto.verification.VerificationTxState
+import im.vector.matrix.android.api.session.events.model.Event
+import im.vector.matrix.android.api.session.events.model.toModel
+import im.vector.matrix.android.common.CommonTestHelper
+import im.vector.matrix.android.common.CryptoTestHelper
+import im.vector.matrix.android.internal.crypto.model.CryptoDeviceInfo
+import im.vector.matrix.android.internal.crypto.model.MXUsersDevicesMap
+import im.vector.matrix.android.internal.crypto.model.rest.KeyVerificationCancel
+import im.vector.matrix.android.internal.crypto.model.rest.KeyVerificationStart
+import im.vector.matrix.android.internal.crypto.model.rest.toValue
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+import java.util.concurrent.CountDownLatch
+
+@RunWith(AndroidJUnit4::class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+class SASTest : InstrumentedTest {
+    private val mTestHelper = CommonTestHelper(context())
+    private val mCryptoTestHelper = CryptoTestHelper(mTestHelper)
+
+    @Test
+    fun test_aliceStartThenAliceCancel() {
+        val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom()
+
+        val aliceSession = cryptoTestData.firstSession
+        val bobSession = cryptoTestData.secondSession
+
+        val aliceVerificationService = aliceSession.cryptoService().verificationService()
+        val bobVerificationService = bobSession!!.cryptoService().verificationService()
+
+        val bobTxCreatedLatch = CountDownLatch(1)
+        val bobListener = object : VerificationService.Listener {
+            override fun transactionUpdated(tx: VerificationTransaction) {
+                bobTxCreatedLatch.countDown()
+            }
+        }
+        bobVerificationService.addListener(bobListener)
+
+        val txID = aliceVerificationService.beginKeyVerification(VerificationMethod.SAS,
+                bobSession.myUserId,
+                bobSession.cryptoService().getMyDevice().deviceId,
+                null)
+        assertNotNull("Alice should have a started transaction", txID)
+
+        val aliceKeyTx = aliceVerificationService.getExistingTransaction(bobSession.myUserId, txID!!)
+        assertNotNull("Alice should have a started transaction", aliceKeyTx)
+
+        mTestHelper.await(bobTxCreatedLatch)
+        bobVerificationService.removeListener(bobListener)
+
+        val bobKeyTx = bobVerificationService.getExistingTransaction(aliceSession.myUserId, txID)
+
+        assertNotNull("Bob should have started verif transaction", bobKeyTx)
+        assertTrue(bobKeyTx is SASDefaultVerificationTransaction)
+        assertNotNull("Bob should have starting a SAS transaction", bobKeyTx)
+        assertTrue(aliceKeyTx is SASDefaultVerificationTransaction)
+        assertEquals("Alice and Bob have same transaction id", aliceKeyTx!!.transactionId, bobKeyTx!!.transactionId)
+
+        val aliceSasTx = aliceKeyTx as SASDefaultVerificationTransaction?
+        val bobSasTx = bobKeyTx as SASDefaultVerificationTransaction?
+
+        assertEquals("Alice state should be started", VerificationTxState.Started, aliceSasTx!!.state)
+        assertEquals("Bob state should be started by alice", VerificationTxState.OnStarted, bobSasTx!!.state)
+
+        // Let's cancel from alice side
+        val cancelLatch = CountDownLatch(1)
+
+        val bobListener2 = object : VerificationService.Listener {
+            override fun transactionUpdated(tx: VerificationTransaction) {
+                if (tx.transactionId == txID) {
+                    val immutableState = (tx as SASDefaultVerificationTransaction).state
+                    if (immutableState is VerificationTxState.Cancelled && !immutableState.byMe) {
+                        cancelLatch.countDown()
+                    }
+                }
+            }
+        }
+        bobVerificationService.addListener(bobListener2)
+
+        aliceSasTx.cancel(CancelCode.User)
+        mTestHelper.await(cancelLatch)
+
+        assertTrue("Should be cancelled on alice side", aliceSasTx.state is VerificationTxState.Cancelled)
+        assertTrue("Should be cancelled on bob side", bobSasTx.state is VerificationTxState.Cancelled)
+
+        val aliceCancelState = aliceSasTx.state as VerificationTxState.Cancelled
+        val bobCancelState = bobSasTx.state as VerificationTxState.Cancelled
+
+        assertTrue("Should be cancelled by me on alice side", aliceCancelState.byMe)
+        assertFalse("Should be cancelled by other on bob side", bobCancelState.byMe)
+
+        assertEquals("Should be User cancelled on alice side", CancelCode.User, aliceCancelState.cancelCode)
+        assertEquals("Should be User cancelled on bob side", CancelCode.User, bobCancelState.cancelCode)
+
+        assertNull(bobVerificationService.getExistingTransaction(aliceSession.myUserId, txID))
+        assertNull(aliceVerificationService.getExistingTransaction(bobSession.myUserId, txID))
+
+        cryptoTestData.cleanUp(mTestHelper)
+    }
+
+    @Test
+    fun test_key_agreement_protocols_must_include_curve25519() {
+        fail("Not passing for the moment")
+        val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom()
+
+        val bobSession = cryptoTestData.secondSession!!
+
+        val protocols = listOf("meh_dont_know")
+        val tid = "00000000"
+
+        // Bob should receive a cancel
+        var cancelReason: CancelCode? = null
+        val cancelLatch = CountDownLatch(1)
+
+        val bobListener = object : VerificationService.Listener {
+            override fun transactionUpdated(tx: VerificationTransaction) {
+                if (tx.transactionId == tid && tx.state is VerificationTxState.Cancelled) {
+                    cancelReason = (tx.state as VerificationTxState.Cancelled).cancelCode
+                    cancelLatch.countDown()
+                }
+            }
+        }
+        bobSession.cryptoService().verificationService().addListener(bobListener)
+
+        // TODO bobSession!!.dataHandler.addListener(object : MXEventListener() {
+        // TODO     override fun onToDeviceEvent(event: Event?) {
+        // TODO         if (event!!.getType() == CryptoEvent.EVENT_TYPE_KEY_VERIFICATION_CANCEL) {
+        // TODO             if (event.contentAsJsonObject?.get("transaction_id")?.asString == tid) {
+        // TODO                 canceledToDeviceEvent = event
+        // TODO                 cancelLatch.countDown()
+        // TODO             }
+        // TODO         }
+        // TODO     }
+        // TODO })
+
+        val aliceSession = cryptoTestData.firstSession
+        val aliceUserID = aliceSession.myUserId
+        val aliceDevice = aliceSession.cryptoService().getMyDevice().deviceId
+
+        val aliceListener = object : VerificationService.Listener {
+            override fun transactionUpdated(tx: VerificationTransaction) {
+                if ((tx as IncomingSasVerificationTransaction).uxState === IncomingSasVerificationTransaction.UxState.SHOW_ACCEPT) {
+                    (tx as IncomingSasVerificationTransaction).performAccept()
+                }
+            }
+        }
+        aliceSession.cryptoService().verificationService().addListener(aliceListener)
+
+        fakeBobStart(bobSession, aliceUserID, aliceDevice, tid, protocols = protocols)
+
+        mTestHelper.await(cancelLatch)
+
+        assertEquals("Request should be cancelled with m.unknown_method", CancelCode.UnknownMethod, cancelReason)
+
+        cryptoTestData.cleanUp(mTestHelper)
+    }
+
+    @Test
+    fun test_key_agreement_macs_Must_include_hmac_sha256() {
+        fail("Not passing for the moment")
+        val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom()
+
+        val bobSession = cryptoTestData.secondSession!!
+
+        val mac = listOf("shaBit")
+        val tid = "00000000"
+
+        // Bob should receive a cancel
+        var canceledToDeviceEvent: Event? = null
+        val cancelLatch = CountDownLatch(1)
+        // TODO bobSession!!.dataHandler.addListener(object : MXEventListener() {
+        // TODO     override fun onToDeviceEvent(event: Event?) {
+        // TODO         if (event!!.getType() == CryptoEvent.EVENT_TYPE_KEY_VERIFICATION_CANCEL) {
+        // TODO             if (event.contentAsJsonObject?.get("transaction_id")?.asString == tid) {
+        // TODO                 canceledToDeviceEvent = event
+        // TODO                 cancelLatch.countDown()
+        // TODO             }
+        // TODO         }
+        // TODO     }
+        // TODO })
+
+        val aliceSession = cryptoTestData.firstSession
+        val aliceUserID = aliceSession.myUserId
+        val aliceDevice = aliceSession.cryptoService().getMyDevice().deviceId
+
+        fakeBobStart(bobSession, aliceUserID, aliceDevice, tid, mac = mac)
+
+        mTestHelper.await(cancelLatch)
+
+        val cancelReq = canceledToDeviceEvent!!.content.toModel<KeyVerificationCancel>()!!
+        assertEquals("Request should be cancelled with m.unknown_method", CancelCode.UnknownMethod.value, cancelReq.code)
+
+        cryptoTestData.cleanUp(mTestHelper)
+    }
+
+    @Test
+    fun test_key_agreement_short_code_include_decimal() {
+        fail("Not passing for the moment")
+        val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom()
+
+        val bobSession = cryptoTestData.secondSession!!
+
+        val codes = listOf("bin", "foo", "bar")
+        val tid = "00000000"
+
+        // Bob should receive a cancel
+        var canceledToDeviceEvent: Event? = null
+        val cancelLatch = CountDownLatch(1)
+        // TODO bobSession!!.dataHandler.addListener(object : MXEventListener() {
+        // TODO     override fun onToDeviceEvent(event: Event?) {
+        // TODO         if (event!!.getType() == CryptoEvent.EVENT_TYPE_KEY_VERIFICATION_CANCEL) {
+        // TODO             if (event.contentAsJsonObject?.get("transaction_id")?.asString == tid) {
+        // TODO                 canceledToDeviceEvent = event
+        // TODO                 cancelLatch.countDown()
+        // TODO             }
+        // TODO         }
+        // TODO     }
+        // TODO })
+
+        val aliceSession = cryptoTestData.firstSession
+        val aliceUserID = aliceSession.myUserId
+        val aliceDevice = aliceSession.cryptoService().getMyDevice().deviceId
+
+        fakeBobStart(bobSession, aliceUserID, aliceDevice, tid, codes = codes)
+
+        mTestHelper.await(cancelLatch)
+
+        val cancelReq = canceledToDeviceEvent!!.content.toModel<KeyVerificationCancel>()!!
+        assertEquals("Request should be cancelled with m.unknown_method", CancelCode.UnknownMethod.value, cancelReq.code)
+
+        cryptoTestData.cleanUp(mTestHelper)
+    }
+
+    private fun fakeBobStart(bobSession: Session,
+                             aliceUserID: String?,
+                             aliceDevice: String?,
+                             tid: String,
+                             protocols: List<String> = SASDefaultVerificationTransaction.KNOWN_AGREEMENT_PROTOCOLS,
+                             hashes: List<String> = SASDefaultVerificationTransaction.KNOWN_HASHES,
+                             mac: List<String> = SASDefaultVerificationTransaction.KNOWN_MACS,
+                             codes: List<String> = SASDefaultVerificationTransaction.KNOWN_SHORT_CODES) {
+        val startMessage = KeyVerificationStart(
+                fromDevice = bobSession.cryptoService().getMyDevice().deviceId,
+                method = VerificationMethod.SAS.toValue(),
+                transactionId = tid,
+                keyAgreementProtocols = protocols,
+                hashes = hashes,
+                messageAuthenticationCodes = mac,
+                shortAuthenticationStrings = codes
+        )
+
+        val contentMap = MXUsersDevicesMap<Any>()
+        contentMap.setObject(aliceUserID, aliceDevice, startMessage)
+
+        // TODO val sendLatch = CountDownLatch(1)
+        // TODO bobSession.cryptoRestClient.sendToDevice(
+        // TODO         EventType.KEY_VERIFICATION_START,
+        // TODO         contentMap,
+        // TODO         tid,
+        // TODO         TestMatrixCallback<Void>(sendLatch)
+        // TODO )
+    }
+
+    // any two devices may only have at most one key verification in flight at a time.
+    // If a device has two verifications in progress with the same device, then it should cancel both verifications.
+    @Test
+    fun test_aliceStartTwoRequests() {
+        val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom()
+
+        val aliceSession = cryptoTestData.firstSession
+        val bobSession = cryptoTestData.secondSession
+
+        val aliceVerificationService = aliceSession.cryptoService().verificationService()
+
+        val aliceCreatedLatch = CountDownLatch(2)
+        val aliceCancelledLatch = CountDownLatch(2)
+        val createdTx = mutableListOf<SASDefaultVerificationTransaction>()
+        val aliceListener = object : VerificationService.Listener {
+            override fun transactionCreated(tx: VerificationTransaction) {
+                createdTx.add(tx as SASDefaultVerificationTransaction)
+                aliceCreatedLatch.countDown()
+            }
+
+            override fun transactionUpdated(tx: VerificationTransaction) {
+                if ((tx as SASDefaultVerificationTransaction).state is VerificationTxState.Cancelled && !(tx.state as VerificationTxState.Cancelled).byMe) {
+                    aliceCancelledLatch.countDown()
+                }
+            }
+        }
+        aliceVerificationService.addListener(aliceListener)
+
+        val bobUserId = bobSession!!.myUserId
+        val bobDeviceId = bobSession.cryptoService().getMyDevice().deviceId
+        aliceVerificationService.beginKeyVerification(VerificationMethod.SAS, bobUserId, bobDeviceId, null)
+        aliceVerificationService.beginKeyVerification(VerificationMethod.SAS, bobUserId, bobDeviceId, null)
+
+        mTestHelper.await(aliceCreatedLatch)
+        mTestHelper.await(aliceCancelledLatch)
+
+        cryptoTestData.cleanUp(mTestHelper)
+    }
+
+    /**
+     * Test that when alice starts a 'correct' request, bob agrees.
+     */
+    @Test
+    fun test_aliceAndBobAgreement() {
+        val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom()
+
+        val aliceSession = cryptoTestData.firstSession
+        val bobSession = cryptoTestData.secondSession
+
+        val aliceVerificationService = aliceSession.cryptoService().verificationService()
+        val bobVerificationService = bobSession!!.cryptoService().verificationService()
+
+        var accepted: ValidVerificationInfoAccept? = null
+        var startReq: ValidVerificationInfoStart.SasVerificationInfoStart? = null
+
+        val aliceAcceptedLatch = CountDownLatch(1)
+        val aliceListener = object : VerificationService.Listener {
+            override fun transactionUpdated(tx: VerificationTransaction) {
+                if ((tx as SASDefaultVerificationTransaction).state === VerificationTxState.OnAccepted) {
+                    val at = tx as SASDefaultVerificationTransaction
+                    accepted = at.accepted
+                    startReq = at.startReq
+                    aliceAcceptedLatch.countDown()
+                }
+            }
+        }
+        aliceVerificationService.addListener(aliceListener)
+
+        val bobListener = object : VerificationService.Listener {
+            override fun transactionUpdated(tx: VerificationTransaction) {
+                if ((tx as IncomingSasVerificationTransaction).uxState === IncomingSasVerificationTransaction.UxState.SHOW_ACCEPT) {
+                    val at = tx as IncomingSasVerificationTransaction
+                    at.performAccept()
+                }
+            }
+        }
+        bobVerificationService.addListener(bobListener)
+
+        val bobUserId = bobSession.myUserId
+        val bobDeviceId = bobSession.cryptoService().getMyDevice().deviceId
+        aliceVerificationService.beginKeyVerification(VerificationMethod.SAS, bobUserId, bobDeviceId, null)
+        mTestHelper.await(aliceAcceptedLatch)
+
+        assertTrue("Should have receive a commitment", accepted!!.commitment?.trim()?.isEmpty() == false)
+
+        // check that agreement is valid
+        assertTrue("Agreed Protocol should be Valid", accepted != null)
+        assertTrue("Agreed Protocol should be known by alice", startReq!!.keyAgreementProtocols.contains(accepted!!.keyAgreementProtocol))
+        assertTrue("Hash should be known by alice", startReq!!.hashes.contains(accepted!!.hash))
+        assertTrue("Hash should be known by alice", startReq!!.messageAuthenticationCodes.contains(accepted!!.messageAuthenticationCode))
+
+        accepted!!.shortAuthenticationStrings.forEach {
+            assertTrue("all agreed Short Code should be known by alice", startReq!!.shortAuthenticationStrings.contains(it))
+        }
+
+        cryptoTestData.cleanUp(mTestHelper)
+    }
+
+    @Test
+    fun test_aliceAndBobSASCode() {
+        val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom()
+
+        val aliceSession = cryptoTestData.firstSession
+        val bobSession = cryptoTestData.secondSession
+
+        val aliceVerificationService = aliceSession.cryptoService().verificationService()
+        val bobVerificationService = bobSession!!.cryptoService().verificationService()
+
+        val aliceSASLatch = CountDownLatch(1)
+        val aliceListener = object : VerificationService.Listener {
+            override fun transactionUpdated(tx: VerificationTransaction) {
+                val uxState = (tx as OutgoingSasVerificationTransaction).uxState
+                when (uxState) {
+                    OutgoingSasVerificationTransaction.UxState.SHOW_SAS -> {
+                        aliceSASLatch.countDown()
+                    }
+                    else                                                -> Unit
+                }
+            }
+        }
+        aliceVerificationService.addListener(aliceListener)
+
+        val bobSASLatch = CountDownLatch(1)
+        val bobListener = object : VerificationService.Listener {
+            override fun transactionUpdated(tx: VerificationTransaction) {
+                val uxState = (tx as IncomingSasVerificationTransaction).uxState
+                when (uxState) {
+                    IncomingSasVerificationTransaction.UxState.SHOW_ACCEPT -> {
+                        tx.performAccept()
+                    }
+                    else                                                   -> Unit
+                }
+                if (uxState === IncomingSasVerificationTransaction.UxState.SHOW_SAS) {
+                    bobSASLatch.countDown()
+                }
+            }
+        }
+        bobVerificationService.addListener(bobListener)
+
+        val bobUserId = bobSession.myUserId
+        val bobDeviceId = bobSession.cryptoService().getMyDevice().deviceId
+        val verificationSAS = aliceVerificationService.beginKeyVerification(VerificationMethod.SAS, bobUserId, bobDeviceId, null)
+        mTestHelper.await(aliceSASLatch)
+        mTestHelper.await(bobSASLatch)
+
+        val aliceTx = aliceVerificationService.getExistingTransaction(bobUserId, verificationSAS!!) as SASDefaultVerificationTransaction
+        val bobTx = bobVerificationService.getExistingTransaction(aliceSession.myUserId, verificationSAS) as SASDefaultVerificationTransaction
+
+        assertEquals("Should have same SAS", aliceTx.getShortCodeRepresentation(SasMode.DECIMAL),
+                bobTx.getShortCodeRepresentation(SasMode.DECIMAL))
+
+        cryptoTestData.cleanUp(mTestHelper)
+    }
+
+    @Test
+    fun test_happyPath() {
+        val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom()
+
+        val aliceSession = cryptoTestData.firstSession
+        val bobSession = cryptoTestData.secondSession
+
+        val aliceVerificationService = aliceSession.cryptoService().verificationService()
+        val bobVerificationService = bobSession!!.cryptoService().verificationService()
+
+        val aliceSASLatch = CountDownLatch(1)
+        val aliceListener = object : VerificationService.Listener {
+            override fun transactionUpdated(tx: VerificationTransaction) {
+                val uxState = (tx as OutgoingSasVerificationTransaction).uxState
+                when (uxState) {
+                    OutgoingSasVerificationTransaction.UxState.SHOW_SAS -> {
+                        tx.userHasVerifiedShortCode()
+                    }
+                    OutgoingSasVerificationTransaction.UxState.VERIFIED -> {
+                        aliceSASLatch.countDown()
+                    }
+                    else                                                -> Unit
+                }
+            }
+        }
+        aliceVerificationService.addListener(aliceListener)
+
+        val bobSASLatch = CountDownLatch(1)
+        val bobListener = object : VerificationService.Listener {
+            override fun transactionUpdated(tx: VerificationTransaction) {
+                val uxState = (tx as IncomingSasVerificationTransaction).uxState
+                when (uxState) {
+                    IncomingSasVerificationTransaction.UxState.SHOW_ACCEPT -> {
+                        tx.performAccept()
+                    }
+                    IncomingSasVerificationTransaction.UxState.SHOW_SAS    -> {
+                        tx.userHasVerifiedShortCode()
+                    }
+                    IncomingSasVerificationTransaction.UxState.VERIFIED    -> {
+                        bobSASLatch.countDown()
+                    }
+                    else                                                   -> Unit
+                }
+            }
+        }
+        bobVerificationService.addListener(bobListener)
+
+        val bobUserId = bobSession.myUserId
+        val bobDeviceId = bobSession.cryptoService().getMyDevice().deviceId
+        aliceVerificationService.beginKeyVerification(VerificationMethod.SAS, bobUserId, bobDeviceId, null)
+        mTestHelper.await(aliceSASLatch)
+        mTestHelper.await(bobSASLatch)
+
+        // Assert that devices are verified
+        val bobDeviceInfoFromAlicePOV: CryptoDeviceInfo? = aliceSession.cryptoService().getDeviceInfo(bobUserId, bobDeviceId)
+        val aliceDeviceInfoFromBobPOV: CryptoDeviceInfo? = bobSession.cryptoService().getDeviceInfo(aliceSession.myUserId, aliceSession.cryptoService().getMyDevice().deviceId)
+
+        // latch wait a bit again
+        Thread.sleep(1000)
+
+        assertTrue("alice device should be verified from bob point of view", aliceDeviceInfoFromBobPOV!!.isVerified)
+        assertTrue("bob device should be verified from alice point of view", bobDeviceInfoFromAlicePOV!!.isVerified)
+        cryptoTestData.cleanUp(mTestHelper)
+    }
+}

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

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.internal.crypto.verification.qrcode
+
+fun hexToByteArray(hex: String): ByteArray {
+    // Remove all spaces
+    return hex.replace(" ", "")
+            .let {
+                if (it.length % 2 != 0) "0$it" else it
+            }
+            .let {
+                ByteArray(it.length / 2)
+                        .apply {
+                            for (i in this.indices) {
+                                val index = i * 2
+                                val v = it.substring(index, index + 2).toInt(16)
+                                this[i] = v.toByte()
+                            }
+                        }
+            }
+}

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

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

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

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.internal.crypto.verification.qrcode
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import im.vector.matrix.android.InstrumentedTest
+import org.amshove.kluent.shouldBe
+import org.amshove.kluent.shouldNotBeEqualTo
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+
+@RunWith(AndroidJUnit4::class)
+@FixMethodOrder(MethodSorters.JVM)
+class SharedSecretTest : InstrumentedTest {
+
+    @Test
+    fun testSharedSecretLengthCase() {
+        repeat(100) {
+            generateSharedSecretV2().length shouldBe 11
+        }
+    }
+
+    @Test
+    fun testSharedDiffCase() {
+        val sharedSecret1 = generateSharedSecretV2()
+        val sharedSecret2 = generateSharedSecretV2()
+
+        sharedSecret1 shouldNotBeEqualTo sharedSecret2
+    }
+}

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

@@ -0,0 +1,232 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.internal.crypto.verification.qrcode
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import im.vector.matrix.android.InstrumentedTest
+import im.vector.matrix.android.api.session.crypto.verification.VerificationMethod
+import im.vector.matrix.android.api.session.crypto.verification.VerificationService
+import im.vector.matrix.android.common.CommonTestHelper
+import im.vector.matrix.android.common.CryptoTestHelper
+import im.vector.matrix.android.common.TestConstants
+import im.vector.matrix.android.internal.crypto.model.rest.UserPasswordAuth
+import im.vector.matrix.android.api.session.crypto.verification.PendingVerificationRequest
+import org.amshove.kluent.shouldBe
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+import java.util.concurrent.CountDownLatch
+
+@RunWith(AndroidJUnit4::class)
+@FixMethodOrder(MethodSorters.JVM)
+class VerificationTest : InstrumentedTest {
+    private val mTestHelper = CommonTestHelper(context())
+    private val mCryptoTestHelper = CryptoTestHelper(mTestHelper)
+
+    data class ExpectedResult(
+            val sasIsSupported: Boolean = false,
+            val otherCanScanQrCode: Boolean = false,
+            val otherCanShowQrCode: Boolean = false
+    )
+
+    private val sas = listOf(
+            VerificationMethod.SAS
+    )
+
+    private val sasShow = listOf(
+            VerificationMethod.SAS,
+            VerificationMethod.QR_CODE_SHOW
+    )
+
+    private val sasScan = listOf(
+            VerificationMethod.SAS,
+            VerificationMethod.QR_CODE_SCAN
+    )
+
+    private val sasShowScan = listOf(
+            VerificationMethod.SAS,
+            VerificationMethod.QR_CODE_SHOW,
+            VerificationMethod.QR_CODE_SCAN
+    )
+
+    @Test
+    fun test_aliceAndBob_sas_sas() = doTest(
+            sas,
+            sas,
+            ExpectedResult(sasIsSupported = true),
+            ExpectedResult(sasIsSupported = true)
+    )
+
+    @Test
+    fun test_aliceAndBob_sas_show() = doTest(
+            sas,
+            sasShow,
+            ExpectedResult(sasIsSupported = true),
+            ExpectedResult(sasIsSupported = true)
+    )
+
+    @Test
+    fun test_aliceAndBob_show_sas() = doTest(
+            sasShow,
+            sas,
+            ExpectedResult(sasIsSupported = true),
+            ExpectedResult(sasIsSupported = true)
+    )
+
+    @Test
+    fun test_aliceAndBob_sas_scan() = doTest(
+            sas,
+            sasScan,
+            ExpectedResult(sasIsSupported = true),
+            ExpectedResult(sasIsSupported = true)
+    )
+
+    @Test
+    fun test_aliceAndBob_scan_sas() = doTest(
+            sasScan,
+            sas,
+            ExpectedResult(sasIsSupported = true),
+            ExpectedResult(sasIsSupported = true)
+    )
+
+    @Test
+    fun test_aliceAndBob_scan_scan() = doTest(
+            sasScan,
+            sasScan,
+            ExpectedResult(sasIsSupported = true),
+            ExpectedResult(sasIsSupported = true)
+    )
+
+    @Test
+    fun test_aliceAndBob_show_show() = doTest(
+            sasShow,
+            sasShow,
+            ExpectedResult(sasIsSupported = true),
+            ExpectedResult(sasIsSupported = true)
+    )
+
+    @Test
+    fun test_aliceAndBob_show_scan() = doTest(
+            sasShow,
+            sasScan,
+            ExpectedResult(sasIsSupported = true, otherCanScanQrCode = true),
+            ExpectedResult(sasIsSupported = true, otherCanShowQrCode = true)
+    )
+
+    @Test
+    fun test_aliceAndBob_scan_show() = doTest(
+            sasScan,
+            sasShow,
+            ExpectedResult(sasIsSupported = true, otherCanShowQrCode = true),
+            ExpectedResult(sasIsSupported = true, otherCanScanQrCode = true)
+    )
+
+    @Test
+    fun test_aliceAndBob_all_all() = doTest(
+            sasShowScan,
+            sasShowScan,
+            ExpectedResult(sasIsSupported = true, otherCanShowQrCode = true, otherCanScanQrCode = true),
+            ExpectedResult(sasIsSupported = true, otherCanShowQrCode = true, otherCanScanQrCode = true)
+    )
+
+    // TODO Add tests without SAS
+
+    private fun doTest(aliceSupportedMethods: List<VerificationMethod>,
+                       bobSupportedMethods: List<VerificationMethod>,
+                       expectedResultForAlice: ExpectedResult,
+                       expectedResultForBob: ExpectedResult) {
+        val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom()
+
+        val aliceSession = cryptoTestData.firstSession
+        val bobSession = cryptoTestData.secondSession!!
+
+        mTestHelper.doSync<Unit> { callback ->
+            aliceSession.cryptoService().crossSigningService()
+                    .initializeCrossSigning(UserPasswordAuth(
+                            user = aliceSession.myUserId,
+                            password = TestConstants.PASSWORD
+                    ), callback)
+        }
+
+        mTestHelper.doSync<Unit> { callback ->
+            bobSession.cryptoService().crossSigningService()
+                    .initializeCrossSigning(UserPasswordAuth(
+                            user = bobSession.myUserId,
+                            password = TestConstants.PASSWORD
+                    ), callback)
+        }
+
+        val aliceVerificationService = aliceSession.cryptoService().verificationService()
+        val bobVerificationService = bobSession.cryptoService().verificationService()
+
+        var aliceReadyPendingVerificationRequest: PendingVerificationRequest? = null
+        var bobReadyPendingVerificationRequest: PendingVerificationRequest? = null
+
+        val latch = CountDownLatch(2)
+        val aliceListener = object : VerificationService.Listener {
+            override fun verificationRequestUpdated(pr: PendingVerificationRequest) {
+                // Step 4: Alice receive the ready request
+                if (pr.isReady) {
+                    aliceReadyPendingVerificationRequest = pr
+                    latch.countDown()
+                }
+            }
+        }
+        aliceVerificationService.addListener(aliceListener)
+
+        val bobListener = object : VerificationService.Listener {
+            override fun verificationRequestCreated(pr: PendingVerificationRequest) {
+                // Step 2: Bob accepts the verification request
+                bobVerificationService.readyPendingVerificationInDMs(
+                        bobSupportedMethods,
+                        aliceSession.myUserId,
+                        cryptoTestData.roomId,
+                        pr.transactionId!!
+                )
+            }
+
+            override fun verificationRequestUpdated(pr: PendingVerificationRequest) {
+                // Step 3: Bob is ready
+                if (pr.isReady) {
+                    bobReadyPendingVerificationRequest = pr
+                    latch.countDown()
+                }
+            }
+        }
+        bobVerificationService.addListener(bobListener)
+
+        val bobUserId = bobSession.myUserId
+        // Step 1: Alice starts a verification request
+        aliceVerificationService.requestKeyVerificationInDMs(aliceSupportedMethods, bobUserId, cryptoTestData.roomId)
+        mTestHelper.await(latch)
+
+        aliceReadyPendingVerificationRequest!!.let { pr ->
+            pr.isSasSupported() shouldBe expectedResultForAlice.sasIsSupported
+            pr.otherCanShowQrCode() shouldBe expectedResultForAlice.otherCanShowQrCode
+            pr.otherCanScanQrCode() shouldBe expectedResultForAlice.otherCanScanQrCode
+        }
+
+        bobReadyPendingVerificationRequest!!.let { pr ->
+            pr.isSasSupported() shouldBe expectedResultForBob.sasIsSupported
+            pr.otherCanShowQrCode() shouldBe expectedResultForBob.otherCanShowQrCode
+            pr.otherCanScanQrCode() shouldBe expectedResultForBob.otherCanScanQrCode
+        }
+
+        cryptoTestData.cleanUp(mTestHelper)
+    }
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -6,9 +6,10 @@
     <uses-permission android:name="android.permission.VIBRATE" />
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
 
-    <application>
+    <application android:networkSecurityConfig="@xml/network_security_config">
 
-        <provider android:name="androidx.work.impl.WorkManagerInitializer"
+        <provider
+            android:name="androidx.work.impl.WorkManagerInitializer"
             android:authorities="${applicationId}.workmanager-init"
             android:exported="false"
             tools:node="remove" />

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

@@ -22,23 +22,27 @@ import androidx.work.Configuration
 import androidx.work.WorkManager
 import com.zhuinden.monarchy.Monarchy
 import im.vector.matrix.android.BuildConfig
-import im.vector.matrix.android.api.auth.Authenticator
+import im.vector.matrix.android.api.auth.AuthenticationService
+import im.vector.matrix.android.api.crypto.MXCryptoConfig
 import im.vector.matrix.android.internal.SessionManager
+import im.vector.matrix.android.internal.crypto.attachments.ElementToDecrypt
+import im.vector.matrix.android.internal.crypto.attachments.MXEncryptedAttachments
 import im.vector.matrix.android.internal.di.DaggerMatrixComponent
 import im.vector.matrix.android.internal.network.UserAgentHolder
 import im.vector.matrix.android.internal.util.BackgroundDetectionObserver
 import org.matrix.olm.OlmManager
+import java.io.InputStream
 import java.util.concurrent.atomic.AtomicBoolean
 import javax.inject.Inject
 
 data class MatrixConfiguration(
-        val applicationFlavor: String = "Default-application-flavor"
+        val applicationFlavor: String = "Default-application-flavor",
+        val cryptoConfig: MXCryptoConfig = MXCryptoConfig()
 ) {
 
     interface Provider {
         fun providesMatrixConfiguration(): MatrixConfiguration
     }
-
 }
 
 /**
@@ -47,7 +51,7 @@ data class MatrixConfiguration(
  */
 class Matrix private constructor(context: Context, matrixConfiguration: MatrixConfiguration) {
 
-    @Inject internal lateinit var authenticator: Authenticator
+    @Inject internal lateinit var authenticationService: AuthenticationService
     @Inject internal lateinit var userAgentHolder: UserAgentHolder
     @Inject internal lateinit var backgroundDetectionObserver: BackgroundDetectionObserver
     @Inject internal lateinit var olmManager: OlmManager
@@ -55,18 +59,17 @@ 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())
         }
         ProcessLifecycleOwner.get().lifecycle.addObserver(backgroundDetectionObserver)
-        userAgentHolder.setApplicationFlavor(matrixConfiguration.applicationFlavor)
     }
 
     fun getUserAgent() = userAgentHolder.userAgent
 
-    fun authenticator(): Authenticator {
-        return authenticator
+    fun authenticationService(): AuthenticationService {
+        return authenticationService
     }
 
     companion object {
@@ -97,6 +100,9 @@ class Matrix private constructor(context: Context, matrixConfiguration: MatrixCo
         fun getSdkVersion(): String {
             return BuildConfig.VERSION_NAME + " (" + BuildConfig.GIT_SDK_REVISION + ")"
         }
-    }
 
+        fun decryptStream(inputStream: InputStream?, elementToDecrypt: ElementToDecrypt): InputStream? {
+            return MXEncryptedAttachments.decryptAttachment(inputStream, elementToDecrypt)
+        }
+    }
 }

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

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

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

@@ -16,7 +16,6 @@
 
 package im.vector.matrix.android.api
 
-
 /**
  * This class contains pattern to match the different Matrix ids
  */
@@ -123,9 +122,9 @@ object MatrixPatterns {
      */
     fun isEventId(str: String?): Boolean {
         return str != null
-               && (str matches PATTERN_CONTAIN_MATRIX_EVENT_IDENTIFIER
-                   || str matches PATTERN_CONTAIN_MATRIX_EVENT_IDENTIFIER_V3
-                   || str matches PATTERN_CONTAIN_MATRIX_EVENT_IDENTIFIER_V4)
+                && (str matches PATTERN_CONTAIN_MATRIX_EVENT_IDENTIFIER
+                || str matches PATTERN_CONTAIN_MATRIX_EVENT_IDENTIFIER_V3
+                || str matches PATTERN_CONTAIN_MATRIX_EVENT_IDENTIFIER_V4)
     }
 
     /**
@@ -145,15 +144,6 @@ object MatrixPatterns {
      * @return null if not found or if matrixId is null
      */
     fun extractServerNameFromId(matrixId: String?): String? {
-        if (matrixId == null) {
-            return null
-        }
-
-        val index = matrixId.indexOf(":")
-
-        return if (index == -1) {
-            null
-        } else matrixId.substring(index + 1)
-
+        return matrixId?.substringAfter(":", missingDelimiterValue = "")?.takeIf { it.isNotEmpty() }
     }
 }

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

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.auth
+
+import im.vector.matrix.android.api.MatrixCallback
+import im.vector.matrix.android.api.auth.data.Credentials
+import im.vector.matrix.android.api.auth.data.HomeServerConnectionConfig
+import im.vector.matrix.android.api.auth.data.LoginFlowResult
+import im.vector.matrix.android.api.auth.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.session.Session
+import im.vector.matrix.android.api.util.Cancelable
+
+/**
+ * This interface defines methods to authenticate or to create an account to a matrix server.
+ */
+interface AuthenticationService {
+
+    /**
+     * Request the supported login flows for this homeserver.
+     * This is the first method to call to be able to get a wizard to login or the create an account
+     */
+    fun getLoginFlow(homeServerConnectionConfig: HomeServerConnectionConfig, callback: MatrixCallback<LoginFlowResult>): Cancelable
+
+    /**
+     * Return a LoginWizard, to login to the homeserver. The login flow has to be retrieved first.
+     */
+    fun getLoginWizard(): LoginWizard
+
+    /**
+     * Return a RegistrationWizard, to create an matrix account on the homeserver. The login flow has to be retrieved first.
+     */
+    fun getRegistrationWizard(): RegistrationWizard
+
+    /**
+     * True when login and password has been sent with success to the homeserver
+     */
+    val isRegistrationStarted: Boolean
+
+    /**
+     * Cancel pending login or pending registration
+     */
+    fun cancelPendingLoginOrRegistration()
+
+    /**
+     * Reset all pending settings, including current HomeServerConnectionConfig
+     */
+    fun reset()
+
+    /**
+     * Check if there is an authenticated [Session].
+     * @return true if there is at least one active session.
+     */
+    fun hasAuthenticatedSessions(): Boolean
+
+    /**
+     * Get the last authenticated [Session], if there is an active session.
+     * @return the last active session if any, or null
+     */
+    fun getLastAuthenticatedSession(): Session?
+
+    /**
+     * 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
+}

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

@@ -1,59 +0,0 @@
-/*
- * Copyright 2019 New Vector Ltd
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package im.vector.matrix.android.api.auth
-
-import im.vector.matrix.android.api.MatrixCallback
-import im.vector.matrix.android.api.auth.data.HomeServerConnectionConfig
-import im.vector.matrix.android.api.auth.data.SessionParams
-import im.vector.matrix.android.api.session.Session
-import im.vector.matrix.android.api.util.Cancelable
-
-/**
- * This interface defines methods to authenticate to a matrix server.
- */
-interface Authenticator {
-
-    /**
-     * @param homeServerConnectionConfig this param is used to configure the Homeserver
-     * @param login the login field
-     * @param password the password field
-     * @param callback  the matrix callback on which you'll receive the result of authentication.
-     * @return return a [Cancelable]
-     */
-    fun authenticate(homeServerConnectionConfig: HomeServerConnectionConfig, login: String, password: String, callback: MatrixCallback<Session>): Cancelable
-
-    /**
-     * Check if there is an authenticated [Session].
-     * @return true if there is at least one active session.
-     */
-    fun hasAuthenticatedSessions(): Boolean
-
-    /**
-     * Get the last authenticated [Session], if there is an active session.
-     * @return the last active session if any, or null
-     */
-    fun getLastAuthenticatedSession(): Session?
-
-    /**
-     * Get an authenticated session. You should at least call authenticate one time before.
-     * If you logout, this session will no longer be valid.
-     *
-     * @param sessionParams the sessionParams to open with.
-     * @return the associated session if any, or null
-     */
-    fun getSession(sessionParams: SessionParams): Session?
-}

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

@@ -18,6 +18,7 @@ package im.vector.matrix.android.api.auth.data
 
 import com.squareup.moshi.Json
 import com.squareup.moshi.JsonClass
+import im.vector.matrix.android.internal.util.md5
 
 /**
  * This data class hold credentials user data.
@@ -30,4 +31,11 @@ data class Credentials(
         @Json(name = "home_server") val homeServer: String,
         @Json(name = "access_token") val accessToken: String,
         @Json(name = "refresh_token") val refreshToken: String?,
-        @Json(name = "device_id") val deviceId: String?)
+        @Json(name = "device_id") val deviceId: String?,
+        // Optional data that may contain info to override home server and/or identity server
+        @Json(name = "well_known") val wellKnown: WellKnown? = null
+)
+
+internal fun Credentials.sessionId(): String {
+    return (if (deviceId.isNullOrBlank()) userId else "$userId|$deviceId").md5()
+}

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

@@ -25,7 +25,7 @@ import okhttp3.TlsVersion
 
 /**
  * This data class holds how to connect to a specific Homeserver.
- * It's used with [im.vector.matrix.android.api.auth.Authenticator] class.
+ * It's used with [im.vector.matrix.android.api.auth.AuthenticationService] class.
  * You should use the [Builder] to create one.
  */
 @JsonClass(generateAdapter = true)
@@ -253,13 +253,5 @@ data class HomeServerConnectionConfig(
                     forceUsageTlsVersions
             )
         }
-
     }
-
-
 }
-
-
-
-
-

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

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.auth.data
+
+import im.vector.matrix.android.internal.auth.data.LoginFlowResponse
+
+// Either a LoginFlowResponse, or an error if the homeserver is outdated
+sealed class LoginFlowResult {
+    data class Success(
+            val loginFlowResponse: LoginFlowResponse,
+            val isLoginAndRegistrationSupported: Boolean,
+            val homeServerUrl: String
+    ) : LoginFlowResult()
+
+    object OutdatedHomeserver : LoginFlowResult()
+}

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

@@ -22,5 +22,6 @@ package im.vector.matrix.android.api.auth.data
  */
 data class SessionParams(
         val credentials: Credentials,
-        val homeServerConnectionConfig: HomeServerConnectionConfig
+        val homeServerConnectionConfig: HomeServerConnectionConfig,
+        val isTokenValid: Boolean
 )

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

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2018 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.auth.data
+
+import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
+
+/**
+ * Model for https://matrix.org/docs/spec/client_server/latest#get-matrix-client-versions
+ *
+ * Ex:
+ * <pre>
+ *   {
+ *     "unstable_features": {
+ *       "m.lazy_load_members": true
+ *     },
+ *     "versions": [
+ *       "r0.0.1",
+ *       "r0.1.0",
+ *       "r0.2.0",
+ *       "r0.3.0"
+ *     ]
+ *   }
+ * </pre>
+ */
+@JsonClass(generateAdapter = true)
+data class Versions(
+        @Json(name = "versions")
+        val supportedVersions: List<String>? = null,
+
+        @Json(name = "unstable_features")
+        val unstableFeatures: Map<String, Boolean>? = null
+)
+
+// MatrixClientServerAPIVersion
+private const val r0_0_1 = "r0.0.1"
+private const val r0_1_0 = "r0.1.0"
+private const val r0_2_0 = "r0.2.0"
+private const val r0_3_0 = "r0.3.0"
+private const val r0_4_0 = "r0.4.0"
+private const val r0_5_0 = "r0.5.0"
+private const val r0_6_0 = "r0.6.0"
+
+// MatrixVersionsFeature
+private const val FEATURE_LAZY_LOAD_MEMBERS = "m.lazy_load_members"
+private const val FEATURE_REQUIRE_IDENTITY_SERVER = "m.require_identity_server"
+private const val FEATURE_ID_ACCESS_TOKEN = "m.id_access_token"
+private const val FEATURE_SEPARATE_ADD_AND_BIND = "m.separate_add_and_bind"
+
+/**
+ * Return true if the SDK supports this homeserver version
+ */
+fun Versions.isSupportedBySdk(): Boolean {
+    return supportLazyLoadMembers()
+}
+
+/**
+ * Return true if the SDK supports this homeserver version for login and registration
+ */
+fun Versions.isLoginAndRegistrationSupportedBySdk(): Boolean {
+    return !doesServerRequireIdentityServerParam()
+            && doesServerAcceptIdentityAccessToken()
+            && doesServerSeparatesAddAndBind()
+}
+
+/**
+ * Return true if the server support the lazy loading of room members
+ *
+ * @return true if the server support the lazy loading of room members
+ */
+private fun Versions.supportLazyLoadMembers(): Boolean {
+    return supportedVersions?.contains(r0_5_0) == true
+            || unstableFeatures?.get(FEATURE_LAZY_LOAD_MEMBERS) == true
+}
+
+/**
+ * Indicate if the `id_server` parameter is required when registering with an 3pid,
+ * adding a 3pid or resetting password.
+ */
+private fun Versions.doesServerRequireIdentityServerParam(): Boolean {
+    if (supportedVersions?.contains(r0_6_0) == true) return false
+    return unstableFeatures?.get(FEATURE_REQUIRE_IDENTITY_SERVER) ?: true
+}
+
+/**
+ * Indicate if the `id_access_token` parameter can be safely passed to the homeserver.
+ * Some homeservers may trigger errors if they are not prepared for the new parameter.
+ */
+private fun Versions.doesServerAcceptIdentityAccessToken(): Boolean {
+    return supportedVersions?.contains(r0_6_0) == true
+            || unstableFeatures?.get(FEATURE_ID_ACCESS_TOKEN) ?: false
+}
+
+private fun Versions.doesServerSeparatesAddAndBind(): Boolean {
+    return supportedVersions?.contains(r0_6_0) == true
+            || unstableFeatures?.get(FEATURE_SEPARATE_ADD_AND_BIND) ?: false
+}

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

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.auth.data
+
+import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
+
+/**
+ * https://matrix.org/docs/spec/client_server/r0.4.0.html#server-discovery
+ * <pre>
+ * {
+ *     "m.homeserver": {
+ *         "base_url": "https://matrix.org"
+ *     },
+ *     "m.identity_server": {
+ *         "base_url": "https://vector.im"
+ *     }
+ *     "m.integrations": {
+ *          "managers": [
+ *              {
+ *                  "api_url": "https://integrations.example.org",
+ *                  "ui_url": "https://integrations.example.org/ui"
+ *              },
+ *              {
+ *                  "api_url": "https://bots.example.org"
+ *              }
+ *          ]
+ *    }
+ * }
+ * </pre>
+ */
+@JsonClass(generateAdapter = true)
+data class WellKnown(
+        @Json(name = "m.homeserver")
+        val homeServer: WellKnownBaseConfig? = null,
+
+        @Json(name = "m.identity_server")
+        val identityServer: WellKnownBaseConfig? = null,
+
+        @Json(name = "m.integrations")
+        val integrations: Map<String, @JvmSuppressWildcards Any>? = null
+) {
+    /**
+     * Returns the list of integration managers proposed
+     */
+    fun getIntegrationManagers(): List<WellKnownManagerConfig> {
+        val managers = ArrayList<WellKnownManagerConfig>()
+        integrations?.get("managers")?.let {
+            (it as? ArrayList<*>)?.let { configs ->
+                configs.forEach { config ->
+                    (config as? Map<*, *>)?.let { map ->
+                        val apiUrl = map["api_url"] as? String
+                        val uiUrl = map["ui_url"] as? String ?: apiUrl
+                        if (apiUrl != null
+                                && apiUrl.startsWith("https://")
+                                && uiUrl!!.startsWith("https://")) {
+                            managers.add(WellKnownManagerConfig(
+                                    apiUrl = apiUrl,
+                                    uiUrl = uiUrl
+                            ))
+                        }
+                    }
+                }
+            }
+        }
+        return managers
+    }
+}

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

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.auth.data
+
+import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
+
+/**
+ * https://matrix.org/docs/spec/client_server/r0.4.0.html#server-discovery
+ * <pre>
+ * {
+ *     "base_url": "https://vector.im"
+ * }
+ * </pre>
+ */
+@JsonClass(generateAdapter = true)
+data class WellKnownBaseConfig(
+        @Json(name = "base_url")
+        val baseURL: String? = null
+)

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

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package im.vector.matrix.android.api.auth.data
+
+data class WellKnownManagerConfig(
+        val apiUrl : String,
+        val uiUrl: String
+)

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

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.auth.login
+
+import im.vector.matrix.android.api.MatrixCallback
+import im.vector.matrix.android.api.session.Session
+import im.vector.matrix.android.api.util.Cancelable
+
+interface LoginWizard {
+
+    /**
+     * @param login the login field
+     * @param password the password field
+     * @param deviceName the initial device name
+     * @param callback  the matrix callback on which you'll receive the result of authentication.
+     * @return return a [Cancelable]
+     */
+    fun login(login: String,
+              password: String,
+              deviceName: String,
+              callback: MatrixCallback<Session>): Cancelable
+
+    /**
+     * Reset user password
+     */
+    fun resetPassword(email: String,
+                      newPassword: String,
+                      callback: MatrixCallback<Unit>): Cancelable
+
+    /**
+     * Confirm the new password, once the user has checked his email
+     */
+    fun resetPasswordMailConfirmed(callback: MatrixCallback<Unit>): Cancelable
+}

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

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.auth.registration
+
+sealed class RegisterThreePid {
+    data class Email(val email: String) : RegisterThreePid()
+    data class Msisdn(val msisdn: String, val countryCode: String) : RegisterThreePid()
+}

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

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.auth.registration
+
+import im.vector.matrix.android.api.session.Session
+
+// Either a session or an object containing data about registration stages
+sealed class RegistrationResult {
+    data class Success(val session: Session) : RegistrationResult()
+    data class FlowResponse(val flowResult: FlowResult) : RegistrationResult()
+}
+
+data class FlowResult(
+        val missingStages: List<Stage>,
+        val completedStages: List<Stage>
+)

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

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.auth.registration
+
+import im.vector.matrix.android.api.MatrixCallback
+import im.vector.matrix.android.api.util.Cancelable
+
+interface RegistrationWizard {
+
+    fun getRegistrationFlow(callback: MatrixCallback<RegistrationResult>): Cancelable
+
+    fun createAccount(userName: String, password: String, initialDeviceDisplayName: String?, callback: MatrixCallback<RegistrationResult>): Cancelable
+
+    fun performReCaptcha(response: String, callback: MatrixCallback<RegistrationResult>): Cancelable
+
+    fun acceptTerms(callback: MatrixCallback<RegistrationResult>): Cancelable
+
+    fun dummy(callback: MatrixCallback<RegistrationResult>): Cancelable
+
+    fun addThreePid(threePid: RegisterThreePid, callback: MatrixCallback<RegistrationResult>): Cancelable
+
+    fun sendAgainThreePid(callback: MatrixCallback<RegistrationResult>): Cancelable
+
+    fun handleValidateThreePid(code: String, callback: MatrixCallback<RegistrationResult>): Cancelable
+
+    fun checkIfEmailHasBeenValidated(delayMillis: Long, callback: MatrixCallback<RegistrationResult>): Cancelable
+
+    val currentThreePid: String?
+
+    // True when login and password has been sent with success to the homeserver
+    val isRegistrationStarted: Boolean
+}

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

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.auth.registration
+
+sealed class Stage(open val mandatory: Boolean) {
+
+    // m.login.recaptcha
+    data class ReCaptcha(override val mandatory: Boolean, val publicKey: String) : Stage(mandatory)
+
+    // m.login.oauth2
+    // m.login.email.identity
+    data class Email(override val mandatory: Boolean) : Stage(mandatory)
+
+    // m.login.msisdn
+    data class Msisdn(override val mandatory: Boolean) : Stage(mandatory)
+
+    // m.login.token
+
+    // m.login.dummy, can be mandatory if there is no other stages. In this case the account cannot be created by just sending a username
+    // and a password, the dummy stage has to be done
+    data class Dummy(override val mandatory: Boolean) : Stage(mandatory)
+
+    // Undocumented yet: m.login.terms
+    data class Terms(override val mandatory: Boolean, val policies: TermPolicies) : Stage(mandatory)
+
+    // For unknown stages
+    data class Other(override val mandatory: Boolean, val type: String, val params: Map<*, *>?) : Stage(mandatory)
+}
+
+typealias TermPolicies = Map<*, *>

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

@@ -17,7 +17,6 @@
 package im.vector.matrix.android.api.comparators
 
 import im.vector.matrix.android.api.interfaces.DatedObject
-import java.util.*
 
 object DatedObjectComparators {
 
@@ -38,4 +37,4 @@ object DatedObjectComparators {
             (datedObject2.date - datedObject1.date).toInt()
         }
     }
-}
+}

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

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.crypto
+
+import im.vector.matrix.android.api.session.crypto.verification.EmojiRepresentation
+import im.vector.matrix.android.internal.crypto.verification.getEmojiForCode
+
+/**
+ * Provide all the emojis used for SAS verification (for debug purpose)
+ */
+fun getAllVerificationEmojis(): List<EmojiRepresentation> {
+    return (0..63).map { getEmojiForCode(it) }
+}

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

@@ -14,14 +14,14 @@
  * limitations under the License.
  */
 
-package im.vector.matrix.android.internal.crypto
+package im.vector.matrix.android.api.crypto
 
 /**
  * Class to define the parameters used to customize or configure the end-to-end crypto.
  */
 data class MXCryptoConfig(
         // Tell whether the encryption of the event content is enabled for the invited members.
-        // By default, we encrypt messages only for the joined members.
-        // The encryption for the invited members will be blocked if the history visibility is "joined".
-        var enableEncryptionForInvitedMembers: Boolean = false
+        // SDK clients can disable this by settings it to false.
+        // Note that the encryption for the invited members will be blocked if the history visibility is "joined".
+        var enableEncryptionForInvitedMembers: Boolean = true
 )

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

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.crypto
+
+/**
+ * RoomEncryptionTrustLevel represents the trust level in an encrypted room.
+ */
+enum class RoomEncryptionTrustLevel {
+    // No one in the room has been verified -> Black shield
+    Default,
+
+    // There are one or more device un-verified -> the app should display a red shield
+    Warning,
+
+    // All devices in the room are verified -> the app should display a green shield
+    Trusted
+}

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

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.extensions
+
+fun Boolean?.orTrue() = this ?: true
+
+fun Boolean?.orFalse() = this ?: false

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

@@ -16,20 +16,21 @@
 
 package im.vector.matrix.android.api.extensions
 
-import im.vector.matrix.android.api.comparators.DatedObjectComparators
-import im.vector.matrix.android.internal.crypto.model.MXDeviceInfo
+import im.vector.matrix.android.internal.crypto.model.CryptoDeviceInfo
 import im.vector.matrix.android.internal.crypto.model.rest.DeviceInfo
-import java.util.*
 
 /* ==========================================================================================
  * MXDeviceInfo
  * ========================================================================================== */
 
-fun MXDeviceInfo.getFingerprintHumanReadable() = fingerprint()
+fun CryptoDeviceInfo.getFingerprintHumanReadable() = fingerprint()
         ?.chunked(4)
         ?.joinToString(separator = " ")
 
+/* ==========================================================================================
+ * DeviceInfo
+ * ========================================================================================== */
 
-fun List<DeviceInfo>.sortByLastSeen() {
-    Collections.sort(this, DatedObjectComparators.descComparator)
-}
+fun List<DeviceInfo>.sortByLastSeen(): List<DeviceInfo> {
+    return this.sortedByDescending { it.lastSeenTs ?: 0 }
+}

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

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.failure
+
+import javax.net.ssl.HttpsURLConnection
+
+fun Throwable.is401() =
+        this is Failure.ServerError
+                && httpCode == HttpsURLConnection.HTTP_UNAUTHORIZED /* 401 */
+                && error.code == MatrixError.M_UNAUTHORIZED
+
+fun Throwable.isTokenError() =
+        this is Failure.ServerError
+                && (error.code == MatrixError.M_UNKNOWN_TOKEN || error.code == MatrixError.M_MISSING_TOKEN)
+
+fun Throwable.shouldBeRetried(): Boolean {
+    return this is Failure.NetworkConnection
+            || (this is Failure.ServerError && error.code == MatrixError.M_LIMIT_EXCEEDED)
+}

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

@@ -31,15 +31,16 @@ import java.io.IOException
  */
 sealed class Failure(cause: Throwable? = null) : Throwable(cause = cause) {
     data class Unknown(val throwable: Throwable? = null) : Failure(throwable)
+    data class Cancelled(val throwable: Throwable? = null) : Failure(throwable)
     data class NetworkConnection(val ioException: IOException? = null) : Failure(ioException)
     data class ServerError(val error: MatrixError, val httpCode: Int) : Failure(RuntimeException(error.toString()))
+    object SuccessError : Failure(RuntimeException(RuntimeException("SuccessResult is false")))
     // When server send an error, but it cannot be interpreted as a MatrixError
-    data class OtherServerError(val errorBody: String, val httpCode: Int) : Failure(RuntimeException(errorBody))
+    data class OtherServerError(val errorBody: String, val httpCode: Int) : Failure(RuntimeException("HTTP $httpCode: $errorBody"))
 
     data class RegistrationFlowError(val registrationFlowResponse: RegistrationFlowResponse) : Failure(RuntimeException(registrationFlowResponse.toString()))
 
     data class CryptoError(val error: MXCryptoError) : Failure(error)
 
     abstract class FeatureFailure : Failure()
-
-}
+}

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

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.failure
+
+// This class will be sent to the bus
+sealed class GlobalError {
+    data class InvalidToken(val softLogout: Boolean) : GlobalError()
+    data class ConsentNotGivenError(val consentUri: String) : GlobalError()
+}

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

@@ -22,46 +22,114 @@ import com.squareup.moshi.JsonClass
 /**
  * This data class holds the error defined by the matrix specifications.
  * You shouldn't have to instantiate it.
+ * Ref: https://matrix.org/docs/spec/client_server/latest#api-standards
  */
 @JsonClass(generateAdapter = true)
 data class MatrixError(
+        /** unique string which can be used to handle an error message */
         @Json(name = "errcode") val code: String,
+        /** human-readable error message */
         @Json(name = "error") val message: String,
 
+        // For M_CONSENT_NOT_GIVEN
         @Json(name = "consent_uri") val consentUri: String? = null,
-        // RESOURCE_LIMIT_EXCEEDED data
+        // For M_RESOURCE_LIMIT_EXCEEDED
         @Json(name = "limit_type") val limitType: String? = null,
-        @Json(name = "admin_contact") val adminUri: String? = null) {
-
+        @Json(name = "admin_contact") val adminUri: String? = null,
+        // For M_LIMIT_EXCEEDED
+        @Json(name = "retry_after_ms") val retryAfterMillis: Long? = null,
+        // For M_UNKNOWN_TOKEN
+        @Json(name = "soft_logout") val isSoftLogout: Boolean = false
+) {
 
     companion object {
-        const val FORBIDDEN = "M_FORBIDDEN"
-        const val UNKNOWN = "M_UNKNOWN"
-        const val UNKNOWN_TOKEN = "M_UNKNOWN_TOKEN"
-        const val MISSING_TOKEN = "M_MISSING_TOKEN"
-        const val BAD_JSON = "M_BAD_JSON"
-        const val NOT_JSON = "M_NOT_JSON"
-        const val NOT_FOUND = "M_NOT_FOUND"
-        const val LIMIT_EXCEEDED = "M_LIMIT_EXCEEDED"
-        const val USER_IN_USE = "M_USER_IN_USE"
-        const val ROOM_IN_USE = "M_ROOM_IN_USE"
-        const val BAD_PAGINATION = "M_BAD_PAGINATION"
-        const val UNAUTHORIZED = "M_UNAUTHORIZED"
-        const val OLD_VERSION = "M_OLD_VERSION"
-        const val UNRECOGNIZED = "M_UNRECOGNIZED"
+        /** Forbidden access, e.g. joining a room without permission, failed login. */
+        const val M_FORBIDDEN = "M_FORBIDDEN"
+        /** An unknown error has occurred. */
+        const val M_UNKNOWN = "M_UNKNOWN"
+        /** The access token specified was not recognised. */
+        const val M_UNKNOWN_TOKEN = "M_UNKNOWN_TOKEN"
+        /** No access token was specified for the request. */
+        const val M_MISSING_TOKEN = "M_MISSING_TOKEN"
+        /** Request contained valid JSON, but it was malformed in some way, e.g. missing required keys, invalid values for keys. */
+        const val M_BAD_JSON = "M_BAD_JSON"
+        /** Request did not contain valid JSON. */
+        const val M_NOT_JSON = "M_NOT_JSON"
+        /** No resource was found for this request. */
+        const val M_NOT_FOUND = "M_NOT_FOUND"
+        /** Too many requests have been sent in a short period of time. Wait a while then try again. */
+        const val M_LIMIT_EXCEEDED = "M_LIMIT_EXCEEDED"
 
-        const val LOGIN_EMAIL_URL_NOT_YET = "M_LOGIN_EMAIL_URL_NOT_YET"
-        const val THREEPID_AUTH_FAILED = "M_THREEPID_AUTH_FAILED"
-        // Error code returned by the server when no account matches the given 3pid
-        const val THREEPID_NOT_FOUND = "M_THREEPID_NOT_FOUND"
-        const val THREEPID_IN_USE = "M_THREEPID_IN_USE"
-        const val SERVER_NOT_TRUSTED = "M_SERVER_NOT_TRUSTED"
-        const val TOO_LARGE = "M_TOO_LARGE"
+        /* ==========================================================================================
+         * Other error codes the client might encounter are
+         * ========================================================================================== */
+
+        /** Encountered when trying to register a user ID which has been taken. */
+        const val M_USER_IN_USE = "M_USER_IN_USE"
+        /** Sent when the room alias given to the createRoom API is already in use. */
+        const val M_ROOM_IN_USE = "M_ROOM_IN_USE"
+        /** (Not documented yet) */
+        const val M_BAD_PAGINATION = "M_BAD_PAGINATION"
+        /** The request was not correctly authorized. Usually due to login failures. */
+        const val M_UNAUTHORIZED = "M_UNAUTHORIZED"
+        /** (Not documented yet) */
+        const val M_OLD_VERSION = "M_OLD_VERSION"
+        /** The server did not understand the request. */
+        const val M_UNRECOGNIZED = "M_UNRECOGNIZED"
+        /** (Not documented yet) */
+        const val M_LOGIN_EMAIL_URL_NOT_YET = "M_LOGIN_EMAIL_URL_NOT_YET"
+        /** Authentication could not be performed on the third party identifier. */
+        const val M_THREEPID_AUTH_FAILED = "M_THREEPID_AUTH_FAILED"
+        /** Sent when a threepid given to an API cannot be used because no record matching the threepid was found. */
+        const val M_THREEPID_NOT_FOUND = "M_THREEPID_NOT_FOUND"
+        /** Sent when a threepid given to an API cannot be used because the same threepid is already in use. */
+        const val M_THREEPID_IN_USE = "M_THREEPID_IN_USE"
+        /** The client's request used a third party server, eg. identity server, that this server does not trust. */
+        const val M_SERVER_NOT_TRUSTED = "M_SERVER_NOT_TRUSTED"
+        /** The request or entity was too large. */
+        const val M_TOO_LARGE = "M_TOO_LARGE"
+        /** (Not documented yet) */
         const val M_CONSENT_NOT_GIVEN = "M_CONSENT_NOT_GIVEN"
-        const val RESOURCE_LIMIT_EXCEEDED = "M_RESOURCE_LIMIT_EXCEEDED"
-        const val WRONG_ROOM_KEYS_VERSION = "M_WRONG_ROOM_KEYS_VERSION"
+        /** The request cannot be completed because the homeserver has reached a resource limit imposed on it. For example,
+         *  a homeserver held in a shared hosting environment may reach a resource limit if it starts using too much memory
+         *  or disk space. The error MUST have an admin_contact field to provide the user receiving the error a place to reach
+         *  out to. Typically, this error will appear on routes which attempt to modify state (eg: sending messages, account
+         *  data, etc) and not routes which only read state (eg: /sync, get account data, etc). */
+        const val M_RESOURCE_LIMIT_EXCEEDED = "M_RESOURCE_LIMIT_EXCEEDED"
+        /** The user ID associated with the request has been deactivated. Typically for endpoints that prove authentication, such as /login. */
+        const val M_USER_DEACTIVATED = "M_USER_DEACTIVATED"
+        /** Encountered when trying to register a user ID which is not valid. */
+        const val M_INVALID_USERNAME = "M_INVALID_USERNAME"
+        /** Sent when the initial state given to the createRoom API is invalid. */
+        const val M_INVALID_ROOM_STATE = "M_INVALID_ROOM_STATE"
+        /** The server does not permit this third party identifier. This may happen if the server only permits,
+         *  for example, email addresses from a particular domain. */
+        const val M_THREEPID_DENIED = "M_THREEPID_DENIED"
+        /** The client's request to create a room used a room version that the server does not support. */
+        const val M_UNSUPPORTED_ROOM_VERSION = "M_UNSUPPORTED_ROOM_VERSION"
+        /** The client attempted to join a room that has a version the server does not support.
+         *  Inspect the room_version property of the error response for the room's version. */
+        const val M_INCOMPATIBLE_ROOM_VERSION = "M_INCOMPATIBLE_ROOM_VERSION"
+        /** The state change requested cannot be performed, such as attempting to unban a user who is not banned. */
+        const val M_BAD_STATE = "M_BAD_STATE"
+        /** The room or resource does not permit guests to access it. */
+        const val M_GUEST_ACCESS_FORBIDDEN = "M_GUEST_ACCESS_FORBIDDEN"
+        /** A Captcha is required to complete the request. */
+        const val M_CAPTCHA_NEEDED = "M_CAPTCHA_NEEDED"
+        /** The Captcha provided did not match what was expected. */
+        const val M_CAPTCHA_INVALID = "M_CAPTCHA_INVALID"
+        /** A required parameter was missing from the request. */
+        const val M_MISSING_PARAM = "M_MISSING_PARAM"
+        /** A parameter that was specified has the wrong value. For example, the server expected an integer and instead received a string. */
+        const val M_INVALID_PARAM = "M_INVALID_PARAM"
+        /** The resource being requested is reserved by an application service, or the application service making the request has not created the resource. */
+        const val M_EXCLUSIVE = "M_EXCLUSIVE"
+        /** The user is unable to reject an invite to join the server notices room. See the Server Notices module for more information. */
+        const val M_CANNOT_LEAVE_SERVER_NOTICE_ROOM = "M_CANNOT_LEAVE_SERVER_NOTICE_ROOM"
+        /** (Not documented yet) */
+        const val M_WRONG_ROOM_KEYS_VERSION = "M_WRONG_ROOM_KEYS_VERSION"
 
         // Possible value for "limit_type"
         const val LIMIT_TYPE_MAU = "monthly_active_user"
     }
-}
+}

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

@@ -21,8 +21,9 @@ package im.vector.matrix.android.api.listeners
  */
 interface ProgressListener {
     /**
+     * Will be invoked on the background thread, not in UI thread.
      * @param progress from 0 to total by contract
      * @param total
      */
     fun onProgress(progress: Int, total: Int)
-}
+}

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

@@ -31,4 +31,4 @@ interface StepProgressListener {
      * @param step The current step, containing progress data if available. Else you should consider progress as indeterminate
      */
     fun onStepProgress(step: Step)
-}
+}

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

@@ -17,7 +17,6 @@
 package im.vector.matrix.android.api.permalinks
 
 import android.text.Spannable
-import im.vector.matrix.android.api.MatrixPatterns
 
 /**
  *  MatrixLinkify take a piece of text and turns all of the
@@ -30,9 +29,15 @@ object MatrixLinkify {
      *
      * @param spannable the text in which the matrix items has to be clickable.
      */
-    fun addLinks(spannable: Spannable?, callback: MatrixPermalinkSpan.Callback?): Boolean {
+    @Suppress("UNUSED_PARAMETER")
+    fun addLinks(spannable: Spannable, callback: MatrixPermalinkSpan.Callback?): Boolean {
+        /**
+         * I disable it because it mess up with pills, and even with pills, it does not work correctly:
+         * The url is not correct. Ex: for @user:matrix.org, the url will be @user:matrix.org, instead of a matrix.to
+         */
+        /*
         // sanity checks
-        if (spannable.isNullOrEmpty()) {
+        if (spannable.isEmpty()) {
             return false
         }
         val text = spannable.toString()
@@ -50,6 +55,7 @@ object MatrixLinkify {
             }
         }
         return hasMatch
+         */
+        return false
     }
-
-}
+}

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

@@ -35,6 +35,4 @@ class MatrixPermalinkSpan(private val url: String,
     override fun onClick(widget: View) {
         callback?.onUrlClicked(url)
     }
-
-
-}
+}