[RN] If recent-list knows a domain, then the app knows it

react/features/recent-list/actionTypes.js

 
 /**
  * Action type to signal a new addition to the list.
+ *
+ * {
+ *     type: _STORE_CURRENT_CONFERENCE,
+ *     locationURL: Object
+ * }
+ *
+ * @protected
  */
-export const STORE_CURRENT_CONFERENCE = Symbol('STORE_CURRENT_CONFERENCE');
+export const _STORE_CURRENT_CONFERENCE = Symbol('_STORE_CURRENT_CONFERENCE');
 
 /**
  * Action type to signal that a new conference duration info is available.
+ *
+ * {
+ *     type: _UPDATE_CONFERENCE_DURATION,
+ *     locationURL: Object
+ * }
+ *
+ * @protected
  */
-export const UPDATE_CONFERENCE_DURATION = Symbol('UPDATE_CONFERENCE_DURATION');
+export const _UPDATE_CONFERENCE_DURATION
+    = Symbol('_UPDATE_CONFERENCE_DURATION');

react/features/recent-list/actions.js

 // @flow
 
 import {
-    STORE_CURRENT_CONFERENCE,
-    UPDATE_CONFERENCE_DURATION
+    _STORE_CURRENT_CONFERENCE,
+    _UPDATE_CONFERENCE_DURATION
 } from './actionTypes';
 
 /**
  * Action to initiate a new addition to the list.
  *
  * @param {Object} locationURL - The current location URL.
+ * @protected
  * @returns {{
- *     type: STORE_CURRENT_CONFERENCE,
+ *     type: _STORE_CURRENT_CONFERENCE,
  *     locationURL: Object
  * }}
  */
