[RN] Disconnect/hangup before joining a new URL

react/features/app/actions.js

 import { loadConfig } from '../base/lib-jitsi-meet';
 
 import { APP_WILL_MOUNT, APP_WILL_UNMOUNT } from './actionTypes';
-import { _getRouteToRender, _parseURIString } from './functions';
+import { _parseURIString } from './functions';
 
 declare var APP: Object;
 
 
     if (oldHost === newHost) {
         dispatchSetLocationURL();
-        dispatchSetRoomAndNavigate();
+        dispatchSetRoom();
     } else {
         // If the host has changed, we need to load the config of the new host
         // and set it, and only after that we can navigate to a different route.
             .then(
                 config => configLoaded(/* err */ undefined, config),
                 err => configLoaded(err, /* config */ undefined))
-            .then(dispatchSetRoomAndNavigate);
+            .then(dispatchSetRoom);
     }
 
     /**
      *
      * @returns {void}
      */
-    function dispatchSetRoomAndNavigate() {
-        dispatch(_setRoomAndNavigate(newLocation.room));
+    function dispatchSetRoom() {
+        dispatch(setRoom(newLocation.room));
     }
 }
 
 
     return loadConfig(protocol + location.host + (location.contextRoot || '/'));
 }
-
-/**
- * Navigates to a route in accord with a specific redux state.
- *
- * @param {Object} state - The redux state which determines/identifies the route
- * to navigate to.
- * @private
- * @returns {void}
- */
-function _navigate(state) {
-    const app = state['features/app'].app;
-    const routeToRender = _getRouteToRender(state);
-
-    app._navigate(routeToRender);
-}
-
-/**
- * Sets room and navigates to new route if needed.
- *
- * @param {string} newRoom - New room name.
- * @private
- * @returns {Function}
- */
-function _setRoomAndNavigate(newRoom) {
-    return (dispatch, getState) => {
-        dispatch(setRoom(newRoom));
-        _navigate(getState());
-    };
-}

react/features/app/components/App.web.js

      * @returns {void}
      */
     _navigate(route) {
-        let path = route.path;
-        const store = this._getStore();
-
-        // The syntax :room bellow is defined by react-router. It "matches a URL
-        // segment up to the next /, ?, or #. The matched string is called a
-        // param."
-        path
-            = path.replace(
-                /:room/g,
-                store.getState()['features/base/conference'].room);
-        path = this._routePath2WindowLocationPathname(path);
+        let path;
+
+        if (route) {
+            path = route.path;
+
+            const store = this._getStore();
+
+            // The syntax :room bellow is defined by react-router. It "matches a
+            // URL segment up to the next /, ?, or #. The matched string is
+            // called a param."
+            path
+                = path.replace(
+                    /:room/g,
+                    store.getState()['features/base/conference'].room);
+            path = this._routePath2WindowLocationPathname(path);
+        }
 
         // Navigate to the specified Route.
         const windowLocation = this.getWindowLocation();
 
-        if (windowLocation.pathname === path) {
+        if (!route || windowLocation.pathname === path) {
             // The browser is at the specified path already and what remains is
             // to make this App instance aware of the route to be rendered at
             // the current location.

react/features/app/middleware.js

+import { SET_ROOM } from '../base/conference';
 import {
     CONNECTION_ESTABLISHED,
-    getURLWithoutParams
+    getURLWithoutParams,
+    SET_LOCATION_URL
 } from '../base/connection';
 import { MiddlewareRegistry } from '../base/redux';
 
     switch (action.type) {
     case CONNECTION_ESTABLISHED:
         return _connectionEstablished(store, next, action);
+
+    case SET_LOCATION_URL:
+    case SET_ROOM:
+        return _setLocationURLOrRoom(store, next, action);
     }
 
     return next(action);
 
     return result;
 }
+
+/**
+ * Navigates to a route in accord with a specific redux state.
+ *
+ * @param {Object} state - The redux state which determines/identifies the route
+ * to navigate to.
+ * @private
+ * @returns {void}
+ */
+function _navigate(state) {
+    const { app, getRouteToRender } = state['features/app'];
+    const routeToRender = getRouteToRender && getRouteToRender(state);
+
+    app._navigate(routeToRender);
+}
+
+/**
+ * Notifies the feature app that the action {@link SET_LOCATION_URL} or
+ * {@link SET_ROOM} is being dispatched within a specific redux {@code store}.
+ *
+ * @param {Store} store - The redux store in which the specified {@code action}
+ * is being dispatched.
+ * @param {Dispatch} next - The redux {@code dispatch} function to dispatch the
+ * specified {@code action} to the specified {@code store}.
+ * @param {Action} action - The redux action {@code SET_LOCATION_URL} or
+ * {@code SET_ROOM} which is being dispatched in the specified {@code store}.
+ * @private
+ * @returns {Object} The new state that is the result of the reduction of the
+ * specified {@code action}.
+ */
+function _setLocationURLOrRoom({ getState }, next, action) {
+    const result = next(action);
+
+    _navigate(getState());
+
+    return result;
+}

react/features/app/reducer.js

-import { ReducerRegistry } from '../base/redux';
+import { SET_ROOM } from '../base/conference';
+import { SET_LOCATION_URL } from '../base/connection';
+
+import { ReducerRegistry, set } from '../base/redux';
 
 import { APP_WILL_MOUNT, APP_WILL_UNMOUNT } from './actionTypes';
+import { _getRouteToRender } from './functions';
 
 ReducerRegistry.register('features/app', (state = {}, action) => {
     switch (action.type) {
             };
         }
         break;
+
+    case SET_LOCATION_URL:
+        return set(state, 'getRouteToRender', undefined);
+
+    case SET_ROOM:
+        return set(state, 'getRouteToRender', _getRouteToRender);
     }
 
     return state;