Convert a function to an asynchronous redux action creator

react/features/base/media/middleware.js

  * @private
  * @returns {void}
  */
-function _syncTrackMutedState(store, track) {
-    const state = store.getState()['features/base/media'];
+function _syncTrackMutedState({ dispatch, getState }, track) {
+    const state = getState()['features/base/media'];
     const muted = state[track.mediaType].muted;
 
     // XXX If muted state of track when it was added is different from our media
     // fired before track gets to state.
     if (track.muted !== muted) {
         track.muted = muted;
-        setTrackMuted(track.jitsiTrack, muted, store);
+        dispatch(setTrackMuted(track.jitsiTrack, muted));
     }
 }

react/features/base/tracks/actions.js

     };
 }
 
+/**
+ * Mutes or unmutes a specific <tt>JitsiLocalTrack</tt>. If the muted state of
+ * the specified <tt>track</tt> is already in accord with the specified
+ * <tt>muted</tt> value, then does nothing. In case the actual muting/unmuting
+ * fails, a rollback action will be dispatched to undo the muting/unmuting.
+ *
+ * @param {JitsiLocalTrack} track - The <tt>JitsiLocalTrack</tt> to mute or
+ * unmute.
+ * @param {boolean} muted - If the specified <tt>track</tt> is to be muted, then
+ * <tt>true</tt>; otherwise, <tt>false</tt>.
+ * @returns {Function}
+ */
+export function setTrackMuted(track, muted) {
+    return dispatch => {
+        if (track.isMuted() === muted) {
+            return Promise.resolve();
+        }
+
+        const f = muted ? 'mute' : 'unmute';
+
+        return track[f]().catch(error => {
+            console.error(`set track ${f} failed`, error);
+
+            const setMuted
+                = track.mediaType === MEDIA_TYPE.AUDIO
+                    ? setAudioMuted
+                    : setVideoMuted;
+
+            dispatch(setMuted(!muted));
+        });
+    };
+}
+
 /**
  * Returns true if the provided JitsiTrack should be rendered as a mirror.
  *

react/features/base/tracks/functions.js

 /* global APP */
 
 import JitsiMeetJS, { JitsiTrackEvents } from '../lib-jitsi-meet';
-import { MEDIA_TYPE, setAudioMuted, setVideoMuted } from '../media';
+import { MEDIA_TYPE } from '../media';
 
 const logger = require('jitsi-meet-logger').getLogger(__filename);
 
 export function getTracksByMediaType(tracks, mediaType) {
     return tracks.filter(t => t.mediaType === mediaType);
 }
-
-/**
- * Mutes or unmutes a specific <tt>JitsiLocalTrack</tt>. If the muted state of
- * the specified <tt>track</tt> is already in accord with the specified
- * <tt>muted</tt> value, then does nothing. In case mute/unmute operation fails
- * (JitsiLocalTrack Promise is rejected) a rollback action will be dispatched on
- * the given store. For example if the mute operation fails then the 'unmute'
- * action will be dispatched to rollback to the previous state in base/media.
- *
- * @param {JitsiLocalTrack} track - The <tt>JitsiLocalTrack</tt> to mute or
- * unmute.
- * @param {boolean} muted - If the specified <tt>track</tt> is to be muted, then
- * <tt>true</tt>; otherwise, <tt>false</tt>.
- * @param {Store} store - The redux store in the context of which the function
- * is to execute and which will be used to dispatch the rollback action in case
- * mute/unmute fails.
-* @returns {Promise}
- */
-export function setTrackMuted(track, muted, { dispatch }) {
-    if (track.isMuted() === muted) {
-        return Promise.resolve();
-    }
-
-    const f = muted ? 'mute' : 'unmute';
-
-    return track[f]().catch(error => {
-        console.error(`set track ${f} failed`, error);
-
-        const setMuted
-            = track.mediaType === MEDIA_TYPE.AUDIO
-                ? setAudioMuted
-                : setVideoMuted;
-
-        dispatch(setMuted(!muted));
-    });
-}

react/features/base/tracks/middleware.js

 } from '../media';
 import { MiddlewareRegistry } from '../redux';
 
+import { setTrackMuted } from './actions';
 import { TRACK_ADDED, TRACK_REMOVED, TRACK_UPDATED } from './actionTypes';
-import { getLocalTrack, setTrackMuted } from './functions';
+import { getLocalTrack } from './functions';
 
 declare var APP: Object;
 
  * respectively, creates/destroys local media tracks. Also listens to
  * media-related actions and performs corresponding operations with tracks.
  *
- * @param {Store} store - Redux store.
+ * @param {Store} store - The redux store.
  * @returns {Function}
  */
 MiddlewareRegistry.register(store => next => action => {
 
 /**
  * Gets the local track associated with a specific <tt>MEDIA_TYPE</tt> in a
- * specific Redux store.
+ * specific redux store.
  *
- * @param {Store} store - The Redux store from which the local track associated
+ * @param {Store} store - The redux store from which the local track associated
  * with the specified <tt>mediaType</tt> is to be retrieved.
  * @param {MEDIA_TYPE} mediaType - The <tt>MEDIA_TYPE</tt> of the local track to
  * be retrieved from the specified <tt>store</tt>.
 /**
  * Mutes or unmutes a local track with a specific media type.
  *
- * @param {Store} store - The Redux store in which the specified action is
+ * @param {Store} store - The redux store in which the specified action is
  * dispatched.
- * @param {Action} action - The Redux action dispatched in the specified store.
+ * @param {Action} action - The redux action dispatched in the specified store.
  * @param {MEDIA_TYPE} mediaType - The {@link MEDIA_TYPE} of the local track
  * which is being muted or unmuted.
  * @private
  * @returns {void}
  */
-function _setMuted(store, action, mediaType: MEDIA_TYPE) {
+function _setMuted(store, { muted }, mediaType: MEDIA_TYPE) {
     const localTrack = _getLocalTrack(store, mediaType);
 
-    if (localTrack) {
-        setTrackMuted(localTrack.jitsiTrack, action.muted, store);
-    }
+    localTrack && store.dispatch(setTrackMuted(localTrack.jitsiTrack, muted));
 }
 
 /**
  * muted states of the local tracks of features/base/tracks with the muted
  * states of features/base/media.
  *
- * @param {Store} store - The Redux store in which the specified <tt>action</tt>
+ * @param {Store} store - The redux store in which the specified <tt>action</tt>
  * is being dispatched.
- * @param {Dispatch} next - The Redux dispatch function to dispatch the
+ * @param {Dispatch} next - The redux dispatch function to dispatch the
  * specified <tt>action</tt> to the specified <tt>store</tt>.
- * @param {Action} action - The Redux action <tt>TRACK_UPDATED</tt> which is
+ * @param {Action} action - The redux action <tt>TRACK_UPDATED</tt> which is
  * being dispatched in the specified <tt>store</tt>.
  * @private
  * @returns {Object} The new state that is the result of the reduction of the