squash: Replace resuming event with CONNECTION_TOKEN_EXPIRED one.

Author: damencho

lang/main.json

@@ -384,7 +384,7 @@
         "lockTitle": "Lock failed",
         "login": "Login",
         "loginFailed": "Login failed.",
-        "loginOnResume": "Your authentication session is about to expire. You need to login again to continue the meeting.",
+        "loginOnResume": "Your authentication session has expired. You need to login again to continue the meeting.",
         "loginQuestion": "Are you sure you want to login and leave the conference?",
         "logoutQuestion": "Are you sure you want to logout and leave the conference?",
         "logoutTitle": "Logout",

react/features/base/connection/actionTypes.ts

@@ -52,14 +52,14 @@ export const CONNECTION_PROPERTIES_UPDATED = 'CONNECTION_PROPERTIES_UPDATED';
 export const CONNECTION_WILL_CONNECT = 'CONNECTION_WILL_CONNECT';
 
 /**
- * The type of (redux) action which signals that a connection will try to resume.
+ * The type of (redux) action which signals that the token for a connection is expired.
  *
  * {
- *     type: CONNECTION_RESUMING,
+ *     type: CONNECTION_TOKEN_EXPIRED,
  *     connection: JitsiConnection
  * }
  */
-export const CONNECTION_RESUMING = 'CONNECTION_RESUMING';
+export const CONNECTION_TOKEN_EXPIRED = 'CONNECTION_TOKEN_EXPIRED';
 
 /**
  * The type of (redux) action which sets the location URL of the application,

react/features/base/connection/actions.any.ts

@@ -18,7 +18,7 @@ import {
     CONNECTION_ESTABLISHED,
     CONNECTION_FAILED,
     CONNECTION_PROPERTIES_UPDATED,
-    CONNECTION_RESUMING,
+    CONNECTION_TOKEN_EXPIRED,
     CONNECTION_WILL_CONNECT,
     SET_LOCATION_URL,
     SET_PREFER_VISITOR
@@ -242,8 +242,8 @@ export function _connectInternal(id?: string, password?: string) {
                 JitsiConnectionEvents.PROPERTIES_UPDATED,
                 _onPropertiesUpdate);
             connection.addEventListener(
-                JitsiConnectionEvents.CONNECTION_RESUMING,
-                _onConnectionResume);
+                JitsiConnectionEvents.CONNECTION_TOKEN_EXPIRED,
+                _onTokenExpired);
 
             /**
              * Unsubscribe the connection instance from
@@ -334,13 +334,8 @@ export function _connectInternal(id?: string, password?: string) {
              * @private
              * @returns {void}
              */
