PushRule: add beforeRuleId and afterRuleId parameter when creating a rule

Use retrofit2.Call.awaitResponse extension provided by Retrofit 2.

.idea/dictionaries/bmarty.xml

@@ -7,17 +7,21 @@
       <w>ciphertext</w>
       <w>coroutine</w>
       <w>decryptor</w>
+      <w>displayname</w>
       <w>emoji</w>
       <w>emojis</w>
       <w>fdroid</w>
       <w>gplay</w>
       <w>hmac</w>
+      <w>homeserver</w>
       <w>ktlint</w>
       <w>linkified</w>
       <w>linkify</w>
       <w>megolm</w>
       <w>msisdn</w>
+      <w>msisdns</w>
       <w>pbkdf</w>
+      <w>pids</w>
       <w>pkcs</w>
       <w>riotx</w>
       <w>signin</w>

CHANGES.md

@@ -1,3 +1,91 @@
+Changes in RiotX 0.23.0 (2020-XX-XX)
+===================================================
+
+Features ✨:
+ - Call with WebRTC support (##611)
+ - Add capability to change the display name (#1529)
+
+Improvements 🙌:
+ - "Add Matrix app" menu is now always visible (#1495)
+
+Bugfix 🐛:
+ - Fix dark theme issue on login screen (#1097)
+ - Incomplete predicate in RealmCryptoStore#getOutgoingRoomKeyRequest (#1519)
+
+Translations 🗣:
+ -
+
+SDK API changes ⚠️:
+ - 
+
+Build 🧱:
+ - Enable code optimization (Proguard)
+ - SDK is now API level 21 minimum, and so RiotX (#405)
+
+Other changes:
+ - Use `retrofit2.Call.awaitResponse` extension provided by Retrofit 2. (#1526)
+ - Fix minor typo in contribution guide (#1512)
+ - Fix self-assignment of callback in `DefaultRoomPushRuleService#setRoomNotificationState` (#1520)
+ - Random housekeeping clean-ups indicated by Lint (#1520)
+
+Changes in RiotX 0.22.0 (2020-06-15)
+===================================================
+
+Features ✨:
+ - Integration Manager and Widget support (#48)
+ - Send stickers (#51)
+
+Improvements 🙌:
+ - New wording for notice when current user is the sender
+ - Hide "X made no changes" event by default in timeline (#1430)
+ - Hide left rooms in breadcrumbs (#766)
+ - Handle PowerLevel properly (#627)
+ - Correctly handle SSO login redirection
+ - SSO login is now performed in the default browser, or in Chrome Custom tab if available (#1400)
+ - Improve checking of homeserver version support (#1442)
+ - Add capability to add and remove a room from the favorites (#1217)
+
+Bugfix 🐛:
+ - Switch theme is not fully taken into account without restarting the app
+ - Temporary fix to show error when user is creating an account on matrix.org with userId containing only digits (#1410)
+ - Reply composer overlay stays on screen too long after send (#1169)
+ - Fix navigation bar icon contrast on API in [21,27[ (#1342)
+ - Fix status bar icon contrast on API in [21,23[
+ - Wrong /query request (#1444)
+ - Make Credentials.homeServer optional because it is deprecated (#1443)
+ - Fix issue on dark themes, after alert popup dismiss
+
+Other changes:
+ - Send plain text in the body of events containing formatted body, as per https://matrix.org/docs/spec/client_server/latest#m-room-message-msgtypes
+ - Update link to Modular url from "https://modular.im/" to "https://modular.im/services/matrix-hosting-riot" and open it using ChromeCustomTab
+
+Changes in RiotX 0.21.0 (2020-05-28)
+===================================================
+
+Features ✨:
+ - Identity server support (#607)
+ - Switch language support (#41)
+ - Display list of attachments of a room (#860)
+
+Improvements 🙌:
+ - Better connectivity lost indicator when airplane mode is on
+ - Add a setting to hide redacted events (#951)
+ - Render formatted_body for m.notice and m.emote (#1196)
+ - Change icon to magnifying-glass to filter room (#1384)
+
+Bugfix 🐛:
+ - After jump to unread, newer messages are never loaded (#1008)
+ - Fix issues with FontScale switch (#69, #645)
+ - "Seen by" uses 12h time (#1378)
+ - Enable markdown (if active) when sending emote (#734)
+ - Screenshots for Rageshake now includes Dialogs such as BottomSheet (#1349)
+
+SDK API changes ⚠️:
+ - initialize with proxy configuration
+
+Other changes:
+ - support new key agreement method for SAS (#1374)
+
 Changes in RiotX 0.20.0 (2020-05-15)
 ===================================================
 

CONTRIBUTING.md

@@ -19,7 +19,11 @@ An Android Studio template has been added to the project to help creating all fi
 
 To install the template (to be done only once):
 - Go to folder `./tools/template`.
-- Run the script `./configure.sh`.
+- Mac OSX: Run the script `./configure.sh`.
+
+   Linux: Run `ANDROID_STUDIO=/path/to/android-studio ./configure`
+    - e.g. `ANDROID_STUDIO=/usr/local/android-studio ./configure`
+
 - Restart Android Studio.
 
 To create a new screen:
@@ -27,7 +31,7 @@ To create a new screen:
 - Then right click on the package, and select `New/New Vector/RiotX Feature`.
 - Follow the Wizard, especially replace `Main` by something more relevant to your feature.
 - Click on `Finish`.
-- Remainning steps are described as TODO in the generated files, or will be pointed out by the compilator, or at runtime :)
+- Remaining steps are described as TODO in the generated files, or will be pointed out by the compilator, or at runtime :)
 
 Note that if the templates are modified, the only things to do is to restart Android Studio for the change to take effect.
 

README.md

@@ -11,8 +11,8 @@ 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)
+[<img src="resources/img/google-play-badge.png" alt="Get it on Google Play" height="60">](https://play.google.com/store/apps/details?id=im.vector.riotx)
+[<img src="resources/img/f-droid-badge.png" alt="Get it on F-Droid" height="60">](https://f-droid.org/app/im.vector.riotx)
 
 Nightly build: [![Buildkite](https://badge.buildkite.com/657d3db27364448d69d54f66c690f7788bc6aa80a7628e37f3.svg?branch=develop)](https://buildkite.com/matrix-dot-org/riotx-android/builds?branch=develop)
 

docs/identity_server.md

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

docs/integration_tests.md

@@ -59,6 +59,12 @@ It's recommended to run tests using an Android Emulator and not a real device. F
 
 You can run all the tests in the `androidTest` folders.
 
+It can be done using this command:
+
+```bash
+./gradlew vector:connectedAndroidTest matrix-sdk-android:connectedAndroidTest
+```
+
 ## Stop Synapse
 
 To stop Synapse, you can run the following commands:

docs/signin.md

@@ -2,7 +2,7 @@
 
 This document describes the flow of signin to a homeserver, and also the flow when user want to reset his password. Examples come from the `matrix.org` homeserver.
 
-## Sign up flows
+## Sign in flows
 
 ### Get the flow
 
@@ -58,7 +58,7 @@ We get credential (200)
 ```json
 {
   "user_id": "@alice:matrix.org",
-  "access_token": "MDAxOGxvY2F0aW9uIG1hdHREDACTEDb2l0MDgxNjptYXRyaXgub3JnCjAwMTZjaWQgdHlwZSA9IGFjY2VzcwowMDIxY2lkIG5vbmNlID0gfnYrSypfdTtkNXIuNWx1KgowMDJmc2lnbmF0dXJlIOsh1XqeAkXexh4qcofl_aR4kHJoSOWYGOhE7-ubX-DZCg",
+  "access_token": "MDAxOGxvY2F0aW9uIG1hdHREDACTEDb2l0MDgxNjptYXRyaXgub3JnCjAwMTZjaWQgdHlwZSA9IGFjY2VzcwowMDIxY2lr",
   "home_server": "matrix.org",
   "device_id": "GTVREDALBF",
   "well_known": {
@@ -117,7 +117,7 @@ We get the credentials (200)
 ```json
 {
   "user_id": "@alice:matrix.org",
-  "access_token": "MDAxOGxvY2F0aW9uIG1hdHJpeC5vcmREDACTEDZXJfaWQgPSBAYmVub2l0MDgxNjptYXRyaXgub3JnCjAwMTZjaWQgdHlwZSA9IGFjY2VzcwowMDIxY2lkIG5vbmNlID0gNjtDY0MwRlNPSFFoOC5wOgowMDJmc2lnbmF0dXJlIGiTRm1mYLLxQywxOh3qzQVT8HoEorSokEP2u-bAwtnYCg",
+  "access_token": "MDAxOGxvY2F0aW9uIG1hdHJpeC5vcmREDACTEDZXJfaWQgPSBAYmVub2l0MDgxNjptYXRyaXgub3Jnfrfdegfszsefddvf",
   "home_server": "matrix.org",
   "device_id": "WBSREDASND",
   "well_known": {
@@ -145,12 +145,59 @@ Not supported yet in RiotX
   "flows": [
     {
       "type": "m.login.sso"
+    },
+    {
+      "type": "m.login.token"
     }
   ]
 }
 ```
 
-In this case, the user can click on "Sign in with SSO" and the web screen will be displayed on the page `https://homeserver.with.sso/_matrix/static/client/login/` and the credentials will be passed back to the native code through the JS bridge
+In this case, the user can click on "Sign in with SSO" and the native web browser, or a ChromeCustomTab if the device supports it, will be launched on the page
+
+> https://homeserver.with.sso/_matrix/client/r0/login/sso/redirect?redirectUrl=riotx%3A%2F%2Friotx
+
+The parameter `redirectUrl` is set to `riotx://riotx`.
+
+ChromeCustomTabs are an intermediate way to display a WebPage, between a WebView and using the external browser. More info can be found [here](https://developer.chrome.com/multidevice/android/customtabs)
+
+The browser will then take care of the SSO login, which may include creating a third party account, entering an email, settings a display name, or any other possibilities.
+
+During the process, user may be asked to validate an email by clicking on a link it contains. The link has to be opened in the browser which initiates the authentication. This is why we cannot use WebView anymore.
+
+Once the process is finished, the web page will call the `redirectUrl` with an extra parameter `loginToken`
+
+> riotx://riotx?loginToken=MDAxOWxvY2F0aW9uIG1vemlsbGEub3JnCjAwMTNpZGVudGlmaWVy
+
+This navigation is intercepted by RiotX by the `LoginActivity`, which will then ask the homeserver to convert this `loginToken` to an access token
+
+> curl -X POST --data $'{"type":"m.login.token","token":"MDAxOWxvY2F0aW9uIG1vemlsbGEub3JnCjAwMTNpZGVudGlmaWVy"}' 'https://homeserver.with.sso/_matrix/client/r0/login'
+
+```json
+{
+  "type": "m.login.token",
+  "token": "MDAxOWxvY2F0aW9uIG1vemlsbGEub3JnCjAwMTNpZGVudGlmaWVy"
+}
+```
+
+We get the credentials (200)
+
+```json
+{
+  "user_id": "@alice:homeserver.with.sso",
+  "access_token": "MDAxOWxvY2F0aW9uIG1vemlsbGEub3JnCjAwMTNpZGVudGlmaWVyIGtleQowMDEwY2lkIGdlbiA9IDEKMDAyY2NpZCB1c2",
+  "home_server": "homeserver.with.sso",
+  "device_id": "DETBTVAHCH",
+  "well_known": {
+    "m.homeserver": {
+      "base_url": "https:\/\/homeserver.with.sso\/"
+    },
+    "m.identity_server": {
+      "base_url": "https:\/\/vector.im"
+    }
+  }
+}
+```
 
 ## Reset password
 

docs/voip_signaling.md

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

matrix-sdk-android-rx/build.gradle

@@ -6,7 +6,7 @@ android {
     compileSdkVersion 29
 
     defaultConfig {
-        minSdkVersion 16
+        minSdkVersion 21
         targetSdkVersion 29
         versionCode 1
         versionName "1.0"

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

@@ -16,6 +16,7 @@
 
 package im.vector.matrix.rx
 
+import im.vector.matrix.android.api.query.QueryStringValue
 import im.vector.matrix.android.api.session.events.model.Event
 import im.vector.matrix.android.api.session.room.Room
 import im.vector.matrix.android.api.session.room.members.RoomMemberQueryParams
@@ -61,7 +62,7 @@ class RxRoom(private val room: Room) {
                 }
     }
 
-    fun liveStateEvent(eventType: String, stateKey: String): Observable<Optional<Event>> {
+    fun liveStateEvent(eventType: String, stateKey: QueryStringValue): Observable<Optional<Event>> {
         return room.getStateEventLive(eventType, stateKey).asObservable()
                 .startWithCallable {
                     room.getStateEvent(eventType, stateKey).toOptional()

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

@@ -17,16 +17,19 @@
 package im.vector.matrix.rx
 
 import androidx.paging.PagedList
+import im.vector.matrix.android.api.query.QueryStringValue
 import im.vector.matrix.android.api.session.Session
 import im.vector.matrix.android.api.session.crypto.crosssigning.MXCrossSigningInfo
 import im.vector.matrix.android.api.session.group.GroupSummaryQueryParams
 import im.vector.matrix.android.api.session.group.model.GroupSummary
+import im.vector.matrix.android.api.session.identity.ThreePid
 import im.vector.matrix.android.api.session.pushers.Pusher
 import im.vector.matrix.android.api.session.room.RoomSummaryQueryParams
 import im.vector.matrix.android.api.session.room.model.RoomSummary
 import im.vector.matrix.android.api.session.room.model.create.CreateRoomParams
 import im.vector.matrix.android.api.session.sync.SyncState
 import im.vector.matrix.android.api.session.user.model.User
+import im.vector.matrix.android.api.session.widgets.model.Widget
 import im.vector.matrix.android.api.util.JsonDict
 import im.vector.matrix.android.api.util.Optional
 import im.vector.matrix.android.api.util.toOptional
@@ -53,10 +56,10 @@ class RxSession(private val session: Session) {
                 }
     }
 
-    fun liveBreadcrumbs(): Observable<List<RoomSummary>> {
-        return session.getBreadcrumbsLive().asObservable()
+    fun liveBreadcrumbs(queryParams: RoomSummaryQueryParams): Observable<List<RoomSummary>> {
+        return session.getBreadcrumbsLive(queryParams).asObservable()
                 .startWithCallable {
-                    session.getBreadcrumbs()
+                    session.getBreadcrumbs(queryParams)
                 }
     }
 
@@ -94,6 +97,11 @@ class RxSession(private val session: Session) {
         return session.getPagedUsersLive(filter, excludedUserIds).asObservable()
     }
 
+    fun liveThreePIds(refreshData: Boolean): Observable<List<ThreePid>> {
+        return session.getThreePidsLive(refreshData).asObservable()
+                .startWithCallable { session.getThreePids() }
+    }
+
     fun createRoom(roomParams: CreateRoomParams): Single<String> = singleBuilder {
         session.createRoom(roomParams, it)
     }
@@ -145,6 +153,18 @@ class RxSession(private val session: Session) {
                     session.getAccountDataEvents(types)
                 }
     }
+
+    fun liveRoomWidgets(
+            roomId: String,
+            widgetId: QueryStringValue,
+            widgetTypes: Set<String>? = null,
+            excludedTypes: Set<String>? = null
+    ): Observable<List<Widget>> {
+        return session.widgetService().getRoomWidgetsLive(roomId, widgetId, widgetTypes, excludedTypes).asObservable()
+                .startWithCallable {
+                    session.widgetService().getRoomWidgets(roomId, widgetId, widgetTypes, excludedTypes)
+                }
+    }
 }
 
 fun Session.rx(): RxSession {

matrix-sdk-android/build.gradle

@@ -23,7 +23,7 @@ android {
     testOptions.unitTests.includeAndroidResources = true
 
     defaultConfig {
-        minSdkVersion 16
+        minSdkVersion 21
         targetSdkVersion 29
         versionCode 1
         versionName "0.0.1"
@@ -35,6 +35,10 @@ android {
         resValue "string", "git_sdk_revision", "\"${gitRevision()}\""
         resValue "string", "git_sdk_revision_unix_date", "\"${gitRevisionUnixDate()}\""
         resValue "string", "git_sdk_revision_date", "\"${gitRevisionDate()}\""
+
+        defaultConfig {
+            consumerProguardFiles 'proguard-rules.pro'
+        }
     }
 
     buildTypes {
@@ -49,9 +53,6 @@ android {
         release {
             buildConfigField "boolean", "LOG_PRIVATE_DATA", "false"
             buildConfigField "okhttp3.logging.HttpLoggingInterceptor.Level", "OKHTTP_LOGGING_LEVEL", "okhttp3.logging.HttpLoggingInterceptor.Level.NONE"
-
-            minifyEnabled false
-            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
         }
     }
 
@@ -158,6 +159,13 @@ dependencies {
     // Bus
     implementation 'org.greenrobot:eventbus:3.1.1'
 
+    // Phone number https://github.com/google/libphonenumber
+    implementation 'com.googlecode.libphonenumber:libphonenumber:8.10.23'
+
+    // Web RTC
+    // TODO meant for development purposes only. See http://webrtc.github.io/webrtc-org/native-code/android/
+    implementation 'org.webrtc:google-webrtc:1.0.+'
+
     debugImplementation 'com.airbnb.okreplay:okreplay:1.5.0'
     releaseImplementation 'com.airbnb.okreplay:noop:1.5.0'
     androidTestImplementation 'com.airbnb.okreplay:espresso:1.5.0'

matrix-sdk-android/proguard-rules.pro

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

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

@@ -28,10 +28,10 @@ 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.send.SendState
 import im.vector.matrix.android.api.session.room.timeline.Timeline
 import im.vector.matrix.android.api.session.room.timeline.TimelineEvent
 import im.vector.matrix.android.api.session.room.timeline.TimelineSettings
@@ -88,7 +88,8 @@ class CommonTestHelper(context: Context) {
     fun syncSession(session: Session) {
         val lock = CountDownLatch(1)
 
-        session.open()
+        GlobalScope.launch(Dispatchers.Main) { session.open() }
+
         session.startSync(true)
 
         val syncLiveData = runBlocking(Dispatchers.Main) {
@@ -116,7 +117,7 @@ class CommonTestHelper(context: Context) {
      */
     fun sendTextMessage(room: Room, message: String, nbOfMessages: Int): List<TimelineEvent> {
         val sentEvents = ArrayList<TimelineEvent>(nbOfMessages)
-        val latch = CountDownLatch(nbOfMessages)
+        val latch = CountDownLatch(1)
         val timelineListener = object : Timeline.Listener {
             override fun onTimelineFailure(throwable: Throwable) {
             }
@@ -127,7 +128,7 @@ class CommonTestHelper(context: Context) {
 
             override fun onTimelineUpdated(snapshot: List<TimelineEvent>) {
                 val newMessages = snapshot
-                        .filter { LocalEcho.isLocalEchoId(it.eventId).not() }
+                        .filter { it.root.sendState == SendState.SYNCED }
                         .filter { it.root.getClearType() == EventType.MESSAGE }
                         .filter { it.root.getClearContent().toModel<MessageContent>()?.body?.startsWith(message) == true }
 
@@ -143,7 +144,8 @@ class CommonTestHelper(context: Context) {
         for (i in 0 until nbOfMessages) {
             room.sendTextMessage(message + " #" + (i + 1))
         }
-        await(latch)
+        // Wait 3 second more per message
+        await(latch, timeout = TestConstants.timeOutMillis + 3_000L * nbOfMessages)
         timeline.removeListener(timelineListener)
         timeline.dispose()
 
@@ -291,6 +293,24 @@ class CommonTestHelper(context: Context) {
         return requestFailure!!
     }
 
+    fun createEventListener(latch: CountDownLatch, predicate: (List<TimelineEvent>) -> Boolean): Timeline.Listener {
+        return object : Timeline.Listener {
+            override fun onTimelineFailure(throwable: Throwable) {
+                // noop
+            }
+
+            override fun onNewTimelineEvents(eventIds: List<String>) {
+                // noop
+            }
+
+            override fun onTimelineUpdated(snapshot: List<TimelineEvent>) {
+                if (predicate(snapshot)) {
+                    latch.countDown()
+                }
+            }
+        }
+    }
+
     /**
      * Await for a latch and ensure the result is true
      *
@@ -349,3 +369,13 @@ class CommonTestHelper(context: Context) {
         session.close()
     }
 }
+
+fun List<TimelineEvent>.checkSendOrder(baseTextMessage: String, numberOfMessages: Int, startIndex: Int): Boolean {
+    return drop(startIndex)
+            .take(numberOfMessages)
+            .foldRightIndexed(true) { index, timelineEvent, acc ->
+        val body = timelineEvent.root.content.toModel<MessageContent>()?.body
+        val currentMessageSuffix = numberOfMessages - index
+        acc && (body == null || body.startsWith(baseTextMessage) && body.endsWith("#$currentMessageSuffix"))
+    }
+}

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

@@ -53,17 +53,19 @@ class CryptoTestHelper(private val mTestHelper: CommonTestHelper) {
     /**
      * @return alice session
      */
-    fun doE2ETestWithAliceInARoom(): CryptoTestData {
+    fun doE2ETestWithAliceInARoom(encryptedRoom: Boolean = true): CryptoTestData {
         val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, defaultSessionParams)
 
         val roomId = mTestHelper.doSync<String> {
             aliceSession.createRoom(CreateRoomParams(name = "MyRoom"), it)
         }
 
-        val room = aliceSession.getRoom(roomId)!!
+        if (encryptedRoom) {
+            val room = aliceSession.getRoom(roomId)!!
 
-        mTestHelper.doSync<Unit> {
-            room.enableEncryption(callback = it)
+            mTestHelper.doSync<Unit> {
+                room.enableEncryption(callback = it)
+            }
         }
 
         return CryptoTestData(aliceSession, roomId)
@@ -72,8 +74,8 @@ class CryptoTestHelper(private val mTestHelper: CommonTestHelper) {
     /**
      * @return alice and bob sessions
      */
-    fun doE2ETestWithAliceAndBobInARoom(): CryptoTestData {
-        val cryptoTestData = doE2ETestWithAliceInARoom()
+    fun doE2ETestWithAliceAndBobInARoom(encryptedRoom: Boolean = true): CryptoTestData {
+        val cryptoTestData = doE2ETestWithAliceInARoom(encryptedRoom)
         val aliceSession = cryptoTestData.firstSession
         val aliceRoomId = cryptoTestData.roomId
 
@@ -246,7 +248,7 @@ class CryptoTestHelper(private val mTestHelper: CommonTestHelper) {
         assertNotNull(eventWireContent.get("session_id"))
         assertNotNull(eventWireContent.get("sender_key"))
 
-        assertEquals(senderSession.sessionParams.credentials.deviceId, eventWireContent.get("device_id"))
+        assertEquals(senderSession.sessionParams.deviceId, eventWireContent.get("device_id"))
 
         assertNotNull(event.eventId)
         assertEquals(roomId, event.roomId)

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

@@ -122,7 +122,7 @@ class XSigningTest : InstrumentedTest {
         // We will want to test that in alice POV, this new device would be trusted by cross signing
 
         val bobSession2 = mTestHelper.logIntoAccount(bobUserId, SessionTestParams(true))
-        val bobSecondDeviceId = bobSession2.sessionParams.credentials.deviceId!!
+        val bobSecondDeviceId = bobSession2.sessionParams.deviceId!!
 
         // Check that bob first session sees the new login
         val data = mTestHelper.doSync<MXUsersDevicesMap<CryptoDeviceInfo>> {

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

@@ -90,7 +90,7 @@ class KeyShareTests : InstrumentedTest {
         } catch (failure: Throwable) {
         }
 
-        val outgoingRequestBefore = aliceSession2.cryptoService().getOutgoingRoomKeyRequest()
+        val outgoingRequestsBefore = aliceSession2.cryptoService().getOutgoingRoomKeyRequests()
         // Try to request
         aliceSession2.cryptoService().requestRoomKeyForEvent(receivedEvent.root)
 
@@ -100,10 +100,10 @@ class KeyShareTests : InstrumentedTest {
         var outGoingRequestId: String? = null
 
         mTestHelper.retryPeriodicallyWithLatch(waitLatch) {
-            aliceSession2.cryptoService().getOutgoingRoomKeyRequest()
+            aliceSession2.cryptoService().getOutgoingRoomKeyRequests()
                     .filter { req ->
                         // filter out request that was known before
-                        !outgoingRequestBefore.any { req.requestId == it.requestId }
+                        !outgoingRequestsBefore.any { req.requestId == it.requestId }
                     }
                     .let {
                         val outgoing = it.firstOrNull { it.sessionId == eventMegolmSessionId }
@@ -115,10 +115,10 @@ class KeyShareTests : InstrumentedTest {
 
         Log.v("TEST", "=======> Outgoing requet Id is $outGoingRequestId")
 
-        val outgoingRequestAfter = aliceSession2.cryptoService().getOutgoingRoomKeyRequest()
+        val outgoingRequestAfter = aliceSession2.cryptoService().getOutgoingRoomKeyRequests()
 
         // We should have a new request
-        Assert.assertTrue(outgoingRequestAfter.size > outgoingRequestBefore.size)
+        Assert.assertTrue(outgoingRequestAfter.size > outgoingRequestsBefore.size)
         Assert.assertNotNull(outgoingRequestAfter.first { it.sessionId == eventMegolmSessionId })
 
         // The first session should see an incoming request
@@ -126,7 +126,7 @@ class KeyShareTests : InstrumentedTest {
         mTestHelper.waitWithLatch { latch ->
             mTestHelper.retryPeriodicallyWithLatch(latch) {
                 // DEBUG LOGS
-                aliceSession.cryptoService().getIncomingRoomKeyRequest().let {
+                aliceSession.cryptoService().getIncomingRoomKeyRequests().let {
                     Log.v("TEST", "Incoming request Session 1 (looking for $outGoingRequestId)")
                     Log.v("TEST", "=========================")
                     it.forEach { keyRequest ->
@@ -135,7 +135,7 @@ class KeyShareTests : InstrumentedTest {
                     Log.v("TEST", "=========================")
                 }
 
-                val incoming = aliceSession.cryptoService().getIncomingRoomKeyRequest().firstOrNull { it.requestId == outGoingRequestId }
+                val incoming = aliceSession.cryptoService().getIncomingRoomKeyRequests().firstOrNull { it.requestId == outGoingRequestId }
                 incoming?.state == GossipingRequestState.REJECTED
             }
         }
@@ -148,14 +148,14 @@ class KeyShareTests : InstrumentedTest {
 
         // Mark the device as trusted
         aliceSession.cryptoService().setDeviceVerification(DeviceTrustLevel(crossSigningVerified = false, locallyVerified = true), aliceSession.myUserId,
-                aliceSession2.sessionParams.credentials.deviceId ?: "")
+                aliceSession2.sessionParams.deviceId ?: "")
 
         // Re request
         aliceSession2.cryptoService().reRequestRoomKeyForEvent(receivedEvent.root)
 
         mTestHelper.waitWithLatch { latch ->
             mTestHelper.retryPeriodicallyWithLatch(latch) {
-                aliceSession.cryptoService().getIncomingRoomKeyRequest().let {
+                aliceSession.cryptoService().getIncomingRoomKeyRequests().let {
                     Log.v("TEST", "Incoming request Session 1")
                     Log.v("TEST", "=========================")
                     it.forEach {
@@ -171,7 +171,7 @@ class KeyShareTests : InstrumentedTest {
         Thread.sleep(6_000)
         mTestHelper.waitWithLatch { latch ->
             mTestHelper.retryPeriodicallyWithLatch(latch) {
-                aliceSession2.cryptoService().getOutgoingRoomKeyRequest().let {
+                aliceSession2.cryptoService().getOutgoingRoomKeyRequests().let {
                     it.any { it.requestBody?.sessionId == eventMegolmSessionId && it.state == OutgoingGossipingRequestState.CANCELLED }
                 }
             }
@@ -252,13 +252,13 @@ class KeyShareTests : InstrumentedTest {
             }
         })
 
-        val txId: String = "m.testVerif12"
-        aliceVerificationService2.beginKeyVerification(VerificationMethod.SAS, aliceSession1.myUserId, aliceSession1.sessionParams.credentials.deviceId
+        val txId = "m.testVerif12"
+        aliceVerificationService2.beginKeyVerification(VerificationMethod.SAS, aliceSession1.myUserId, aliceSession1.sessionParams.deviceId
                 ?: "", txId)
 
         mTestHelper.waitWithLatch { latch ->
             mTestHelper.retryPeriodicallyWithLatch(latch) {
-                aliceSession1.cryptoService().getDeviceInfo(aliceSession1.myUserId, aliceSession2.sessionParams.credentials.deviceId ?: "")?.isVerified == true
+                aliceSession1.cryptoService().getDeviceInfo(aliceSession1.myUserId, aliceSession2.sessionParams.deviceId ?: "")?.isVerified == true
             }
         }
 

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

@@ -835,7 +835,7 @@ class KeysBackupTest : InstrumentedTest {
         assertTrue(signature.valid)
         assertNotNull(signature.device)
         assertEquals(cryptoTestData.firstSession.cryptoService().getMyDevice().deviceId, signature.deviceId)
-        assertEquals(signature.device!!.deviceId, cryptoTestData.firstSession.sessionParams.credentials.deviceId)
+        assertEquals(signature.device!!.deviceId, cryptoTestData.firstSession.sessionParams.deviceId)
 
         stateObserver.stopAndCheckStates(null)
         cryptoTestData.cleanUp(mTestHelper)
@@ -997,7 +997,7 @@ class KeysBackupTest : InstrumentedTest {
             keysBackup.backupAllGroupSessions(null, it)
         }
 
-        val oldDeviceId = cryptoTestData.firstSession.sessionParams.credentials.deviceId!!
+        val oldDeviceId = cryptoTestData.firstSession.sessionParams.deviceId!!
         val oldKeyBackupVersion = keysBackup.currentBackupVersion
         val aliceUserId = cryptoTestData.firstSession.myUserId
 

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

@@ -468,14 +468,19 @@ class SASTest : InstrumentedTest {
 
         val aliceSASLatch = CountDownLatch(1)
         val aliceListener = object : VerificationService.Listener {
+            var matchOnce = true
             override fun transactionUpdated(tx: VerificationTransaction) {
                 val uxState = (tx as OutgoingSasVerificationTransaction).uxState
+                Log.v("TEST", "== aliceState ${uxState.name}")
                 when (uxState) {
                     OutgoingSasVerificationTransaction.UxState.SHOW_SAS -> {
                         tx.userHasVerifiedShortCode()
                     }
                     OutgoingSasVerificationTransaction.UxState.VERIFIED -> {
-                        aliceSASLatch.countDown()
+                        if (matchOnce) {
+                            matchOnce = false
+                            aliceSASLatch.countDown()
+                        }
                     }
                     else                                                -> Unit
                 }
@@ -485,14 +490,23 @@ class SASTest : InstrumentedTest {
 
         val bobSASLatch = CountDownLatch(1)
         val bobListener = object : VerificationService.Listener {
+            var acceptOnce = true
+            var matchOnce = true
             override fun transactionUpdated(tx: VerificationTransaction) {
                 val uxState = (tx as IncomingSasVerificationTransaction).uxState
+                Log.v("TEST", "== bobState ${uxState.name}")
                 when (uxState) {
                     IncomingSasVerificationTransaction.UxState.SHOW_ACCEPT -> {
-                        tx.performAccept()
+                        if (acceptOnce) {
+                            acceptOnce = false
+                            tx.performAccept()
+                        }
                     }
                     IncomingSasVerificationTransaction.UxState.SHOW_SAS    -> {
-                        tx.userHasVerifiedShortCode()
+                        if (matchOnce) {
+                            matchOnce = false
+                            tx.userHasVerifiedShortCode()
+                        }
                     }
                     IncomingSasVerificationTransaction.UxState.VERIFIED    -> {
                         bobSASLatch.countDown()
@@ -579,7 +593,7 @@ class SASTest : InstrumentedTest {
                 requestID!!,
                 cryptoTestData.roomId,
                 bobSession.myUserId,
-                bobSession.sessionParams.credentials.deviceId!!,
+                bobSession.sessionParams.deviceId!!,
                 null)
 
         bobVerificationService.beginKeyVerificationInDMs(
@@ -587,7 +601,7 @@ class SASTest : InstrumentedTest {
                 requestID!!,
                 cryptoTestData.roomId,
                 aliceSession.myUserId,
-                aliceSession.sessionParams.credentials.deviceId!!,
+                aliceSession.sessionParams.deviceId!!,
                 null)
 
         // we should reach SHOW SAS on both

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

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

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

@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.session.room.timeline
+
+import im.vector.matrix.android.InstrumentedTest
+import im.vector.matrix.android.api.extensions.orFalse
+import im.vector.matrix.android.api.session.events.model.EventType
+import im.vector.matrix.android.api.session.events.model.toModel
+import im.vector.matrix.android.api.session.room.model.message.MessageContent
+import im.vector.matrix.android.api.session.room.timeline.Timeline
+import im.vector.matrix.android.api.session.room.timeline.TimelineSettings
+import im.vector.matrix.android.common.CommonTestHelper
+import im.vector.matrix.android.common.CryptoTestHelper
+import im.vector.matrix.android.common.checkSendOrder
+import org.amshove.kluent.shouldBeFalse
+import org.amshove.kluent.shouldBeTrue
+import org.junit.Assert.assertTrue
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import org.junit.runners.MethodSorters
+import timber.log.Timber
+import java.util.concurrent.CountDownLatch
+
+@RunWith(JUnit4::class)
+@FixMethodOrder(MethodSorters.JVM)
+class TimelineBackToPreviousLastForwardTest : InstrumentedTest {
+
+    private val commonTestHelper = CommonTestHelper(context())
+    private val cryptoTestHelper = CryptoTestHelper(commonTestHelper)
+
+    /**
+     * This test ensure that if we have a chunk in the timeline which is due to a sync, and we click to permalink of an
+     * even contained in a previous lastForward chunk, we will be able to go back to the live
+     */
+    @Test
+    fun backToPreviousLastForwardTest() {
+        val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoom(false)
+
+        val aliceSession = cryptoTestData.firstSession
+        val bobSession = cryptoTestData.secondSession!!
+        val aliceRoomId = cryptoTestData.roomId
+
+        aliceSession.cryptoService().setWarnOnUnknownDevices(false)
+        bobSession.cryptoService().setWarnOnUnknownDevices(false)
+
+        val roomFromAlicePOV = aliceSession.getRoom(aliceRoomId)!!
+        val roomFromBobPOV = bobSession.getRoom(aliceRoomId)!!
+
+        val bobTimeline = roomFromBobPOV.createTimeline(null, TimelineSettings(30))
+        bobTimeline.start()
+
+        var roomCreationEventId: String? = null
+
+        run {
+            val lock = CountDownLatch(1)
+            val eventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Bob timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root}")
+                }
+
+                roomCreationEventId = snapshot.lastOrNull()?.root?.eventId
+                // Ok, we have the 8 first messages of the initial sync (room creation and bob join event)
+                snapshot.size == 8
+            }
+
+            bobTimeline.addListener(eventsListener)
+            commonTestHelper.await(lock)
+            bobTimeline.removeAllListeners()
+
+            bobTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeFalse()
+            bobTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeFalse()
+        }
+
+        // Bob stop to sync
+        bobSession.stopSync()
+
+        val messageRoot = "First messages from Alice"
+
+        // Alice sends 30 messages
+        commonTestHelper.sendTextMessage(
+                roomFromAlicePOV,
+                messageRoot,
+                30)
+
+        // Bob start to sync
+        bobSession.startSync(true)
+
+        run {
+            val lock = CountDownLatch(1)
+            val eventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Bob timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root}")
+                }
+
+                // Ok, we have the 10 last messages from Alice.
+                snapshot.size == 10
+                        && snapshot.all { it.root.content.toModel<MessageContent>()?.body?.startsWith(messageRoot).orFalse() }
+            }
+
+            bobTimeline.addListener(eventsListener)
+            commonTestHelper.await(lock)
+            bobTimeline.removeAllListeners()
+
+            bobTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeTrue()
+            bobTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeFalse()
+        }
+
+        // Bob navigate to the first event (room creation event), so inside the previous last forward chunk
+        run {
+            val lock = CountDownLatch(1)
+            val eventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Bob timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root}")
+                }
+
+                // The event is in db, so it is fetch and auto pagination occurs, half of the number of events we have for this chunk (?)
+                snapshot.size == 4
+            }
+
+            bobTimeline.addListener(eventsListener)
+
+            // Restart the timeline to the first sent event, which is already in the database, so pagination should start automatically
+            assertTrue(roomFromBobPOV.getTimeLineEvent(roomCreationEventId!!) != null)
+
+            bobTimeline.restartWithEventId(roomCreationEventId)
+
+            commonTestHelper.await(lock)
+            bobTimeline.removeAllListeners()
+
+            bobTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeTrue()
+            bobTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeFalse()
+        }
+
+        // Bob scroll to the future
+        run {
+            val lock = CountDownLatch(1)
+            val eventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Bob timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root}")
+                }
+
+                // Bob can see the first event of the room (so Back pagination has worked)
+                snapshot.lastOrNull()?.root?.getClearType() == EventType.STATE_ROOM_CREATE
+                        // 8 for room creation item, and 30 for the forward pagination
+                        && snapshot.size == 38
+                        && snapshot.checkSendOrder(messageRoot, 30, 0)
+            }
+
+            bobTimeline.addListener(eventsListener)
+
+            bobTimeline.paginate(Timeline.Direction.FORWARDS, 50)
+
+            commonTestHelper.await(lock)
+            bobTimeline.removeAllListeners()
+
+            bobTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeFalse()
+            bobTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeFalse()
+        }
+        bobTimeline.dispose()
+
+        cryptoTestData.cleanUp(commonTestHelper)
+    }
+}

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

@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.session.room.timeline
+
+import im.vector.matrix.android.InstrumentedTest
+import im.vector.matrix.android.api.extensions.orFalse
+import im.vector.matrix.android.api.session.events.model.EventType
+import im.vector.matrix.android.api.session.events.model.toModel
+import im.vector.matrix.android.api.session.room.model.message.MessageContent
+import im.vector.matrix.android.api.session.room.timeline.Timeline
+import im.vector.matrix.android.api.session.room.timeline.TimelineSettings
+import im.vector.matrix.android.common.CommonTestHelper
+import im.vector.matrix.android.common.CryptoTestHelper
+import im.vector.matrix.android.common.checkSendOrder
+import org.amshove.kluent.shouldBeFalse
+import org.amshove.kluent.shouldBeTrue
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import org.junit.runners.MethodSorters
+import timber.log.Timber
+import java.util.concurrent.CountDownLatch
+
+@RunWith(JUnit4::class)
+@FixMethodOrder(MethodSorters.JVM)
+class TimelineForwardPaginationTest : InstrumentedTest {
+
+    private val commonTestHelper = CommonTestHelper(context())
+    private val cryptoTestHelper = CryptoTestHelper(commonTestHelper)
+
+    /**
+     * This test ensure that if we click to permalink, we will be able to go back to the live
+     */
+    @Test
+    fun forwardPaginationTest() {
+        val numberOfMessagesToSend = 90
+        val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceInARoom(false)
+
+        val aliceSession = cryptoTestData.firstSession
+        val aliceRoomId = cryptoTestData.roomId
+
+        aliceSession.cryptoService().setWarnOnUnknownDevices(false)
+
+        val roomFromAlicePOV = aliceSession.getRoom(aliceRoomId)!!
+
+        // Alice sends X messages
+        val message = "Message from Alice"
+        val sentMessages = commonTestHelper.sendTextMessage(
+                roomFromAlicePOV,
+                message,
+                numberOfMessagesToSend)
+
+        // Alice clear the cache
+        commonTestHelper.doSync<Unit> {
+            aliceSession.clearCache(it)
+        }
+
+        // And restarts the sync
+        aliceSession.startSync(true)
+
+        val aliceTimeline = roomFromAlicePOV.createTimeline(null, TimelineSettings(30))
+        aliceTimeline.start()
+
+        // Alice sees the 10 last message of the room, and can only navigate BACKWARD
+        run {
+            val lock = CountDownLatch(1)
+            val eventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Alice timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root.content}")
+                }
+
+                // Ok, we have the 10 last messages of the initial sync
+                snapshot.size == 10
+                        && snapshot.all { it.root.content.toModel<MessageContent>()?.body?.startsWith(message).orFalse() }
+            }
+
+            // Open the timeline at last sent message
+            aliceTimeline.addListener(eventsListener)
+            commonTestHelper.await(lock)
+            aliceTimeline.removeAllListeners()
+
+            aliceTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeTrue()
+            aliceTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeFalse()
+        }
+
+        // Alice navigates to the first message of the room, which is not in its database. A GET /context is performed
+        // Then she can paginate BACKWARD and FORWARD
+        run {
+            val lock = CountDownLatch(1)
+            val aliceEventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Alice timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root.content}")
+                }
+
+                // The event is not in db, so it is fetch alone
+                snapshot.size == 1
+                        && snapshot.all { it.root.content.toModel<MessageContent>()?.body?.startsWith("Message from Alice").orFalse() }
+            }
+
+            aliceTimeline.addListener(aliceEventsListener)
+
+            // Restart the timeline to the first sent event
+            aliceTimeline.restartWithEventId(sentMessages.last().eventId)
+
+            commonTestHelper.await(lock)
+            aliceTimeline.removeAllListeners()
+
+            aliceTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeTrue()
+            aliceTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeTrue()
+        }
+
+        // Alice paginates BACKWARD and FORWARD of 50 events each
+        // Then she can only navigate FORWARD
+        run {
+            val lock = CountDownLatch(1)
+            val aliceEventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Alice timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root.content}")
+                }
+
+                // Alice can see the first event of the room (so Back pagination has worked)
+                snapshot.lastOrNull()?.root?.getClearType() == EventType.STATE_ROOM_CREATE
+                        // 6 for room creation item (backward pagination), 1 for the context, and 50 for the forward pagination
+                        && snapshot.size == 6 + 1 + 50
+            }
+
+            aliceTimeline.addListener(aliceEventsListener)
+
+            // Restart the timeline to the first sent event
+            // We ask to load event backward and forward
+            aliceTimeline.paginate(Timeline.Direction.BACKWARDS, 50)
+            aliceTimeline.paginate(Timeline.Direction.FORWARDS, 50)
+
+            commonTestHelper.await(lock)
+            aliceTimeline.removeAllListeners()
+
+            aliceTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeTrue()
+            aliceTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeFalse()
+        }
+
+        // Alice paginates once again FORWARD for 50 events
+        // All the timeline is retrieved, she cannot paginate anymore in both direction
+        run {
+            val lock = CountDownLatch(1)
+            val aliceEventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Alice timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root.content}")
+                }
+                // 6 for room creation item (backward pagination),and numberOfMessagesToSend (all the message of the room)
+                snapshot.size == 6 + numberOfMessagesToSend
+                        && snapshot.checkSendOrder(message, numberOfMessagesToSend, 0)
+            }
+
+            aliceTimeline.addListener(aliceEventsListener)
+
+            // Ask for a forward pagination
+            aliceTimeline.paginate(Timeline.Direction.FORWARDS, 50)
+
+            commonTestHelper.await(lock)
+            aliceTimeline.removeAllListeners()
+
+            // The timeline is fully loaded
+            aliceTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeFalse()
+            aliceTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeFalse()
+        }
+
+        aliceTimeline.dispose()
+
+        cryptoTestData.cleanUp(commonTestHelper)
+    }
+}

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

@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.session.room.timeline
+
+import im.vector.matrix.android.InstrumentedTest
+import im.vector.matrix.android.api.extensions.orFalse
+import im.vector.matrix.android.api.session.events.model.EventType
+import im.vector.matrix.android.api.session.events.model.toModel
+import im.vector.matrix.android.api.session.room.model.message.MessageContent
+import im.vector.matrix.android.api.session.room.timeline.Timeline
+import im.vector.matrix.android.api.session.room.timeline.TimelineSettings
+import im.vector.matrix.android.common.CommonTestHelper
+import im.vector.matrix.android.common.CryptoTestHelper
+import im.vector.matrix.android.common.checkSendOrder
+import org.amshove.kluent.shouldBeFalse
+import org.amshove.kluent.shouldBeTrue
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import org.junit.runners.MethodSorters
+import timber.log.Timber
+import java.util.concurrent.CountDownLatch
+
+@RunWith(JUnit4::class)
+@FixMethodOrder(MethodSorters.JVM)
+class TimelinePreviousLastForwardTest : InstrumentedTest {
+
+    private val commonTestHelper = CommonTestHelper(context())
+    private val cryptoTestHelper = CryptoTestHelper(commonTestHelper)
+
+    /**
+     * This test ensure that if we have a chunk in the timeline which is due to a sync, and we click to permalink, we will be able to go back to the live
+     */
+    @Test
+    fun previousLastForwardTest() {
+        val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoom(false)
+
+        val aliceSession = cryptoTestData.firstSession
+        val bobSession = cryptoTestData.secondSession!!
+        val aliceRoomId = cryptoTestData.roomId
+
+        aliceSession.cryptoService().setWarnOnUnknownDevices(false)
+        bobSession.cryptoService().setWarnOnUnknownDevices(false)
+
+        val roomFromAlicePOV = aliceSession.getRoom(aliceRoomId)!!
+        val roomFromBobPOV = bobSession.getRoom(aliceRoomId)!!
+
+        val bobTimeline = roomFromBobPOV.createTimeline(null, TimelineSettings(30))
+        bobTimeline.start()
+
+        run {
+            val lock = CountDownLatch(1)
+            val eventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Bob timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root}")
+                }
+
+                // Ok, we have the 8 first messages of the initial sync (room creation and bob invite and join events)
+                snapshot.size == 8
+            }
+
+            bobTimeline.addListener(eventsListener)
+            commonTestHelper.await(lock)
+            bobTimeline.removeAllListeners()
+
+            bobTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeFalse()
+            bobTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeFalse()
+        }
+
+        // Bob stop to sync
+        bobSession.stopSync()
+
+        val firstMessage = "First messages from Alice"
+        // Alice sends 30 messages
+        val firstMessageFromAliceId = commonTestHelper.sendTextMessage(
+                roomFromAlicePOV,
+                firstMessage,
+                30)
+                .last()
+                .eventId
+
+        // Bob start to sync
+        bobSession.startSync(true)
+
+        run {
+            val lock = CountDownLatch(1)
+            val eventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Bob timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root}")
+                }
+
+                // Ok, we have the 10 last messages from Alice. This will be our future previous lastForward chunk
+                snapshot.size == 10
+                        && snapshot.all { it.root.content.toModel<MessageContent>()?.body?.startsWith(firstMessage).orFalse() }
+            }
+
+            bobTimeline.addListener(eventsListener)
+            commonTestHelper.await(lock)
+            bobTimeline.removeAllListeners()
+
+            bobTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeTrue()
+            bobTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeFalse()
+        }
+
+        // Bob stop to sync
+        bobSession.stopSync()
+
+        val secondMessage = "Second messages from Alice"
+        // Alice sends again 30 messages
+        commonTestHelper.sendTextMessage(
+                roomFromAlicePOV,
+                secondMessage,
+                30)
+
+        // Bob start to sync
+        bobSession.startSync(true)
+
+        run {
+            val lock = CountDownLatch(1)
+            val eventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Bob timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root}")
+                }
+
+                // Ok, we have the 10 last messages from Alice. This will be our future previous lastForward chunk
+                snapshot.size == 10
+                        && snapshot.all { it.root.content.toModel<MessageContent>()?.body?.startsWith(secondMessage).orFalse() }
+            }
+
+            bobTimeline.addListener(eventsListener)
+            commonTestHelper.await(lock)
+            bobTimeline.removeAllListeners()
+
+            bobTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeTrue()
+            bobTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeFalse()
+        }
+
+        // Bob navigate to the first message sent from Alice
+        run {
+            val lock = CountDownLatch(1)
+            val eventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Bob timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root}")
+                }
+
+                // The event is not in db, so it is fetch
+                snapshot.size == 1
+            }
+
+            bobTimeline.addListener(eventsListener)
+
+            // Restart the timeline to the first sent event, and paginate in both direction
+            bobTimeline.restartWithEventId(firstMessageFromAliceId)
+            bobTimeline.paginate(Timeline.Direction.BACKWARDS, 50)
+            bobTimeline.paginate(Timeline.Direction.FORWARDS, 50)
+
+            commonTestHelper.await(lock)
+            bobTimeline.removeAllListeners()
+
+            bobTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeTrue()
+            bobTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeTrue()
+        }
+
+        // Paginate in both direction
+        run {
+            val lock = CountDownLatch(1)
+            val eventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Bob timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root}")
+                }
+
+                snapshot.size == 8 + 1 + 35
+            }
+
+            bobTimeline.addListener(eventsListener)
+
+            // Paginate in both direction
+            bobTimeline.paginate(Timeline.Direction.BACKWARDS, 50)
+            // Ensure the chunk in the middle is included in the next pagination
+            bobTimeline.paginate(Timeline.Direction.FORWARDS, 35)
+
+            commonTestHelper.await(lock)
+            bobTimeline.removeAllListeners()
+
+            bobTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeTrue()
+            bobTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeFalse()
+        }
+
+        // Bob scroll to the future, till the live
+        run {
+            val lock = CountDownLatch(1)
+            val eventsListener = commonTestHelper.createEventListener(lock) { snapshot ->
+                Timber.e("Bob timeline updated: with ${snapshot.size} events:")
+                snapshot.forEach {
+                    Timber.w(" event ${it.root}")
+                }
+
+                // Bob can see the first event of the room (so Back pagination has worked)
+                snapshot.lastOrNull()?.root?.getClearType() == EventType.STATE_ROOM_CREATE
+                        // 8 for room creation item 60 message from Alice
+                        && snapshot.size == 8 + 60
+                        && snapshot.checkSendOrder(secondMessage, 30, 0)
+                        && snapshot.checkSendOrder(firstMessage, 30, 30)
+            }
+
+            bobTimeline.addListener(eventsListener)
+
+            bobTimeline.paginate(Timeline.Direction.FORWARDS, 50)
+
+            commonTestHelper.await(lock)
+            bobTimeline.removeAllListeners()
+
+            bobTimeline.hasMoreToLoad(Timeline.Direction.FORWARDS).shouldBeFalse()
+            bobTimeline.hasMoreToLoad(Timeline.Direction.BACKWARDS).shouldBeFalse()
+        }
+
+        bobTimeline.dispose()
+
+        cryptoTestData.cleanUp(commonTestHelper)
+    }
+}

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

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

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

@@ -23,7 +23,6 @@ import androidx.work.WorkManager
 import com.zhuinden.monarchy.Monarchy
 import im.vector.matrix.android.BuildConfig
 import im.vector.matrix.android.api.auth.AuthenticationService
-import im.vector.matrix.android.api.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
@@ -32,20 +31,10 @@ 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 java.util.concurrent.Executors
+import java.util.concurrent.atomic.AtomicBoolean
 import javax.inject.Inject
 
-data class MatrixConfiguration(
-        val applicationFlavor: String = "Default-application-flavor",
-        val cryptoConfig: MXCryptoConfig = MXCryptoConfig()
-) {
-
-    interface Provider {
-        fun providesMatrixConfiguration(): MatrixConfiguration
-    }
-}
-
 /**
  * This is the main entry point to the matrix sdk.
  * To get the singleton instance, use getInstance static method.

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

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api
+
+import im.vector.matrix.android.api.crypto.MXCryptoConfig
+import java.net.Proxy
+
+data class MatrixConfiguration(
+        val applicationFlavor: String = "Default-application-flavor",
+        val cryptoConfig: MXCryptoConfig = MXCryptoConfig(),
+        val integrationUIUrl: String = "https://scalar.vector.im/",
+        val integrationRestUrl: String = "https://scalar.vector.im/api",
+        val integrationWidgetUrls: List<String> = listOf(
+                "https://scalar.vector.im/_matrix/integrations/v1",
+                "https://scalar.vector.im/api",
+                "https://scalar-staging.vector.im/_matrix/integrations/v1",
+                "https://scalar-staging.vector.im/api",
+                "https://scalar-staging.riot.im/scalar/api"
+        ),
+        /**
+         * Optional proxy to connect to the matrix servers
+         * You can create one using for instance Proxy(proxyType, InetSocketAddress(hostname, port)
+         */
+        val proxy: Proxy? = null
+) {
+
+    /**
+     * Can be implemented by your Application class
+     */
+    interface Provider {
+        fun providesMatrixConfiguration(): MatrixConfiguration
+    }
+}

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

@@ -20,7 +20,6 @@ import im.vector.matrix.android.api.MatrixCallback
 import im.vector.matrix.android.api.auth.data.Credentials
 import im.vector.matrix.android.api.auth.data.HomeServerConnectionConfig
 import im.vector.matrix.android.api.auth.data.LoginFlowResult
-import im.vector.matrix.android.api.auth.data.SessionParams
 import im.vector.matrix.android.api.auth.login.LoginWizard
 import im.vector.matrix.android.api.auth.registration.RegistrationWizard
 import im.vector.matrix.android.api.auth.wellknown.WellknownResult
@@ -37,6 +36,11 @@ interface AuthenticationService {
      */
     fun getLoginFlow(homeServerConnectionConfig: HomeServerConnectionConfig, callback: MatrixCallback<LoginFlowResult>): Cancelable
 
+    /**
+     * Request the supported login flows for the corresponding sessionId.
+     */
+    fun getLoginFlowOfSession(sessionId: String, callback: MatrixCallback<LoginFlowResult>): Cancelable
+
     /**
      * Return a LoginWizard, to login to the homeserver. The login flow has to be retrieved first.
      */
@@ -74,15 +78,6 @@ interface AuthenticationService {
      */
     fun getLastAuthenticatedSession(): Session?
 
-    /**
-     * Get an authenticated session. You should at least call authenticate one time before.
-     * If you logout, this session will no longer be valid.
-     *
-     * @param sessionParams the sessionParams to open with.
-     * @return the associated session if any, or null
-     */
-    fun getSession(sessionParams: SessionParams): Session?
-
     /**
      * Create a session after a SSO successful login
      */

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

@@ -32,6 +32,6 @@ const val REGISTER_FALLBACK_PATH = "/_matrix/static/client/register/"
  * Path to use when the client want to connect using SSO
  * Ref: https://matrix.org/docs/spec/client_server/latest#sso-client-login
  */
-const val SSO_FALLBACK_PATH = "/_matrix/client/r0/login/sso/redirect"
+const val SSO_REDIRECT_PATH = "/_matrix/client/r0/login/sso/redirect"
 
 const val SSO_REDIRECT_URL_PARAM = "redirectUrl"

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

@@ -45,7 +45,7 @@ data class Credentials(
          * @Deprecated. Clients should extract the server_name from user_id (by splitting at the first colon)
          * if they require it. Note also that homeserver is not spelt this way.
          */
-        @Json(name = "home_server") val homeServer: String,
+        @Json(name = "home_server") val homeServer: String?,
         /**
          * ID of the logged-in device. Will be the same as the corresponding parameter in the request, if one was specified.
          */

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

@@ -20,6 +20,7 @@ import android.net.Uri
 import com.squareup.moshi.JsonClass
 import im.vector.matrix.android.api.auth.data.HomeServerConnectionConfig.Builder
 import im.vector.matrix.android.internal.network.ssl.Fingerprint
+import im.vector.matrix.android.internal.util.ensureTrailingSlash
 import okhttp3.CipherSuite
 import okhttp3.TlsVersion
 
@@ -68,18 +69,14 @@ data class HomeServerConnectionConfig(
          */
         fun withHomeServerUri(hsUri: Uri): Builder {
             if (hsUri.scheme != "http" && hsUri.scheme != "https") {
-                throw RuntimeException("Invalid home server URI: " + hsUri)
+                throw RuntimeException("Invalid home server URI: $hsUri")
             }
             // ensure trailing /
-            homeServerUri = if (!hsUri.toString().endsWith("/")) {
-                try {
-                    val url = hsUri.toString()
-                    Uri.parse("$url/")
-                } catch (e: Exception) {
-                    throw RuntimeException("Invalid home server URI: $hsUri")
-                }
-            } else {
-                hsUri
+            val hsString = hsUri.toString().ensureTrailingSlash()
+            homeServerUri = try {
+                Uri.parse(hsString)
+            } catch (e: Exception) {
+                throw RuntimeException("Invalid home server URI: $hsUri")
             }
             return this
         }
@@ -97,15 +94,11 @@ data class HomeServerConnectionConfig(
                 throw RuntimeException("Invalid identity server URI: $identityServerUri")
             }
             // ensure trailing /
-            if (!identityServerUri.toString().endsWith("/")) {
-                try {
-                    val url = identityServerUri.toString()
-                    this.identityServerUri = Uri.parse("$url/")
-                } catch (e: Exception) {
-                    throw RuntimeException("Invalid identity server URI: $identityServerUri")
-                }
-            } else {
-                this.identityServerUri = identityServerUri
+            val isString = identityServerUri.toString().ensureTrailingSlash()
+            this.identityServerUri = try {
+                Uri.parse(isString)
+            } catch (e: Exception) {
+                throw RuntimeException("Invalid identity server URI: $identityServerUri")
             }
             return this
         }

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

@@ -16,12 +16,10 @@
 
 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
+// Either a list of supported login types, or an error if the homeserver is outdated
 sealed class LoginFlowResult {
     data class Success(
-            val loginFlowResponse: LoginFlowResponse,
+            val supportedLoginTypes: List<String>,
             val isLoginAndRegistrationSupported: Boolean,
             val homeServerUrl: String
     ) : LoginFlowResult()

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package im.vector.matrix.android.internal.auth.data
+package im.vector.matrix.android.api.auth.data
 
 object LoginFlowTypes {
     const val PASSWORD = "m.login.password"

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

@@ -21,7 +21,48 @@ package im.vector.matrix.android.api.auth.data
  * You don't have to manually instantiate it.
  */
 data class SessionParams(
+        /**
+         * Please consider using shortcuts instead
+         */
         val credentials: Credentials,
+
+        /**
+         * Please consider using shortcuts instead
+         */
         val homeServerConnectionConfig: HomeServerConnectionConfig,
+
+        /**
+         * Set to false if the current token is not valid anymore. Application should not have to use this info.
+         */
         val isTokenValid: Boolean
-)
+) {
+    /*
+     * Shortcuts. Usually the application should only need to use these shortcuts
+     */
+
+    /**
+     * The userId of the session (Ex: "@user:domain.org")
+     */
+    val userId = credentials.userId
+
+    /**
+     * The deviceId of the session (Ex: "ABCDEFGH")
+     */
+    val deviceId = credentials.deviceId
+
+    /**
+     * The current homeserver Url. It can be different that the homeserver url entered
+     * during login phase, because a redirection may have occurred
+     */
+    val homeServerUrl = homeServerConnectionConfig.homeServerUri.toString()
+
+    /**
+     * The current homeserver host
+     */
+    val homeServerHost = homeServerConnectionConfig.homeServerUri.host
+
+    /**
+     * The default identity server url if any, returned by the homeserver during login phase
+     */
+    val defaultIdentityServerUrl = homeServerConnectionConfig.identityServerUri?.toString()
+}

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

@@ -54,30 +54,4 @@ data class WellKnown(
 
         @Json(name = "m.integrations")
         val integrations: JsonDict? = 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/login/LoginWizard.kt

@@ -34,6 +34,12 @@ interface LoginWizard {
               deviceName: String,
               callback: MatrixCallback<Session>): Cancelable
 
+    /**
+     * Exchange a login token to an access token
+     */
+    fun loginWithToken(loginToken: String,
+                       callback: MatrixCallback<Session>): Cancelable
+
     /**
      * Reset user password
      */

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

@@ -21,15 +21,12 @@ 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)

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

@@ -19,11 +19,11 @@ 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(
+data class MXCryptoConfig constructor(
         // Tell whether the encryption of the event content is enabled for the invited members.
         // 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,
+        val enableEncryptionForInvitedMembers: Boolean = true,
 
         /**
          * If set to true, the SDK will automatically ignore room key request (gossiping)
@@ -31,6 +31,5 @@ data class MXCryptoConfig(
          * If set to false, the request will be forwarded to the application layer; in this
          * case the application can decide to prompt the user.
          */
-        var discardRoomKeyRequestsFromUntrustedDevices : Boolean = true
-
+        val discardRoomKeyRequestsFromUntrustedDevices: Boolean = true
 )

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

@@ -16,10 +16,15 @@
 
 package im.vector.matrix.android.api.extensions
 
-inline fun <A> tryThis(operation: () -> A): A? {
+import timber.log.Timber
+
+inline fun <A> tryThis(message: String? = null, operation: () -> A): A? {
     return try {
         operation()
     } catch (any: Throwable) {
+        if (message != null) {
+            Timber.e(any, message)
+        }
         null
     }
 }

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

@@ -39,7 +39,10 @@ data class MatrixError(
         // 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
+        @Json(name = "soft_logout") val isSoftLogout: Boolean = false,
+        // For M_INVALID_PEPPER
+        // {"error": "pepper does not match 'erZvr'", "lookup_pepper": "pQgMS", "algorithm": "sha256", "errcode": "M_INVALID_PEPPER"}
+        @Json(name = "lookup_pepper") val newLookupPepper: String? = null
 ) {
 
     companion object {
@@ -129,6 +132,11 @@ data class MatrixError(
         /** (Not documented yet) */
         const val M_WRONG_ROOM_KEYS_VERSION = "M_WRONG_ROOM_KEYS_VERSION"
 
+        const val M_TERMS_NOT_SIGNED = "M_TERMS_NOT_SIGNED"
+
+        // For identity service
+        const val M_INVALID_PEPPER = "M_INVALID_PEPPER"
+
         // Possible value for "limit_type"
         const val LIMIT_TYPE_MAU = "monthly_active_user"
     }

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

@@ -29,13 +29,25 @@ interface PushRuleService {
 
     fun getPushRules(scope: String = RuleScope.GLOBAL): RuleSet
 
-    fun updatePushRuleEnableStatus(kind: RuleKind, pushRule: PushRule, enabled: Boolean, callback: MatrixCallback<Unit>): Cancelable
+    fun updatePushRuleEnableStatus(kind: RuleKind,
+                                   pushRule: PushRule,
+                                   enabled: Boolean,
+                                   callback: MatrixCallback<Unit>): Cancelable
 
-    fun addPushRule(kind: RuleKind, pushRule: PushRule, callback: MatrixCallback<Unit>): Cancelable
+    fun addPushRule(kind: RuleKind,
+                    pushRule: PushRule,
+                    beforeRuleId: String?,
+                    afterRuleId: String?,
+                    callback: MatrixCallback<Unit>): Cancelable
 
-    fun updatePushRuleActions(kind: RuleKind, oldPushRule: PushRule, newPushRule: PushRule, callback: MatrixCallback<Unit>): Cancelable
+    fun updatePushRuleActions(kind: RuleKind,
+                              oldPushRule: PushRule,
+                              newPushRule: PushRule,
+                              callback: MatrixCallback<Unit>): Cancelable
 
-    fun removePushRule(kind: RuleKind, pushRule: PushRule, callback: MatrixCallback<Unit>): Cancelable
+    fun removePushRule(kind: RuleKind,
+                       pushRule: PushRule,
+                       callback: MatrixCallback<Unit>): Cancelable
 
     fun addPushRuleListener(listener: PushRuleListener)
 

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

@@ -39,6 +39,6 @@ class SenderNotificationPermissionCondition(
 
     fun isSatisfied(event: Event, powerLevels: PowerLevelsContent): Boolean {
         val powerLevelsHelper = PowerLevelsHelper(powerLevels)
-        return event.senderId != null && powerLevelsHelper.getUserPowerLevel(event.senderId) >= powerLevelsHelper.notificationLevel(key)
+        return event.senderId != null && powerLevelsHelper.getUserPowerLevelValue(event.senderId) >= powerLevelsHelper.notificationLevel(key)
     }
 }

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

@@ -31,7 +31,7 @@ internal data class GetPushRulesResponse(
         val global: RuleSet,
 
         /**
-         * Device specific rules, apply only to current device
+         * Device specific rules, apply only to current device. Not used anymore
          */
         @Json(name = "device")
         val device: RuleSet? = null

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

@@ -25,8 +25,8 @@ sealed class QueryStringValue {
     object IsNotNull : QueryStringValue()
     object IsEmpty : QueryStringValue()
     object IsNotEmpty : QueryStringValue()
-    data class Equals(val string: String, val case: Case) : QueryStringValue()
-    data class Contains(val string: String, val case: Case) : QueryStringValue()
+    data class Equals(val string: String, val case: Case = Case.SENSITIVE) : QueryStringValue()
+    data class Contains(val string: String, val case: Case = Case.SENSITIVE) : QueryStringValue()
 
     enum class Case {
         SENSITIVE,

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

@@ -24,12 +24,15 @@ import im.vector.matrix.android.api.pushrules.PushRuleService
 import im.vector.matrix.android.api.session.account.AccountService
 import im.vector.matrix.android.api.session.accountdata.AccountDataService
 import im.vector.matrix.android.api.session.cache.CacheService
+import im.vector.matrix.android.api.session.call.CallSignalingService
 import im.vector.matrix.android.api.session.content.ContentUploadStateTracker
 import im.vector.matrix.android.api.session.content.ContentUrlResolver
 import im.vector.matrix.android.api.session.crypto.CryptoService
 import im.vector.matrix.android.api.session.file.FileService
 import im.vector.matrix.android.api.session.group.GroupService
 import im.vector.matrix.android.api.session.homeserver.HomeServerCapabilitiesService
+import im.vector.matrix.android.api.session.identity.IdentityService
+import im.vector.matrix.android.api.session.integrationmanager.IntegrationManagerService
 import im.vector.matrix.android.api.session.profile.ProfileService
 import im.vector.matrix.android.api.session.pushers.PushersService
 import im.vector.matrix.android.api.session.room.RoomDirectoryService
@@ -39,7 +42,9 @@ import im.vector.matrix.android.api.session.securestorage.SharedSecretStorageSer
 import im.vector.matrix.android.api.session.signout.SignOutService
 import im.vector.matrix.android.api.session.sync.FilterService
 import im.vector.matrix.android.api.session.sync.SyncState
+import im.vector.matrix.android.api.session.terms.TermsService
 import im.vector.matrix.android.api.session.user.UserService
+import im.vector.matrix.android.api.session.widgets.WidgetService
 
 /**
  * This interface defines interactions with a session.
@@ -54,6 +59,7 @@ interface Session :
         SignOutService,
         FilterService,
         FileService,
+        TermsService,
         ProfileService,
         PushRuleService,
         PushersService,
@@ -77,7 +83,7 @@ interface Session :
      * Useful shortcut to get access to the userId
      */
     val myUserId: String
-        get() = sessionParams.credentials.userId
+        get() = sessionParams.userId
 
     /**
      * The sessionId
@@ -145,6 +151,26 @@ interface Session :
      */
     fun cryptoService(): CryptoService
 
+    /**
+     * Returns the identity service associated with the session
+     */
+    fun identityService(): IdentityService
+
+    /**
+     * Returns the widget service associated with the session
+     */
+    fun widgetService(): WidgetService
+
+    /**
+     * Returns the integration manager service associated with the session
+     */
+    fun integrationManagerService(): IntegrationManagerService
+
+    /**
+     * Returns the call signaling service associated with the session
+     */
+    fun callSignalingService(): CallSignalingService
+
     /**
      * Add a listener to the session.
      * @param listener the listener to add.

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

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.session.call
+
+import im.vector.matrix.android.api.MatrixCallback
+import im.vector.matrix.android.api.util.Cancelable
+
+interface CallSignalingService {
+
+    fun getTurnServer(callback: MatrixCallback<TurnServerResponse>): Cancelable
+
+    /**
+     * Create an outgoing call
+     */
+    fun createOutgoingCall(roomId: String, otherUserId: String, isVideoCall: Boolean): MxCall
+
+    fun addCallListener(listener: CallsListener)
+
+    fun removeCallListener(listener: CallsListener)
+
+    fun getCallWithId(callId: String) : MxCall?
+}

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

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.session.call
+
+import org.webrtc.PeerConnection
+
+sealed class CallState {
+
+    /** Idle, setting up objects */
+    object Idle : CallState()
+
+    /** Dialing.  Outgoing call is signaling the remote peer */
+    object Dialing : CallState()
+
+    /** Local ringing. Incoming call offer received */
+    object LocalRinging : CallState()
+
+    /** Answering.  Incoming call is responding to remote peer */
+    object Answering : CallState()
+
+    /**
+     * Connected. Incoming/Outgoing call, ice layer connecting or connected
+     * Notice that the PeerState failed is not always final, if you switch network, new ice candidtates
+     * could be exchanged, and the connection could go back to connected
+     * */
+    data class Connected(val iceConnectionState: PeerConnection.PeerConnectionState) : CallState()
+
+    /** Terminated.  Incoming/Outgoing call, the call is terminated */
+    object Terminated : CallState()
+}

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

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.session.call
+
+import im.vector.matrix.android.api.session.room.model.call.CallAnswerContent
+import im.vector.matrix.android.api.session.room.model.call.CallCandidatesContent
+import im.vector.matrix.android.api.session.room.model.call.CallHangupContent
+import im.vector.matrix.android.api.session.room.model.call.CallInviteContent
+
+interface CallsListener {
+    /**
+     * Called when there is an incoming call within the room.
+     */
+    fun onCallInviteReceived(mxCall: MxCall, callInviteContent: CallInviteContent)
+
+    fun onCallIceCandidateReceived(mxCall: MxCall, iceCandidatesContent: CallCandidatesContent)
+
+    /**
+     * An outgoing call is started.
+     */
+    fun onCallAnswerReceived(callAnswerContent: CallAnswerContent)
+
+    /**
+     * Called when a called has been hung up
+     */
+    fun onCallHangupReceived(callHangupContent: CallHangupContent)
+
+    fun onCallManagedByOtherSession(callId: String)
+}

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

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package im.vector.matrix.android.api.session.call
+
+import org.webrtc.EglBase
+import timber.log.Timber
+
+/**
+ * The root [EglBase] instance shared by the entire application for
+ * the sake of reducing the utilization of system resources (such as EGL
+ * contexts)
+ * by performing a runtime check.
+ */
+object EglUtils {
+
+    // TODO how do we release that?
+
+    /**
+     * Lazily creates and returns the one and only [EglBase] which will
+     * serve as the root for all contexts that are needed.
+     */
+    @get:Synchronized var rootEglBase: EglBase? = null
+        get() {
+            if (field == null) {
+                val configAttributes = EglBase.CONFIG_PLAIN
+                try {
+                    field = EglBase.createEgl14(configAttributes)
+                            ?: EglBase.createEgl10(configAttributes) // Fall back to EglBase10.
+                } catch (ex: Throwable) {
+                    Timber.e(ex, "Failed to create EglBase")
+                }
+            }
+            return field
+        }
+        private set
+
+    val rootEglBaseContext: EglBase.Context?
+        get() {
+            val eglBase = rootEglBase
+            return eglBase?.eglBaseContext
+        }
+}

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

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.session.call
+
+import org.webrtc.IceCandidate
+import org.webrtc.SessionDescription
+
+interface MxCallDetail {
+    val callId: String
+    val isOutgoing: Boolean
+    val roomId: String
+    val otherUserId: String
+    val isVideoCall: Boolean
+}
+
+/**
+ * Define both an incoming call and on outgoing call
+ */
+interface MxCall : MxCallDetail {
+
+    var state: CallState
+    /**
+     * Pick Up the incoming call
+     * It has no effect on outgoing call
+     */
+    fun accept(sdp: SessionDescription)
+
+    /**
+     * Reject an incoming call
+     * It's an alias to hangUp
+     */
+    fun reject() = hangUp()
+
+    /**
+     * End the call
+     */
+    fun hangUp()
+
+    /**
+     * Start a call
+     * Send offer SDP to the other participant.
+     */
+    fun offerSdp(sdp: SessionDescription)
+
+    /**
+     * Send Ice candidate to the other participant.
+     */
+    fun sendLocalIceCandidates(candidates: List<IceCandidate>)
+
+    /**
+     * Send removed ICE candidates to the other participant.
+     */
+    fun sendLocalIceCandidateRemovals(candidates: List<IceCandidate>)
+
+    fun addListener(listener: StateListener)
+    fun removeListener(listener: StateListener)
+
+    interface StateListener {
+        fun onStateUpdate(call: MxCall)
+    }
+}

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

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.session.call
+
+import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
+
+// TODO Should not be exposed
+/**
+ * Ref: https://matrix.org/docs/spec/client_server/r0.6.1#get-matrix-client-r0-voip-turnserver
+ */
+@JsonClass(generateAdapter = true)
+data class TurnServerResponse(
+        /**
+         * Required. The username to use.
+         */
+        @Json(name = "username") val username: String?,
+
+        /**
+         * Required. The password to use.
+         */
+        @Json(name = "password") val password: String?,
+
+        /**
+         * Required. A list of TURN URIs
+         */
+        @Json(name = "uris") val uris: List<String>?,
+
+        /**
+         * Required. The time-to-live in seconds
+         */
+        @Json(name = "ttl") val ttl: Int?
+)

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

@@ -138,7 +138,9 @@ interface CryptoService {
 
     fun removeSessionListener(listener: NewSessionListener)
 
-    fun getOutgoingRoomKeyRequest(): List<OutgoingRoomKeyRequest>
-    fun getIncomingRoomKeyRequest(): List<IncomingRoomKeyRequest>
+    fun getOutgoingRoomKeyRequests(): List<OutgoingRoomKeyRequest>
+
+    fun getIncomingRoomKeyRequests(): List<IncomingRoomKeyRequest>
+
     fun getGossipingEventsTrail(): List<Event>
 }

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

@@ -98,7 +98,7 @@ data class Event(
      * @return true if event is state event.
      */
     fun isStateEvent(): Boolean {
-        return EventType.isStateEvent(getClearType())
+        return stateKey != null
     }
 
     // ==============================================================================================================
@@ -162,6 +162,8 @@ data class Event(
      */
     fun isRedactedBySameUser() = senderId == unsignedData?.redactedEvent?.senderId
 
+    fun resolvedPrevContent(): Content? = prevContent ?: unsignedData?.prevContent
+
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
         if (javaClass != other?.javaClass) return false
@@ -220,3 +222,11 @@ fun Event.isImageMessage(): Boolean {
         else                      -> false
     }
 }
+
+fun Event.isVideoMessage(): Boolean {
+    return getClearType() == EventType.MESSAGE
+            && when (getClearContent()?.toModel<MessageContent>()?.msgType) {
+        MessageType.MSGTYPE_VIDEO -> true
+        else                      -> false
+    }
+}

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

@@ -38,6 +38,8 @@ object EventType {
 
     // State Events
 
+    const val STATE_ROOM_WIDGET_LEGACY = "im.vector.modular.widgets"
+    const val STATE_ROOM_WIDGET = "m.widget"
     const val STATE_ROOM_NAME = "m.room.name"
     const val STATE_ROOM_TOPIC = "m.room.topic"
     const val STATE_ROOM_AVATAR = "m.room.avatar"
@@ -56,7 +58,6 @@ object EventType {
     const val STATE_ROOM_ENCRYPTION = "m.room.encryption"
 
     // Call Events
-
     const val CALL_INVITE = "m.call.invite"
     const val CALL_CANDIDATES = "m.call.candidates"
     const val CALL_ANSWER = "m.call.answer"
@@ -84,29 +85,6 @@ object EventType {
     // Unwedging
     internal const val DUMMY = "m.dummy"
 
-    private val STATE_EVENTS = listOf(
-            STATE_ROOM_NAME,
-            STATE_ROOM_TOPIC,
-            STATE_ROOM_AVATAR,
-            STATE_ROOM_MEMBER,
-            STATE_ROOM_THIRD_PARTY_INVITE,
-            STATE_ROOM_CREATE,
-            STATE_ROOM_JOIN_RULES,
-            STATE_ROOM_GUEST_ACCESS,
-            STATE_ROOM_POWER_LEVELS,
-            STATE_ROOM_ALIASES,
-            STATE_ROOM_TOMBSTONE,
-            STATE_ROOM_CANONICAL_ALIAS,
-            STATE_ROOM_HISTORY_VISIBILITY,
-            STATE_ROOM_RELATED_GROUPS,
-            STATE_ROOM_PINNED_EVENT,
-            STATE_ROOM_ENCRYPTION
-    )
-
-    fun isStateEvent(type: String): Boolean {
-        return STATE_EVENTS.contains(type)
-    }
-
     fun isCallEvent(type: String): Boolean {
         return type == CALL_INVITE
                 || type == CALL_CANDIDATES

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

@@ -24,7 +24,15 @@ data class HomeServerCapabilities(
         /**
          * Max size of file which can be uploaded to the homeserver in bytes. [MAX_UPLOAD_FILE_SIZE_UNKNOWN] if unknown or not retrieved yet
          */
-        val maxUploadFileSize: Long = MAX_UPLOAD_FILE_SIZE_UNKNOWN
+        val maxUploadFileSize: Long = MAX_UPLOAD_FILE_SIZE_UNKNOWN,
+        /**
+         * Last version identity server and binding supported
+         */
+        val lastVersionIdentityServerSupported: Boolean = false,
+        /**
+         * Default identity server url, provided in Wellknown
+         */
+        val defaultIdentityServerUrl: String? = null
 ) {
     companion object {
         const val MAX_UPLOAD_FILE_SIZE_UNKNOWN = -1L

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

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

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

@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.session.identity
+
+import im.vector.matrix.android.api.MatrixCallback
+import im.vector.matrix.android.api.util.Cancelable
+
+/**
+ * Provides access to the identity server configuration and services identity server can provide
+ */
+interface IdentityService {
+    /**
+     * Return the default identity server of the user, which may have been provided at login time by the homeserver,
+     * or by the Well-known setup of the homeserver
+     * It may be different from the current configured identity server
+     */
+    fun getDefaultIdentityServer(): String?
+
+    /**
+     * Return the current identity server URL used by this account. Returns null if no identity server is configured.
+     */
+    fun getCurrentIdentityServerUrl(): String?
+
+    /**
+     * Check if the identity server is valid
+     * See https://matrix.org/docs/spec/identity_service/latest#status-check
+     * RiotX SDK only supports identity server API v2
+     */
+    fun isValidIdentityServer(url: String, callback: MatrixCallback<Unit>): Cancelable
+
+    /**
+     * Update the identity server url.
+     * If successful, any previous identity server will be disconnected.
+     * In case of error, any previous identity server will remain configured.
+     * @param url the new url.
+     * @param callback will notify the user if change is successful. The String will be the final url of the identity server.
+     * The SDK can prepend "https://" for instance.
+     */
+    fun setNewIdentityServer(url: String, callback: MatrixCallback<String>): Cancelable
+
+    /**
+     * Disconnect (logout) from the current identity server
+     */
+    fun disconnect(callback: MatrixCallback<Unit>): Cancelable
+
+    /**
+     * This will ask the identity server to send an email or an SMS to let the user confirm he owns the ThreePid
+     */
+    fun startBindThreePid(threePid: ThreePid, callback: MatrixCallback<Unit>): Cancelable
+
+    /**
+     * This will cancel a pending binding of threePid.
+     */
+    fun cancelBindThreePid(threePid: ThreePid, callback: MatrixCallback<Unit>): Cancelable
+
+    /**
+     * This will ask the identity server to send an new email or a new SMS to let the user confirm he owns the ThreePid
+     */
+    fun sendAgainValidationCode(threePid: ThreePid, callback: MatrixCallback<Unit>): Cancelable
+
+    /**
+     * Submit the code that the identity server has sent to the user (in email or SMS)
+     * Once successful, you will have to call [finalizeBindThreePid]
+     * @param code the code sent to the user
+     */
+    fun submitValidationToken(threePid: ThreePid, code: String, callback: MatrixCallback<Unit>): Cancelable
+
+    /**
+     * This will perform the actual association of ThreePid and Matrix account
+     */
+    fun finalizeBindThreePid(threePid: ThreePid, callback: MatrixCallback<Unit>): Cancelable
+
+    /**
+     * Unbind a threePid
+     * The request will actually be done on the homeserver
+     */
+    fun unbindThreePid(threePid: ThreePid, callback: MatrixCallback<Unit>): Cancelable
+
+    /**
+     * Search MatrixId of users providing email and phone numbers
+     */
+    fun lookUp(threePids: List<ThreePid>, callback: MatrixCallback<List<FoundThreePid>>): Cancelable
+
+    /**
+     * Get the status of the current user's threePid
+     * A lookup will be performed, but also pending binding state will be restored
+     *
+     * @param threePids the list of threePid the user owns (retrieved form the homeserver)
+     * @param callback onSuccess will be called with a map of ThreePid -> SharedState
+     */
+    fun getShareStatus(threePids: List<ThreePid>, callback: MatrixCallback<Map<ThreePid, SharedState>>): Cancelable
+
+    fun addListener(listener: IdentityServiceListener)
+    fun removeListener(listener: IdentityServiceListener)
+}

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

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.session.identity
+
+import im.vector.matrix.android.api.failure.Failure
+
+sealed class IdentityServiceError : Failure.FeatureFailure() {
+    object OutdatedIdentityServer : IdentityServiceError()
+    object OutdatedHomeServer : IdentityServiceError()
+    object NoIdentityServerConfigured : IdentityServiceError()
+    object TermsNotSignedException : IdentityServiceError()
+    object BulkLookupSha256NotSupported : IdentityServiceError()
+    object BindingError : IdentityServiceError()
+    object NoCurrentBindingError : IdentityServiceError()
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 New Vector Ltd
+ * Copyright (c) 2020 New Vector Ltd
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,9 +13,9 @@
  * 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
-)
+package im.vector.matrix.android.api.session.identity
+
+interface IdentityServiceListener {
+    fun onIdentityServerChange()
+}

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

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

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

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.session.identity
+
+import com.google.i18n.phonenumbers.NumberParseException
+import com.google.i18n.phonenumbers.PhoneNumberUtil
+import im.vector.matrix.android.internal.session.profile.ThirdPartyIdentifier
+
+sealed class ThreePid(open val value: String) {
+    data class Email(val email: String) : ThreePid(email)
+    data class Msisdn(val msisdn: String) : ThreePid(msisdn)
+}
+
+internal fun ThreePid.toMedium(): String {
+    return when (this) {
+        is ThreePid.Email  -> ThirdPartyIdentifier.MEDIUM_EMAIL
+        is ThreePid.Msisdn -> ThirdPartyIdentifier.MEDIUM_MSISDN
+    }
+}
+
+@Throws(NumberParseException::class)
+internal fun ThreePid.Msisdn.getCountryCode(): String {
+    return with(PhoneNumberUtil.getInstance()) {
+        getRegionCodeForCountryCode(parse("+$msisdn", null).countryCode)
+    }
+}

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

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package im.vector.matrix.android.api.session.integrationmanager
+
+/**
+ * This class holds configuration of integration manager.
+ */
+data class IntegrationManagerConfig(
+        val uiUrl: String,
+        val restUrl: String,
+        val kind: Kind
+) {
+
+    // Order matters, first is preferred
+    /**
+     * The kind of config, it will reflect where the data is coming from.
+     */
+    enum class Kind {
+        /**
+         * Defined in UserAccountData
+         */
+        ACCOUNT,
+        /**
+         * Defined in Wellknown
+         */
+        HOMESERVER,
+        /**
+         * Fallback value, hardcoded by the SDK
+         */
+        DEFAULT
+    }
+}

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

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.session.integrationmanager
+
+import im.vector.matrix.android.api.MatrixCallback
+import im.vector.matrix.android.api.util.Cancelable
+
+/**
+ * This is the entry point to manage integration. You can grab an instance of this service through an active session.
+ */
+interface IntegrationManagerService {
+
+    /**
+     * This listener allow you to observe change related to integrations.
+     */
+    interface Listener {
+        /**
+         * Is called whenever integration is enabled or disabled, comes from user account data.
+         */
+        fun onIsEnabledChanged(enabled: Boolean) {
+            // No-op
+        }
+
+        /**
+         * Is called whenever configs from user account data or wellknown are updated.
+         */
+        fun onConfigurationChanged(configs: List<IntegrationManagerConfig>) {
+            // No-op
+        }
+
+        /**
+         * Is called whenever widget permissions from user account data are updated.
+         */
+        fun onWidgetPermissionsChanged(widgets: Map<String, Boolean>) {
+            // No-op
+        }
+    }
+
+    /**
+     * Adds a listener to observe changes.
+     */
+    fun addListener(listener: Listener)
+
+    /**
+     * Removes a previously added listener.
+     */
+    fun removeListener(listener: Listener)
+
+    /**
+     * Return the list of current configurations, sorted by kind. First one is preferred.
+     * See [IntegrationManagerConfig.Kind]
+     */
+    fun getOrderedConfigs(): List<IntegrationManagerConfig>
+
+    /**
+     * Return the preferred current configuration.
+     * See [IntegrationManagerConfig.Kind]
+     */
+    fun getPreferredConfig(): IntegrationManagerConfig
+
+    /**
+     * Returns true if integration is enabled, false otherwise.
+     */
+    fun isIntegrationEnabled(): Boolean
+
+    /**
+     * Offers to enable or disable the integration.
+     * @param enable the param to change
+     * @param callback the matrix callback to listen for result.
+     * @return Cancelable
+     */
+    fun setIntegrationEnabled(enable: Boolean, callback: MatrixCallback<Unit>): Cancelable
+
+    /**
+     * Offers to allow or disallow a widget.
+     * @param stateEventId the eventId of the state event defining the widget.
+     * @param allowed the param to change
+     * @param callback the matrix callback to listen for result.
+     * @return Cancelable
+     */
+    fun setWidgetAllowed(stateEventId: String, allowed: Boolean, callback: MatrixCallback<Unit>): Cancelable
+
+    /**
+     * Returns true if the widget is allowed, false otherwise.
+     * @param stateEventId the eventId of the state event defining the widget.
+     */
+    fun isWidgetAllowed(stateEventId: String): Boolean
+
+    /**
+     * Offers to allow or disallow a native widget domain.
+     * @param widgetType the widget type to check for
+     * @param domain the domain to check for
+     */
+    fun setNativeWidgetDomainAllowed(widgetType: String, domain: String, allowed: Boolean, callback: MatrixCallback<Unit>): Cancelable
+
+    /**
+     * Returns true if the widget domain is allowed, false otherwise.
+     * @param widgetType the widget type to check for
+     * @param domain the domain to check for
+     */
+    fun isNativeWidgetDomainAllowed(widgetType: String, domain: String): Boolean
+}

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

@@ -17,7 +17,9 @@
 
 package im.vector.matrix.android.api.session.profile
 
+import androidx.lifecycle.LiveData
 import im.vector.matrix.android.api.MatrixCallback
+import im.vector.matrix.android.api.session.identity.ThreePid
 import im.vector.matrix.android.api.util.Cancelable
 import im.vector.matrix.android.api.util.JsonDict
 import im.vector.matrix.android.api.util.Optional
@@ -33,12 +35,19 @@ interface ProfileService {
     }
 
     /**
-     * Return the current dispayname for this user
+     * Return the current display name for this user
      * @param userId the userId param to look for
      *
      */
     fun getDisplayName(userId: String, matrixCallback: MatrixCallback<Optional<String>>): Cancelable
 
+    /**
+     * Update the display name for this user
+     * @param userId the userId to update the display name of
+     * @param newDisplayName the new display name of the user
+     */
+    fun setDisplayName(userId: String, newDisplayName: String, matrixCallback: MatrixCallback<Unit>): Cancelable
+
     /**
      * Return the current avatarUrl for this user.
      * @param userId the userId param to look for
@@ -53,4 +62,15 @@ interface ProfileService {
      *
      */
     fun getProfile(userId: String, matrixCallback: MatrixCallback<JsonDict>): Cancelable
+
+    /**
+     * Get the current user 3Pids
+     */
+    fun getThreePids(): List<ThreePid>
+
+    /**
+     * Get the current user 3Pids Live
+     * @param refreshData set to true to fetch data from the homeserver
+     */
+    fun getThreePidsLive(refreshData: Boolean): LiveData<List<ThreePid>>
 }

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

@@ -17,6 +17,7 @@
 package im.vector.matrix.android.api.session.room
 
 import androidx.lifecycle.LiveData
+import im.vector.matrix.android.api.session.room.call.RoomCallService
 import im.vector.matrix.android.api.session.room.crypto.RoomCryptoService
 import im.vector.matrix.android.api.session.room.members.MembershipService
 import im.vector.matrix.android.api.session.room.model.RoomSummary
@@ -27,8 +28,10 @@ import im.vector.matrix.android.api.session.room.reporting.ReportingService
 import im.vector.matrix.android.api.session.room.send.DraftService
 import im.vector.matrix.android.api.session.room.send.SendService
 import im.vector.matrix.android.api.session.room.state.StateService
+import im.vector.matrix.android.api.session.room.tags.TagsService
 import im.vector.matrix.android.api.session.room.timeline.TimelineService
 import im.vector.matrix.android.api.session.room.typing.TypingService
+import im.vector.matrix.android.api.session.room.uploads.UploadsService
 import im.vector.matrix.android.api.util.Optional
 
 /**
@@ -40,9 +43,12 @@ interface Room :
         DraftService,
         ReadService,
         TypingService,
+        TagsService,
         MembershipService,
         StateService,
+        UploadsService,
         ReportingService,
+        RoomCallService,
         RelationService,
         RoomCryptoService,
         RoomPushRuleService {

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

@@ -73,15 +73,17 @@ interface RoomService {
 
     /**
      * Get a snapshot list of Breadcrumbs
+     * @param queryParams parameters to query the room summaries. It can be use to keep only joined rooms, for instance.
      * @return the immutable list of [RoomSummary]
      */
-    fun getBreadcrumbs(): List<RoomSummary>
+    fun getBreadcrumbs(queryParams: RoomSummaryQueryParams): List<RoomSummary>
 
     /**
      * Get a live list of Breadcrumbs
+     * @param queryParams parameters to query the room summaries. It can be use to keep only joined rooms, for instance.
      * @return the [LiveData] of [RoomSummary]
      */
-    fun getBreadcrumbsLive(): LiveData<List<RoomSummary>>
+    fun getBreadcrumbsLive(queryParams: RoomSummaryQueryParams): LiveData<List<RoomSummary>>
 
     /**
      * Inform the Matrix SDK that a room is displayed.

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

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.session.room.call
+
+/**
+ * This interface defines methods to handle calls in a room. It's implemented at the room level.
+ */
+interface RoomCallService {
+    /**
+     * Return true if calls (audio or video) can be performed on this Room
+     */
+    fun canStartCall(): Boolean
+}

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

@@ -63,6 +63,27 @@ interface MembershipService {
                reason: String? = null,
                callback: MatrixCallback<Unit>): Cancelable
 
+    /**
+     * Ban a user from the room
+     */
+    fun ban(userId: String,
+            reason: String? = null,
+            callback: MatrixCallback<Unit>): Cancelable
+
+    /**
+     * Unban a user from the room
+     */
+    fun unban(userId: String,
+              reason: String? = null,
+              callback: MatrixCallback<Unit>): Cancelable
+
+    /**
+     * Kick a user from the room
+     */
+    fun kick(userId: String,
+             reason: String? = null,
+             callback: MatrixCallback<Unit>): Cancelable
+
     /**
      * Join the room, or accept an invitation.
      */

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

@@ -17,10 +17,12 @@
 package im.vector.matrix.android.api.session.room.model
 
 import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
 
 /**
  * Represents the membership of a user on a room
  */
+@JsonClass(generateAdapter = false)
 enum class Membership(val value: String) {
 
     NONE("none"),
@@ -44,6 +46,10 @@ enum class Membership(val value: String) {
         return this == KNOCK || this == LEAVE || this == BAN
     }
 
+    fun isActive(): Boolean {
+        return activeMemberships().contains(this)
+    }
+
     companion object {
         fun activeMemberships(): List<Membership> {
             return listOf(INVITE, JOIN)

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

@@ -18,21 +18,21 @@ package im.vector.matrix.android.api.session.room.model
 
 import com.squareup.moshi.Json
 import com.squareup.moshi.JsonClass
-import im.vector.matrix.android.api.session.room.powerlevels.PowerLevelsConstants
+import im.vector.matrix.android.api.session.room.powerlevels.Role
 
 /**
  * Class representing the EventType.EVENT_TYPE_STATE_ROOM_POWER_LEVELS state event content.
  */
 @JsonClass(generateAdapter = true)
 data class PowerLevelsContent(
-        @Json(name = "ban") val ban: Int = PowerLevelsConstants.DEFAULT_ROOM_MODERATOR_LEVEL,
-        @Json(name = "kick") val kick: Int = PowerLevelsConstants.DEFAULT_ROOM_MODERATOR_LEVEL,
-        @Json(name = "invite") val invite: Int = PowerLevelsConstants.DEFAULT_ROOM_MODERATOR_LEVEL,
-        @Json(name = "redact") val redact: Int = PowerLevelsConstants.DEFAULT_ROOM_MODERATOR_LEVEL,
-        @Json(name = "events_default") val eventsDefault: Int = PowerLevelsConstants.DEFAULT_ROOM_USER_LEVEL,
+        @Json(name = "ban") val ban: Int = Role.Moderator.value,
+        @Json(name = "kick") val kick: Int = Role.Moderator.value,
+        @Json(name = "invite") val invite: Int = Role.Moderator.value,
+        @Json(name = "redact") val redact: Int = Role.Moderator.value,
+        @Json(name = "events_default") val eventsDefault: Int = Role.Default.value,
         @Json(name = "events") val events: MutableMap<String, Int> = HashMap(),
-        @Json(name = "users_default") val usersDefault: Int = PowerLevelsConstants.DEFAULT_ROOM_USER_LEVEL,
+        @Json(name = "users_default") val usersDefault: Int = Role.Default.value,
         @Json(name = "users") val users: MutableMap<String, Int> = HashMap(),
-        @Json(name = "state_default") val stateDefault: Int = PowerLevelsConstants.DEFAULT_ROOM_MODERATOR_LEVEL,
+        @Json(name = "state_default") val stateDefault: Int = Role.Moderator.value,
         @Json(name = "notifications") val notifications: Map<String, Any> = HashMap()
 )

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

@@ -17,7 +17,9 @@
 package im.vector.matrix.android.api.session.room.model
 
 import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
 
+@JsonClass(generateAdapter = false)
 enum class RoomDirectoryVisibility {
     @Json(name = "private") PRIVATE,
     @Json(name = "public") PUBLIC

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

@@ -29,6 +29,7 @@ data class RoomGuestAccessContent(
         @Json(name = "guest_access") val guestAccess: GuestAccess? = null
 )
 
+@JsonClass(generateAdapter = false)
 enum class GuestAccess(val value: String) {
     @Json(name = "can_join")
     CanJoin("can_join"),

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

@@ -17,10 +17,12 @@
 package im.vector.matrix.android.api.session.room.model
 
 import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
 
 /**
  * Ref: https://matrix.org/docs/spec/client_server/latest#room-history-visibility
  */
+@JsonClass(generateAdapter = false)
 enum class RoomHistoryVisibility {
     /**
      * All events while this is the m.room.history_visibility value may be shared by any

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

@@ -18,10 +18,12 @@
 package im.vector.matrix.android.api.session.room.model
 
 import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
 
 /**
  * Enum for [RoomJoinRulesContent] : https://matrix.org/docs/spec/client_server/r0.4.0#m-room-join-rules
  */
+@JsonClass(generateAdapter = false)
 enum class RoomJoinRules(val value: String) {
 
     @Json(name = "public")

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

@@ -59,6 +59,12 @@ data class RoomSummary constructor(
     val hasNewMessages: Boolean
         get() = notificationCount != 0
 
+    val isFavorite: Boolean
+        get() = tags.any { it.name == RoomTag.ROOM_TAG_FAVOURITE }
+
+    val canStartCall: Boolean
+        get() = isDirect && joinedMembersCount == 2
+
     companion object {
         const val NOT_IN_BREADCRUMBS = -1
     }

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

@@ -19,16 +19,34 @@ package im.vector.matrix.android.api.session.room.model.call
 import com.squareup.moshi.Json
 import com.squareup.moshi.JsonClass
 
+/**
+ * This event is sent by the callee when they wish to answer the call.
+ */
 @JsonClass(generateAdapter = true)
 data class CallAnswerContent(
+        /**
+         * Required. The ID of the call this event relates to.
+         */
         @Json(name = "call_id") val callId: String,
-        @Json(name = "version") val version: Int,
-        @Json(name = "answer") val answer: Answer
+        /**
+         * Required. The session description object
+         */
+        @Json(name = "answer") val answer: Answer,
+        /**
+         * Required. The version of the VoIP specification this messages adheres to. This specification is version 0.
+         */
+        @Json(name = "version") val version: Int = 0
 ) {
 
     @JsonClass(generateAdapter = true)
     data class Answer(
-            @Json(name = "type") val type: String,
+            /**
+             * Required. The type of session description. Must be 'answer'.
+             */
+            @Json(name = "type") val type: SdpType = SdpType.ANSWER,
+            /**
+             * Required. The SDP text of the session description.
+             */
             @Json(name = "sdp") val sdp: String
     )
 }

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

@@ -19,17 +19,39 @@ package im.vector.matrix.android.api.session.room.model.call
 import com.squareup.moshi.Json
 import com.squareup.moshi.JsonClass
 
+/**
+ * This event is sent by callers after sending an invite and by the callee after answering.
+ * Its purpose is to give the other party additional ICE candidates to try using to communicate.
+ */
 @JsonClass(generateAdapter = true)
 data class CallCandidatesContent(
+        /**
+         * Required. The ID of the call this event relates to.
+         */
         @Json(name = "call_id") val callId: String,
-        @Json(name = "version") val version: Int,
-        @Json(name = "candidates") val candidates: List<Candidate> = emptyList()
+        /**
+         * Required. Array of objects describing the candidates.
+         */
+        @Json(name = "candidates") val candidates: List<Candidate> = emptyList(),
+        /**
+         * Required. The version of the VoIP specification this messages adheres to. This specification is version 0.
+         */
+        @Json(name = "version") val version: Int = 0
 ) {
 
     @JsonClass(generateAdapter = true)
     data class Candidate(
+            /**
+             * Required. The SDP media type this candidate is intended for.
+             */
             @Json(name = "sdpMid") val sdpMid: String,
-            @Json(name = "sdpMLineIndex") val sdpMLineIndex: String,
+            /**
+             * Required. The index of the SDP 'm' line this candidate is intended for.
+             */
+            @Json(name = "sdpMLineIndex") val sdpMLineIndex: Int,
+            /**
+             * Required. The SDP 'a' line of the candidate.
+             */
             @Json(name = "candidate") val candidate: String
     )
 }

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

@@ -19,8 +19,32 @@ package im.vector.matrix.android.api.session.room.model.call
 import com.squareup.moshi.Json
 import com.squareup.moshi.JsonClass
 
+/**
+ * Sent by either party to signal their termination of the call. This can be sent either once
+ * the call has been established or before to abort the call.
+ */
 @JsonClass(generateAdapter = true)
 data class CallHangupContent(
+        /**
+         * Required. The ID of the call this event relates to.
+         */
         @Json(name = "call_id") val callId: String,
-        @Json(name = "version") val version: Int
-)
+        /**
+         * Required. The version of the VoIP specification this message adheres to. This specification is version 0.
+         */
+        @Json(name = "version") val version: Int = 0,
+        /**
+         * Optional error reason for the hangup. This should not be provided when the user naturally ends or rejects the call.
+         * When there was an error in the call negotiation, this should be `ice_failed` for when ICE negotiation fails
+         * or `invite_timeout` for when the other party did not answer in time. One of: ["ice_failed", "invite_timeout"]
+         */
+        @Json(name = "reason") val reason: Reason? = null
+) {
+    enum class Reason {
+        @Json(name = "ice_failed")
+        ICE_FAILED,
+
+        @Json(name = "invite_timeout")
+        INVITE_TIMEOUT
+    }
+}

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

@@ -19,23 +19,45 @@ package im.vector.matrix.android.api.session.room.model.call
 import com.squareup.moshi.Json
 import com.squareup.moshi.JsonClass
 
+/**
+ * This event is sent by the caller when they wish to establish a call.
+ */
 @JsonClass(generateAdapter = true)
 data class CallInviteContent(
-        @Json(name = "call_id") val callId: String,
-        @Json(name = "version") val version: Int,
-        @Json(name = "lifetime") val lifetime: Int,
-        @Json(name = "offer") val offer: Offer
+        /**
+         * Required. A unique identifier for the call.
+         */
+        @Json(name = "call_id") val callId: String?,
+        /**
+         * Required. The session description object
+         */
+        @Json(name = "offer") val offer: Offer?,
+        /**
+         * Required. The version of the VoIP specification this message adheres to. This specification is version 0.
+         */
+        @Json(name = "version") val version: Int? = 0,
+        /**
+         * Required. The time in milliseconds that the invite is valid for.
+         * Once the invite age exceeds this value, clients should discard it.
+         * They should also no longer show the call as awaiting an answer in the UI.
+         */
+        @Json(name = "lifetime") val lifetime: Int?
 ) {
-
     @JsonClass(generateAdapter = true)
     data class Offer(
-            @Json(name = "type") val type: String,
-            @Json(name = "sdp") val sdp: String
+            /**
+             * Required. The type of session description. Must be 'offer'.
+             */
+            @Json(name = "type") val type: SdpType? = SdpType.OFFER,
+            /**
+             * Required. The SDP text of the session description.
+             */
+            @Json(name = "sdp") val sdp: String?
     ) {
         companion object {
             const val SDP_VIDEO = "m=video"
         }
     }
 
-    fun isVideo(): Boolean = offer.sdp.contains(Offer.SDP_VIDEO)
+    fun isVideo(): Boolean = offer?.sdp?.contains(Offer.SDP_VIDEO) == true
 }

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

@@ -1,25 +1,27 @@
 /*
- * Copyright 2020 New Vector Ltd
+ * Copyright (c) 2020 New Vector Ltd
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- * http://www.apache.org/licenses/LICENSE-2.0
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- *
  */
 
-package im.vector.matrix.android.api.session.room.powerlevels
+package im.vector.matrix.android.api.session.room.model.call
 
-object PowerLevelsConstants {
+import com.squareup.moshi.Json
 
-    const val DEFAULT_ROOM_ADMIN_LEVEL = 100
-    const val DEFAULT_ROOM_MODERATOR_LEVEL = 50
-    const val DEFAULT_ROOM_USER_LEVEL = 0
+enum class SdpType {
+    @Json(name = "offer")
+    OFFER,
+
+    @Json(name = "answer")
+    ANSWER
 }

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

@@ -17,7 +17,9 @@
 package im.vector.matrix.android.api.session.room.model.create
 
 import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
 
+@JsonClass(generateAdapter = false)
 enum class CreateRoomPreset {
     @Json(name = "private_chat")
     PRESET_PRIVATE_CHAT,

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/model/message/MessageContentWithFormattedBody.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.api.session.room.model.message
+
+interface MessageContentWithFormattedBody : MessageContent {
+    /**
+     * The format used in the formatted_body. Currently only "org.matrix.custom.html" is supported.
+     */
+    val format: String?
+
+    /**
+     * The formatted version of the body. This is required if format is specified.
+     */
+    val formattedBody: String?
+
+    /**
+     * Get the formattedBody, only if not blank and if the format is equal to "org.matrix.custom.html"
+     */
+    val matrixFormattedBody: String?
+        get() = formattedBody?.takeIf { it.isNotBlank() && format == MessageFormat.FORMAT_MATRIX_HTML }
+}

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

@@ -34,15 +34,15 @@ data class MessageEmoteContent(
         @Json(name = "body") override val body: String,
 
         /**
-         * The format used in the formatted_body. Currently only org.matrix.custom.html is supported.
+         * The format used in the formatted_body. Currently only "org.matrix.custom.html" is supported.
          */
-        @Json(name = "format") val format: String? = null,
+        @Json(name = "format") override val format: String? = null,
 
         /**
          * The formatted version of the body. This is required if format is specified.
          */
-        @Json(name = "formatted_body") val formattedBody: String? = null,
+        @Json(name = "formatted_body") override val formattedBody: String? = null,
 
         @Json(name = "m.relates_to") override val relatesTo: RelationDefaultContent? = null,
         @Json(name = "m.new_content") override val newContent: Content? = null
-) : MessageContent
+) : MessageContentWithFormattedBody

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

@@ -34,15 +34,15 @@ data class MessageNoticeContent(
         @Json(name = "body") override val body: String,
 
         /**
-         * The format used in the formatted_body. Currently only org.matrix.custom.html is supported.
+         * The format used in the formatted_body. Currently only "org.matrix.custom.html" is supported.
          */
-        @Json(name = "format") val format: String? = null,
+        @Json(name = "format") override val format: String? = null,
 
         /**
          * The formatted version of the body. This is required if format is specified.
          */
-        @Json(name = "formatted_body") val formattedBody: String? = null,
+        @Json(name = "formatted_body") override val formattedBody: String? = null,
 
         @Json(name = "m.relates_to") override val relatesTo: RelationDefaultContent? = null,
         @Json(name = "m.new_content") override val newContent: Content? = null
-) : MessageContent
+) : MessageContentWithFormattedBody

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

@@ -34,15 +34,15 @@ data class MessageTextContent(
         @Json(name = "body") override val body: String,
 
         /**
-         * The format used in the formatted_body. Currently only org.matrix.custom.html is supported.
+         * The format used in the formatted_body. Currently only "org.matrix.custom.html" is supported.
          */
-        @Json(name = "format") val format: String? = null,
+        @Json(name = "format") override val format: String? = null,
 
         /**
          * The formatted version of the body. This is required if format is specified.
          */
-        @Json(name = "formatted_body") val formattedBody: String? = null,
+        @Json(name = "formatted_body") override val formattedBody: String? = null,
 
         @Json(name = "m.relates_to") override val relatesTo: RelationDefaultContent? = null,
         @Json(name = "m.new_content") override val newContent: Content? = null
-) : MessageContent
+) : MessageContentWithFormattedBody

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

@@ -22,9 +22,8 @@ data class RoomTag(
 ) {
 
     companion object {
-        val ROOM_TAG_FAVOURITE = "m.favourite"
-        val ROOM_TAG_LOW_PRIORITY = "m.lowpriority"
-        val ROOM_TAG_NO_TAG = "m.recent"
-        val ROOM_TAG_SERVER_NOTICE = "m.server_notice"
+        const val ROOM_TAG_FAVOURITE = "m.favourite"
+        const val ROOM_TAG_LOW_PRIORITY = "m.lowpriority"
+        const val ROOM_TAG_SERVER_NOTICE = "m.server_notice"
     }
 }

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

@@ -20,23 +20,20 @@ package im.vector.matrix.android.api.session.room.notification
  * Defines the room notification state
  */
 enum class RoomNotificationState {
-    /**
-     * All the messages will trigger a noisy notification
-     */
-    ALL_MESSAGES_NOISY,
-
     /**
      * All the messages will trigger a notification
+     * This is the default for DMs
      */
     ALL_MESSAGES,
 
     /**
-     * Only the messages with user display name / user name will trigger notifications
+     * Only the messages with user display name / user name, or keywords will trigger notifications
+     * This is the default for Rooms
      */
-    MENTIONS_ONLY,
+    MENTIONS_AND_KEYWORDS,
 
     /**
      * No notifications
      */
-    MUTE
+    NONE
 }

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

@@ -17,7 +17,6 @@
 
 package im.vector.matrix.android.api.session.room.powerlevels
 
-import im.vector.matrix.android.api.session.events.model.EventType
 import im.vector.matrix.android.api.session.room.model.PowerLevelsContent
 
 /**
@@ -31,32 +30,84 @@ class PowerLevelsHelper(private val powerLevelsContent: PowerLevelsContent) {
      * @param userId the user id
      * @return the power level
      */
-    fun getUserPowerLevel(userId: String): Int {
+    fun getUserPowerLevelValue(userId: String): Int {
         return powerLevelsContent.users.getOrElse(userId) {
             powerLevelsContent.usersDefault
         }
     }
 
+    /**
+     * Returns the user power level of a dedicated user Id
+     *
+     * @param userId the user id
+     * @return the power level
+     */
+    fun getUserRole(userId: String): Role {
+        val value = getUserPowerLevelValue(userId)
+        return Role.fromValue(value, powerLevelsContent.eventsDefault)
+    }
+
     /**
      * Tell if an user can send an event of a certain type
      *
+     * @param userId  the id of the user to check for.
+     * @param isState true if the event is a state event (ie. state key is not null)
      * @param eventType the event type to check for
-     * @param userId          the user id
      * @return true if the user can send this type of event
      */
-    fun isAllowedToSend(eventType: String, userId: String): Boolean {
-        return if (eventType.isNotEmpty() && userId.isNotEmpty()) {
-            val powerLevel = getUserPowerLevel(userId)
+    fun isUserAllowedToSend(userId: String, isState: Boolean, eventType: String?): Boolean {
+        return if (userId.isNotEmpty()) {
+            val powerLevel = getUserPowerLevelValue(userId)
             val minimumPowerLevel = powerLevelsContent.events[eventType]
-                                    ?: if (EventType.isStateEvent(eventType)) {
-                                        powerLevelsContent.stateDefault
-                                    } else {
-                                        powerLevelsContent.eventsDefault
-                                    }
+                    ?: if (isState) {
+                        powerLevelsContent.stateDefault
+                    } else {
+                        powerLevelsContent.eventsDefault
+                    }
             powerLevel >= minimumPowerLevel
         } else false
     }
 
+    /**
+     * Check if the user have the necessary power level to invite
+     * @param userId the id of the user to check for.
+     * @return true if able to invite
+     */
+    fun isUserAbleToInvite(userId: String): Boolean {
+        val powerLevel = getUserPowerLevelValue(userId)
+        return powerLevel >= powerLevelsContent.invite
+    }
+
+    /**
+     * Check if the user have the necessary power level to ban
+     * @param userId the id of the user to check for.
+     * @return true if able to ban
+     */
+    fun isUserAbleToBan(userId: String): Boolean {
+        val powerLevel = getUserPowerLevelValue(userId)
+        return powerLevel >= powerLevelsContent.ban
+    }
+
+    /**
+     * Check if the user have the necessary power level to kick
+     * @param userId the id of the user to check for.
+     * @return true if able to kick
+     */
+    fun isUserAbleToKick(userId: String): Boolean {
+        val powerLevel = getUserPowerLevelValue(userId)
+        return powerLevel >= powerLevelsContent.kick
+    }
+
+    /**
+     * Check if the user have the necessary power level to redact
+     * @param userId the id of the user to check for.
+     * @return true if able to redact
+     */
+    fun isUserAbleToRedact(userId: String): Boolean {
+        val powerLevel = getUserPowerLevelValue(userId)
+        return powerLevel >= powerLevelsContent.redact
+    }
+
     /**
      * Get the notification level for a dedicated key.
      *
@@ -68,7 +119,7 @@ class PowerLevelsHelper(private val powerLevelsContent: PowerLevelsContent) {
             // the first implementation was a string value
             is String -> value.toInt()
             is Int    -> value
-            else      -> PowerLevelsConstants.DEFAULT_ROOM_MODERATOR_LEVEL
+            else      -> Role.Moderator.value
         }
     }
 }

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

@@ -0,0 +1,46 @@
+/*
+ * 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.session.room.powerlevels
+
+import androidx.annotation.StringRes
+import im.vector.matrix.android.R
+
+sealed class Role(open val value: Int, @StringRes val res: Int) : Comparable<Role> {
+    object Admin : Role(100, R.string.power_level_admin)
+    object Moderator : Role(50, R.string.power_level_moderator)
+    object Default : Role(0, R.string.power_level_default)
+    data class Custom(override val value: Int) : Role(value, R.string.power_level_custom)
+
+    override fun compareTo(other: Role): Int {
+        return value.compareTo(other.value)
+    }
+
+    companion object {
+
+        // Order matters, default value should be checked after defined roles
+        fun fromValue(value: Int, default: Int): Role {
+            return when (value) {
+                Admin.value     -> Admin
+                Moderator.value -> Moderator
+                Default.value,
+                default         -> Default
+                else            -> Custom(value)
+            }
+        }
+    }
+}

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

@@ -17,6 +17,7 @@
 package im.vector.matrix.android.api.session.room.send
 
 import im.vector.matrix.android.api.session.content.ContentAttachmentData
+import im.vector.matrix.android.api.session.events.model.Content
 import im.vector.matrix.android.api.session.events.model.Event
 import im.vector.matrix.android.api.session.room.model.message.MessageType
 import im.vector.matrix.android.api.session.room.model.message.OptionItem
@@ -28,6 +29,14 @@ import im.vector.matrix.android.api.util.Cancelable
  */
 interface SendService {
 
+    /**
+     * Method to send a generic event asynchronously. If you want to send a state event, please use [StateService] instead.
+     * @param eventType the type of the event
+     * @param content the optional body as a json dict.
+     * @return a [Cancelable]
+     */
+    fun sendEvent(eventType: String, content: Content?): Cancelable
+
     /**
      * Method to send a text message asynchronously.
      * The text to send can be a Spannable and contains special spans (MatrixItemSpan) that will be translated

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

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.session.room.sender
+
+data class SenderInfo(
+        val userId: String,
+        /**
+         * Consider using [disambiguatedDisplayName]
+         */
+        val displayName: String?,
+        val isUniqueDisplayName: Boolean,
+        val avatarUrl: String?
+) {
+    val disambiguatedDisplayName: String
+        get() = when {
+            displayName.isNullOrBlank() -> userId
+            isUniqueDisplayName         -> displayName
+            else                        -> "$displayName ($userId)"
+        }
+}

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

@@ -18,7 +18,10 @@ package im.vector.matrix.android.api.session.room.state
 
 import androidx.lifecycle.LiveData
 import im.vector.matrix.android.api.MatrixCallback
+import im.vector.matrix.android.api.query.QueryStringValue
 import im.vector.matrix.android.api.session.events.model.Event
+import im.vector.matrix.android.api.util.Cancelable
+import im.vector.matrix.android.api.util.JsonDict
 import im.vector.matrix.android.api.util.Optional
 
 interface StateService {
@@ -26,9 +29,15 @@ interface StateService {
     /**
      * Update the topic of the room
      */
-    fun updateTopic(topic: String, callback: MatrixCallback<Unit>)
+    fun updateTopic(topic: String, callback: MatrixCallback<Unit>): Cancelable
 
-    fun getStateEvent(eventType: String, stateKey: String): Event?
+    fun sendStateEvent(eventType: String, stateKey: String?, body: JsonDict, callback: MatrixCallback<Unit>): Cancelable
 
-    fun getStateEventLive(eventType: String, stateKey: String): LiveData<Optional<Event>>
+    fun getStateEvent(eventType: String, stateKey: QueryStringValue = QueryStringValue.NoCondition): Event?
+
+    fun getStateEventLive(eventType: String, stateKey: QueryStringValue = QueryStringValue.NoCondition): LiveData<Optional<Event>>
+
+    fun getStateEvents(eventTypes: Set<String>, stateKey: QueryStringValue = QueryStringValue.NoCondition): List<Event>
+
+    fun getStateEventsLive(eventTypes: Set<String>, stateKey: QueryStringValue = QueryStringValue.NoCondition): LiveData<List<Event>>
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/tags/TagsService.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.api.session.room.tags
+
+import im.vector.matrix.android.api.MatrixCallback
+import im.vector.matrix.android.api.util.Cancelable
+
+/**
+ * This interface defines methods to handle tags of a room. It's implemented at the room level.
+ */
+interface TagsService {
+    /**
+     * Add a tag to a room
+     */
+    fun addTag(tag: String, order: Double?, callback: MatrixCallback<Unit>): Cancelable
+
+    /**
+     * Remove tag from a room
+     */
+    fun deleteTag(tag: String, callback: MatrixCallback<Unit>): Cancelable
+}

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

@@ -58,7 +58,7 @@ interface Timeline {
 
     /**
      * Check if the timeline can be enriched by paginating.
-     * @param the direction to check in
+     * @param direction the direction to check in
      * @return true if timeline can be enriched
      */
     fun hasMoreToLoad(direction: Direction): Boolean

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

@@ -16,6 +16,7 @@
 
 package im.vector.matrix.android.api.session.room.timeline
 
+import im.vector.matrix.android.BuildConfig
 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.RelationType
@@ -25,6 +26,7 @@ import im.vector.matrix.android.api.session.room.model.ReadReceipt
 import im.vector.matrix.android.api.session.room.model.message.MessageContent
 import im.vector.matrix.android.api.session.room.model.message.MessageStickerContent
 import im.vector.matrix.android.api.session.room.model.message.isReply
+import im.vector.matrix.android.api.session.room.sender.SenderInfo
 import im.vector.matrix.android.api.util.ContentUtils.extractUsefulTextFromReply
 import im.vector.matrix.android.internal.crypto.model.event.EncryptedEventContent
 
@@ -38,13 +40,17 @@ data class TimelineEvent(
         val localId: Long,
         val eventId: String,
         val displayIndex: Int,
-        val senderName: String?,
-        val isUniqueDisplayName: Boolean,
-        val senderAvatar: String?,
+        val senderInfo: SenderInfo,
         val annotations: EventAnnotationsSummary? = null,
         val readReceipts: List<ReadReceipt> = emptyList()
 ) {
 
+    init {
+        if (BuildConfig.DEBUG) {
+            assert(eventId == root.eventId)
+        }
+    }
+
     val metadata = HashMap<String, Any>()
 
     /**
@@ -62,14 +68,6 @@ data class TimelineEvent(
         }
     }
 
-    fun getDisambiguatedDisplayName(): String {
-        return when {
-            senderName.isNullOrBlank() -> root.senderId ?: ""
-            isUniqueDisplayName        -> senderName
-            else                       -> "$senderName (${root.senderId})"
-        }
-    }
-
     /**
      * Get the metadata associated with a key.
      * @param key the key to get the metadata

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

@@ -28,6 +28,14 @@ data class TimelineSettings(
          * A flag to filter edit events
          */
         val filterEdits: Boolean = false,
+        /**
+         * A flag to filter redacted events
+         */
+        val filterRedacted: Boolean = false,
+        /**
+         * A flag to filter useless events, such as membership events without any change
+         */
+        val filterUseless: Boolean = false,
         /**
          * A flag to filter by types. It should be used with [allowedTypes] field
          */
@@ -40,5 +48,4 @@ data class TimelineSettings(
          * If true, will build read receipts for each event.
          */
         val buildReadReceipts: Boolean = true
-
 )

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

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.session.room.uploads
+
+data class GetUploadsResult(
+        // List of fetched Events, most recent first
+        val uploadEvents: List<UploadEvent>,
+        // token to get more events
+        val nextToken: String,
+        // True if there are more event to load
+        val hasMore: Boolean
+)

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

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.session.room.uploads
+
+import im.vector.matrix.android.api.session.events.model.Event
+import im.vector.matrix.android.api.session.room.model.message.MessageWithAttachmentContent
+import im.vector.matrix.android.api.session.room.sender.SenderInfo
+
+/**
+ * Wrapper around on Event.
+ * Similar to [im.vector.matrix.android.api.session.room.timeline.TimelineEvent], contains an Event with extra useful data
+ */
+data class UploadEvent(
+        val root: Event,
+        val eventId: String,
+        val contentWithAttachmentContent: MessageWithAttachmentContent,
+        val senderInfo: SenderInfo
+)

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/uploads/UploadsService.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.api.session.room.uploads
+
+import im.vector.matrix.android.api.MatrixCallback
+import im.vector.matrix.android.api.util.Cancelable
+
+/**
+ * This interface defines methods to get event with uploads (= attachments) sent to a room. It's implemented at the room level.
+ */
+interface UploadsService {
+
+    /**
+     * Get a list of events containing URL sent to a room, from most recent to oldest one
+     * @param numberOfEvents the expected number of events to retrieve. The result can contain less events.
+     * @param since token to get next page, or null to get the first page
+     */
+    fun getUploads(numberOfEvents: Int,
+                   since: String?,
+                   callback: MatrixCallback<GetUploadsResult>): Cancelable
+}

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

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

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

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.matrix.android.api.session.terms
+
+import im.vector.matrix.android.api.MatrixCallback
+import im.vector.matrix.android.api.util.Cancelable
+
+interface TermsService {
+    enum class ServiceType {
+        IntegrationManager,
+        IdentityService
+    }
+
+    fun getTerms(serviceType: ServiceType,
+                 baseUrl: String,
+                 callback: MatrixCallback<GetTermsResponse>): Cancelable
+
+    fun agreeToTerms(serviceType: ServiceType,
+                     baseUrl: String,
+                     agreedUrls: List<String>,
+                     token: String?,
+                     callback: MatrixCallback<Unit>): Cancelable
+}