[RN] Keep track of ongoing network requests

Works only for XHR requests, which is the only network request mobile performs
(WebRTC traffic aside). The fetch API is implemented on top of XHR, so that's
covered too.

Requests are kept in the redux store until they complete, at which point they
are removed.

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

 import '../../mobile/background';
 import '../../mobile/external-api';
 import '../../mobile/full-screen';
+import '../../mobile/net-interceptor';
 import '../../mobile/permissions';
 import '../../mobile/proximity';
 import '../../mobile/wake-lock';

react/features/mobile/net-interceptor/actionTypes.js

+/**
+ * The type of redux action to update the pending network requests mapping.
+ *
+ * {
+ *     type: UPDATE_NETWORK_REQUESTS,
+ *     requests: Object
+ * }
+ *
+ * @protected
+ */
+export const UPDATE_NETWORK_REQUESTS = Symbol('UPDATE_NETWORK_REQUESTS');

react/features/mobile/net-interceptor/functions.js

+import _ from 'lodash';
+import XHRInterceptor from 'react-native/Libraries/Network/XHRInterceptor';
+
+import { UPDATE_NETWORK_REQUESTS } from './actionTypes';
+
+/**
+ * Global index for keeping track of XHR requests.
+ * @type {number}
+ */
+let reqIndex = 0;
+
+/**
+ * Starts intercepting network requests. Only XHR requests are supported at the
+ * moment.
+ *
+ * Ongoing request information is kept in redux, and it's removed as soon as a
+ * given request is complete.
+ *
+ * @param {Object} store - The redux store.
+ * @returns {void}
+ */
+export function startNetInterception({ dispatch, getState }) {
+    XHRInterceptor.setOpenCallback((method, url, xhr) => {
+        xhr._reqIndex = reqIndex++;
+
+        const requests = getState()['features/net-interceptor'].requests || {};
+        const newRequests = _.cloneDeep(requests);
+        const request = {
+            method,
+            url
+        };
+
+        newRequests[xhr._reqIndex] = request;
+
+        dispatch({
+            type: UPDATE_NETWORK_REQUESTS,
+            requests: newRequests
+        });
+    });
+
+    XHRInterceptor.setResponseCallback((...args) => {
+        const xhr = args.slice(-1)[0];
+
+        if (typeof xhr._reqIndex === 'undefined') {
+            return;
+        }
+
+        const requests = getState()['features/net-interceptor'].requests || {};
+        const newRequests = _.cloneDeep(requests);
+
+        delete newRequests[xhr._reqIndex];
+
+        dispatch({
+            type: UPDATE_NETWORK_REQUESTS,
+            requests: newRequests
+        });
+    });
+
+    XHRInterceptor.enableInterception();
+}
+
+/**
+ * Stops intercepting network requests.
+ *
+ * @param {Object} store - The redux store.
+ * @returns {void}
+ */
+export function stopNetInterception({ dispatch }) {
+    XHRInterceptor.disableInterception();
+
+    dispatch({
+        type: UPDATE_NETWORK_REQUESTS,
+        requests: {}
+    });
+}

react/features/mobile/net-interceptor/index.js

+import './middleware';
+import './reducer';

react/features/mobile/net-interceptor/middleware.js

+import { APP_WILL_MOUNT, APP_WILL_UNMOUNT } from '../../app';
+import { MiddlewareRegistry } from '../../base/redux';
+
+import { startNetInterception, stopNetInterception } from './functions';
+
+/**
+ * Middleware which captures app startup and conference actions in order to
+ * clear the image cache.
+ *
+ * @returns {Function}
+ */
+MiddlewareRegistry.register(store => next => action => {
+    const result = next(action);
+
+    switch (action.type) {
+    case APP_WILL_MOUNT:
+        startNetInterception(store);
+        break;
+    case APP_WILL_UNMOUNT:
+        stopNetInterception(store);
+        break;
+    }
+
+    return result;
+});

react/features/mobile/net-interceptor/reducer.js

+import { ReducerRegistry } from '../../base/redux';
+
+import { UPDATE_NETWORK_REQUESTS } from './actionTypes';
+
+ReducerRegistry.register('features/net-interceptor', (state = {}, action) => {
+    switch (action.type) {
+    case UPDATE_NETWORK_REQUESTS:
+        return {
+            ...state,
+            requests: action.requests
+        };
+    }
+
+    return state;
+});