v15.0.0

Prepare changelog for v15.0.0
v15.0.0-rc.1
2021-10-25 11:22:22 +01:00 · 2021-10-25 11:22:21 +01:00 · 2021-10-19 10:50:42 +01:00 · 2021-10-19 10:50:41 +01:00 · 2021-10-15 14:32:19 +01:00 · 2021-10-15 14:32:13 +01:00
29 changed files with 1200 additions and 544 deletions
@@ -1,3 +1,70 @@
+Changes in [15.0.0](https://github.com/vector-im/element-desktop/releases/tag/v15.0.0) (2021-10-25)
+===================================================================================================
+
+## 🚨 BREAKING CHANGES
+ * Use `ICallFeedOpts` in the `CallFeed` constructor. To construct a new `CallFeed` object you have to pass `ICallFeedOpts` e.g. `const callFeed = new CallFeed({client ([\#1964](https://github.com/matrix-org/matrix-js-sdk/pull/1964)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+
+## ✨ Features
+ * Make threads use 'm.thread' relation ([\#1980](https://github.com/matrix-org/matrix-js-sdk/pull/1980)).
+ * Try to answer a call without video if we can't access the camera  ([\#1972](https://github.com/matrix-org/matrix-js-sdk/pull/1972)). Fixes vector-im/element-web#17975 and vector-im/element-web#17975. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Make `opts` in `importRoomKeys()` optional ([\#1974](https://github.com/matrix-org/matrix-js-sdk/pull/1974)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Enable TypeScript declaration maps ([\#1966](https://github.com/matrix-org/matrix-js-sdk/pull/1966)). Contributed by [Alexendoo](https://github.com/Alexendoo).
+
+## 🐛 Bug Fixes
+ * Fix `requestVerificationDM` with chronological `pendingEventOrdering` ([\#1943](https://github.com/matrix-org/matrix-js-sdk/pull/1943)). Contributed by [freaktechnik](https://github.com/freaktechnik).
+
+Changes in [15.0.0-rc.1](https://github.com/vector-im/element-desktop/releases/tag/v15.0.0-rc.1) (2021-10-19)
+=============================================================================================================
+
+## 🚨 BREAKING CHANGES
+ * Use `ICallFeedOpts` in the `CallFeed` constructor. To construct a new `CallFeed` object you have to pass `ICallFeedOpts` e.g. `const callFeed = new CallFeed({client ([\#1964](https://github.com/matrix-org/matrix-js-sdk/pull/1964)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+
+## ✨ Features
+ * Make threads use 'm.thread' relation ([\#1980](https://github.com/matrix-org/matrix-js-sdk/pull/1980)).
+ * Try to answer a call without video if we can't access the camera  ([\#1972](https://github.com/matrix-org/matrix-js-sdk/pull/1972)). Fixes vector-im/element-web#17975 and vector-im/element-web#17975. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Make `opts` in `importRoomKeys()` optional ([\#1974](https://github.com/matrix-org/matrix-js-sdk/pull/1974)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Enable TypeScript declaration maps ([\#1966](https://github.com/matrix-org/matrix-js-sdk/pull/1966)). Contributed by [Alexendoo](https://github.com/Alexendoo).
+
+## 🐛 Bug Fixes
+ * Fix `requestVerificationDM` with chronological `pendingEventOrdering` ([\#1943](https://github.com/matrix-org/matrix-js-sdk/pull/1943)). Contributed by [freaktechnik](https://github.com/freaktechnik).
+
+Changes in [14.0.1](https://github.com/vector-im/element-desktop/releases/tag/v14.0.1) (2021-10-12)
+===================================================================================================
+
+## 🚨 BREAKING CHANGES
+ * Support for call upgrades. `setLocalVideoMuted()` and `setMicrophoneMuted()` are now `async` and return the new mute state ([\#1827](https://github.com/matrix-org/matrix-js-sdk/pull/1827)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+
+## ✨ Features
+ * Implement file versioning for tree spaces ([\#1952](https://github.com/matrix-org/matrix-js-sdk/pull/1952)).
+ * Allow answering calls without audio/video ([\#1950](https://github.com/matrix-org/matrix-js-sdk/pull/1950)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Add `bound` to `IThreepid` ([\#1941](https://github.com/matrix-org/matrix-js-sdk/pull/1941)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Add `trusted_locally` to `TrustInfo` ([\#1942](https://github.com/matrix-org/matrix-js-sdk/pull/1942)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+
+## 🐛 Bug Fixes
+ * Fix incorrect return value type in getJoinedRooms() ([\#1959](https://github.com/matrix-org/matrix-js-sdk/pull/1959)). Contributed by [psrpinto](https://github.com/psrpinto).
+ * Make sure to set `callLengthInterval` only once ([\#1958](https://github.com/matrix-org/matrix-js-sdk/pull/1958)). Fixes vector-im/element-web#19221 and vector-im/element-web#19221. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Fix event partitioning from non threading ready clients ([\#1948](https://github.com/matrix-org/matrix-js-sdk/pull/1948)).
+ * Ensure unencrypted fields get exposed by getEffectiveEvent() ([\#1938](https://github.com/matrix-org/matrix-js-sdk/pull/1938)). Fixes vector-im/element-web#19062 and vector-im/element-web#19062.
+
+
+Changes in [14.0.0-rc.1](https://github.com/vector-im/element-desktop/releases/tag/v14.0.0-rc.1) (2021-10-04)
+=============================================================================================================
+
+## 🚨 BREAKING CHANGES
+ * Support for call upgrades. `setLocalVideoMuted()` and `setMicrophoneMuted()` are now `async` and return the new mute state ([\#1827](https://github.com/matrix-org/matrix-js-sdk/pull/1827)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+
+## ✨ Features
+ * Implement file versioning for tree spaces ([\#1952](https://github.com/matrix-org/matrix-js-sdk/pull/1952)).
+ * Allow answering calls without audio/video ([\#1950](https://github.com/matrix-org/matrix-js-sdk/pull/1950)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Add `bound` to `IThreepid` ([\#1941](https://github.com/matrix-org/matrix-js-sdk/pull/1941)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Add `trusted_locally` to `TrustInfo` ([\#1942](https://github.com/matrix-org/matrix-js-sdk/pull/1942)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+
+## 🐛 Bug Fixes
+ * Fix incorrect return value type in getJoinedRooms() ([\#1959](https://github.com/matrix-org/matrix-js-sdk/pull/1959)). Contributed by [psrpinto](https://github.com/psrpinto).
+ * Make sure to set `callLengthInterval` only once ([\#1958](https://github.com/matrix-org/matrix-js-sdk/pull/1958)). Fixes vector-im/element-web#19221 and vector-im/element-web#19221. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Fix event partitioning from non threading ready clients ([\#1948](https://github.com/matrix-org/matrix-js-sdk/pull/1948)).
+ * Ensure unencrypted fields get exposed by getEffectiveEvent() ([\#1938](https://github.com/matrix-org/matrix-js-sdk/pull/1938)). Fixes vector-im/element-web#19062 and vector-im/element-web#19062.
+
 Changes in [13.0.0](https://github.com/vector-im/element-desktop/releases/tag/v13.0.0) (2021-09-27)
 ===================================================================================================

@@ -98,6 +98,21 @@ We use continuous integration, and all pull requests get automatically tested:
 if your change breaks the build, then the PR will show that there are failed
 checks, so please check back after a few minutes.

+Tests
+-----
+If your PR is a feature (ie. if it's being labelled with the 'T-Enhancement'
+label) then we require that the PR also includes tests. These need to test that
+your feature works as expected and ideally test edge cases too. For the js-sdk
+itself, your tests should generally be unit tests. matrix-react-sdk also uses
+these guidelines, so for that your tests can be unit tests using
+react-test-utils, snapshot tests or screenshot tests.
+
+We don't require tests for bug fixes (T-Defect) but strongly encourage regression
+tests for the bug itself wherever possible.
+
+In the future we may formalise this more with a minimum test coverage
+percentage for the diff.
+
 Code style
 ----------
 The js-sdk aims to target TypeScript/ES6. All new files should be written in
@@ -1,6 +1,6 @@
 {
  "name": "matrix-js-sdk",
-  "version": "13.0.0",
+  "version": "15.0.0",
  "description": "Matrix Client-Server SDK for Javascript",
  "scripts": {
    "prepublishOnly": "yarn build",
@@ -14,21 +14,25 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { MatrixClient } from "../../../src";
+import { IContent, MatrixClient, MatrixEvent } from "../../../src";
 import { Room } from "../../../src/models/room";
-import { UNSTABLE_MSC3089_BRANCH } from "../../../src/@types/event";
+import { IEncryptedFile, RelationType, UNSTABLE_MSC3089_BRANCH } from "../../../src/@types/event";
 import { EventTimelineSet } from "../../../src/models/event-timeline-set";
 import { EventTimeline } from "../../../src/models/event-timeline";
 import { MSC3089Branch } from "../../../src/models/MSC3089Branch";
+import { MSC3089TreeSpace } from "../../../src/models/MSC3089TreeSpace";

 describe("MSC3089Branch", () => {
    let client: MatrixClient;
    // @ts-ignore - TS doesn't know that this is a type
    let indexEvent: any;
+    let directory: MSC3089TreeSpace;
    let branch: MSC3089Branch;
+    let branch2: MSC3089Branch;

    const branchRoomId = "!room:example.org";
    const fileEventId = "$file";
+    const fileEventId2 = "$second_file";

    const staticTimelineSets = {} as EventTimelineSet;
    const staticRoom = {
@@ -50,7 +54,12 @@ describe("MSC3089Branch", () => {
            getRoomId: () => branchRoomId,
            getStateKey: () => fileEventId,
        });
-        branch = new MSC3089Branch(client, indexEvent);
+        directory = new MSC3089TreeSpace(client, branchRoomId);
+        branch = new MSC3089Branch(client, indexEvent, directory);
+        branch2 = new MSC3089Branch(client, {
+            getRoomId: () => branchRoomId,
+            getStateKey: () => fileEventId2,
+        } as MatrixEvent, directory);
    });

    it('should know the file event ID', () => {
@@ -69,13 +78,15 @@ describe("MSC3089Branch", () => {
    });

    it('should be able to delete the file', async () => {
+        const eventIdOrder = [fileEventId, fileEventId2];
+
        const stateFn = jest.fn()
            .mockImplementation((roomId: string, eventType: string, content: any, stateKey: string) => {
                expect(roomId).toEqual(branchRoomId);
                expect(eventType).toEqual(UNSTABLE_MSC3089_BRANCH.unstable); // test that we're definitely using the unstable value
                expect(content).toMatchObject({});
                expect(content['active']).toBeUndefined();
-                expect(stateKey).toEqual(fileEventId);
+                expect(stateKey).toEqual(eventIdOrder[stateFn.mock.calls.length - 1]);

                return Promise.resolve(); // return value not used
            });
@@ -83,16 +94,19 @@ describe("MSC3089Branch", () => {

        const redactFn = jest.fn().mockImplementation((roomId: string, eventId: string) => {
            expect(roomId).toEqual(branchRoomId);
-            expect(eventId).toEqual(fileEventId);
+            expect(eventId).toEqual(eventIdOrder[stateFn.mock.calls.length - 1]);

            return Promise.resolve(); // return value not used
        });
        client.redactEvent = redactFn;

+        branch.getVersionHistory = () => Promise.resolve([branch, branch2]);
+        branch2.getVersionHistory = () => Promise.resolve([branch2]);
+
        await branch.delete();

-        expect(stateFn).toHaveBeenCalledTimes(1);
-        expect(redactFn).toHaveBeenCalledTimes(1);
+        expect(stateFn).toHaveBeenCalledTimes(2);
+        expect(redactFn).toHaveBeenCalledTimes(2);
    });

    it('should know its name', async () => {
@@ -127,6 +141,22 @@ describe("MSC3089Branch", () => {
        expect(stateFn).toHaveBeenCalledTimes(1);
    });

+    it('should be v1 by default', () => {
+        indexEvent.getContent = () => ({ active: true });
+
+        const res = branch.version;
+
+        expect(res).toEqual(1);
+    });
+
+    it('should be vN when set', () => {
+        indexEvent.getContent = () => ({ active: true, version: 3 });
+
+        const res = branch.version;
+
+        expect(res).toEqual(3);
+    });
+
    it('should be unlocked by default', async () => {
        indexEvent.getContent = () => ({ active: true });

@@ -169,13 +199,13 @@ describe("MSC3089Branch", () => {
    it('should be able to return event information', async () => {
        const mxcLatter = "example.org/file";
        const fileContent = { isFile: "not quite", url: "mxc://" + mxcLatter };
-        const eventsArr = [
-            { getId: () => "$not-file", getContent: () => ({}) },
-            { getId: () => fileEventId, getContent: () => ({ file: fileContent }) },
-        ];
-        client.getEventTimeline = () => Promise.resolve({
-            getEvents: () => eventsArr,
-        }) as any as Promise<EventTimeline>; // partial
+        const fileEvent = { getId: () => fileEventId, getOriginalContent: () => ({ file: fileContent }) };
+        staticRoom.getUnfilteredTimelineSet = () => ({
+            findEventById: (eventId) => {
+                expect(eventId).toEqual(fileEventId);
+                return fileEvent;
+            },
+        }) as EventTimelineSet;
        client.mxcUrlToHttp = (mxc: string) => {
            expect(mxc).toEqual("mxc://" + mxcLatter);
            return `https://example.org/_matrix/media/v1/download/${mxcLatter}`;
@@ -194,17 +224,109 @@ describe("MSC3089Branch", () => {
    it('should be able to return the event object', async () => {
        const mxcLatter = "example.org/file";
        const fileContent = { isFile: "not quite", url: "mxc://" + mxcLatter };
-        const eventsArr = [
-            { getId: () => "$not-file", getContent: () => ({}) },
-            { getId: () => fileEventId, getContent: () => ({ file: fileContent }) },
-        ];
-        client.getEventTimeline = () => Promise.resolve({
-            getEvents: () => eventsArr,
-        }) as any as Promise<EventTimeline>; // partial
+        const fileEvent = { getId: () => fileEventId, getOriginalContent: () => ({ file: fileContent }) };
+        staticRoom.getUnfilteredTimelineSet = () => ({
+            findEventById: (eventId) => {
+                expect(eventId).toEqual(fileEventId);
+                return fileEvent;
+            },
+        }) as EventTimelineSet;
+        client.mxcUrlToHttp = (mxc: string) => {
+            expect(mxc).toEqual("mxc://" + mxcLatter);
+            return `https://example.org/_matrix/media/v1/download/${mxcLatter}`;
+        };
        client.decryptEventIfNeeded = () => Promise.resolve();

        const res = await branch.getFileEvent();
        expect(res).toBeDefined();
-        expect(res).toBe(eventsArr[1]);
+        expect(res).toBe(fileEvent);
+    });
+
+    it('should create new versions of itself', async () => {
+        const canaryName = "canary";
+        const fileContents = "contents go here";
+        const canaryContents = Uint8Array.from(Array.from(fileContents).map((_, i) => fileContents.charCodeAt(i)));
+        const canaryFile = {} as IEncryptedFile;
+        const canaryAddl = { canary: true };
+        indexEvent.getContent = () => ({ active: true, retained: true });
+        const stateKeyOrder = [fileEventId2, fileEventId];
+        const stateFn = jest.fn()
+            .mockImplementation((roomId: string, eventType: string, content: any, stateKey: string) => {
+                expect(roomId).toEqual(branchRoomId);
+                expect(eventType).toEqual(UNSTABLE_MSC3089_BRANCH.unstable); // test that we're definitely using the unstable value
+                expect(stateKey).toEqual(stateKeyOrder[stateFn.mock.calls.length - 1]);
+                if (stateKey === fileEventId) {
+                    expect(content).toMatchObject({
+                        retained: true, // canary for copying state
+                        active: false,
+                    });
+                } else if (stateKey === fileEventId2) {
+                    expect(content).toMatchObject({
+                        active: true,
+                        version: 2,
+                        name: canaryName,
+                    });
+                } else {
+                    throw new Error("Unexpected state key: " + stateKey);
+                }
+
+                return Promise.resolve(); // return value not used
+            });
+        client.sendStateEvent = stateFn;
+
+        const createFn = jest.fn().mockImplementation((
+            name: string,
+            contents: ArrayBuffer,
+            info: Partial<IEncryptedFile>,
+            addl: IContent,
+        ) => {
+            expect(name).toEqual(canaryName);
+            expect(contents).toBe(canaryContents);
+            expect(info).toBe(canaryFile);
+            expect(addl).toMatchObject({
+                ...canaryAddl,
+                "m.new_content": true,
+                "m.relates_to": {
+                    "rel_type": RelationType.Replace,
+                    "event_id": fileEventId,
+                },
+            });
+
+            return Promise.resolve({ event_id: fileEventId2 });
+        });
+        directory.createFile = createFn;
+
+        await branch.createNewVersion(canaryName, canaryContents, canaryFile, canaryAddl);
+
+        expect(stateFn).toHaveBeenCalledTimes(2);
+        expect(createFn).toHaveBeenCalledTimes(1);
+    });
+
+    it('should fetch file history', async () => {
+        branch2.getFileEvent = () => Promise.resolve({
+            replacingEventId: () => undefined,
+            getId: () => fileEventId2,
+        } as MatrixEvent);
+        branch.getFileEvent = () => Promise.resolve({
+            replacingEventId: () => fileEventId2,
+            getId: () => fileEventId,
+        } as MatrixEvent);
+
+        const events = [await branch.getFileEvent(), await branch2.getFileEvent(), {
+            replacingEventId: () => null,
+            getId: () => "$unknown",
+        }];
+        staticRoom.getLiveTimeline = () => ({ getEvents: () => events }) as EventTimeline;
+
+        directory.getFile = (evId: string) => {
+            expect(evId).toEqual(fileEventId);
+            return branch;
+        };
+
+        const results = await branch2.getVersionHistory();
+        expect(results).toMatchObject([
+            branch2,
+            branch,
+        ]);
    });
 });
@@ -908,6 +908,7 @@ describe("MSC3089TreeSpace", () => {
                body: fileName,
                url: mxc,
                file: fileInfo,
+                metadata: true, // additional content from test
                [UNSTABLE_MSC3089_LEAF.unstable]: {}, // test to ensure we're definitely using unstable
            });

@@ -925,14 +926,82 @@ describe("MSC3089TreeSpace", () => {
                    name: fileName,
                });

-                return Promise.resolve(); // return value not used.
+                return Promise.resolve({ event_id: "wrong" }); // return value shouldn't be used
            });
        client.sendStateEvent = sendStateFn;

        const buf = Uint8Array.from(Array.from(fileContents).map((_, i) => fileContents.charCodeAt(i)));

        // We clone the file info just to make sure it doesn't get mutated for the test.
-        await tree.createFile(fileName, buf, Object.assign({}, fileInfo));
+        const result = await tree.createFile(fileName, buf, Object.assign({}, fileInfo), { metadata: true });
+        expect(result).toMatchObject({ event_id: fileEventId });
+
+        expect(uploadFn).toHaveBeenCalledTimes(1);
+        expect(sendMsgFn).toHaveBeenCalledTimes(1);
+        expect(sendStateFn).toHaveBeenCalledTimes(1);
+    });
+
+    it('should upload file versions', async () => {
+        const mxc = "mxc://example.org/file";
+        const fileInfo = {
+            mimetype: "text/plain",
+            // other fields as required by encryption, but ignored here
+        };
+        const fileEventId = "$file";
+        const fileName = "My File.txt";
+        const fileContents = "This is a test file";
+
+        // Mock out Blob for the test environment
+        (<any>global).Blob = MockBlob;
+
+        const uploadFn = jest.fn().mockImplementation((contents: Blob, opts: any) => {
+            expect(contents).toBeInstanceOf(Blob);
+            expect(contents.size).toEqual(fileContents.length);
+            expect(opts).toMatchObject({
+                includeFilename: false,
+                onlyContentUri: true, // because the tests rely on this - we shouldn't really be testing  for this.
+            });
+            return Promise.resolve(mxc);
+        });
+        client.uploadContent = uploadFn;
+
+        const sendMsgFn = jest.fn().mockImplementation((roomId: string, contents: any) => {
+            expect(roomId).toEqual(tree.roomId);
+            const content = {
+                msgtype: MsgType.File,
+                body: fileName,
+                url: mxc,
+                file: fileInfo,
+            };
+            expect(contents).toMatchObject({
+                ...content,
+                "m.new_content": content,
+                [UNSTABLE_MSC3089_LEAF.unstable]: {}, // test to ensure we're definitely using unstable
+            });
+
+            return Promise.resolve({ event_id: fileEventId }); // eslint-disable-line camelcase
+        });
+        client.sendMessage = sendMsgFn;
+
+        const sendStateFn = jest.fn()
+            .mockImplementation((roomId: string, eventType: string, content: any, stateKey: string) => {
+                expect(roomId).toEqual(tree.roomId);
+                expect(eventType).toEqual(UNSTABLE_MSC3089_BRANCH.unstable); // test to ensure we're definitely using unstable
+                expect(stateKey).toEqual(fileEventId);
+                expect(content).toMatchObject({
+                    active: true,
+                    name: fileName,
+                });
+
+                return Promise.resolve({ event_id: "wrong" }); // return value shouldn't be used
+            });
+        client.sendStateEvent = sendStateFn;
+
+        const buf = Uint8Array.from(Array.from(fileContents).map((_, i) => fileContents.charCodeAt(i)));
+
+        // We clone the file info just to make sure it doesn't get mutated for the test.
+        const result = await tree.createFile(fileName, buf, Object.assign({}, fileInfo), { "m.new_content": true });
+        expect(result).toMatchObject({ event_id: fileEventId });

        expect(uploadFn).toHaveBeenCalledTimes(1);
        expect(sendMsgFn).toHaveBeenCalledTimes(1);
@@ -985,4 +1054,22 @@ describe("MSC3089TreeSpace", () => {
        expect(files.length).toEqual(1);
        expect(files[0].indexEvent).toBe(firstFile);
    });
+
+    it('should list all files', () => {
+        const firstFile = { getContent: () => ({ active: true }) };
+        const secondFile = { getContent: () => ({ active: false }) }; // deliberately inactive
+        room.currentState = {
+            getStateEvents: (eventType: string, stateKey?: string) => {
+                expect(eventType).toEqual(UNSTABLE_MSC3089_BRANCH.unstable); // test to ensure we're definitely using unstable
+                expect(stateKey).toBeUndefined();
+                return [firstFile, secondFile];
+            },
+        };
+
+        const files = tree.listAllFiles();
+        expect(files).toBeDefined();
+        expect(files.length).toEqual(2);
+        expect(files[0].indexEvent).toBe(firstFile);
+        expect(files[1].indexEvent).toBe(secondFile);
+    });
 });
@@ -1,5 +1,5 @@
 import * as utils from "../test-utils";
-import { EventStatus, MatrixEvent } from "../../src";
+import { DuplicateStrategy, EventStatus, MatrixEvent } from "../../src";
 import { EventTimeline } from "../../src/models/event-timeline";
 import { RoomState } from "../../src";
 import { Room } from "../../src";
@@ -113,7 +113,7 @@ describe("Room", function() {
            dupe.event.event_id = events[0].getId();
            room.addLiveEvents(events);
            expect(room.timeline[0]).toEqual(events[0]);
-            room.addLiveEvents([dupe], "replace");
+            room.addLiveEvents([dupe], DuplicateStrategy.Replace);
            expect(room.timeline[0]).toEqual(dupe);
        });

@@ -83,6 +83,28 @@ class MockRTCPeerConnection {
    getStats() { return []; }
 }

+class MockMediaStream {
+    constructor(
+        public id,
+    ) {}
+
+    getTracks() { return []; }
+    getAudioTracks() { return [{ enabled: true }]; }
+    getVideoTracks() { return [{ enabled: true }]; }
+    addEventListener() {}
+}
+
+class MockMediaDeviceInfo {
+    constructor(
+        public kind: "audio" | "video",
+    ) {}
+}
+
+class MockMediaHandler {
+    getUserMediaStream() { return new MockMediaStream("mock_stream_from_media_handler"); }
+    stopUserMediaStream() {}
+}
+
 describe('Call', function() {
    let client;
    let call;
@@ -98,13 +120,9 @@ describe('Call', function() {
        global.navigator = {
            mediaDevices: {
                // @ts-ignore Mock
-                getUserMedia: () => {
-                    return {
-                        getTracks: () => [],
-                        getAudioTracks: () => [],
-                        getVideoTracks: () => [],
-                    };
-                },
+                getUserMedia: () => new MockMediaStream("local_stream"),
+                // @ts-ignore Mock
+                enumerateDevices: async () => [new MockMediaDeviceInfo("audio"), new MockMediaDeviceInfo("video")],
            },
        };

@@ -115,7 +133,7 @@ describe('Call', function() {
            RTCSessionDescription: {},
            // @ts-ignore Mock
            RTCIceCandidate: {},
-            getUserMedia: {},
+            getUserMedia: () => new MockMediaStream("local_stream"),
        };
        // @ts-ignore Mock
        global.document = {};
@@ -124,6 +142,8 @@ describe('Call', function() {
        // We just stub out sendEvent: we're not interested in testing the client's
        // event sending code here
        client.client.sendEvent = () => {};
+        client.client.mediaHandler = new MockMediaHandler;
+        client.client.getMediaHandler = () => client.client.mediaHandler;
        client.httpBackend.when("GET", "/voip/turnServer").respond(200, {});
        call = new MatrixCall({
            client: client.client,
@@ -319,7 +339,7 @@ describe('Call', function() {
                        sdp: DUMMY_SDP,
                    },
                    [SDPStreamMetadataKey]: {
-                        "stream_id": {
+                        "remote_stream": {
                            purpose: SDPStreamMetadataPurpose.Usermedia,
                            audio_muted: true,
                            video_muted: false,
@@ -329,8 +349,8 @@ describe('Call', function() {
            },
        });

-        call.pushRemoteFeed({ id: "stream_id", getAudioTracks: () => ["track1"], getVideoTracks: () => ["track1"] });
-        const feed = call.getFeeds().find((feed) => feed.stream.id === "stream_id");
+        call.pushRemoteFeed(new MockMediaStream("remote_stream"));
+        const feed = call.getFeeds().find((feed) => feed.stream.id === "remote_stream");
        expect(feed?.purpose).toBe(SDPStreamMetadataPurpose.Usermedia);
        expect(feed?.isAudioMuted()).toBeTruthy();
        expect(feed?.isVideoMuted()).not.toBeTruthy();
@@ -363,4 +383,16 @@ describe('Call', function() {
        call.setScreensharingEnabled(true);
        expect(call.setScreensharingEnabledWithoutMetadataSupport).toHaveBeenCalled();
    });
+
+    it("should fallback to answering with no video", async () => {
+        await client.httpBackend.flush();
+
+        call.shouldAnswerWithMediaType = (wantedValue: boolean) => wantedValue;
+        client.client.mediaHandler.getUserMediaStream = jest.fn().mockRejectedValue("reject");
+
+        await call.answer(true, true);
+
+        expect(client.client.mediaHandler.getUserMediaStream).toHaveBeenNthCalledWith(1, true, true);
+        expect(client.client.mediaHandler.getUserMediaStream).toHaveBeenNthCalledWith(2, true, false);
+    });
 });
@@ -92,6 +92,14 @@ export enum EventType {
 export enum RelationType {
    Annotation = "m.annotation",
    Replace = "m.replace",
+    /**
+     * Note, "io.element.thread" is hardcoded
+     * Should be replaced with "m.thread" once MSC3440 lands
+     * Can not use `UnstableValue` as TypeScript does not
+     * allow computed values in enums
+     * https://github.com/microsoft/TypeScript/issues/27976
+     */
+    Thread = "io.element.thread",
 }

 export enum MsgType {
@@ -168,11 +176,6 @@ export const UNSTABLE_ELEMENT_FUNCTIONAL_USERS = new UnstableValue(
    "io.element.functional_members",
    "io.element.functional_members");

-export const UNSTABLE_ELEMENT_REPLY_IN_THREAD = new UnstableValue(
-    "m.in_thread",
-    "io.element.in_thread",
-);
-
 export interface IEncryptedFile {
    url: string;
    mimetype?: string;
@@ -25,4 +25,5 @@ export interface IThreepid {
    address: string;
    validated_at: number; // eslint-disable-line camelcase
    added_at: number; // eslint-disable-line camelcase
+    bound?: boolean;
 }
@@ -531,7 +531,7 @@ export interface IRequestTokenResponse {
    submit_url?: string;
 }

-interface IRequestMsisdnTokenResponse extends IRequestTokenResponse {
+export interface IRequestMsisdnTokenResponse extends IRequestTokenResponse {
    msisdn: string;
    success: boolean;
    intl_fmt: string;
@@ -568,6 +568,10 @@ interface IRoomInitialSyncResponse {
    presence: Partial<IEvent>; // legacy and undocumented, api is deprecated so this won't get attention
 }

+interface IJoinedRoomsResponse {
+    joined_rooms: string[];
+}
+
 interface IJoinedMembersResponse {
    joined: {
        [userId: string]: {
@@ -2370,7 +2374,7 @@ export class MatrixClient extends EventEmitter {
     * @return {Promise} a promise which resolves when the keys
     *    have been imported
     */
-    public importRoomKeys(keys: IMegolmSessionData[], opts: IImportRoomKeysOpts): Promise<void> {
+    public importRoomKeys(keys: IMegolmSessionData[], opts?: IImportRoomKeysOpts): Promise<void> {
        if (!this.crypto) {
            throw new Error("End-to-end encryption disabled");
        }
@@ -4039,10 +4043,8 @@ export class MatrixClient extends EventEmitter {
        // Work backwards first, looking at create events.
        let createEvent = currentRoom.currentState.getStateEvents(EventType.RoomCreate, "");
        while (createEvent) {
-            logger.log(`Looking at ${createEvent.getId()}`);
            const predecessor = createEvent.getContent()['predecessor'];
            if (predecessor && predecessor['room_id']) {
-                logger.log(`Looking at predecessor ${predecessor['room_id']}`);
                const refRoom = this.getRoom(predecessor['room_id']);
                if (!refRoom) break; // end of the chain

@@ -4288,7 +4290,16 @@ export class MatrixClient extends EventEmitter {
     * @return {module:http-api.MatrixError} Rejects: with an error response.
     */
    public kick(roomId: string, userId: string, reason?: string, callback?: Callback): Promise<{}> {
-        return this.setMembershipState(roomId, userId, "leave", reason, callback);
+        const path = utils.encodeUri("/rooms/$roomId/kick", {
+            $roomId: roomId,
+        });
+        const data = {
+            user_id: userId,
+            reason: reason,
+        };
+        return this.http.authedRequest(
+            callback, "POST", path, undefined, data,
+        );
    }

    /**
@@ -5022,7 +5033,7 @@ export class MatrixClient extends EventEmitter {
        email: string,
        clientSecret: string,
        sendAttempt: number,
-        nextLink: string,
+        nextLink?: string,
    ): Promise<IRequestTokenResponse> {
        return this.requestTokenFromEndpoint(
            "/account/3pid/email/requestToken",
@@ -5054,7 +5065,7 @@ export class MatrixClient extends EventEmitter {
        phoneNumber: string,
        clientSecret: string,
        sendAttempt: number,
-        nextLink: string,
+        nextLink?: string,
    ): Promise<IRequestMsisdnTokenResponse> {
        return this.requestTokenFromEndpoint(
            "/account/3pid/msisdn/requestToken",
@@ -6665,7 +6676,7 @@ export class MatrixClient extends EventEmitter {
     * @return {Promise} Resolves: A list of the user's current rooms
     * @return {module:http-api.MatrixError} Rejects: with an error response.
     */
-    public getJoinedRooms(): Promise<string[]> {
+    public getJoinedRooms(): Promise<IJoinedRoomsResponse> {
        const path = utils.encodeUri("/joined_rooms", {});
        return this.http.authedRequest(undefined, "GET", path);
    }
@@ -341,12 +341,15 @@ class MegolmEncryption extends EncryptionAlgorithm {
            await Promise.all([
                (async () => {
                    // share keys with devices that we already have a session for
-                    logger.debug(`Sharing keys with existing Olm sessions in ${this.roomId}`);
+                    logger.debug(`Sharing keys with existing Olm sessions in ${this.roomId}`, olmSessions);
                    await this.shareKeyWithOlmSessions(session, key, payload, olmSessions);
                    logger.debug(`Shared keys with existing Olm sessions in ${this.roomId}`);
                })(),
                (async () => {
-                    logger.debug(`Sharing keys (start phase 1) with new Olm sessions in ${this.roomId}`);
+                    logger.debug(
+                        `Sharing keys (start phase 1) with new Olm sessions in ${this.roomId}`,
+                        devicesWithoutSession,
+                    );
                    const errorDevices = [];

                    // meanwhile, establish olm sessions for devices that we don't
@@ -403,8 +406,11 @@ class MegolmEncryption extends EncryptionAlgorithm {
                    logger.debug(`Shared keys (all phases done) with new Olm sessions in ${this.roomId}`);
                })(),
                (async () => {
-                    logger.debug(`Notifying blocked devices in ${this.roomId}`);
-                    // also, notify blocked devices that they're blocked
+                    logger.debug(`There are ${Object.entries(blocked).length} blocked devices in ${this.roomId}`,
+                        Object.entries(blocked));
+
+                    // also, notify newly blocked devices that they're blocked
+                    logger.debug(`Notifying newly blocked devices in ${this.roomId}`);
                    const blockedMap: Record<string, Record<string, { device: IBlockedDevice }>> = {};
                    let blockedCount = 0;
                    for (const [userId, userBlockedDevices] of Object.entries(blocked)) {
@@ -421,7 +427,7 @@ class MegolmEncryption extends EncryptionAlgorithm {
                    }

                    await this.notifyBlockedDevices(session, blockedMap);
-                    logger.debug(`Notified ${blockedCount} blocked devices in ${this.roomId}`);
+                    logger.debug(`Notified ${blockedCount} newly blocked devices in ${this.roomId}`, blockedMap);
                })(),
            ]);
        };
@@ -697,7 +703,7 @@ class MegolmEncryption extends EncryptionAlgorithm {

        await this.baseApis.sendToDevice("org.matrix.room_key.withheld", contentMap);

-        // store that we successfully uploaded the keys of the current slice
+        // record the fact that we notified these blocked devices
        for (const userId of Object.keys(contentMap)) {
            for (const deviceId of Object.keys(contentMap[userId])) {
                session.markNotifiedBlockedDevice(userId, deviceId);
@@ -846,9 +852,9 @@ class MegolmEncryption extends EncryptionAlgorithm {

        this.getDevicesWithoutSessions(devicemap, devicesByUser, errorDevices);

-        logger.debug(`Sharing keys with Olm sessions in ${this.roomId}`);
+        logger.debug(`Sharing keys with newly created Olm sessions in ${this.roomId}`);
        await this.shareKeyWithOlmSessions(session, key, payload, devicemap);
-        logger.debug(`Shared keys with Olm sessions in ${this.roomId}`);
+        logger.debug(`Shared keys with newly created Olm sessions in ${this.roomId}`);
    }

    private async shareKeyWithOlmSessions(
@@ -864,7 +870,8 @@ class MegolmEncryption extends EncryptionAlgorithm {
                `megolm keys for ${session.sessionId} ` +
                `in ${this.roomId} (slice ${i + 1}/${userDeviceMaps.length})`;
            try {
-                logger.debug(`Sharing ${taskDetail}`);
+                logger.debug(`Sharing ${taskDetail}`,
+                    userDeviceMaps[i].map((d) => `${d.userId}/${d.deviceInfo.deviceId}`));
                await this.encryptAndSendKeysToDevices(
                    session, key.chain_index, userDeviceMaps[i], payload,
                );
@@ -906,14 +913,16 @@ class MegolmEncryption extends EncryptionAlgorithm {
            );
        }

-        const filteredFailedDevices =
-            await this.olmDevice.filterOutNotifiedErrorDevices(failedDevices);
+        const unnotifiedFailedDevices =
+            await this.olmDevice.filterOutNotifiedErrorDevices(
+                failedDevices,
+            );
        logger.debug(
-            `Filtered down to ${filteredFailedDevices.length} error devices ` +
-            `in ${this.roomId}`,
+            `Need to notify ${unnotifiedFailedDevices.length} failed devices ` +
+            `which haven't been notified before in ${this.roomId}`,
        );
        const blockedMap: Record<string, Record<string, { device: IBlockedDevice }>> = {};
-        for (const { userId, deviceInfo } of filteredFailedDevices) {
+        for (const { userId, deviceInfo } of unnotifiedFailedDevices) {
            blockedMap[userId] = blockedMap[userId] || {};
            // we use a similar format to what
            // olmlib.ensureOlmSessionsForDevices returns, so that
@@ -930,7 +939,7 @@ class MegolmEncryption extends EncryptionAlgorithm {
        // send the notifications
        await this.notifyBlockedDevices(session, blockedMap);
        logger.debug(
-            `Notified ${filteredFailedDevices.length} devices we failed to ` +
+            `Notified ${unnotifiedFailedDevices.length} devices we failed to ` +
            `create Olm sessions in ${this.roomId}`,
        );
    }
@@ -142,7 +142,7 @@ export interface IImportOpts {
 }

 export interface IImportRoomKeysOpts {
-    progressCallback: (stage: IImportOpts) => void;
+    progressCallback?: (stage: IImportOpts) => void;
    untrusted?: boolean;
    source?: string; // TODO: Enum
 }
@@ -49,6 +49,8 @@ type SigInfo = {
 export type TrustInfo = {
    usable: boolean; // is the backup trusted, true iff there is a sig that is valid & from a trusted device
    sigs: SigInfo[];
+    // eslint-disable-next-line camelcase
+    trusted_locally?: boolean;
 };

 export interface IKeyBackupCheck {
@@ -40,7 +40,7 @@ import {
    ISecretRequest,
    SecretStorageKeyObject,
 } from './SecretStorage';
-import { IAddSecretStorageKeyOpts, ISecretStorageKeyInfo } from "./api";
+import { IAddSecretStorageKeyOpts, IImportRoomKeysOpts, ISecretStorageKeyInfo } from "./api";
 import { OutgoingRoomKeyRequestManager } from './OutgoingRoomKeyRequestManager';
 import { IndexedDBCryptoStore } from './store/indexeddb-crypto-store';
 import { ReciprocateQRCode, SCAN_QR_CODE_METHOD, SHOW_QR_CODE_METHOD } from './verification/QRCode';
@@ -58,7 +58,7 @@ import { BackupManager } from "./backup";
 import { IStore } from "../store";
 import { Room } from "../models/room";
 import { RoomMember } from "../models/room-member";
-import { MatrixEvent } from "../models/event";
+import { MatrixEvent, EventStatus } from "../models/event";
 import { MatrixClient, IKeysUploadResponse, SessionStore, ISignedKey } from "../client";
 import type { EncryptionAlgorithm, DecryptionAlgorithm } from "./algorithms/base";
 import type { IRoomEncryption, RoomList } from "./RoomList";
@@ -2658,7 +2658,7 @@ export class Crypto extends EventEmitter {
     * @param {Function} opts.progressCallback called with an object which has a stage param
     * @return {Promise} a promise which resolves once the keys have been imported
     */
-    public importRoomKeys(keys: IMegolmSessionData[], opts: any = {}): Promise<any> { // TODO types
+    public importRoomKeys(keys: IMegolmSessionData[], opts: IImportRoomKeysOpts = {}): Promise<any> { // TODO types
        let successes = 0;
        let failures = 0;
        const total = keys.length;
@@ -3201,6 +3201,29 @@ export class Crypto extends EventEmitter {
        createRequest: any, // TODO types
        isLiveEvent = true,
    ): Promise<void> {
+        // Wait for event to get its final ID with pendingEventOrdering: "chronological", since DM channels depend on it.
+        if (event.isSending() && event.status != EventStatus.SENT) {
+            let eventIdListener;
+            let statusListener;
+            try {
+                await new Promise((resolve, reject) => {
+                    eventIdListener = resolve;
+                    statusListener = () => {
+                        if (event.status == EventStatus.CANCELLED) {
+                            reject(new Error("Event status set to CANCELLED."));
+                        }
+                    };
+                    event.once("Event.localEventIdReplaced", eventIdListener);
+                    event.on("Event.status", statusListener);
+                });
+            } catch (err) {
+                logger.error("error while waiting for the verification event to be sent: " + err.message);
+                return;
+            } finally {
+                event.removeListener("Event.localEventIdReplaced", eventIdListener);
+                event.removeListener("Event.status", statusListener);
+            }
+        }
        let request = requestsMap.getRequest(event);
        let isNewRequest = false;
        if (!request) {
@@ -15,8 +15,9 @@ limitations under the License.
 */

 import { MatrixClient } from "../client";
-import { IEncryptedFile, UNSTABLE_MSC3089_BRANCH } from "../@types/event";
-import { MatrixEvent } from "./event";
+import { IEncryptedFile, RelationType, UNSTABLE_MSC3089_BRANCH } from "../@types/event";
+import { IContent, MatrixEvent } from "./event";
+import { MSC3089TreeSpace } from "./MSC3089TreeSpace";

 /**
 * Represents a [MSC3089](https://github.com/matrix-org/matrix-doc/pull/3089) branch - a reference
@@ -24,7 +25,11 @@ import { MatrixEvent } from "./event";
 * without notice.
 */
 export class MSC3089Branch {
-    public constructor(private client: MatrixClient, public readonly indexEvent: MatrixEvent) {
+    public constructor(
+        private client: MatrixClient,
+        public readonly indexEvent: MatrixEvent,
+        public readonly directory: MSC3089TreeSpace,
+    ) {
        // Nothing to do
    }

@@ -42,19 +47,27 @@ export class MSC3089Branch {
        return this.indexEvent.getContent()["active"] === true;
    }

+    /**
+     * Version for the file, one-indexed.
+     */
+    public get version(): number {
+        return this.indexEvent.getContent()["version"] ?? 1;
+    }
+
    private get roomId(): string {
        return this.indexEvent.getRoomId();
    }

    /**
-     * Deletes the file from the tree.
+     * Deletes the file from the tree, including all prior edits/versions.
     * @returns {Promise<void>} Resolves when complete.
     */
    public async delete(): Promise<void> {
        await this.client.sendStateEvent(this.roomId, UNSTABLE_MSC3089_BRANCH.name, {}, this.id);
        await this.client.redactEvent(this.roomId, this.id);

-        // TODO: Delete edit history as well
+        const nextVersion = (await this.getVersionHistory())[1]; // [0] will be us
+        if (nextVersion) await nextVersion.delete(); // implicit recursion
    }

    /**
@@ -104,7 +117,7 @@ export class MSC3089Branch {
    public async getFileInfo(): Promise<{ info: IEncryptedFile, httpUrl: string }> {
        const event = await this.getFileEvent();

-        const file = event.getContent()['file'];
+        const file = event.getOriginalContent()['file'];
        const httpUrl = this.client.mxcUrlToHttp(file['url']);

        return { info: file, httpUrl: httpUrl };
@@ -118,15 +131,88 @@ export class MSC3089Branch {
        const room = this.client.getRoom(this.roomId);
        if (!room) throw new Error("Unknown room");

-        const timeline = await this.client.getEventTimeline(room.getUnfilteredTimelineSet(), this.id);
-        if (!timeline) throw new Error("Failed to get timeline for room event");
-
-        const event = timeline.getEvents().find(e => e.getId() === this.id);
+        const event = room.getUnfilteredTimelineSet().findEventById(this.id);
        if (!event) throw new Error("Failed to find event");

-        // Sometimes the event context doesn't decrypt for us, so do that.
-        await this.client.decryptEventIfNeeded(event, { emit: false, isRetry: false });
+        // Sometimes the event isn't decrypted for us, so do that. We specifically set `emit: true`
+        // to ensure that the relations system in the sdk will function.
+        await this.client.decryptEventIfNeeded(event, { emit: true, isRetry: true });

        return event;
    }
+
+    /**
+     * Creates a new version of this file.
+     * @param {string} name The name of the file.
+     * @param {ArrayBuffer} encryptedContents The encrypted contents.
+     * @param {Partial<IEncryptedFile>} info The encrypted file information.
+     * @param {IContent} additionalContent Optional event content fields to include in the message.
+     * @returns {Promise<void>} Resolves when uploaded.
+     */
+    public async createNewVersion(
+        name: string,
+        encryptedContents: ArrayBuffer,
+        info: Partial<IEncryptedFile>,
+        additionalContent?: IContent,
+    ): Promise<void> {
+        const fileEventResponse = await this.directory.createFile(name, encryptedContents, info, {
+            ...(additionalContent ?? {}),
+            "m.new_content": true,
+            "m.relates_to": {
+                "rel_type": RelationType.Replace,
+                "event_id": this.id,
+            },
+        });
+
+        // Update the version of the new event
+        await this.client.sendStateEvent(this.roomId, UNSTABLE_MSC3089_BRANCH.name, {
+            active: true,
+            name: name,
+            version: this.version + 1,
+        }, fileEventResponse['event_id']);
+
+        // Deprecate ourselves
+        await this.client.sendStateEvent(this.roomId, UNSTABLE_MSC3089_BRANCH.name, {
+            ...(this.indexEvent.getContent()),
+            active: false,
+        }, this.id);
+    }
+
+    /**
+     * Gets the file's version history, starting at this file.
+     * @returns {Promise<MSC3089Branch[]>} Resolves to the file's version history, with the
+     * first element being the current version and the last element being the first version.
+     */
+    public async getVersionHistory(): Promise<MSC3089Branch[]> {
+        const fileHistory: MSC3089Branch[] = [];
+        fileHistory.push(this); // start with ourselves
+
+        const room = this.client.getRoom(this.roomId);
+        if (!room) throw new Error("Invalid or unknown room");
+
+        // Clone the timeline to reverse it, getting most-recent-first ordering, hopefully
+        // shortening the awful loop below. Without the clone, we can unintentionally mutate
+        // the timeline.
+        const timelineEvents = [...room.getLiveTimeline().getEvents()].reverse();
+
+        // XXX: This is a very inefficient search, but it's the best we can do with the
+        // relations structure we have in the SDK. As of writing, it is not worth the
+        // investment in improving the structure.
+        let childEvent: MatrixEvent;
+        let parentEvent = await this.getFileEvent();
+        do {
+            childEvent = timelineEvents.find(e => e.replacingEventId() === parentEvent.getId());
+            if (childEvent) {
+                const branch = this.directory.getFile(childEvent.getId());
+                if (branch) {
+                    fileHistory.push(branch);
+                    parentEvent = childEvent;
+                } else {
+                    break; // prevent infinite loop
+                }
+            }
+        } while (childEvent);
+
+        return fileHistory;
+    }
 }
@@ -30,6 +30,7 @@ import {
 import { MSC3089Branch } from "./MSC3089Branch";
 import promiseRetry from "p-retry";
 import { isRoomSharedHistory } from "../crypto/algorithms/megolm";
+import { ISendEventResponse } from "../@types/requests";

 /**
 * The recommended defaults for a tree space's power levels. Note that this
@@ -452,26 +453,38 @@ export class MSC3089TreeSpace {
     * @param {ArrayBuffer} encryptedContents The encrypted contents.
     * @param {Partial<IEncryptedFile>} info The encrypted file information.
     * @param {IContent} additionalContent Optional event content fields to include in the message.
-     * @returns {Promise<void>} Resolves when uploaded.
+     * @returns {Promise<ISendEventResponse>} Resolves to the file event's sent response.
     */
    public async createFile(
        name: string,
        encryptedContents: ArrayBuffer,
        info: Partial<IEncryptedFile>,
        additionalContent?: IContent,
-    ): Promise<void> {
+    ): Promise<ISendEventResponse> {
        const mxc = await this.client.uploadContent(new Blob([encryptedContents]), {
            includeFilename: false,
            onlyContentUri: true,
        });
        info.url = mxc;

-        const res = await this.client.sendMessage(this.roomId, {
-            ...(additionalContent ?? {}),
+        const fileContent = {
            msgtype: MsgType.File,
            body: name,
            url: mxc,
            file: info,
+        };
+
+        additionalContent = additionalContent ?? {};
+        if (additionalContent["m.new_content"]) {
+            // We do the right thing according to the spec, but due to how relations are
+            // handled we also end up duplicating this information to the regular `content`
+            // as well.
+            additionalContent["m.new_content"] = fileContent;
+        }
+
+        const res = await this.client.sendMessage(this.roomId, {
+            ...additionalContent,
+            ...fileContent,
            [UNSTABLE_MSC3089_LEAF.name]: {},
        });

@@ -479,6 +492,8 @@ export class MSC3089TreeSpace {
            active: true,
            name: name,
        }, res['event_id']);
+
+        return res;
    }

    /**
@@ -488,7 +503,7 @@ export class MSC3089TreeSpace {
     */
    public getFile(fileEventId: string): MSC3089Branch {
        const branch = this.room.currentState.getStateEvents(UNSTABLE_MSC3089_BRANCH.name, fileEventId);
-        return branch ? new MSC3089Branch(this.client, branch) : null;
+        return branch ? new MSC3089Branch(this.client, branch, this) : null;
    }

    /**
@@ -496,7 +511,15 @@ export class MSC3089TreeSpace {
     * @returns {MSC3089Branch[]} The known files. May be empty, but not null.
     */
    public listFiles(): MSC3089Branch[] {
+        return this.listAllFiles().filter(b => b.isActive);
+    }
+
+    /**
+     * Gets an array of all known files for the tree, including inactive/invalid ones.
+     * @returns {MSC3089Branch[]} The known files. May be empty, but not null.
+     */
+    public listAllFiles(): MSC3089Branch[] {
        const branches = this.room.currentState.getStateEvents(UNSTABLE_MSC3089_BRANCH.name) ?? [];
-        return branches.map(e => new MSC3089Branch(this.client, e)).filter(b => b.isActive);
+        return branches.map(e => new MSC3089Branch(this.client, e, this));
    }
 }
@@ -27,6 +27,7 @@ import { Relations } from './relations';
 import { Room } from "./room";
 import { Filter } from "../filter";
 import { EventType, RelationType } from "../@types/event";
+import { RoomState } from "./room-state";

 // var DEBUG = false;
 const DEBUG = true;
@@ -45,6 +46,11 @@ interface IOpts {
    unstableClientRelationAggregation?: boolean;
 }

+export enum DuplicateStrategy {
+    Ignore = "ignore",
+    Replace = "replace",
+}
+
 export class EventTimelineSet extends EventEmitter {
    private readonly timelineSupport: boolean;
    private unstableClientRelationAggregation: boolean;
@@ -509,8 +515,14 @@ export class EventTimelineSet extends EventEmitter {
     * @param {MatrixEvent} event Event to be added
     * @param {string?} duplicateStrategy 'ignore' or 'replace'
     * @param {boolean} fromCache whether the sync response came from cache
+     * @param roomState the state events to reconcile metadata from
     */
-    public addLiveEvent(event: MatrixEvent, duplicateStrategy?: "ignore" | "replace", fromCache = false): void {
+    public addLiveEvent(
+        event: MatrixEvent,
+        duplicateStrategy: DuplicateStrategy = DuplicateStrategy.Ignore,
+        fromCache = false,
+        roomState?: RoomState,
+    ): void {
        if (this.filter) {
            const events = this.filter.filterRoomTimeline([event]);
            if (!events.length) {
@@ -520,16 +532,19 @@ export class EventTimelineSet extends EventEmitter {

        const timeline = this._eventIdToTimeline[event.getId()];
        if (timeline) {
-            if (duplicateStrategy === "replace") {
+            if (duplicateStrategy === DuplicateStrategy.Replace) {
                debuglog("EventTimelineSet.addLiveEvent: replacing duplicate event " +
                    event.getId());
                const tlEvents = timeline.getEvents();
                for (let j = 0; j < tlEvents.length; j++) {
                    if (tlEvents[j].getId() === event.getId()) {
                        // still need to set the right metadata on this event
+                        if (!roomState) {
+                            roomState = timeline.getState(EventTimeline.FORWARDS);
+                        }
                        EventTimeline.setEventMetadata(
                            event,
-                            timeline.getState(EventTimeline.FORWARDS),
+                            roomState,
                            false,
                        );
                        tlEvents[j] = event;
@@ -545,7 +560,7 @@ export class EventTimelineSet extends EventEmitter {
            return;
        }

-        this.addEventToTimeline(event, this.liveTimeline, false, fromCache);
+        this.addEventToTimeline(event, this.liveTimeline, false, fromCache, roomState);
    }

    /**
@@ -566,9 +581,10 @@ export class EventTimelineSet extends EventEmitter {
        timeline: EventTimeline,
        toStartOfTimeline: boolean,
        fromCache = false,
+        roomState?: RoomState,
    ) {
        const eventId = event.getId();
-        timeline.addEvent(event, toStartOfTimeline);
+        timeline.addEvent(event, toStartOfTimeline, roomState);
        this._eventIdToTimeline[eventId] = timeline;

        this.setRelationsTarget(event);
@@ -347,8 +347,11 @@ export class EventTimeline {
     * @param {MatrixEvent} event   new event
     * @param {boolean}  atStart     true to insert new event at the start
     */
-    public addEvent(event: MatrixEvent, atStart: boolean): void {
-        const stateContext = atStart ? this.startState : this.endState;
+    public addEvent(event: MatrixEvent, atStart: boolean, stateContext?: RoomState): void {
+        if (!stateContext) {
+            stateContext = atStart ? this.startState : this.endState;
+        }
+
        const timelineSet = this.getTimelineSet();

        if (timelineSet.room) {
@@ -28,7 +28,6 @@ import {
    EventType,
    MsgType,
    RelationType,
-    UNSTABLE_ELEMENT_REPLY_IN_THREAD,
 } from "../@types/event";
 import { Crypto } from "../crypto";
 import { deepSortedObjectEntries } from "../utils";
@@ -119,7 +118,7 @@ interface IAggregatedRelation {
    key?: string;
 }

-interface IEventRelation {
+export interface IEventRelation {
    rel_type: RelationType | string;
    event_id: string;
    key?: string;
@@ -285,8 +284,28 @@ export class MatrixEvent extends EventEmitter {
     * @returns {IEvent} The event in wire format.
     */
    public getEffectiveEvent(): IEvent {
-        // clearEvent doesn't have all the fields, so we'll copy what we can from this.event
-        return Object.assign({}, this.event, this.clearEvent) as IEvent;
+        const content = Object.assign({}, this.getContent()); // clone for mutation
+
+        if (this.getWireType() === EventType.RoomMessageEncrypted) {
+            // Encrypted events sometimes aren't symmetrical on the `content` so we'll copy
+            // that over too, but only for missing properties. We don't copy over mismatches
+            // between the plain and decrypted copies of `content` because we assume that the
+            // app is relying on the decrypted version, so we want to expose that as a source
+            // of truth here too.
+            for (const [key, value] of Object.entries(this.getWireContent())) {
+                // Skip fields from the encrypted event schema though - we don't want to leak
+                // these.
+                if (["algorithm", "ciphertext", "device_id", "sender_key", "session_id"].includes(key)) {
+                    continue;
+                }
+
+                if (content[key] === undefined) content[key] = value;
+            }
+        }
+
+        // clearEvent doesn't have all the fields, so we'll copy what we can from this.event.
+        // We also copy over our "fixed" content key.
+        return Object.assign({}, this.event, this.clearEvent, { content }) as IEvent;
    }

    /**
@@ -399,30 +418,39 @@ export class MatrixEvent extends EventEmitter {

    /**
     * @experimental
-     * Get the event ID of the replied event
+     * Get the event ID of the thread head
     */
-    public get replyEventId(): string {
-        const relations = this.getWireContent()["m.relates_to"];
-        return relations?.["m.in_reply_to"]?.["event_id"];
+    public get threadRootId(): string {
+        const relatesTo = this.getWireContent()?.["m.relates_to"];
+        if (relatesTo?.rel_type === RelationType.Thread) {
+            return relatesTo.event_id;
+        }
    }

    /**
     * @experimental
-     * Determines whether a reply should be rendered in a thread
-     * or in the main room timeline
     */
-    public get replyInThread(): boolean {
-        const replyTo = this.getWireContent()
-            ?.["m.relates_to"]
-            ?.["m.in_reply_to"];
-        return (this.replyEventId
-            && replyTo[UNSTABLE_ELEMENT_REPLY_IN_THREAD.name])
-            || this.thread instanceof Thread;
+    public get isThreadRelation(): boolean {
+        return !!this.threadRootId;
+    }
+
+    /**
+     * @experimental
+     */
+    public get isThreadRoot(): boolean {
+        const thread = this.getThread();
+        return thread?.id === this.getId();
    }

    public get parentEventId(): string {
-        return this.replyEventId
-            || this.getWireContent()["m.relates_to"]?.event_id;
+        const relations = this.getWireContent()["m.relates_to"];
+        return relations?.["m.in_reply_to"]?.["event_id"]
+            || relations?.event_id;
+    }
+
+    public get replyEventId(): string {
+        const relations = this.getWireContent()["m.relates_to"];
+        return relations?.["m.in_reply_to"]?.["event_id"];
    }

    /**
@@ -578,7 +578,7 @@ export class RoomState extends EventEmitter {
     * @param {number} powerLevel The power level of the member
     * @return {boolean} true if the given power level is sufficient
     */
-    private hasSufficientPowerLevelFor(action: string, powerLevel: number): boolean {
+    public hasSufficientPowerLevelFor(action: string, powerLevel: number): boolean {
        const powerLevelsEvent = this.getStateEvents(EventType.RoomPowerLevels, "");

        let powerLevels = {};
@@ -20,7 +20,7 @@ limitations under the License.

 import { EventEmitter } from "events";

-import { EventTimelineSet } from "./event-timeline-set";
+import { EventTimelineSet, DuplicateStrategy } from "./event-timeline-set";
 import { EventTimeline } from "./event-timeline";
 import { getHttpUriForMxc } from "../content-repo";
 import * as utils from "../utils";
@@ -149,7 +149,7 @@ export class Room extends EventEmitter {
    /**
     * @experimental
     */
-    public threads = new Set<Thread>();
+    public threads = new Map<string, Thread>();

    /**
     * Construct a new Room.
@@ -1068,19 +1068,6 @@ export class Room extends EventEmitter {
        );
    }

-    /**
-     * @experimental
-     */
-    public addThread(thread: Thread): Set<Thread> {
-        this.threads.add(thread);
-        if (!thread.ready) {
-            thread.once(ThreadEvent.Ready, this.dedupeThreads);
-            this.emit(ThreadEvent.Update, thread);
-            this.reEmitter.reEmit(thread, [ThreadEvent.Update, ThreadEvent.Ready]);
-        }
-        return this.threads;
-    }
-
    /**
     * @experimental
     */
@@ -1097,26 +1084,6 @@ export class Room extends EventEmitter {
        return Array.from(this.threads.values());
    }

-    /**
-     * Two threads starting from a different child event can end up
-     * with the same event root. This method ensures that the duplicates
-     * are removed
-     * @experimental
-     */
-    private dedupeThreads = (readyThread): void => {
-        const deduped = Array.from(this.threads).reduce((dedupedThreads, thread) => {
-            if (dedupedThreads.has(thread.id)) {
-                dedupedThreads.get(thread.id).merge(thread);
-            } else {
-                dedupedThreads.set(thread.id, thread);
-            }
-
-            return dedupedThreads;
-        }, new Map<string, Thread>());
-
-        this.threads = new Set<Thread>(deduped.values());
-    };
-
    /**
     * Get a member from the current room state.
     * @param {string} userId The user ID of the member.
@@ -1293,28 +1260,38 @@ export class Room extends EventEmitter {
        }
    }

+    public findThreadForEvent(event: MatrixEvent): Thread {
+        if (!event) {
+            return null;
+        }
+        if (event.isThreadRelation) {
+            return this.threads.get(event.threadRootId);
+        } else {
+            const parentEvent = this.findEventById(event.parentEventId);
+            return this.findThreadForEvent(parentEvent);
+        }
+    }
+
    /**
     * Add an event to a thread's timeline. Will fire "Thread.update"
     * @experimental
     */
    public addThreadedEvent(event: MatrixEvent): void {
-        if (event.getUnsigned().transaction_id) {
-            const existingEvent = this.txnToEvent[event.getUnsigned().transaction_id];
-            if (existingEvent) {
-                // remote echo of an event we sent earlier
-                this.handleRemoteEcho(event, existingEvent);
-            }
-        }
-        let thread = this.findEventById(event.parentEventId)?.getThread();
+        let thread = this.findThreadForEvent(event);
        if (thread) {
            thread.addEvent(event);
        } else {
-            thread = new Thread([event], this, this.client);
-        }
-
-        if (!this.threads.has(thread)) {
-            this.addThread(thread);
+            const events = [event];
+            const rootEvent = this.findEventById(event.threadRootId);
+            if (rootEvent) {
+                events.unshift(rootEvent);
+            }
+            thread = new Thread(events, this, this.client);
+            this.reEmitter.reEmit(thread, [ThreadEvent.Update, ThreadEvent.Ready]);
+            this.threads.set(thread.id, thread);
+            this.emit(ThreadEvent.New, thread);
        }
+        this.emit(ThreadEvent.Update, thread);
    }

    /**
@@ -1327,12 +1304,12 @@ export class Room extends EventEmitter {
     * @fires module:client~MatrixClient#event:"Room.timeline"
     * @private
     */
-    private addLiveEvent(event: MatrixEvent, duplicateStrategy?: "ignore" | "replace", fromCache = false): void {
+    private addLiveEvent(event: MatrixEvent, duplicateStrategy?: DuplicateStrategy, fromCache = false): void {
        if (event.isRedaction()) {
            const redactId = event.event.redacts;

            // if we know about this event, redact its contents now.
-            const redactedEvent = this.getUnfilteredTimelineSet().findEventById(redactId);
+            const redactedEvent = this.findEventById(redactId);
            if (redactedEvent) {
                redactedEvent.makeRedacted(event);

@@ -1416,7 +1393,7 @@ export class Room extends EventEmitter {
        // TODO: Enable "pending events" for threads
        // There's a fair few things to update to make them work with Threads
        // Will get back to it when the plan is to build a more polished UI ready for production
-        if (this.client?.supportsExperimentalThreads() && event.replyInThread) {
+        if (this.client?.supportsExperimentalThreads() && event.threadRootId) {
            return;
        }

@@ -1592,14 +1569,6 @@ export class Room extends EventEmitter {
            oldEventId, oldStatus);
    }

-    public findThreadByEventId(eventId: string): Thread {
-        for (const thread of this.threads) {
-            if (thread.has(eventId)) {
-                return thread;
-            }
-        }
-    }
-
    /**
     * Update the status / event id on a pending event, to reflect its transmission
     * progress.
@@ -1713,7 +1682,7 @@ export class Room extends EventEmitter {
     * @param {boolean} fromCache whether the sync response came from cache
     * @throws If <code>duplicateStrategy</code> is not falsey, 'replace' or 'ignore'.
     */
-    public addLiveEvents(events: MatrixEvent[], duplicateStrategy?: "replace" | "ignore", fromCache = false): void {
+    public addLiveEvents(events: MatrixEvent[], duplicateStrategy?: DuplicateStrategy, fromCache = false): void {
        let i;
        if (duplicateStrategy && ["replace", "ignore"].indexOf(duplicateStrategy) === -1) {
            throw new Error("duplicateStrategy MUST be either 'replace' or 'ignore'");
@@ -1740,6 +1709,10 @@ export class Room extends EventEmitter {
            // TODO: We should have a filter to say "only add state event
            // types X Y Z to the timeline".
            this.addLiveEvent(events[i], duplicateStrategy, fromCache);
+            const thread = this.threads.get(events[i].getId());
+            if (thread && !thread.ready) {
+                thread.addEvent(events[i], true);
+            }
        }
    }

@@ -17,12 +17,14 @@ limitations under the License.
 import { EventEmitter } from "events";
 import { MatrixClient } from "../matrix";
 import { MatrixEvent } from "./event";
+import { EventTimeline } from "./event-timeline";
 import { EventTimelineSet } from './event-timeline-set';
 import { Room } from './room';

 export enum ThreadEvent {
+    New = "Thread.new",
    Ready = "Thread.ready",
-    Update = "Thread.update"
+    Update = "Thread.update",
 }

 /**
@@ -36,7 +38,6 @@ export class Thread extends EventEmitter {
    /**
     * A reference to all the events ID at the bottom of the threads
     */
-    public readonly tail = new Set<string>();
    public readonly timelineSet: EventTimelineSet;

    constructor(
@@ -58,22 +59,33 @@ export class Thread extends EventEmitter {
     * Will fire "Thread.update"
     * @param event The event to add
     */
-    public async addEvent(event: MatrixEvent): Promise<void> {
+    public async addEvent(event: MatrixEvent, toStartOfTimeline = false): Promise<void> {
        if (this.timelineSet.findEventById(event.getId()) || event.status !== null) {
            return;
        }

-        if (this.tail.has(event.replyEventId)) {
-            this.tail.delete(event.replyEventId);
+        if (!this.root) {
+            if (event.isThreadRelation) {
+                this.root = event.threadRootId;
+            } else {
+                this.root = event.getId();
+            }
        }
-        this.tail.add(event.getId());

-        if (!event.replyEventId || !this.timelineSet.findEventById(event.replyEventId)) {
-            this.root = event.getId();
-        }
+        // all the relevant membership info to hydrate events with a sender
+        // is held in the main room timeline
+        // We want to fetch the room state from there and pass it down to this thread
+        // timeline set to let it reconcile an event with its relevant RoomMember
+        const roomState = this.room.getLiveTimeline().getState(EventTimeline.FORWARDS);

        event.setThread(this);
-        this.timelineSet.addLiveEvent(event);
+        this.timelineSet.addEventToTimeline(
+            event,
+            this.timelineSet.getLiveTimeline(),
+            toStartOfTimeline,
+            false,
+            roomState,
+        );

        if (this.ready) {
            this.client.decryptEventIfNeeded(event, {});
@@ -81,31 +93,6 @@ export class Thread extends EventEmitter {
        this.emit(ThreadEvent.Update, this);
    }

-    /**
-     * Completes the reply chain with all events
-     * missing from the current sync data
-     * Will fire "Thread.ready"
-     */
-    public async fetchReplyChain(): Promise<void> {
-        if (!this.ready) {
-            let mxEvent = this.room.findEventById(this.rootEvent.replyEventId);
-            if (!mxEvent) {
-                mxEvent = await this.fetchEventById(
-                    this.rootEvent.getRoomId(),
-                    this.rootEvent.replyEventId,
-                );
-            }
-
-            this.addEvent(mxEvent);
-            if (mxEvent.replyEventId) {
-                await this.fetchReplyChain();
-            } else {
-                await this.decryptEvents();
-                this.emit(ThreadEvent.Ready, this);
-            }
-        }
-    }
-
    private async decryptEvents(): Promise<void> {
        await Promise.allSettled(
            Array.from(this.timelineSet.getLiveTimeline().getEvents()).map(event => {
@@ -114,18 +101,6 @@ export class Thread extends EventEmitter {
        );
    }

-    /**
-     * Fetches an event over the network
-     */
-    private async fetchEventById(roomId: string, eventId: string): Promise<MatrixEvent> {
-        const response = await this.client.http.authedRequest(
-            undefined,
-            "GET",
-            `/rooms/${roomId}/event/${eventId}`,
-        );
-        return new MatrixEvent(response);
-    }
-
    /**
     * Finds an event by ID in the current thread
     */
@@ -137,7 +112,7 @@ export class Thread extends EventEmitter {
     * Determines thread's ready status
     */
    public get ready(): boolean {
-        return this.rootEvent.replyEventId === undefined;
+        return this.rootEvent !== undefined;
    }

    /**
@@ -203,18 +178,22 @@ export class Thread extends EventEmitter {
        super.on(event, listener);
        return this;
    }
+
    public once(event: ThreadEvent, listener: (...args: any[]) => void): this {
        super.once(event, listener);
        return this;
    }
+
    public off(event: ThreadEvent, listener: (...args: any[]) => void): this {
        super.off(event, listener);
        return this;
    }
+
    public addListener(event: ThreadEvent, listener: (...args: any[]) => void): this {
        super.addListener(event, listener);
        return this;
    }
+
    public removeListener(event: ThreadEvent, listener: (...args: any[]) => void): this {
        super.removeListener(event, listener);
        return this;
@@ -47,7 +47,7 @@ export class RoomHierarchy {
     * @constructor
     */
    constructor(
-        private readonly root: Room,
+        public readonly root: Room,
        private readonly pageSize?: number,
        private readonly maxDepth?: number,
        private readonly suggestedOnly = false,
@@ -61,6 +61,10 @@ export class RoomHierarchy {
        return !!this.serverSupportError || !!this.nextBatch || !this._rooms;
    }

+    public get loading(): boolean {
+        return !!this.loadRequest;
+    }
+
    public get rooms(): IHierarchyRoom[] {
        return this._rooms;
    }
@@ -319,13 +319,13 @@ export class SyncApi {
                // An event should live in the thread timeline if
                // - It's a reply in thread event
                // - It's related to a reply in thread event
-                let shouldLiveInThreadTimeline = event.replyInThread;
+                let shouldLiveInThreadTimeline = event.isThreadRelation;
                if (!shouldLiveInThreadTimeline) {
-                    const parentEventId = event.getWireContent()["m.relates_to"]?.event_id;
+                    const parentEventId = event.parentEventId;
                    const parentEvent = room?.findEventById(parentEventId) || events.find((mxEv: MatrixEvent) => {
                        return mxEv.getId() === parentEventId;
                    });
-                    shouldLiveInThreadTimeline = parentEvent?.replyInThread;
+                    shouldLiveInThreadTimeline = parentEvent?.isThreadRelation;
                }
                memo[shouldLiveInThreadTimeline ? 1 : 0].push(event);
                return memo;
@@ -391,6 +391,19 @@ export class MatrixCall extends EventEmitter {
        });
    }

+    public get hasLocalUserMediaAudioTrack(): boolean {
+        return this.localUsermediaStream?.getAudioTracks().length > 0;
+    }
+
+    public get hasRemoteUserMediaAudioTrack(): boolean {
+        return this.getRemoteFeeds().some((feed) => {
+            return (
+                feed.purpose === SDPStreamMetadataPurpose.Usermedia &&
+                feed.stream.getAudioTracks().length > 0
+            );
+        });
+    }
+
    public get localUsermediaFeed(): CallFeed {
        return this.getLocalFeeds().find((feed) => feed.purpose === SDPStreamMetadataPurpose.Usermedia);
    }
@@ -484,7 +497,15 @@ export class MatrixCall extends EventEmitter {
        if (existingFeed) {
            existingFeed.setNewStream(stream);
        } else {
-            this.feeds.push(new CallFeed(stream, userId, purpose, this.client, this.roomId, audioMuted, videoMuted));
+            this.feeds.push(new CallFeed({
+                client: this.client,
+                roomId: this.roomId,
+                userId,
+                stream,
+                purpose,
+                audioMuted,
+                videoMuted,
+            }));
            this.emit(CallEvent.FeedsChanged, this.feeds);
        }

@@ -515,7 +536,15 @@ export class MatrixCall extends EventEmitter {
        if (feed) {
            feed.setNewStream(stream);
        } else {
-            this.feeds.push(new CallFeed(stream, userId, purpose, this.client, this.roomId, false, false));
+            this.feeds.push(new CallFeed({
+                client: this.client,
+                roomId: this.roomId,
+                audioMuted: false,
+                videoMuted: false,
+                userId,
+                stream,
+                purpose,
+            }));
            this.emit(CallEvent.FeedsChanged, this.feeds);
        }

@@ -530,7 +559,15 @@ export class MatrixCall extends EventEmitter {
        if (existingFeed) {
            existingFeed.setNewStream(stream);
        } else {
-            this.feeds.push(new CallFeed(stream, userId, purpose, this.client, this.roomId, false, false));
+            this.feeds.push(new CallFeed({
+                client: this.client,
+                roomId: this.roomId,
+                audioMuted: stream.getAudioTracks().length === 0,
+                videoMuted: stream.getVideoTracks().length === 0,
+                userId,
+                stream,
+                purpose,
+            }));
            this.emit(CallEvent.FeedsChanged, this.feeds);
        }

@@ -683,30 +720,62 @@ export class MatrixCall extends EventEmitter {
        this.setState(CallState.Ended);
    }

+    private shouldAnswerWithMediaType(
+        wantedValue: boolean | undefined, valueOfTheOtherSide: boolean | undefined, type: "audio" | "video",
+    ): boolean {
+        if (wantedValue && !valueOfTheOtherSide) {
+            // TODO: Figure out how to do this
+            logger.warn(`Unable to answer with ${type} because the other side isn't sending it either.`);
+            return false;
+        } else if (
+            !utils.isNullOrUndefined(wantedValue) &&
+            wantedValue !== valueOfTheOtherSide &&
+            !this.opponentSupportsSDPStreamMetadata()
+        ) {
+            logger.warn(
+                `Unable to answer with ${type}=${wantedValue} because the other side doesn't support it. ` +
+                `Answering with ${type}=${valueOfTheOtherSide}.`,
+            );
+            return valueOfTheOtherSide;
+        }
+        return wantedValue ?? valueOfTheOtherSide;
+    }
+
    /**
     * Answer a call.
     */
-    public async answer(): Promise<void> {
-        if (this.inviteOrAnswerSent) {
-            return;
-        }
+    public async answer(audio?: boolean, video?: boolean): Promise<void> {
+        if (this.inviteOrAnswerSent) return;
+        // TODO: Figure out how to do this
+        if (audio === false && video === false) throw new Error("You CANNOT answer a call without media");

        logger.debug(`Answering call ${this.callId}`);

        if (!this.localUsermediaStream && !this.waitForLocalAVStream) {
+            const prevState = this.state;
+            const answerWithAudio = this.shouldAnswerWithMediaType(audio, this.hasRemoteUserMediaAudioTrack, "audio");
+            const answerWithVideo = this.shouldAnswerWithMediaType(video, this.hasRemoteUserMediaVideoTrack, "video");
+
            this.setState(CallState.WaitLocalMedia);
            this.waitForLocalAVStream = true;

            try {
                const mediaStream = await this.client.getMediaHandler().getUserMediaStream(
-                    true,
-                    this.hasRemoteUserMediaVideoTrack,
+                    answerWithAudio, answerWithVideo,
                );
                this.waitForLocalAVStream = false;
                this.gotUserMediaForAnswer(mediaStream);
            } catch (e) {
-                this.getUserMediaFailed(e);
-                return;
+                if (answerWithVideo) {
+                    // Try to answer without video
+                    logger.warn("Failed to getUserMedia(), trying to getUserMedia() without video");
+                    this.setState(prevState);
+                    this.waitForLocalAVStream = false;
+                    await this.answer(answerWithAudio, false);
+                } else {
+                    this.getUserMediaFailed(e);
+                    return;
+                }
            }
        } else if (this.waitForLocalAVStream) {
            this.setState(CallState.WaitLocalMedia);
@@ -774,6 +843,50 @@ export class MatrixCall extends EventEmitter {
        this.sendVoipEvent(EventType.CallReject, {});
    }

+    /**
+     * Adds an audio and/or video track - upgrades the call
+     * @param {boolean} audio should add an audio track
+     * @param {boolean} video should add an video track
+     */
+    private async upgradeCall(
+        audio: boolean, video: boolean,
+    ): Promise<void> {
+        // We don't do call downgrades
+        if (!audio && !video) return;
+        if (!this.opponentSupportsSDPStreamMetadata()) return;
+
+        try {
+            const upgradeAudio = audio && !this.hasLocalUserMediaAudioTrack;
+            const upgradeVideo = video && !this.hasLocalUserMediaVideoTrack;
+            logger.debug(`Upgrading call: audio?=${upgradeAudio} video?=${upgradeVideo}`);
+
+            const stream = await this.client.getMediaHandler().getUserMediaStream(upgradeAudio, upgradeVideo);
+            if (upgradeAudio && upgradeVideo) {
+                if (this.hasLocalUserMediaAudioTrack) return;
+                if (this.hasLocalUserMediaVideoTrack) return;
+
+                this.pushLocalFeed(stream, SDPStreamMetadataPurpose.Usermedia);
+            } else if (upgradeAudio) {
+                if (this.hasLocalUserMediaAudioTrack) return;
+
+                const audioTrack = stream.getAudioTracks()[0];
+                this.localUsermediaStream.addTrack(audioTrack);
+                this.peerConn.addTrack(audioTrack, this.localUsermediaStream);
+            } else if (upgradeVideo) {
+                if (this.hasLocalUserMediaVideoTrack) return;
+
+                const videoTrack = stream.getVideoTracks()[0];
+                this.localUsermediaStream.addTrack(videoTrack);
+                this.peerConn.addTrack(videoTrack, this.localUsermediaStream);
+            }
+        } catch (error) {
+            logger.error("Failed to upgrade the call", error);
+            this.emit(CallEvent.Error,
+                new CallError(CallErrorCode.NoUserMedia, "Failed to get camera access: ", error),
+            );
+        }
+    }
+
    /**
     * Returns true if this.remoteSDPStreamMetadata is defined, otherwise returns false
     * @returns {boolean} can screenshare
@@ -888,10 +1001,20 @@ export class MatrixCall extends EventEmitter {
    /**
     * Set whether our outbound video should be muted or not.
     * @param {boolean} muted True to mute the outbound video.
+     * @returns the new mute state
     */
-    public setLocalVideoMuted(muted: boolean): void {
+    public async setLocalVideoMuted(muted: boolean): Promise<boolean> {
+        if (!await this.client.getMediaHandler().hasVideoDevice()) {
+            return this.isLocalVideoMuted();
+        }
+
+        if (!this.hasLocalUserMediaVideoTrack && !muted) {
+            await this.upgradeCall(false, true);
+            return this.isLocalVideoMuted();
+        }
        this.localUsermediaFeed?.setVideoMuted(muted);
        this.updateMuteStatus();
+        return this.isLocalVideoMuted();
    }

    /**
@@ -910,10 +1033,20 @@ export class MatrixCall extends EventEmitter {
    /**
     * Set whether the microphone should be muted or not.
     * @param {boolean} muted True to mute the mic.
+     * @returns the new mute state
     */
-    public setMicrophoneMuted(muted: boolean): void {
+    public async setMicrophoneMuted(muted: boolean): Promise<boolean> {
+        if (!await this.client.getMediaHandler().hasAudioDevice()) {
+            return this.isMicrophoneMuted();
+        }
+
+        if (!this.hasLocalUserMediaAudioTrack && !muted) {
+            await this.upgradeCall(true, false);
+            return this.isMicrophoneMuted();
+        }
        this.localUsermediaFeed?.setAudioMuted(muted);
        this.updateMuteStatus();
+        return this.isMicrophoneMuted();
    }

    /**
@@ -1482,10 +1615,13 @@ export class MatrixCall extends EventEmitter {
        // chrome doesn't implement any of the 'onstarted' events yet
        if (this.peerConn.iceConnectionState == 'connected') {
            this.setState(CallState.Connected);
-            this.callLengthInterval = setInterval(() => {
-                this.callLength++;
-                this.emit(CallEvent.LengthChanged, this.callLength);
-            }, 1000);
+
+            if (!this.callLengthInterval) {
+                this.callLengthInterval = setInterval(() => {
+                    this.callLength++;
+                    this.emit(CallEvent.LengthChanged, this.callLength);
+                }, 1000);
+            }
        } else if (this.peerConn.iceConnectionState == 'failed') {
            this.hangup(CallErrorCode.IceFailed, false);
        }
@@ -22,6 +22,16 @@ import { RoomMember } from "../models/room-member";
 const POLLING_INTERVAL = 250; // ms
 const SPEAKING_THRESHOLD = -60; // dB

+export interface ICallFeedOpts {
+    client: MatrixClient;
+    roomId: string;
+    userId: string;
+    stream: MediaStream;
+    purpose: SDPStreamMetadataPurpose;
+    audioMuted: boolean;
+    videoMuted: boolean;
+}
+
 export enum CallFeedEvent {
    NewStream = "new_stream",
    MuteStateChanged = "mute_state_changed",
@@ -30,6 +40,14 @@ export enum CallFeedEvent {
 }

 export class CallFeed extends EventEmitter {
+    public stream: MediaStream;
+    public userId: string;
+    public purpose: SDPStreamMetadataPurpose;
+
+    private client: MatrixClient;
+    private roomId: string;
+    private audioMuted: boolean;
+    private videoMuted: boolean;
    private measuringVolumeActivity = false;
    private audioContext: AudioContext;
    private analyser: AnalyserNode;
@@ -38,17 +56,18 @@ export class CallFeed extends EventEmitter {
    private speaking = false;
    private volumeLooperTimeout: number;

-    constructor(
-        public stream: MediaStream,
-        public userId: string,
-        public purpose: SDPStreamMetadataPurpose,
-        private client: MatrixClient,
-        private roomId: string,
-        private audioMuted: boolean,
-        private videoMuted: boolean,
-    ) {
+    constructor(opts: ICallFeedOpts) {
        super();

+        this.client = opts.client;
+        this.roomId = opts.roomId;
+        this.userId = opts.userId;
+        this.purpose = opts.purpose;
+        this.audioMuted = opts.audioMuted;
+        this.videoMuted = opts.videoMuted;
+
+        this.updateStream(null, opts.stream);
+
        if (this.hasAudioTrack) {
            this.initVolumeMeasuring();
        }
@@ -58,6 +77,25 @@ export class CallFeed extends EventEmitter {
        return this.stream.getAudioTracks().length > 0;
    }

+    private updateStream(oldStream: MediaStream, newStream: MediaStream): void {
+        if (oldStream) {
+            oldStream.removeEventListener("addtrack", this.onAddTrack);
+            this.measureVolumeActivity(false);
+        }
+        if (newStream) {
+            this.stream = newStream;
+            newStream.addEventListener("addtrack", this.onAddTrack);
+
+            if (this.hasAudioTrack) {
+                this.initVolumeMeasuring();
+            } else {
+                this.measureVolumeActivity(false);
+            }
+        }
+
+        this.emit(CallFeedEvent.NewStream, this.stream);
+    }
+
    private initVolumeMeasuring(): void {
        const AudioContext = window.AudioContext || window.webkitAudioContext;
        if (!this.hasAudioTrack || !AudioContext) return;
@@ -74,6 +112,10 @@ export class CallFeed extends EventEmitter {
        this.frequencyBinCount = new Float32Array(this.analyser.frequencyBinCount);
    }

+    private onAddTrack = (): void => {
+        this.emit(CallFeedEvent.NewStream, this.stream);
+    };
+
    /**
     * Returns callRoom member
     * @returns member of the callRoom
@@ -116,14 +158,7 @@ export class CallFeed extends EventEmitter {
     * @param newStream new stream with which to replace the current one
     */
    public setNewStream(newStream: MediaStream): void {
-        this.stream = newStream;
-        this.emit(CallFeedEvent.NewStream, this.stream);
-
-        if (this.hasAudioTrack) {
-            this.initVolumeMeasuring();
-        } else {
-            this.measureVolumeActivity(false);
-        }
+        this.updateStream(this.stream, newStream);
    }

    /**
@@ -43,23 +43,37 @@ export class MediaHandler {
        this.videoInput = deviceId;
    }

+    public async hasAudioDevice(): Promise<boolean> {
+        const devices = await navigator.mediaDevices.enumerateDevices();
+        return devices.filter(device => device.kind === "audioinput").length > 0;
+    }
+
+    public async hasVideoDevice(): Promise<boolean> {
+        const devices = await navigator.mediaDevices.enumerateDevices();
+        return devices.filter(device => device.kind === "videoinput").length > 0;
+    }
+
    /**
     * @returns {MediaStream} based on passed parameters
     */
    public async getUserMediaStream(audio: boolean, video: boolean): Promise<MediaStream> {
+        const shouldRequestAudio = audio && await this.hasAudioDevice();
+        const shouldRequestVideo = video && await this.hasVideoDevice();
+
        let stream: MediaStream;

        // Find a stream with matching tracks
        const matchingStream = this.userMediaStreams.find((stream) => {
-            if (audio !== (stream.getAudioTracks().length > 0)) return false;
-            if (video !== (stream.getVideoTracks().length > 0)) return false;
+            if (shouldRequestAudio !== (stream.getAudioTracks().length > 0)) return false;
+            if (shouldRequestVideo !== (stream.getVideoTracks().length > 0)) return false;
+            return true;
        });

        if (matchingStream) {
            logger.log("Cloning user media stream", matchingStream.id);
            stream = matchingStream.clone();
        } else {
-            const constraints = this.getUserMediaContraints(audio, video);
+            const constraints = this.getUserMediaContraints(shouldRequestAudio, shouldRequestVideo);
            logger.log("Getting user media with constraints", constraints);
            stream = await navigator.mediaDevices.getUserMedia(constraints);
        }
@@ -1,6 +1,7 @@
 {
  "extends": "./tsconfig.json",
  "compilerOptions": {
+    "declarationMap": true,
    "sourceMap": true,
    "noEmit": false,
    "emitDecoratorMetadata": true,
Author	SHA1	Message	Date
RiotRobot	ab06f57965	v15.0.0	2021-10-25 11:22:22 +01:00
RiotRobot	c46209a159	Prepare changelog for v15.0.0	2021-10-25 11:22:21 +01:00
RiotRobot	526758a07f	v15.0.0-rc.1	2021-10-19 10:50:42 +01:00
RiotRobot	9686fba81e	Prepare changelog for v15.0.0-rc.1	2021-10-19 10:50:41 +01:00
Germain	bbc547fd7f	Merge pull request #1982 from matrix-org/gsouquet/thread-event-new	2021-10-15 14:32:19 +01:00
Germain	7d5dbeaf2d	Merge pull request #1981 from matrix-org/gsouquet/threads-root-guard	2021-10-15 14:32:13 +01:00
Germain Souquet	8c19cf45e2	Dispatch a Thread.New event	2021-10-15 11:09:14 +01:00
Germain Souquet	c9277de8ee	Remove console statement	2021-10-15 10:31:43 +01:00
Germain Souquet	b5baca51a6	Null-guard for thread root event not loaded yet	2021-10-15 10:22:32 +01:00
Germain	fc800821f9	Merge pull request #1980 from matrix-org/gsouquet/threads-relations	2021-10-15 08:53:42 +01:00
Germain Souquet	efbc46937f	Null-guard for event that do not have a thread	2021-10-14 17:37:33 +01:00
Germain Souquet	9ceeb2d220	Delete UnstableValue and use hardcoded value for m.thread	2021-10-14 17:09:00 +01:00
Germain Souquet	7b89862ed0	Make threads use 'm.thread' relation	2021-10-14 16:56:48 +01:00
David Baker	6804e4290a	Merge pull request #1972 from SimonBrandner/feature/answer-no-cam Try to answer a call without video if we can't access the camera	2021-10-14 12:15:35 +01:00
David Baker	0a3d820fda	Merge pull request #1943 from freaktechnik/develop Fix `requestVerificationDM` with chronological `pendingEventOrdering`	2021-10-14 12:14:20 +01:00
Michael Telatynski	e2a9c95ea8	Merge pull request #1974 from SimonBrandner/task/security-ts	2021-10-14 10:02:14 +01:00
Šimon Brandner	3aefc9f02e	Add tests for falling back to answering with no video Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-10-14 08:46:36 +02:00
Šimon Brandner	0042cb5292	Fix importRoomKeys() definition Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-10-13 16:50:27 +02:00
Denis Kasak	b288c97372	Merge pull request #1975 from matrix-org/dkasak/more-detailed-room-key-sharing-logging More detailed logging when sharing room keys	2021-10-12 13:26:43 +00:00
Denis Kasak	a0de1740a4	Add comma per review Co-authored-by: Michael Telatynski <7t3chguy@gmail.com>	2021-10-12 13:23:22 +00:00
Denis Kasak	8e2e3018d8	Log device objects for existing/new devices when sharing room keys.	2021-10-12 13:48:41 +02:00
Denis Kasak	60e93024e7	Fix comment regarding marking blocked devices as notified.	2021-10-12 13:43:28 +02:00
Denis Kasak	d89aa365f9	More detailed logging of blocked devices. Separately log how many blocked devices there are in total and list them out. Then, log how many devices were notified because they were newly blocked and list those out too.	2021-10-12 13:43:28 +02:00
Denis Kasak	4241263f2c	Make log message regarding notifying unnotified failed devices clearer.	2021-10-12 13:43:26 +02:00
Denis Kasak	b009f9c21b	Log more clearly when we're sharing room keys with new Olm sessions.	2021-10-12 13:41:04 +02:00
Denis Kasak	04ccec6de3	Log which devices room keys were shared with.	2021-10-12 13:41:04 +02:00
RiotRobot	e7b41fadd0	Merge branch 'master' into develop	2021-10-12 08:50:43 +01:00
RiotRobot	2dc1acef2e	Resetting package fields for development	2021-10-12 08:36:13 +01:00
RiotRobot	b977b629f4	Merge branch 'release-v14.0.1'	2021-10-12 08:35:42 +01:00
RiotRobot	6bbd493e20	v14.0.1	2021-10-12 08:29:30 +01:00
RiotRobot	38ad435af5	Prepare changelog for v14.0.1	2021-10-12 08:29:30 +01:00
RiotRobot	8f245af317	Merge branch 'master' into develop	2021-10-11 11:48:22 +01:00
RiotRobot	9b2bfbe7d0	v14.0.0	2021-10-11 11:44:54 +01:00
RiotRobot	f69ea85e55	Prepare changelog for v14.0.0	2021-10-11 11:44:53 +01:00
Šimon Brandner	7559a10526	Make opts in importRoomKeys optional Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-10-10 08:36:11 +02:00
Šimon Brandner	68dbe959bb	Add a logline Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-10-10 08:19:29 +02:00
Šimon Brandner	74a875aa23	Add MockMediaDeviceInfo Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-10-10 08:19:29 +02:00
Šimon Brandner	4b679c5056	Try to answer without video if we can't access it Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-10-10 08:19:22 +02:00
Šimon Brandner	cb8a260b9c	Improve handling when we don't have a camera Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-10-09 08:36:19 +02:00
Robert Long	7d7975b8bb	Fix connecting to a call without a webcam Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-10-09 08:05:59 +02:00
Travis Ralston	f12513da96	Merge pull request #1971 from matrix-org/travis/spam-log Remove excess logging from getRoomUpgradeHistory()	2021-10-08 10:33:07 -06:00
Travis Ralston	785a3e3381	Remove excess logging from getRoomUpgradeHistory() On large accounts this can now cause a massive amount of spam. It's not really providing any value in day-to-day debugging either.	2021-10-08 10:28:20 -06:00
RiotRobot	f5fcc20840	v14.0.0-rc.2	2021-10-07 17:42:40 +01:00
RiotRobot	17e20c17b3	Prepare changelog for v14.0.0-rc.2	2021-10-07 17:42:40 +01:00
Michael Telatynski	39fd350ffe	Merge pull request #1969 from matrix-org/t3chguy/cp/space-hierarchy	2021-10-06 16:51:32 +01:00
Michael Telatynski	b4d100baff	Tweak Room Hierarchy root visibility and add loading getter	2021-10-06 13:29:13 +01:00
Michael Telatynski	29bc83f4a7	Merge pull request #1968 from matrix-org/t3chguy/fix/19276	2021-10-06 13:27:12 +01:00
Michael Telatynski	13c8774d45	Tweak Room Hierarchy root visibility and add loading getter	2021-10-06 10:25:27 +01:00
Travis Ralston	c9212e770d	Merge pull request #1966 from Alexendoo/declaration-map Enable TypeScript declaration maps	2021-10-05 13:39:47 -06:00
Germain	08aa7803e3	Merge pull request #1964 from SimonBrandner/feature/call-feed-opts	2021-10-04 15:02:49 +01:00
Alex Macleod	770858c255	Enable TypeScript declaration maps This allows go-to-definition to reach the original .ts files for consumers of the package. It emits .d.ts.map files alongside the regular .d.ts files e.g. in sdk.createClient go-to-definition on createClient will place the cursor at the function in src/matrix.ts rather than inside a definition file lib/matrix.d.ts Signed-off-by: Alex Macleod <alex@macleod.io>	2021-10-04 14:36:50 +01:00
Germain Souquet	c73bb7d408	Update dependencies	2021-10-04 12:30:14 +01:00
RiotRobot	15cd675354	v14.0.0-rc.1	2021-10-04 11:55:19 +01:00
RiotRobot	e8137d3f88	Prepare changelog for v14.0.0-rc.1	2021-10-04 11:55:19 +01:00
Šimon Brandner	c63abe9988	Use `ICallFeedOpts` in the `CallFeed` constructor Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-10-02 08:12:43 +02:00
Germain	a7a08fd760	Merge pull request #1962 from matrix-org/gsouquet/fix-19229	2021-10-01 15:46:30 +01:00
Germain	df51f95fbd	Merge pull request #1963 from matrix-org/gsouquet/fix-19225	2021-10-01 12:11:35 +01:00
Germain Souquet	a14cf1a339	Remove unused DuplicateStrategy	2021-10-01 12:07:16 +01:00
Germain Souquet	30758600f0	Prepend events to thread when fetching the reply chain	2021-10-01 10:49:46 +01:00
Germain	823242a93c	Merge pull request #1959 from psrpinto/fix/joined-rooms-response	2021-09-30 17:54:53 +01:00
Martin Giger	482e3c4cb7	Skip waiting if already sent and abort on cancel	2021-09-30 16:58:08 +02:00
Germain Souquet	1dbd7158ad	Prevent redactions to be sent as pending events Co-authored-by: Dariusz Niemczyk <Palid@users.noreply.github.com>	2021-09-30 13:56:52 +01:00
Michael Telatynski	46b3f0babd	Merge pull request #1958 from SimonBrandner/fix/call-length	2021-09-29 15:04:02 +01:00
Šimon Brandner	b4bc554d7a	Make sure to `callLengthInterval` only once Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-09-29 15:46:22 +02:00
Paulo Pinto	1485969493	Return IJoinedRoomsResponse from getJoinedRooms(), instead of string[] Signed-off-by: Paulo Pinto <paulo.pinto@automattic.com>	2021-09-29 11:45:01 +01:00
Travis Ralston	92f7ddcf3e	Merge pull request #1954 from SimonBrandner/task/src-ts Changes for TS migration	2021-09-27 13:45:06 -06:00
Travis Ralston	90d480b4cf	Merge pull request #1952 from matrix-org/travis/fsdk/versions Implement file versioning for tree spaces	2021-09-27 10:04:22 -06:00
RiotRobot	2515d07c8f	Resetting package fields for development	2021-09-27 14:23:47 +01:00
RiotRobot	7acb9416c2	Merge branch 'master' into develop	2021-09-27 14:23:47 +01:00
Michael Telatynski	0c4212ca90	Merge pull request #1935 from matrix-org/t3chguy/fix/18969	2021-09-27 11:08:07 +01:00
Germain	9a06a05a75	Merge pull request #1953 from SimonBrandner/fix/audio-upgrade	2021-09-27 10:18:13 +01:00
Šimon Brandner	f05a0615f7	Export IRequestMsisdnTokenResponse Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-09-27 09:45:07 +02:00
Šimon Brandner	6b93687ff0	Pass correct params to upgradeCall() to upgrade audio Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-09-26 13:10:00 +02:00
Travis Ralston	8d910d5e26	Merge pull request #1950 from SimonBrandner/feature/flexible-answer Allow answering calls without audio/video	2021-09-25 23:39:20 -06:00
Šimon Brandner	9264050f41	Update src/webrtc/call.ts Co-authored-by: Travis Ralston <travpc@gmail.com>	2021-09-26 07:26:08 +02:00
Travis Ralston	eab0c54663	Appease the linter	2021-09-25 20:47:59 -06:00
Travis Ralston	82a254b7bd	Implement file versioning for tree spaces The diff isn't super clear on how this works, but the general idea is that the MSC3089Branches (files) now know which directory they came from, and the directories (MSC3089TreeSpace) can tell when files are triggering uploads referencing themselves so it can add all the replacement metadata onto the event. There's a few challenges with how relations work in the js-sdk which has shaped the API surface exposed by this change. Specifically, there is a `getVersionHistory()` function instead of a function to get a certain prior version: the js-sdk doesn't track parent events in the relation structures so cannot determine what the event could have replaced. In order to trigger the built-in relations structures, we must trigger decryption with `emit: true`. This is so an internal listener in the relations system can pick up `Event.decrypted`.	2021-09-25 20:44:17 -06:00
Šimon Brandner	0f6a59ed98	Allow answering calls without audio/video Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-09-25 10:00:51 +02:00
Travis Ralston	afb4682987	Merge pull request #1949 from SimonBrandner/fix/mic-state Fix not returning new mic mute state	2021-09-25 01:14:11 -06:00
Šimon Brandner	a18326519b	Add missing return statement Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-09-25 08:26:13 +02:00
Germain	b033540f95	Merge pull request #1948 from matrix-org/gsouquet/fix-sync-partitioning	2021-09-24 15:43:27 +01:00
Germain Souquet	ff529d733d	Fix event partitioning from non threading ready clients	2021-09-24 14:54:40 +01:00
Germain	5951958c05	Merge pull request #1945 from matrix-org/gsouquet/thread-serialise-18720	2021-09-24 11:17:39 +01:00
David Baker	886f2fb95d	Merge pull request #1947 from matrix-org/dbkr/we_like_tests Add tests requirements to CONTRIBUTING	2021-09-23 18:15:32 +01:00
David Baker	f6ce0c581e	Add tests requirements to CONTRIBUTING Fixes https://github.com/vector-im/element-web/issues/19136	2021-09-23 14:09:01 +01:00
Germain	5ce68b6c12	Merge pull request #1944 from matrix-org/gsouquet/thread-state-events-18719	2021-09-23 09:17:02 +01:00
Germain Souquet	c748aebfc5	Add context to explain why we fetch roomstate in threads	2021-09-22 17:36:12 +01:00
Germain Souquet	f8ec445ff0	Fix addLiveEvent with 'replace' strategy	2021-09-22 17:14:18 +01:00
Germain Souquet	5d4f347eaa	Add thread serialisation helper	2021-09-22 11:35:19 +01:00
Germain Souquet	1359c0574e	Share room state events with thread's timelines	2021-09-22 11:19:08 +01:00
Travis Ralston	b1d239b292	Merge pull request #1934 from aaronraimist/kick-api Switch to /kick API	2021-09-21 23:30:23 -06:00
Travis Ralston	70031415e8	Merge pull request #1938 from matrix-org/travis/fix-widgets-relations Ensure unencrypted fields get exposed by getEffectiveEvent()	2021-09-21 23:16:18 -06:00
Martin Giger	3c97d17770	Fix requestVerificationDM with chronological pendingEventOrdering Signed-off-by: Martin Giger <martin@humanoids.be>	2021-09-21 20:04:07 +02:00
Travis Ralston	5a73a9758a	Merge pull request #1941 from SimonBrandner/feature/bound Add `bound` to `IThreepid`	2021-09-21 11:36:36 -06:00
Travis Ralston	6848e96244	Merge pull request #1942 from SimonBrandner/feature/trusted_locally Add `trusted_locally` to `TrustInfo`	2021-09-21 11:26:35 -06:00
Travis Ralston	b53566e074	Merge pull request #1827 from SimonBrandner/feature/call-upgrades Support for call upgrades	2021-09-21 09:10:02 -06:00
Šimon Brandner	012b914a97	Add `trusted_locally` to `TrustInfo` Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-09-21 16:20:39 +02:00
Šimon Brandner	3c6eed0135	Add bound to IThreepid Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-09-21 14:56:33 +02:00
Šimon Brandner	b83977e72f	Add @param docs Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-09-20 16:40:46 +02:00
Šimon Brandner	5c6a643436	Merge branch 'feature/call-upgrades' of https://github.com/SimonBrandner/matrix-js-sdk into feature/call-upgrades	2021-09-19 07:44:40 +02:00
Šimon Brandner	1ca1a69eb8	Fix docs Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-09-19 07:44:28 +02:00
Šimon Brandner	76ea1ba192	Improve log Co-authored-by: Travis Ralston <travpc@gmail.com>	2021-09-19 07:43:09 +02:00
Šimon Brandner	8cd8ec134e	Merge remote-tracking branch 'upstream/develop' into feature/call-upgrades	2021-09-19 07:42:04 +02:00
Travis Ralston	9f42647a75	Ensure unencrypted fields get exposed by getEffectiveEvent() Fixes https://github.com/vector-im/element-web/issues/19062	2021-09-18 16:26:08 -06:00
Šimon Brandner	a4cacbc73a	Add call upgrade support Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-09-18 12:32:13 +02:00
Šimon Brandner	f24840d09c	Make CallFeed handle addTrack events Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-09-18 12:31:54 +02:00
Šimon Brandner	acb7991cc5	Fix getUserMediaStream() not being able to handle streams of different track combinations Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-09-18 12:27:24 +02:00
Šimon Brandner	6addc7dd3d	Add MockMediaStream Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-09-18 12:27:08 +02:00
Michael Telatynski	4606422e57	Make RoomState::hasSufficientPowerLevelFor public	2021-09-17 15:35:03 +01:00
Aaron Raimist	35ee58dfe1	Switch to /kick API Signed-off-by: Aaron Raimist <aaron@raim.ist>	2021-09-17 01:05:21 -05:00