-            function _onConnectionResume(): void {
-                // when inline, we cancel resume as we will get a new token and refresh it by resuming
-                if (isTokenAuthInline(getState()['features/base/config']) && getState()['features/base/jwt'].jwt) {
-                    connection.cancelResume();
-                }
-
-                dispatch(_connectionResuming(connection));
+            function _onTokenExpired(): void {
+                dispatch(_connectionTokenExpired(connection));
             }
 
             /**
@@ -385,18 +380,18 @@ function _connectionWillConnect(connection: Object) {
 }
 
 /**
- * Create an action for when a connection will resume.
+ * Create an action for when a connection token is expired.
  *
- * @param {JitsiConnection} connection - The {@code JitsiConnection} which will resume.
+ * @param {JitsiConnection} connection - The {@code JitsiConnection} token is expired.
  * @private
  * @returns {{
- *     type: CONNECTION_RESUMING,
+ *     type: CONNECTION_TOKEN_EXPIRED,
  *     connection: JitsiConnection
  * }}
  */
-function _connectionResuming(connection: Object) {
+function _connectionTokenExpired(connection: Object) {
     return {
-        type: CONNECTION_RESUMING,
+        type: CONNECTION_TOKEN_EXPIRED,
         connection
     };
 }

react/features/base/jwt/middleware.ts

@@ -4,14 +4,17 @@ import { AnyAction } from 'redux';
 
 import { IStore } from '../../app/types';
 import { loginWithPopup } from '../../authentication/actions';
+import LoginQuestionDialog from '../../authentication/components/web/LoginQuestionDialog';
 import { getTokenAuthUrl, isTokenAuthInline } from '../../authentication/functions';
 import { isVpaasMeeting } from '../../jaas/functions';
 import { hideNotification, showNotification } from '../../notifications/actions';
 import { NOTIFICATION_TIMEOUT_TYPE, NOTIFICATION_TYPE } from '../../notifications/constants';
 import { authStatusChanged } from '../conference/actions.any';
 import { getCurrentConference } from '../conference/functions';
 import { SET_CONFIG } from '../config/actionTypes';
-import { CONNECTION_ESTABLISHED, CONNECTION_RESUMING, SET_LOCATION_URL } from '../connection/actionTypes';
+import { CONNECTION_ESTABLISHED, CONNECTION_TOKEN_EXPIRED, SET_LOCATION_URL } from '../connection/actionTypes';
+import { openDialog } from '../dialog/actions';
+import { browser } from '../lib-jitsi-meet';
 import { participantUpdated } from '../participants/actions';
 import { getLocalParticipant } from '../participants/functions';
 import { IParticipant } from '../participants/types';
@@ -55,12 +58,11 @@ MiddlewareRegistry.register(store => next => action => {
         // XXX The JSON Web Token (JWT) is not the only piece of state that we
         // have decided to store in the feature jwt
         return _setConfigOrLocationURL(store, next, action);
-    case CONNECTION_RESUMING: {
+    case CONNECTION_TOKEN_EXPIRED: {
         const jwt = state['features/base/jwt'].jwt;
         const refreshToken = state['features/base/jwt'].refreshToken;
 
-        if (typeof APP !== 'undefined'
-                && jwt && isTokenAuthInline(state['features/base/config'])
+        if (typeof APP !== 'undefined' && jwt
                 && validateJwt(jwt).find((e: any) => e.key === JWT_VALIDATION_ERRORS.TOKEN_EXPIRED)) {
             const { connection, locationURL = { href: '' } as URL } = state['features/base/connection'];
             const { tenant } = parseURIString(locationURL.href) || {};
@@ -92,23 +94,39 @@ MiddlewareRegistry.register(store => next => action => {
                             customActionHandler: [ () => {
                                 store.dispatch(hideNotification(PROMPT_LOGIN_NOTIFICATION_ID));
 
-                                // Use refresh token if available, otherwise fall back to silent login
-                                loginWithPopup(url)
-                                    .then((result: { accessToken: string; idToken: string; refreshToken?: string; }) => {
-                                        // @ts-ignore
-                                        const token: string = result.accessToken;
-                                        const idToken: string = result.idToken;
-                                        const newRefreshToken: string | undefined = result.refreshToken;
-
-                                        // @ts-ignore
-                                        dispatch(setJWT(token, idToken, newRefreshToken || refreshToken));
-
-                                        connection?.refreshToken(token)
-                                            .catch((err: any) => {
-                                                dispatch(setJWT());
-                                                logger.error(err);
-                                            });
-                                    }).catch(logger.error);
+                                if (isTokenAuthInline(state['features/base/config'])) {
+                                    // Use refresh token if available, otherwise fall back to silent login
+                                    loginWithPopup(url)
+                                        .then((result: { accessToken: string; idToken: string; refreshToken?: string; }) => {
+                                            // @ts-ignore
+                                            const token: string = result.accessToken;
+                                            const idToken: string = result.idToken;
+                                            const newRefreshToken: string | undefined = result.refreshToken;
+
+                                            // @ts-ignore
+                                            dispatch(setJWT(token, idToken, newRefreshToken || refreshToken));
+
+                                            connection?.refreshToken(token)
+                                                .catch((err: any) => {
+                                                    dispatch(setJWT());
+                                                    logger.error(err);
+                                                });
+                                        }).catch(logger.error);
+                                } else {
+                                    dispatch(openDialog('LoginQuestionDialog', LoginQuestionDialog, {
+                                        handler: () => {
+                                            // Give time for the dialog to close.
+                                            setTimeout(() => {
+                                                if (browser.isElectron()) {
+                                                    window.open(url, '_blank');
+                                                } else {
+                                                    window.location.href = url;
+                                                }
+                                            }, 500);
+                                        }
+                                    }));
+                                }
+
                             } ],
                             appearance: NOTIFICATION_TYPE.ERROR
                         }, NOTIFICATION_TIMEOUT_TYPE.STICKY));