2016-11-02 16:12:51 +01:00
|
|
|
/*
|
2016-11-03 12:48:49 +01:00
|
|
|
Copyright 2016 Aviral Dasgupta
|
|
|
|
Copyright 2016 OpenMarket Ltd
|
2020-04-30 17:02:37 +02:00
|
|
|
Copyright 2017-2020 New Vector Ltd
|
2016-11-02 16:12:51 +01:00
|
|
|
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
|
2021-06-30 14:28:31 +02:00
|
|
|
import { UpdateCheckStatus } from "matrix-react-sdk/src/BasePlatform";
|
2016-11-02 17:02:55 +01:00
|
|
|
import request from 'browser-request';
|
2020-05-14 05:15:30 +02:00
|
|
|
import dis from 'matrix-react-sdk/src/dispatcher/dispatcher';
|
2021-06-30 14:28:31 +02:00
|
|
|
import { _t } from 'matrix-react-sdk/src/languageHandler';
|
|
|
|
import { hideToast as hideUpdateToast, showToast as showUpdateToast } from "matrix-react-sdk/src/toasts/UpdateToast";
|
|
|
|
import { Action } from "matrix-react-sdk/src/dispatcher/actions";
|
2020-05-29 19:24:45 +02:00
|
|
|
import { CheckUpdatesPayload } from 'matrix-react-sdk/src/dispatcher/payloads/CheckUpdatesPayload';
|
2016-11-24 17:46:15 +01:00
|
|
|
import UAParser from 'ua-parser-js';
|
2021-10-15 16:56:22 +02:00
|
|
|
import { logger } from "matrix-js-sdk/src/logger";
|
|
|
|
|
2021-12-09 23:57:46 +01:00
|
|
|
import VectorBasePlatform from './VectorBasePlatform';
|
|
|
|
|
2018-11-22 19:25:55 +01:00
|
|
|
const POKE_RATE_MS = 10 * 60 * 1000; // 10 min
|
2017-06-03 13:50:47 +02:00
|
|
|
|
2016-11-02 18:45:35 +01:00
|
|
|
export default class WebPlatform extends VectorBasePlatform {
|
2021-01-15 13:35:42 +01:00
|
|
|
constructor() {
|
|
|
|
super();
|
|
|
|
// Register service worker if available on this platform
|
2021-01-15 13:25:21 +01:00
|
|
|
if ('serviceWorker' in navigator) {
|
|
|
|
navigator.serviceWorker.register('sw.js');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-15 13:35:42 +01:00
|
|
|
getHumanReadableName(): string {
|
|
|
|
return 'Web Platform'; // no translation required: only used for analytics
|
|
|
|
}
|
|
|
|
|
2016-11-02 18:36:48 +01:00
|
|
|
/**
|
|
|
|
* Returns true if the platform supports displaying
|
|
|
|
* notifications, otherwise false.
|
|
|
|
*/
|
2017-05-02 22:29:19 +02:00
|
|
|
supportsNotifications(): boolean {
|
2020-05-20 20:56:54 +02:00
|
|
|
return Boolean(window.Notification);
|
2016-11-02 18:36:48 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns true if the application currently has permission
|
|
|
|
* to display notifications. Otherwise false.
|
|
|
|
*/
|
2017-05-02 22:29:19 +02:00
|
|
|
maySendNotifications(): boolean {
|
2020-05-20 20:56:54 +02:00
|
|
|
return window.Notification.permission === 'granted';
|
2016-11-02 18:36:48 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Requests permission to send notifications. Returns
|
|
|
|
* a promise that is resolved when the user has responded
|
|
|
|
* to the request. The promise has a single string argument
|
|
|
|
* that is 'granted' if the user allowed the request or
|
|
|
|
* 'denied' otherwise.
|
|
|
|
*/
|
2017-05-02 22:29:19 +02:00
|
|
|
requestNotificationPermission(): Promise<string> {
|
2016-11-02 18:36:48 +01:00
|
|
|
// annoyingly, the latest spec says this returns a
|
|
|
|
// promise, but this is only supported in Chrome 46
|
|
|
|
// and Firefox 47, so adapt the callback API.
|
2018-10-03 02:34:57 +02:00
|
|
|
return new Promise(function(resolve, reject) {
|
2020-05-20 20:56:54 +02:00
|
|
|
window.Notification.requestPermission((result) => {
|
2018-10-03 02:34:57 +02:00
|
|
|
resolve(result);
|
|
|
|
});
|
2018-10-05 17:41:45 +02:00
|
|
|
});
|
2016-11-02 18:36:48 +01:00
|
|
|
}
|
|
|
|
|
2021-11-23 08:42:24 +01:00
|
|
|
private getMostRecentVersion(): Promise<string> {
|
2016-11-17 18:27:21 +01:00
|
|
|
// We add a cachebuster to the request to make sure that we know about
|
|
|
|
// the most recent version on the origin server. That might not
|
|
|
|
// actually be the version we'd get on a reload (particularly in the
|
|
|
|
// presence of intermediate caching proxies), but still: we're trying
|
|
|
|
// to tell the user that there is a new version.
|
2018-10-03 02:34:57 +02:00
|
|
|
|
2021-12-07 05:11:01 +01:00
|
|
|
return new Promise((resolve, reject) => {
|
2018-10-03 02:34:57 +02:00
|
|
|
request(
|
|
|
|
{
|
|
|
|
method: "GET",
|
|
|
|
url: "version",
|
|
|
|
qs: { cachebuster: Date.now() },
|
|
|
|
},
|
|
|
|
(err, response, body) => {
|
|
|
|
if (err || response.status < 200 || response.status >= 300) {
|
|
|
|
if (err === null) err = { status: response.status };
|
|
|
|
reject(err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-12-07 05:11:01 +01:00
|
|
|
resolve(this.getNormalizedAppVersion(body.trim()));
|
2018-10-03 02:34:57 +02:00
|
|
|
},
|
|
|
|
);
|
2018-10-05 17:41:45 +02:00
|
|
|
});
|
2016-11-02 17:02:55 +01:00
|
|
|
}
|
|
|
|
|
2021-12-07 05:11:01 +01:00
|
|
|
getNormalizedAppVersion(version: string): string {
|
2021-11-23 08:42:24 +01:00
|
|
|
// if version looks like semver with leading v, strip it
|
2021-12-07 05:11:01 +01:00
|
|
|
// (matches scripts/normalize-version.sh)
|
2021-11-23 08:42:24 +01:00
|
|
|
const semVerRegex = new RegExp("^v[0-9]+.[0-9]+.[0-9]+(-.+)?$");
|
2021-12-07 05:11:01 +01:00
|
|
|
if (semVerRegex.test(version)) {
|
|
|
|
return version.substr(1);
|
2016-11-08 11:47:01 +01:00
|
|
|
}
|
2021-12-07 05:11:01 +01:00
|
|
|
return version;
|
2021-12-06 13:12:29 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
getAppVersion(): Promise<string> {
|
2021-12-07 05:11:01 +01:00
|
|
|
return Promise.resolve(this.getNormalizedAppVersion(process.env.VERSION));
|
2016-11-08 11:47:01 +01:00
|
|
|
}
|
|
|
|
|
2017-06-03 13:50:47 +02:00
|
|
|
startUpdater() {
|
2017-06-11 20:19:17 +02:00
|
|
|
this.pollForUpdate();
|
2020-05-20 21:01:11 +02:00
|
|
|
setInterval(this.pollForUpdate, POKE_RATE_MS);
|
2017-06-03 13:50:47 +02:00
|
|
|
}
|
|
|
|
|
2020-05-20 20:56:54 +02:00
|
|
|
async canSelfUpdate(): Promise<boolean> {
|
2018-12-18 18:42:55 +01:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2020-05-20 21:01:11 +02:00
|
|
|
pollForUpdate = () => {
|
2021-11-23 08:42:24 +01:00
|
|
|
return this.getMostRecentVersion().then((mostRecentVersion) => {
|
2021-12-07 05:11:01 +01:00
|
|
|
const currentVersion = this.getNormalizedAppVersion(process.env.VERSION);
|
2021-12-06 13:12:29 +01:00
|
|
|
|
|
|
|
if (currentVersion !== mostRecentVersion) {
|
2021-11-23 08:42:24 +01:00
|
|
|
if (this.shouldShowUpdate(mostRecentVersion)) {
|
2021-12-06 13:12:29 +01:00
|
|
|
showUpdateToast(currentVersion, mostRecentVersion);
|
2020-05-29 20:59:48 +02:00
|
|
|
}
|
2020-05-29 19:24:45 +02:00
|
|
|
return { status: UpdateCheckStatus.Ready };
|
2020-05-23 00:08:46 +02:00
|
|
|
} else {
|
|
|
|
hideUpdateToast();
|
2016-11-02 17:02:55 +01:00
|
|
|
}
|
2020-05-23 00:08:46 +02:00
|
|
|
|
2020-05-29 19:24:45 +02:00
|
|
|
return { status: UpdateCheckStatus.NotAvailable };
|
2016-11-02 17:02:55 +01:00
|
|
|
}, (err) => {
|
2021-10-15 16:56:22 +02:00
|
|
|
logger.error("Failed to poll for update", err);
|
2017-06-11 20:19:17 +02:00
|
|
|
return {
|
2020-05-29 19:24:45 +02:00
|
|
|
status: UpdateCheckStatus.Error,
|
2017-06-11 20:19:17 +02:00
|
|
|
detail: err.message || err.status ? err.status.toString() : 'Unknown Error',
|
|
|
|
};
|
|
|
|
});
|
2020-05-20 21:01:11 +02:00
|
|
|
};
|
2017-06-11 20:19:17 +02:00
|
|
|
|
2020-05-26 11:04:49 +02:00
|
|
|
startUpdateCheck() {
|
2017-06-11 20:19:17 +02:00
|
|
|
super.startUpdateCheck();
|
|
|
|
this.pollForUpdate().then((updateState) => {
|
2020-05-29 19:24:45 +02:00
|
|
|
dis.dispatch<CheckUpdatesPayload>({
|
|
|
|
action: Action.CheckUpdates,
|
|
|
|
...updateState,
|
2017-06-11 20:19:17 +02:00
|
|
|
});
|
2016-11-02 17:02:55 +01:00
|
|
|
});
|
2020-05-26 11:04:49 +02:00
|
|
|
}
|
2016-11-02 17:02:55 +01:00
|
|
|
|
|
|
|
installUpdate() {
|
2021-10-15 16:55:32 +02:00
|
|
|
window.location.reload();
|
2016-11-02 17:02:55 +01:00
|
|
|
}
|
2016-11-24 17:46:15 +01:00
|
|
|
|
2017-05-02 22:29:19 +02:00
|
|
|
getDefaultDeviceDisplayName(): string {
|
2020-07-15 10:38:55 +02:00
|
|
|
// strip query-string and fragment from uri
|
2021-02-11 15:47:50 +01:00
|
|
|
const url = new URL(window.location.href);
|
|
|
|
|
|
|
|
// `appName` in the format `develop.element.io/abc/xyz`
|
|
|
|
const appName = [
|
|
|
|
url.host,
|
|
|
|
url.pathname.replace(/\/$/, ""), // Remove trailing slash if present
|
2021-02-11 17:27:30 +01:00
|
|
|
].join("");
|
2016-11-24 17:46:15 +01:00
|
|
|
|
2017-05-02 22:29:19 +02:00
|
|
|
const ua = new UAParser();
|
2017-06-06 13:38:06 +02:00
|
|
|
const browserName = ua.getBrowser().name || "unknown browser";
|
2020-04-30 16:58:53 +02:00
|
|
|
let osName = ua.getOS().name || "unknown OS";
|
|
|
|
// Stylise the value from the parser to match Apple's current branding.
|
|
|
|
if (osName === "Mac OS") osName = "macOS";
|
2020-04-30 17:50:01 +02:00
|
|
|
return _t('%(appName)s (%(browserName)s, %(osName)s)', {
|
|
|
|
appName,
|
|
|
|
browserName,
|
|
|
|
osName,
|
|
|
|
});
|
2016-11-24 17:46:15 +01:00
|
|
|
}
|
2017-01-10 19:39:21 +01:00
|
|
|
|
2020-05-20 20:56:54 +02:00
|
|
|
screenCaptureErrorString(): string | null {
|
2017-01-10 19:39:21 +01:00
|
|
|
// it won't work at all if you're not on HTTPS so whine whine whine
|
2020-05-20 20:56:54 +02:00
|
|
|
if (window.location.protocol !== "https:") {
|
2017-05-31 15:51:08 +02:00
|
|
|
return _t("You need to be using HTTPS to place a screen-sharing call.");
|
2017-01-10 19:39:21 +01:00
|
|
|
}
|
|
|
|
return null;
|
|
|
|
}
|
2017-04-10 18:40:09 +02:00
|
|
|
|
|
|
|
reload() {
|
2021-10-15 16:55:32 +02:00
|
|
|
window.location.reload();
|
2017-04-10 18:40:09 +02:00
|
|
|
}
|
2016-11-02 16:12:51 +01:00
|
|
|
}
|