-export function storeCurrentConference(locationURL: Object) {
+export function _storeCurrentConference(locationURL: Object) {
     return {
-        type: STORE_CURRENT_CONFERENCE,
+        type: _STORE_CURRENT_CONFERENCE,
         locationURL
     };
 }
  * Action to initiate the update of the duration of the last conference.
  *
  * @param {Object} locationURL - The current location URL.
+ * @protected
  * @returns {{
- *     type: UPDATE_CONFERENCE_DURATION,
+ *     type: _UPDATE_CONFERENCE_DURATION,
  *     locationURL: Object
  * }}
  */
-export function updateConferenceDuration(locationURL: Object) {
+export function _updateConferenceDuration(locationURL: Object) {
     return {
-        type: UPDATE_CONFERENCE_DURATION,
+        type: _UPDATE_CONFERENCE_DURATION,
         locationURL
     };
 }

react/features/recent-list/middleware.js

 // @flow
 
+import { APP_WILL_MOUNT } from '../app';
 import { CONFERENCE_WILL_LEAVE, SET_ROOM } from '../base/conference';
+import { addKnownDomains } from '../base/known-domains';
 import { MiddlewareRegistry } from '../base/redux';
+import { parseURIString } from '../base/util';
 
-import { storeCurrentConference, updateConferenceDuration } from './actions';
+import { _storeCurrentConference, _updateConferenceDuration } from './actions';
 
 /**
  * Middleware that captures joined rooms so they can be saved into
  */
 MiddlewareRegistry.register(store => next => action => {
     switch (action.type) {
+    case APP_WILL_MOUNT:
+        return _appWillMount(store, next, action);
+
     case CONFERENCE_WILL_LEAVE:
-        _updateConferenceDuration(store);
-        break;
+        return _conferenceWillLeave(store, next, action);
 
     case SET_ROOM:
-        _maybeStoreCurrentConference(store, action);
-        break;
+        return _setRoom(store, next, action);
     }
 
     return next(action);
 });
 
 /**
- * Checks if there is a current conference (upon SET_ROOM action), and saves it
- * if necessary.
+ * Notifies the feature recent-list that the redux action {@link APP_WILL_MOUNT}
+ * is being dispatched in a specific redux store.
  *
- * @param {Store} store - The redux store.
- * @param {Dispatch} next - The redux {@code dispatch} function.
- * @param {Action} action - The redux action.
+ * @param {Store} store - The redux store in which the specified action is being
+ * dispatched.
+ * @param {Dispatch} next - The redux {@code dispatch} function to dispatch the
+ * specified action to the specified store.
+ * @param {Action} action - The redux action {@code APP_WILL_MOUNT} which is
+ * being dispatched in the specified redux store.
  * @private
- * @returns {void}
+ * @returns {*} The result returned by {@code next(action)}.
  */
-function _maybeStoreCurrentConference({ dispatch, getState }, { room }) {
-    if (room) {
-        const { locationURL } = getState()['features/base/connection'];
+function _appWillMount({ dispatch, getState }, next, action) {
+    const result = next(action);
+
+    // It's an opportune time to transfer the feature recent-list's knowledge
+    // about "known domains" (which is local to the feature) to the feature
+    // base/known-domains (which is global to the app).
+    //
+    // XXX Since the feature recent-list predates the feature calendar-sync and,
+    // consequently, the feature known-domains, it's possible for the feature
+    // known-list to know of domains which the feature known-domains is yet to
+    // discover.
+    const knownDomains = [];
 
-        dispatch(storeCurrentConference(locationURL));
+    for (const { conference } of getState()['features/recent-list']) {
+        const uri = parseURIString(conference);
+        let host;
+
+        uri && (host = uri.host) && knownDomains.push(host);
     }
+    knownDomains.length && dispatch(addKnownDomains(knownDomains));
+
+    return result;
 }
 
 /**
  * Updates the duration of the last conference stored in the list.
  *
  * @param {Store} store - The redux store.
+ * @param {Dispatch} next - The redux {@code dispatch} function.
+ * @param {Action} action - The redux action {@link CONFERENCE_WILL_LEAVE}.
  * @private
- * @returns {void}
+ * @returns {*} The result returned by {@code next(action)}.
  */
-function _updateConferenceDuration({ dispatch, getState }) {
-    const { locationURL } = getState()['features/base/connection'];
+function _conferenceWillLeave({ dispatch, getState }, next, action) {
+    dispatch(
+        _updateConferenceDuration(
+            getState()['features/base/connection'].locationURL));
 
-    dispatch(updateConferenceDuration(locationURL));
+    return next(action);
+}
+
+/**
+ * Checks if there is a current conference (upon SET_ROOM action), and saves it
+ * if necessary.
+ *
+ * @param {Store} store - The redux store.
+ * @param {Dispatch} next - The redux {@code dispatch} function.
+ * @param {Action} action - The redux action {@link SET_ROOM}.
+ * @private
+ * @returns {*} The result returned by {@code next(action)}.
+ */
+function _setRoom({ dispatch, getState }, next, action) {
+    if (action.room) {
+        const { locationURL } = getState()['features/base/connection'];
+
+        if (locationURL) {
+            dispatch(_storeCurrentConference(locationURL));
+
+            // Whatever domain the feature recent-list knows about, the app as a
+            // whole should know about.
+            //
+            // XXX Technically, _storeCurrentConference could be turned into an
+            // asynchronous action creator which dispatches both
+            // _STORE_CURRENT_CONFERENCE and addKnownDomains but...
+            dispatch(addKnownDomains(locationURL.host));
+        }
+    }
+
+    return next(action);
 }

react/features/recent-list/reducer.js

 import { PersistenceRegistry } from '../base/storage';
 
 import {
-    STORE_CURRENT_CONFERENCE,
-    UPDATE_CONFERENCE_DURATION
+    _STORE_CURRENT_CONFERENCE,
+    _UPDATE_CONFERENCE_DURATION
 } from './actionTypes';
 
 const logger = require('jitsi-meet-logger').getLogger(__filename);
         case APP_WILL_MOUNT:
             return _appWillMount(state);
 
-        case STORE_CURRENT_CONFERENCE:
+        case _STORE_CURRENT_CONFERENCE:
             return _storeCurrentConference(state, action);
 
-        case UPDATE_CONFERENCE_DURATION:
+        case _UPDATE_CONFERENCE_DURATION:
             return _updateConferenceDuration(state, action);
 
         default: