[RN] Try to create local tracks when unmuting, if track is missing

This is only desired when the unmuting action took place due to a manual user
intervention or the audio-only mode being disengaged.

react/features/base/conference/middleware.js

     dispatch(setLastN(audioOnly ? 0 : undefined));
 
     // Mute/unmute the local video.
-    dispatch(setVideoMuted(audioOnly, VIDEO_MUTISM_AUTHORITY.AUDIO_ONLY));
+    dispatch(
+        setVideoMuted(
+            audioOnly,
+            VIDEO_MUTISM_AUTHORITY.AUDIO_ONLY,
+            /* ensureTrack */ true));
 
     if (typeof APP !== 'undefined') {
         // TODO This should be a temporary solution that lasts only until

react/features/base/media/actions.js

  *
  * @param {boolean} muted - True if the local audio is to be muted or false if
  * the local audio is to be unmuted.
+ * @param {boolean} ensureTrack - True if we want to ensure that a new track is
+ * created if missing.
  * @returns {{
  *     type: SET_AUDIO_MUTED,
+ *     ensureTrack: boolean,
  *     muted: boolean
  * }}
  */
-export function setAudioMuted(muted: boolean) {
+export function setAudioMuted(muted: boolean, ensureTrack: boolean = false) {
     return {
         type: SET_AUDIO_MUTED,
+        ensureTrack,
         muted
     };
 }
  * the local video is to be unmuted.
  * @param {number} authority - The {@link VIDEO_MUTISM_AUTHORITY} which is
  * muting/unmuting the local video.
+ * @param {boolean} ensureTrack - True if we want to ensure that a new track is
+ * created if missing.
  * @returns {Function}
  */
 export function setVideoMuted(
         muted: boolean,
-        authority: number = VIDEO_MUTISM_AUTHORITY.USER) {
+        authority: number = VIDEO_MUTISM_AUTHORITY.USER,
+        ensureTrack: boolean = false) {
     return (dispatch: Dispatch<*>, getState: Function) => {
         const oldValue = getState()['features/base/media'].video.muted;
 
 
         return dispatch({
             type: SET_VIDEO_MUTED,
+            ensureTrack,
             muted: newValue
         });
     };

react/features/base/tracks/middleware.js

 } from '../media';
 import { MiddlewareRegistry } from '../redux';
 
+import { createLocalTracksA } from './actions';
 import { TRACK_ADDED, TRACK_REMOVED, TRACK_UPDATED } from './actionTypes';
 import { getLocalTrack, setTrackMuted } from './functions';
 
  * @private
  * @returns {void}
  */
-function _setMuted(store, { muted }, mediaType: MEDIA_TYPE) {
+function _setMuted(store, { ensureTrack, muted }, mediaType: MEDIA_TYPE) {
     const localTrack = _getLocalTrack(store, mediaType);
 
-    localTrack && setTrackMuted(localTrack.jitsiTrack, muted);
+    if (localTrack) {
+        setTrackMuted(localTrack.jitsiTrack, muted);
+    } else if (!muted && ensureTrack && typeof APP === 'undefined') {
+        // FIXME: This only runs on mobile now because web has its own way of
+        // creating local tracks. Adjust the check once they are unified.
+        store.dispatch(createLocalTracksA({ devices: [ mediaType ] }));
+    }
 }

react/features/toolbox/components/Toolbox.native.js

     MEDIA_TYPE,
     setAudioMuted,
     setVideoMuted,
-    toggleCameraFacingMode
+    toggleCameraFacingMode,
+    VIDEO_MUTISM_AUTHORITY
 } from '../../base/media';
 import { Container } from '../../base/react';
 import { ColorPalette } from '../../base/styles';
         // sets the state of base/media. Whether the user's intention will turn
         // into reality is a whole different story which is of no concern to the
         // tapping.
-        this.props.dispatch(setAudioMuted(!this.props._audioMuted));
+        this.props.dispatch(
+            setAudioMuted(
+                !this.props._audioMuted,
+                VIDEO_MUTISM_AUTHORITY.USER,
+                /* ensureTrack */ true));
     }
 
     /**
         // sets the state of base/media. Whether the user's intention will turn
         // into reality is a whole different story which is of no concern to the
         // tapping.
-        this.props.dispatch(setVideoMuted(!this.props._videoMuted));
+        this.props.dispatch(
+            setVideoMuted(
+                !this.props._videoMuted,
+                VIDEO_MUTISM_AUTHORITY.USER,
+                /* ensureTrack */ true));
     }
 
     /**