From 7ea4008daa733b45e39a5aec3dad2e2aa9ee857c Mon Sep 17 00:00:00 2001 From: Travis Ralston Date: Fri, 22 Feb 2019 16:33:20 -0700 Subject: [PATCH 1/2] Implement support for watching for changes in settings This implements a dream of one day being able to listen for changes in a settings to react to them, regardless of which device actually changed the setting. The use case for this kind of thing is extremely limited, but when it is needed it should be more than powerful enough. --- docs/settings.md | 33 +++++ src/MatrixClientPeg.js | 4 +- src/settings/SettingsStore.js | 117 ++++++++++++++++++ src/settings/WatchManager.js | 57 +++++++++ .../handlers/AccountSettingsHandler.js | 48 ++++++- .../handlers/ConfigSettingsHandler.js | 8 ++ .../handlers/DefaultSettingsHandler.js | 9 ++ .../handlers/DeviceSettingsHandler.js | 16 +++ src/settings/handlers/LocalEchoWrapper.js | 9 ++ .../MatrixClientBackedSettingsHandler.js | 48 +++++++ .../handlers/RoomAccountSettingsHandler.js | 51 +++++++- .../handlers/RoomDeviceSettingsHandler.js | 18 +++ src/settings/handlers/RoomSettingsHandler.js | 49 +++++++- src/settings/handlers/SettingsHandler.js | 24 ++++ 14 files changed, 484 insertions(+), 7 deletions(-) create mode 100644 src/settings/WatchManager.js create mode 100644 src/settings/handlers/MatrixClientBackedSettingsHandler.js diff --git a/docs/settings.md b/docs/settings.md index cdba01e04a9..9762e7a73e1 100644 --- a/docs/settings.md +++ b/docs/settings.md @@ -131,6 +131,32 @@ SettingsStore.getValue(...); // this will return the value set in `setValue` abo ``` +## Watching for changes + +Most use cases do not need to set up a watcher because they are able to react to changes as they are made, or the changes which are made are not significant enough for it to matter. Watchers are intended to be used in scenarios where it is important to react to changes made by other logged in devices. Typically, this would be done within the component itself, however the component should not be aware of the intricacies of setting inversion or remapping to particular data structures. Instead, a generic watcher interface is provided on `SettingsStore` to watch (and subsequently unwatch) for changes in a setting. + +An example of a watcher in action would be: + +```javascript +class MyComponent extends React.Component { + + settingWatcherRef = null; + + componentWillMount() { + this.settingWatcherRef = SettingsStore.watchSetting("roomColor", "!example:matrix.org", (settingName, roomId, level, newVal) => { + // Always re-read the setting value from the store to avoid reacting to changes which do not have a consequence. For example, the + // room color could have been changed at the device level, but an account override prevents that change from making a difference. + const actualVal = SettingsStore.getValue(settingName, "!example:matrix.org"); + if (actualVal !== this.state.color) this.setState({color: actualVal}); + }); + } + + componentWillUnmount() { + SettingsStore.unwatchSetting(this.settingWatcherRef); + } +} +``` + # Maintainers Reference @@ -159,3 +185,10 @@ Features automatically get considered as `disabled` if they are not listed in th ``` If `enableLabs` is true in the configuration, the default for features becomes `"labs"`. + +### Watchers + +Watchers can appear complicated under the hood: the request to watch a setting is actually forked off to individual handlers for watching. This means that the handlers need to track their changes and listen for remote changes where possible, but also makes it much easier for the `SettingsStore` to react to changes. The handler is going to know the best things to listen for (specific events, account data, etc) and thus it is left as a responsibility for the handler to track changes. + +In practice, handlers which rely on remote changes (account data, room events, etc) will always attach a listener to the `MatrixClient`. They then watch for changes to events they care about and send off appropriate updates to the generalized `WatchManager` - a class specifically designed to deduplicate the logic of managing watchers. The handlers which are localized to the local client (device) generally just trigger the `WatchManager` when they manipulate the setting themselves as there's nothing to really 'watch'. + \ No newline at end of file diff --git a/src/MatrixClientPeg.js b/src/MatrixClientPeg.js index e36034c69d3..1cf29c3e829 100644 --- a/src/MatrixClientPeg.js +++ b/src/MatrixClientPeg.js @@ -30,6 +30,7 @@ import MatrixActionCreators from './actions/MatrixActionCreators'; import {phasedRollOutExpiredForUser} from "./PhasedRollOut"; import Modal from './Modal'; import {verificationMethods} from 'matrix-js-sdk/lib/crypto'; +import MatrixClientBackedSettingsHandler from "./settings/handlers/MatrixClientBackedSettingsHandler"; interface MatrixClientCreds { homeserverUrl: string, @@ -137,8 +138,9 @@ class MatrixClientPeg { opts.pendingEventOrdering = "detached"; opts.lazyLoadMembers = true; - // Connect the matrix client to the dispatcher + // Connect the matrix client to the dispatcher and setting handlers MatrixActionCreators.start(this.matrixClient); + MatrixClientBackedSettingsHandler.matrixClient = this.matrixClient; console.log(`MatrixClientPeg: really starting MatrixClient`); await this.get().startClient(opts); diff --git a/src/settings/SettingsStore.js b/src/settings/SettingsStore.js index 1bdd72dc5fc..1704ad9db22 100644 --- a/src/settings/SettingsStore.js +++ b/src/settings/SettingsStore.js @@ -1,5 +1,6 @@ /* Copyright 2017 Travis Ralston +Copyright 2019 New Vector Ltd. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -23,6 +24,7 @@ import RoomSettingsHandler from "./handlers/RoomSettingsHandler"; import ConfigSettingsHandler from "./handlers/ConfigSettingsHandler"; import {_t} from '../languageHandler'; import SdkConfig from "../SdkConfig"; +import dis from '../dispatcher'; import {SETTINGS} from "./Settings"; import LocalEchoWrapper from "./handlers/LocalEchoWrapper"; @@ -98,6 +100,121 @@ const LEVEL_ORDER = [ * be enabled). */ export default class SettingsStore { + // We support watching settings for changes, and do so only at the levels which are + // relevant to the setting. We pass the watcher on to the handlers and aggregate it + // before sending it off to the caller. We need to track which callback functions we + // provide to the handlers though so we can unwatch it on demand. In practice, we + // return a "callback reference" to the caller which correlates to an entry in this + // dictionary for each handler's callback function. + // + // We also maintain a list of monitors which are special watchers: they cause dispatches + // when the setting changes. We track which rooms we're monitoring though to ensure we + // don't duplicate updates on the bus. + static _watchers = {}; // { callbackRef => { level => callbackFn } } + static _monitors = {}; // { settingName => { roomId => callbackRef } } + + /** + * Watches for changes in a particular setting. This is done without any local echo + * wrapping and fires whenever a change is detected in a setting's value. Watching + * is intended to be used in scenarios where the app needs to react to changes made + * by other devices. It is otherwise expected that callers will be able to use the + * Controller system or track their own changes to settings. Callers should retain + * @param {string} settingName The setting name to watch + * @param {String} roomId The room ID to watch for changes in. May be null for 'all'. + * @param {function} callbackFn A function to be called when a setting change is + * detected. Four arguments can be expected: the setting name, the room ID (may be null), + * the level the change happened at, and finally the new value for those arguments. The + * callback may need to do a call to #getValue() to see if a consequential change has + * occurred. + * @returns {string} A reference to the watcher that was employed. + */ + static watchSetting(settingName, roomId, callbackFn) { + const setting = SETTINGS[settingName]; + const originalSettingName = settingName; + if (!setting) throw new Error(`${settingName} is not a setting`); + + if (setting.invertedSettingName) { + settingName = setting.invertedSettingName; + } + + const watcherId = `${new Date().getTime()}_${settingName}_${roomId}`; + SettingsStore._watchers[watcherId] = {}; + + const levels = Object.keys(LEVEL_HANDLERS); + for (const level of levels) { + const handler = SettingsStore._getHandler(originalSettingName, level); + if (!handler) continue; + + const localizedCallback = (changedInRoomId, newVal) => { + callbackFn(originalSettingName, changedInRoomId, level, newVal); + }; + + console.log(`Starting watcher for ${settingName}@${roomId || ''} at level ${level}`); + SettingsStore._watchers[watcherId][level] = localizedCallback; + handler.watchSetting(settingName, roomId, localizedCallback); + } + + return watcherId; + } + + /** + * Stops the SettingsStore from watching a setting. This is a no-op if the watcher + * provided is not found. + * @param {string} watcherReference The watcher reference (received from #watchSetting) + * to cancel. + */ + static unwatchSetting(watcherReference) { + if (!SettingsStore._watchers[watcherReference]) return; + + for (const handlerName of Object.keys(SettingsStore._watchers[watcherReference])) { + const handler = LEVEL_HANDLERS[handlerName]; + if (!handler) continue; + handler.unwatchSetting(SettingsStore._watchers[watcherReference][handlerName]); + } + + delete SettingsStore._watchers[watcherReference]; + } + + /** + * Sets up a monitor for a setting. This behaves similar to #watchSetting except instead + * of making a call to a callback, it forwards all changes to the dispatcher. Callers can + * expect to listen for the 'setting_updated' action with an object containing settingName, + * roomId, level, and newValue. + * @param {string} settingName The setting name to monitor. + * @param {String} roomId The room ID to monitor for changes in. Use null for all rooms. + */ + static monitorSetting(settingName, roomId) { + if (!this._monitors[settingName]) this._monitors[settingName] = {}; + + const registerWatcher = () => { + this._monitors[settingName][roomId] = SettingsStore.watchSetting( + settingName, roomId, (settingName, inRoomId, level, newValue) => { + dis.dispatch({ + action: 'setting_updated', + settingName, + roomId: inRoomId, + level, + newValue, + }); + }, + ); + }; + + const hasRoom = Object.keys(this._monitors[settingName]).find((r) => r === roomId || r === null); + if (!hasRoom) { + registerWatcher(); + } else { + if (roomId === null) { + // Unregister all existing watchers and register the new one + for (const roomId of Object.keys(this._monitors[settingName])) { + SettingsStore.unwatchSetting(this._monitors[settingName][roomId]); + } + this._monitors[settingName] = {}; + registerWatcher(); + } // else a watcher is already registered for the room, so don't bother registering it again + } + } + /** * Gets the translated display name for a given setting * @param {string} settingName The setting to look up. diff --git a/src/settings/WatchManager.js b/src/settings/WatchManager.js new file mode 100644 index 00000000000..05615293929 --- /dev/null +++ b/src/settings/WatchManager.js @@ -0,0 +1,57 @@ +/* +Copyright 2019 New Vector Ltd. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +/** + * Generalized management class for dealing with watchers on a per-handler (per-level) + * basis without duplicating code. Handlers are expected to push updates through this + * class, which are then proxied outwards to any applicable watchers. + */ +export class WatchManager { + _watchers = {}; // { settingName: { roomId: callbackFns[] } } + + // Proxy for handlers to delegate changes to this manager + watchSetting(settingName, roomId, cb) { + if (!this._watchers[settingName]) this._watchers[settingName] = {}; + if (!this._watchers[settingName][roomId]) this._watchers[settingName][roomId] = []; + this._watchers[settingName][roomId].push(cb); + } + + // Proxy for handlers to delegate changes to this manager + unwatchSetting(cb) { + for (const settingName of Object.keys(this._watchers)) { + for (const roomId of Object.keys(this._watchers[settingName])) { + let idx; + while ((idx = this._watchers[settingName][roomId].indexOf(cb)) !== -1) { + this._watchers[settingName][roomId].splice(idx, 1); + } + } + } + } + + notifyUpdate(settingName, inRoomId, newValue) { + if (!this._watchers[settingName]) return; + + const roomWatchers = this._watchers[settingName]; + const callbacks = []; + + if (inRoomId !== null && roomWatchers[inRoomId]) callbacks.push(...roomWatchers[inRoomId]); + if (roomWatchers[null]) callbacks.push(...roomWatchers[null]); + + for (const callback of callbacks) { + callback(inRoomId, newValue); + } + } +} diff --git a/src/settings/handlers/AccountSettingsHandler.js b/src/settings/handlers/AccountSettingsHandler.js index b8227095738..4bef585e6b0 100644 --- a/src/settings/handlers/AccountSettingsHandler.js +++ b/src/settings/handlers/AccountSettingsHandler.js @@ -1,5 +1,6 @@ /* Copyright 2017 Travis Ralston +Copyright 2019 New Vector Ltd. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -14,14 +15,49 @@ See the License for the specific language governing permissions and limitations under the License. */ -import SettingsHandler from "./SettingsHandler"; import MatrixClientPeg from '../../MatrixClientPeg'; +import {WatchManager} from "../WatchManager"; +import MatrixClientBackedSettingsHandler from "./MatrixClientBackedSettingsHandler"; /** * Gets and sets settings at the "account" level for the current user. * This handler does not make use of the roomId parameter. */ -export default class AccountSettingHandler extends SettingsHandler { +export default class AccountSettingsHandler extends MatrixClientBackedSettingsHandler { + constructor() { + super(); + + this._watchers = new WatchManager(); + this._onAccountData = this._onAccountData.bind(this); + } + + initMatrixClient(oldClient, newClient) { + if (oldClient) { + oldClient.removeListener("accountData", this._onAccountData); + } + + newClient.on("accountData", this._onAccountData); + } + + _onAccountData(event) { + if (event.getType() === "org.matrix.preview_urls") { + let val = event.getContent()['disable']; + if (typeof(val) !== "boolean") { + val = null; + } else { + val = !val; + } + + this._watchers.notifyUpdate("urlPreviewsEnabled", null, val); + } else if (event.getType() === "im.vector.web.settings") { + // We can't really discern what changed, so trigger updates for everything + for (const settingName of Object.keys(event.getContent())) { + console.log(settingName); + this._watchers.notifyUpdate(settingName, null, event.getContent()[settingName]); + } + } + } + getValue(settingName, roomId) { // Special case URL previews if (settingName === "urlPreviewsEnabled") { @@ -67,6 +103,14 @@ export default class AccountSettingHandler extends SettingsHandler { return cli !== undefined && cli !== null; } + watchSetting(settingName, roomId, cb) { + this._watchers.watchSetting(settingName, roomId, cb); + } + + unwatchSetting(cb) { + this._watchers.unwatchSetting(cb); + } + _getSettings(eventType = "im.vector.web.settings") { const cli = MatrixClientPeg.get(); if (!cli) return null; diff --git a/src/settings/handlers/ConfigSettingsHandler.js b/src/settings/handlers/ConfigSettingsHandler.js index a54ad1cef66..095347a5426 100644 --- a/src/settings/handlers/ConfigSettingsHandler.js +++ b/src/settings/handlers/ConfigSettingsHandler.js @@ -47,4 +47,12 @@ export default class ConfigSettingsHandler extends SettingsHandler { isSupported() { return true; // SdkConfig is always there } + + watchSetting(settingName, roomId, cb) { + // no-op: no changes possible + } + + unwatchSetting(cb) { + // no-op: no changes possible + } } diff --git a/src/settings/handlers/DefaultSettingsHandler.js b/src/settings/handlers/DefaultSettingsHandler.js index 11e8b729bc5..83824850b3a 100644 --- a/src/settings/handlers/DefaultSettingsHandler.js +++ b/src/settings/handlers/DefaultSettingsHandler.js @@ -1,5 +1,6 @@ /* Copyright 2017 Travis Ralston +Copyright 2019 New Vector Ltd. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -51,4 +52,12 @@ export default class DefaultSettingsHandler extends SettingsHandler { isSupported() { return true; } + + watchSetting(settingName, roomId, cb) { + // no-op: no changes possible + } + + unwatchSetting(cb) { + // no-op: no changes possible + } } diff --git a/src/settings/handlers/DeviceSettingsHandler.js b/src/settings/handlers/DeviceSettingsHandler.js index b2a225e190d..457fb888e99 100644 --- a/src/settings/handlers/DeviceSettingsHandler.js +++ b/src/settings/handlers/DeviceSettingsHandler.js @@ -1,5 +1,6 @@ /* Copyright 2017 Travis Ralston +Copyright 2019 New Vector Ltd. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -17,6 +18,7 @@ limitations under the License. import Promise from 'bluebird'; import SettingsHandler from "./SettingsHandler"; import MatrixClientPeg from "../../MatrixClientPeg"; +import {WatchManager} from "../WatchManager"; /** * Gets and sets settings at the "device" level for the current device. @@ -31,6 +33,7 @@ export default class DeviceSettingsHandler extends SettingsHandler { constructor(featureNames) { super(); this._featureNames = featureNames; + this._watchers = new WatchManager(); } getValue(settingName, roomId) { @@ -66,18 +69,22 @@ export default class DeviceSettingsHandler extends SettingsHandler { // Special case notifications if (settingName === "notificationsEnabled") { localStorage.setItem("notifications_enabled", newValue); + this._watchers.notifyUpdate(settingName, null, newValue); return Promise.resolve(); } else if (settingName === "notificationBodyEnabled") { localStorage.setItem("notifications_body_enabled", newValue); + this._watchers.notifyUpdate(settingName, null, newValue); return Promise.resolve(); } else if (settingName === "audioNotificationsEnabled") { localStorage.setItem("audio_notifications_enabled", newValue); + this._watchers.notifyUpdate(settingName, null, newValue); return Promise.resolve(); } const settings = this._getSettings() || {}; settings[settingName] = newValue; localStorage.setItem("mx_local_settings", JSON.stringify(settings)); + this._watchers.notifyUpdate(settingName, null, newValue); return Promise.resolve(); } @@ -90,6 +97,14 @@ export default class DeviceSettingsHandler extends SettingsHandler { return localStorage !== undefined && localStorage !== null; } + watchSetting(settingName, roomId, cb) { + this._watchers.watchSetting(settingName, roomId, cb); + } + + unwatchSetting(cb) { + this._watchers.unwatchSetting(cb); + } + _getSettings() { const value = localStorage.getItem("mx_local_settings"); if (!value) return null; @@ -111,5 +126,6 @@ export default class DeviceSettingsHandler extends SettingsHandler { _writeFeature(featureName, enabled) { localStorage.setItem("mx_labs_feature_" + featureName, enabled); + this._watchers.notifyUpdate(featureName, null, enabled); } } diff --git a/src/settings/handlers/LocalEchoWrapper.js b/src/settings/handlers/LocalEchoWrapper.js index d616edd9fb9..3b1200f0b7b 100644 --- a/src/settings/handlers/LocalEchoWrapper.js +++ b/src/settings/handlers/LocalEchoWrapper.js @@ -1,5 +1,6 @@ /* Copyright 2017 Travis Ralston +Copyright 2019 New Vector Ltd. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -66,4 +67,12 @@ export default class LocalEchoWrapper extends SettingsHandler { isSupported() { return this._handler.isSupported(); } + + watchSetting(settingName, roomId, cb) { + this._handler.watchSetting(settingName, roomId, cb); + } + + unwatchSetting(cb) { + this._handler.unwatchSetting(cb); + } } diff --git a/src/settings/handlers/MatrixClientBackedSettingsHandler.js b/src/settings/handlers/MatrixClientBackedSettingsHandler.js new file mode 100644 index 00000000000..effe7ae9a71 --- /dev/null +++ b/src/settings/handlers/MatrixClientBackedSettingsHandler.js @@ -0,0 +1,48 @@ +/* +Copyright 2019 New Vector Ltd. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +import SettingsHandler from "./SettingsHandler"; + +// Dev note: This whole class exists in the event someone logs out and back in - we want +// to make sure the right MatrixClient is listening for changes. + +/** + * Represents the base class for settings handlers which need access to a MatrixClient. + * This class performs no logic and should be overridden. + */ +export default class MatrixClientBackedSettingsHandler extends SettingsHandler { + static _matrixClient; + static _instances = []; + + static set matrixClient(client) { + const oldClient = MatrixClientBackedSettingsHandler._matrixClient; + MatrixClientBackedSettingsHandler._matrixClient = client; + + for (const instance of MatrixClientBackedSettingsHandler._instances) { + instance.initMatrixClient(oldClient, client); + } + } + + constructor() { + super(); + + MatrixClientBackedSettingsHandler._instances.push(this); + } + + initMatrixClient() { + console.warn("initMatrixClient not overridden"); + } +} diff --git a/src/settings/handlers/RoomAccountSettingsHandler.js b/src/settings/handlers/RoomAccountSettingsHandler.js index d0dadc2de7c..448b42f61e4 100644 --- a/src/settings/handlers/RoomAccountSettingsHandler.js +++ b/src/settings/handlers/RoomAccountSettingsHandler.js @@ -1,5 +1,6 @@ /* Copyright 2017 Travis Ralston +Copyright 2019 New Vector Ltd. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -14,13 +15,51 @@ See the License for the specific language governing permissions and limitations under the License. */ -import SettingsHandler from "./SettingsHandler"; import MatrixClientPeg from '../../MatrixClientPeg'; +import MatrixClientBackedSettingsHandler from "./MatrixClientBackedSettingsHandler"; +import {WatchManager} from "../WatchManager"; /** * Gets and sets settings at the "room-account" level for the current user. */ -export default class RoomAccountSettingsHandler extends SettingsHandler { +export default class RoomAccountSettingsHandler extends MatrixClientBackedSettingsHandler { + constructor() { + super(); + + this._watchers = new WatchManager(); + this._onAccountData = this._onAccountData.bind(this); + } + + initMatrixClient(oldClient, newClient) { + if (oldClient) { + oldClient.removeListener("Room.accountData", this._onAccountData); + } + + newClient.on("Room.accountData", this._onAccountData); + } + + _onAccountData(event, room) { + const roomId = room.roomId; + + if (event.getType() === "org.matrix.room.preview_urls") { + let val = event.getContent()['disable']; + if (typeof (val) !== "boolean") { + val = null; + } else { + val = !val; + } + + this._watchers.notifyUpdate("urlPreviewsEnabled", roomId, val); + } else if (event.getType() === "org.matrix.room.color_scheme") { + this._watchers.notifyUpdate("roomColor", roomId, event.getContent()); + } else if (event.getType() === "im.vector.web.settings") { + // We can't really discern what changed, so trigger updates for everything + for (const settingName of Object.keys(event.getContent())) { + this._watchers.notifyUpdate(settingName, roomId, event.getContent()[settingName]); + } + } + } + getValue(settingName, roomId) { // Special case URL previews if (settingName === "urlPreviewsEnabled") { @@ -74,6 +113,14 @@ export default class RoomAccountSettingsHandler extends SettingsHandler { return cli !== undefined && cli !== null; } + watchSetting(settingName, roomId, cb) { + this._watchers.watchSetting(settingName, roomId, cb); + } + + unwatchSetting(cb) { + this._watchers.unwatchSetting(cb); + } + _getSettings(roomId, eventType = "im.vector.web.settings") { const room = MatrixClientPeg.get().getRoom(roomId); if (!room) return null; diff --git a/src/settings/handlers/RoomDeviceSettingsHandler.js b/src/settings/handlers/RoomDeviceSettingsHandler.js index 186be3041f7..710c5e62550 100644 --- a/src/settings/handlers/RoomDeviceSettingsHandler.js +++ b/src/settings/handlers/RoomDeviceSettingsHandler.js @@ -1,5 +1,6 @@ /* Copyright 2017 Travis Ralston +Copyright 2019 New Vector Ltd. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -16,12 +17,19 @@ limitations under the License. import Promise from 'bluebird'; import SettingsHandler from "./SettingsHandler"; +import {WatchManager} from "../WatchManager"; /** * Gets and sets settings at the "room-device" level for the current device in a particular * room. */ export default class RoomDeviceSettingsHandler extends SettingsHandler { + constructor() { + super(); + + this._watchers = new WatchManager(); + } + getValue(settingName, roomId) { // Special case blacklist setting to use legacy values if (settingName === "blacklistUnverifiedDevices") { @@ -44,6 +52,7 @@ export default class RoomDeviceSettingsHandler extends SettingsHandler { if (!value["blacklistUnverifiedDevicesPerRoom"]) value["blacklistUnverifiedDevicesPerRoom"] = {}; value["blacklistUnverifiedDevicesPerRoom"][roomId] = newValue; localStorage.setItem("mx_local_settings", JSON.stringify(value)); + this._watchers.notifyUpdate(settingName, roomId, newValue); return Promise.resolve(); } @@ -54,6 +63,7 @@ export default class RoomDeviceSettingsHandler extends SettingsHandler { localStorage.setItem(this._getKey(settingName, roomId), newValue); } + this._watchers.notifyUpdate(settingName, roomId, newValue); return Promise.resolve(); } @@ -65,6 +75,14 @@ export default class RoomDeviceSettingsHandler extends SettingsHandler { return localStorage !== undefined && localStorage !== null; } + watchSetting(settingName, roomId, cb) { + this._watchers.watchSetting(settingName, roomId, cb); + } + + unwatchSetting(cb) { + this._watchers.unwatchSetting(cb); + } + _read(key) { const rawValue = localStorage.getItem(key); if (!rawValue) return null; diff --git a/src/settings/handlers/RoomSettingsHandler.js b/src/settings/handlers/RoomSettingsHandler.js index 71abff94f62..1622b44dd0e 100644 --- a/src/settings/handlers/RoomSettingsHandler.js +++ b/src/settings/handlers/RoomSettingsHandler.js @@ -1,5 +1,6 @@ /* Copyright 2017 Travis Ralston +Copyright 2019 New Vector Ltd. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -14,13 +15,49 @@ See the License for the specific language governing permissions and limitations under the License. */ -import SettingsHandler from "./SettingsHandler"; import MatrixClientPeg from '../../MatrixClientPeg'; +import MatrixClientBackedSettingsHandler from "./MatrixClientBackedSettingsHandler"; +import {WatchManager} from "../WatchManager"; /** * Gets and sets settings at the "room" level. */ -export default class RoomSettingsHandler extends SettingsHandler { +export default class RoomSettingsHandler extends MatrixClientBackedSettingsHandler { + constructor() { + super(); + + this._watchers = new WatchManager(); + this._onEvent = this._onEvent.bind(this); + } + + initMatrixClient(oldClient, newClient) { + if (oldClient) { + oldClient.removeListener("RoomState.events", this._onEvent); + } + + newClient.on("RoomState.events", this._onEvent); + } + + _onEvent(event) { + const roomId = event.getRoomId(); + + if (event.getType() === "org.matrix.room.preview_urls") { + let val = event.getContent()['disable']; + if (typeof (val) !== "boolean") { + val = null; + } else { + val = !val; + } + + this._watchers.notifyUpdate("urlPreviewsEnabled", roomId, val); + } else if (event.getType() === "im.vector.web.settings") { + // We can't really discern what changed, so trigger updates for everything + for (const settingName of Object.keys(event.getContent())) { + this._watchers.notifyUpdate(settingName, roomId, event.getContent()[settingName]); + } + } + } + getValue(settingName, roomId) { // Special case URL previews if (settingName === "urlPreviewsEnabled") { @@ -64,6 +101,14 @@ export default class RoomSettingsHandler extends SettingsHandler { return cli !== undefined && cli !== null; } + watchSetting(settingName, roomId, cb) { + this._watchers.watchSetting(settingName, roomId, cb); + } + + unwatchSetting(cb) { + this._watchers.unwatchSetting(cb); + } + _getSettings(roomId, eventType = "im.vector.web.settings") { const room = MatrixClientPeg.get().getRoom(roomId); if (!room) return null; diff --git a/src/settings/handlers/SettingsHandler.js b/src/settings/handlers/SettingsHandler.js index 69f633c650d..0a704d5be73 100644 --- a/src/settings/handlers/SettingsHandler.js +++ b/src/settings/handlers/SettingsHandler.js @@ -1,5 +1,6 @@ /* Copyright 2017 Travis Ralston +Copyright 2019 New Vector Ltd. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -68,4 +69,27 @@ export default class SettingsHandler { isSupported() { return false; } + + /** + * Watches for a setting change within this handler. The caller should preserve + * a reference to the callback so that it may be unwatched. The caller should + * additionally provide a unique callback for multiple watchers on the same setting. + * @param {string} settingName The setting name to watch for changes in. + * @param {String} roomId The room ID to watch for changes in. + * @param {function} cb A function taking two arguments: the room ID the setting changed + * in and the new value for the setting at this level in the given room. + */ + watchSetting(settingName, roomId, cb) { + throw new Error("Invalid operation: watchSetting was not overridden"); + } + + /** + * Unwatches a previously watched setting. If the callback is not associated with + * a watcher, this is a no-op. + * @param {function} cb A callback function previously supplied to watchSetting + * which should no longer be used. + */ + unwatchSetting(cb) { + throw new Error("Invalid operation: unwatchSetting was not overridden"); + } } From b0cc69bca934865e93d759d33bba3850e9f53fda Mon Sep 17 00:00:00 2001 From: Travis Ralston Date: Fri, 22 Feb 2019 16:57:41 -0700 Subject: [PATCH 2/2] Add an option to sort the room list by recents first Fixes https://github.com/vector-im/riot-web/issues/8892 --- .../settings/tabs/PreferencesSettingsTab.js | 7 ++++ src/i18n/strings/en_EN.json | 2 ++ src/settings/Settings.js | 7 +++- src/stores/RoomListStore.js | 34 ++++++++++++++++++- 4 files changed, 48 insertions(+), 2 deletions(-) diff --git a/src/components/views/settings/tabs/PreferencesSettingsTab.js b/src/components/views/settings/tabs/PreferencesSettingsTab.js index d76dc8f3dd7..d40e5327893 100644 --- a/src/components/views/settings/tabs/PreferencesSettingsTab.js +++ b/src/components/views/settings/tabs/PreferencesSettingsTab.js @@ -44,6 +44,10 @@ export default class PreferencesSettingsTab extends React.Component { 'showDisplaynameChanges', ]; + static ROOM_LIST_SETTINGS = [ + 'RoomList.orderByImportance', + ]; + static ADVANCED_SETTINGS = [ 'alwaysShowEncryptionIcons', 'Pill.shouldShowPillAvatar', @@ -104,6 +108,9 @@ export default class PreferencesSettingsTab extends React.Component { {_t("Timeline")} {this._renderGroup(PreferencesSettingsTab.TIMELINE_SETTINGS)} + {_t("Room list")} + {this._renderGroup(PreferencesSettingsTab.ROOM_LIST_SETTINGS)} + {_t("Advanced")} {this._renderGroup(PreferencesSettingsTab.ADVANCED_SETTINGS)} {autoLaunchOption} diff --git a/src/i18n/strings/en_EN.json b/src/i18n/strings/en_EN.json index 84c9dacd07f..d7c82e23e60 100644 --- a/src/i18n/strings/en_EN.json +++ b/src/i18n/strings/en_EN.json @@ -306,6 +306,7 @@ "Enable widget screenshots on supported widgets": "Enable widget screenshots on supported widgets", "Prompt before sending invites to potentially invalid matrix IDs": "Prompt before sending invites to potentially invalid matrix IDs", "Show developer tools": "Show developer tools", + "Order rooms in the room list by most important first instead of most recent": "Order rooms in the room list by most important first instead of most recent", "Collecting app version information": "Collecting app version information", "Collecting logs": "Collecting logs", "Uploading report": "Uploading report", @@ -554,6 +555,7 @@ "Preferences": "Preferences", "Composer": "Composer", "Timeline": "Timeline", + "Room list": "Room list", "Autocomplete delay (ms)": "Autocomplete delay (ms)", "To change the room's avatar, you must be a": "To change the room's avatar, you must be a", "To change the room's name, you must be a": "To change the room's name, you must be a", diff --git a/src/settings/Settings.js b/src/settings/Settings.js index cf68fed8ba2..e4db12f5ba7 100644 --- a/src/settings/Settings.js +++ b/src/settings/Settings.js @@ -1,6 +1,6 @@ /* Copyright 2017 Travis Ralston -Copyright 2018 New Vector Ltd +Copyright 2018, 2019 New Vector Ltd. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -340,4 +340,9 @@ export const SETTINGS = { displayName: _td('Show developer tools'), default: false, }, + "RoomList.orderByImportance": { + supportedLevels: LEVELS_ACCOUNT_SETTINGS, + displayName: _td('Order rooms in the room list by most important first instead of most recent'), + default: true, + }, }; diff --git a/src/stores/RoomListStore.js b/src/stores/RoomListStore.js index 0a11c2774a6..aec57dedebf 100644 --- a/src/stores/RoomListStore.js +++ b/src/stores/RoomListStore.js @@ -59,6 +59,22 @@ class RoomListStore extends Store { this._recentsComparator = this._recentsComparator.bind(this); } + /** + * Alerts the RoomListStore to a potential change in how room list sorting should + * behave. + * @param {boolean} forceRegeneration True to force a change in the algorithm + */ + updateSortingAlgorithm(forceRegeneration=false) { + const byImportance = SettingsStore.getValue("RoomList.orderByImportance"); + if (byImportance !== this._state.orderRoomsByImportance || forceRegeneration) { + console.log("Updating room sorting algorithm: sortByImportance=" + byImportance); + this._setState({orderRoomsByImportance: byImportance}); + + // Trigger a resort of the entire list to reflect the change in algorithm + this._generateInitialRoomLists(); + } + } + _init() { // Initialise state const defaultLists = { @@ -77,7 +93,10 @@ class RoomListStore extends Store { presentationLists: defaultLists, // like `lists`, but with arrays of rooms instead ready: false, stickyRoomId: null, + orderRoomsByImportance: true, }; + + SettingsStore.monitorSetting('RoomList.orderByImportance', null); } _setState(newState) { @@ -99,6 +118,11 @@ class RoomListStore extends Store { __onDispatch(payload) { const logicallyReady = this._matrixClient && this._state.ready; switch (payload.action) { + case 'setting_updated': { + if (payload.settingName !== 'RoomList.orderByImportance') break; + this.updateSortingAlgorithm(); + } + break; // Initialise state after initial sync case 'MatrixActions.sync': { if (!(payload.prevState !== 'PREPARED' && payload.state === 'PREPARED')) { @@ -106,7 +130,7 @@ class RoomListStore extends Store { } this._matrixClient = payload.matrixClient; - this._generateInitialRoomLists(); + this.updateSortingAlgorithm(/*force=*/true); } break; case 'MatrixActions.Room.receipt': { @@ -517,6 +541,14 @@ class RoomListStore extends Store { } _calculateCategory(room) { + if (!this._state.orderRoomsByImportance) { + // Effectively disable the categorization of rooms if we're supposed to + // be sorting by more recent messages first. This triggers the timestamp + // comparison bit of _setRoomCategory and _recentsComparator instead of + // the category ordering. + return CATEGORY_IDLE; + } + const mentions = room.getUnreadNotificationCount("highlight") > 0; if (mentions) return CATEGORY_RED;