jiti-meet/react/features/app/actions.js

279 lines
9.1 KiB
JavaScript
Raw Normal View History

/* @flow */
import { setRoom } from '../base/conference';
import {
configWillLoad,
loadConfigError,
restoreConfig,
setConfig,
storeConfig
} from '../base/config';
import { setLocationURL } from '../base/connection';
import { loadConfig } from '../base/lib-jitsi-meet';
2017-07-21 21:12:02 +00:00
import { parseURIString } from '../base/util';
2017-06-09 19:09:23 +00:00
import { APP_WILL_MOUNT, APP_WILL_UNMOUNT } from './actionTypes';
declare var APP: Object;
/**
* Triggers an in-app navigation to a specific route. Allows navigation to be
* abstracted between the mobile/React Native and Web/React applications.
*
* @param {string|undefined} uri - The URI to which to navigate. It may be a
* full URL with an HTTP(S) scheme, a full or partial URI with the app-specific
* scheme, or a mere room name.
* @returns {Function}
*/
export function appNavigate(uri: ?string) {
return (dispatch: Dispatch<*>, getState: Function) =>
2017-07-21 21:12:02 +00:00
_appNavigateToOptionalLocation(dispatch, getState, parseURIString(uri));
}
2017-04-19 14:52:27 +00:00
/**
* Triggers an in-app navigation to a specific location URI.
*
* @param {Dispatch} dispatch - The redux {@code dispatch} function.
* @param {Function} getState - The redux function that gets/retrieves the redux
* state.
* @param {Object} newLocation - The location URI to navigate to. The value
* cannot be undefined and is assumed to have all properties such as
2017-08-31 19:16:44 +00:00
* {@code host}, {@code contextRoot}, and {@code room} defined. Depending on the
* property, it may have a value equal to {@code undefined} and that may be
* acceptable.
* @private
* @returns {Promise<void>}
*/
function _appNavigateToMandatoryLocation(
dispatch: Dispatch<*>, getState: Function,
newLocation: Object
): Promise<void> {
const { room } = newLocation;
dispatch(configWillLoad(newLocation));
return (
_loadConfig(dispatch, getState, newLocation)
.then(
config => loadConfigSettled(/* error */ undefined, config),
error => loadConfigSettled(error, /* config */ undefined))
.then(() => dispatch(setRoom(room))));
/**
* Notifies that an attempt to load a configuration has completed. Due to
* the asynchronous nature of the loading, the specified {@code config} may
2017-08-31 19:16:44 +00:00
* or may not be required by the time the notification arrives.
*
* @param {string|undefined} error - If the loading has failed, the error
* detailing the cause of the failure.
* @param {Object|undefined} config - If the loading has succeeded, the
* loaded configuration.
* @returns {void}
*/
function loadConfigSettled(error, config) {
// FIXME Due to the asynchronous nature of the loading, the specified
2017-08-31 19:16:44 +00:00
// config may or may not be required by the time the notification
// arrives.
const promise
= dispatch(setLocationURL(new URL(newLocation.toString())));
if (error) {
// XXX The failure could be, for example, because of a
// certificate-related error. In which case the connection will
// fail later in Strophe anyway.
return promise.then(() => {
dispatch(loadConfigError(error, newLocation));
throw error;
});
2017-04-19 14:52:27 +00:00
}
return promise.then(() =>
dispatch(setConfig(config)));
}
}
2016-12-07 22:06:16 +00:00
/**
* Triggers an in-app navigation to a specific or undefined location (URI).
*
* @param {Dispatch} dispatch - The redux {@code dispatch} function.
* @param {Function} getState - The redux function that gets/retrieves the redux
* state.
* @param {Object} location - The location (URI) to navigate to. The value may
* be undefined.
* @private
* @returns {void}
*/
function _appNavigateToOptionalLocation(
dispatch: Dispatch<*>, getState: Function,
location: Object) {
// If the specified location (URI) does not identify a host, use the app's
// default.
if (!location || !location.host) {
const defaultLocation
2017-07-21 21:12:02 +00:00
= parseURIString(getState()['features/app'].app._getDefaultURL());
if (location) {
location.host = defaultLocation.host;
// FIXME Turn location's host, hostname, and port properties into
// setters in order to reduce the risks of inconsistent state.
location.hostname = defaultLocation.hostname;
location.port = defaultLocation.port;
location.protocol = defaultLocation.protocol;
} else {
// eslint-disable-next-line no-param-reassign
location = defaultLocation;
}
}
2017-01-25 22:11:44 +00:00
location.protocol || (location.protocol = 'https:');
return _appNavigateToMandatoryLocation(dispatch, getState, location);
}
/**
* Signals that a specific App will mount (in the terms of React).
*
* @param {App} app - The App which will mount.
* @returns {{
* type: APP_WILL_MOUNT,
* app: App
* }}
*/
export function appWillMount(app: Object) {
return (dispatch: Dispatch<*>) => {
dispatch({
type: APP_WILL_MOUNT,
app
});
// TODO There was a redux action creator appInit which I did not like
// because we already had the redux action creator appWillMount and,
// respectively, the redux action APP_WILL_MOUNT. So I set out to remove
// appInit and managed to move everything it was doing but the
// following. Which is not extremely bad because we haven't moved the
// API module into its own feature yet so we're bound to work on that in
// the future.
typeof APP === 'object' && APP.API.init();
};
}
/**
* Signals that a specific App will unmount (in the terms of React).
*
* @param {App} app - The App which will unmount.
* @returns {{
* type: APP_WILL_UNMOUNT,
* app: App
* }}
*/
export function appWillUnmount(app: Object) {
return {
type: APP_WILL_UNMOUNT,
app
};
}
/**
* Loads config.js from a specific host.
*
* @param {Dispatch} dispatch - The redux {@code dispatch} function.
* @param {Function} getState - The redux {@code getState} function.
* @param {Object} location - The location URI which specifies the host to load
* the config.js from.
2017-08-31 19:16:44 +00:00
* @private
* @returns {Promise<Object>}
*/
function _loadConfig(
dispatch: Dispatch<*>,
getState: Function,
{ contextRoot, host, protocol, room }) {
// XXX As the mobile/React Native app does not employ config on the
// WelcomePage, do not download config.js from the deployment when
// navigating to the WelcomePage - the perceived/visible navigation will be
// faster.
if (!room && typeof APP === 'undefined') {
return Promise.resolve();
}
/* eslint-disable no-param-reassign */
protocol = protocol.toLowerCase();
// The React Native app supports an app-specific scheme which is sure to not
// be supported by fetch (or whatever loadConfig utilizes).
2017-07-21 21:12:02 +00:00
protocol !== 'http:' && protocol !== 'https:' && (protocol = 'https:');
// TDOO userinfo
2017-09-05 20:53:39 +00:00
const baseURL = `${protocol}//${host}${contextRoot || '/'}`;
let url = `${baseURL}config.js`;
// XXX In order to support multiple shards, tell the room to the deployment.
room && (url += `?room=${room.toLowerCase()}`);
/* eslint-enable no-param-reassign */
return loadConfig(url).then(
2017-09-05 20:53:39 +00:00
/* onFulfilled */ config => {
dispatch(storeConfig(baseURL, config));
2017-09-05 20:53:39 +00:00
return config;
},
/* onRejected */ error => {
// XXX The (down)loading of config failed. Try to use the last
// successfully fetched for that deployment. It may not match the
// shard.
const config = restoreConfig(baseURL);
if (config) {
return config;
2017-09-05 20:53:39 +00:00
}
2017-09-05 20:53:39 +00:00
throw error;
});
}
/**
* Redirects to another page generated by replacing the path in the original URL
* with the given path.
*
* @param {(string)} pathname - The path to navigate to.
* @returns {Function}
*/
export function redirectWithStoredParams(pathname: string) {
return (dispatch: Dispatch<*>, getState: Function) => {
const { locationURL } = getState()['features/base/connection'];
const newLocationURL = new URL(locationURL.href);
newLocationURL.pathname = pathname;
window.location.assign(newLocationURL.toString());
};
}
/**
* Reloads the page by restoring the original URL.
*
* @returns {Function}
*/
export function reloadWithStoredParams() {
return (dispatch: Dispatch<*>, getState: Function) => {
const { locationURL } = getState()['features/base/connection'];
const windowLocation = window.location;
const oldSearchString = windowLocation.search;
windowLocation.replace(locationURL.toString());
if (window.self !== window.top
&& locationURL.search === oldSearchString) {
// NOTE: Assuming that only the hash or search part of the URL will
// be changed!
// location.reload will not trigger redirect/reload for iframe when
// only the hash params are changed. That's why we need to call
// reload in addition to replace.
windowLocation.reload();
}
};
}