matrix.to/src/open/ClientViewModel.js

/*
Copyright 2020 The Matrix.org Foundation C.I.C.

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 {isWebPlatform, isDesktopPlatform, Platform} from "../Platform.js";
import {ViewModel} from "../utils/ViewModel.js";
import {IdentifierKind} from "../Link.js";

function getMatchingPlatforms(client, supportedPlatforms) {
    const clientPlatforms = client.platforms;
    const matchingPlatforms = supportedPlatforms.filter(p => {
        return clientPlatforms.includes(p);
    });
    return matchingPlatforms;
}

export class ClientViewModel extends ViewModel {
	constructor(options) {
		super(options);
		const {client, link, pickClient} = options;
		this._client = client;
		this._link = link;
		this._pickClient = pickClient;
        // to provide "choose other client" button after calling pick()
        this._clientListViewModel = null;
        this._update();
	}

    _update() {
		const matchingPlatforms = getMatchingPlatforms(this._client, this.platforms);
		this._webPlatform = matchingPlatforms.find(p => isWebPlatform(p));
		this._nativePlatform = matchingPlatforms.find(p => !isWebPlatform(p));
        const preferredPlatform = matchingPlatforms.find(p => p === this.preferences.platform);
		this._proposedPlatform = preferredPlatform || this._nativePlatform || this._webPlatform;

        this.openActions = this._createOpenActions();
		this.installActions = this._createInstallActions();
		this._clientCanIntercept = !!(this._nativePlatform && this._client.canInterceptMatrixToLinks(this._nativePlatform));
		this._showOpen = this.openActions.length && !this._clientCanIntercept;
        const proposedDeepLink = this._client.getDeepLink(this._proposedPlatform, this._link);
        this._openWillNavigateIfNotInstalled = false;
        if (this._showOpen && !isWebPlatform(this._proposedPlatform)) {
            try {
                if (new URL(proposedDeepLink).protocol === "https:") {
                    this._openWillNavigateIfNotInstalled = true;
                }
            } catch (err) {}
        }
    }

    // these are only shown in the open stage
    _createOpenActions() {
        const hasPreferredWebInstance = this.hasPreferredWebInstance;
        let deepLinkLabel = "Continue";
        if (hasPreferredWebInstance) {
            if (this._proposedPlatform === this._nativePlatform) {
                deepLinkLabel = "Open in app";
            } else {
                deepLinkLabel = `Open on ${this._client.getPreferredWebInstance(this._link)}`;
            }
        }
        const actions = [];
        const proposedDeepLink = this._client.getDeepLink(this._proposedPlatform, this._link);
        if (proposedDeepLink) {
            actions.push({
                label: deepLinkLabel,
                url: proposedDeepLink,
                primary: true,
                activated: () => {
                    this._pickClient(this._client);
                    this.preferences.setClient(this._client.id, this._proposedPlatform);
                    // only show install screen if we tried to open a native deeplink
                    if (this._showOpen && this._proposedPlatform === this._nativePlatform) {
                        this._showOpen = false;
                        this.emitChange();
                    }
                },
            });
        }
        // show only if there is a preferred instance, and if we don't already link to it in the first button
        if (hasPreferredWebInstance && this._webPlatform && this._proposedPlatform !== this._webPlatform) {
            actions.push({
                label: `Open on ${this._client.getPreferredWebInstance(this._link)}`,
                url: this._client.getDeepLink(this._webPlatform, this._link),
                kind: "open-in-web",
                activated: () => {} // don't persist this choice as we don't persist the preferred web instance, it's in the url
            });
        }
        return actions;
    }

    // these are only shown in the install stage
	_createInstallActions() {
		let actions = [];
		if (this._nativePlatform) {
			const nativeActions = (this._client.getInstallLinks(this._nativePlatform) || []).map(installLink => {
				return {
					label: installLink.getDescription(this._nativePlatform),
					url: installLink.createInstallURL(this._link),
					kind: installLink.channelId,
					primary: true,
					activated: () => this.preferences.setClient(this._client.id, this._nativePlatform),
				};
			});
			actions.push(...nativeActions);
		}
		if (this._webPlatform) {
			const webDeepLink = this._client.getDeepLink(this._webPlatform, this._link);
			if (webDeepLink) {
                const webLabel = this.hasPreferredWebInstance ?
                    `Open on ${this._client.getPreferredWebInstance(this._link)}` :
                    `Continue in your browser`;
				actions.push({
					label: webLabel,
					url: webDeepLink,
					kind: "open-in-web",
					activated: () => {
                        if (!this.hasPreferredWebInstance) {
                            this.preferences.setClient(this._client.id, this._webPlatform);
                        }
                    },
				});
			}
		}
		return actions;
	}

    get hasPreferredWebInstance() {
        // also check there is a web platform that matches the platforms the user is on (mobile or desktop web)
        return this._webPlatform && typeof this._client.getPreferredWebInstance(this._link) === "string";
    }

    get hostedByBannerLabel() {
        const preferredWebInstance = this._client.getPreferredWebInstance(this._link);
        if (this._webPlatform && preferredWebInstance) {
            let label = preferredWebInstance;
            const subDomainIdx = preferredWebInstance.lastIndexOf(".", preferredWebInstance.lastIndexOf("."));
            if (subDomainIdx !== -1) {
                label = preferredWebInstance.substr(preferredWebInstance.length - subDomainIdx + 1);
            }
            return `Hosted by ${label}`;
        }
        return;
    }

    get homepage() {
        return this._client.homepage;
    }

	get identifier() {
		return this._link.identifier;
	}

	get description() {
		return this._client.description;
	}

	get clientId() {
		return this._client.id;
	}

    get name() {
        return this._client.name;
    }

    get iconUrl() {
        return this._client.icon;
    }

    get showOpen() {
        return this._showOpen;
    }

    get showInstall() {
        // also show install options in open screen if the deeplink is
        // a https link that should be intercepted by the native app
        // because if it isn't installed, you will just go to that
        // website and never see the install options here.
        return !this._showOpen || this._openWillNavigateIfNotInstalled;
    }

	get textInstructions() {
        let instructions = this._client.getLinkInstructions(this._proposedPlatform, this._link);
        if (instructions && !Array.isArray(instructions)) {
            instructions = [instructions];
        }
		return instructions;
	}

    get copyString() {
        return this._client.getCopyString(this._proposedPlatform, this._link);
    }

	get showDeepLinkInInstall() {
        // we can assume this._nativePlatform as this._clientCanIntercept already checks it
		return this._clientCanIntercept && !!this._client.getDeepLink(this._nativePlatform, this._link);
	}

	get availableOnPlatformNames() {
		const platforms = this._client.platforms;
		const textPlatforms = [];
		const hasWebPlatform = platforms.some(p => isWebPlatform(p));
		if (hasWebPlatform) {
			textPlatforms.push("Web");
		}
		const desktopPlatforms = platforms.filter(p => isDesktopPlatform(p));
		if (desktopPlatforms.length === 1) {
			textPlatforms.push(desktopPlatforms[0]);
		} else {
			textPlatforms.push("Desktop");
		}
		if (platforms.includes(Platform.Android)) {
			textPlatforms.push("Android");
		}
		if (platforms.includes(Platform.iOS)) {
			textPlatforms.push("iOS");
		}
		return textPlatforms;
	}

    pick(clientListViewModel) {
        this._clientListViewModel = clientListViewModel;
        this.emitChange();
    }

    // whether or not we are only showing this client (in open or install stage)
    get showBack() {
        return !!this._clientListViewModel;
    }

    back() {
        if (this._clientListViewModel) {
            const vm = this._clientListViewModel;
            this._clientListViewModel = null;
            // clear the client preference so we default back to to native link if any
            // in the list with all clients, and also if we refresh, we get the list with
            // all clients rather than having our "change client" click reverted.
            this.preferences.setClient(undefined, undefined);
            this._update();
            this.emitChange();
            vm.showAll();
        }
    }
}