ref: use getCurrentConference

Try to use the getCurrentConference function wherever the indention is
to check for the current conference.

react/features/base/conference/actions.js

 } from './constants';
 import {
     _addLocalTracksToConference,
+    getCurrentConference,
     sendLocalParticipant
 } from './functions';
 
 export function setStartMutedPolicy(
         startAudioMuted: boolean, startVideoMuted: boolean) {
     return (dispatch: Dispatch<*>, getState: Function) => {
-        const { conference } = getState()['features/base/conference'];
+        const conference = getCurrentConference(getState());
 
-        conference.setStartMutedPolicy({
+        conference && conference.setStartMutedPolicy({
             audio: startAudioMuted,
             video: startVideoMuted
         });

react/features/base/connection/actions.native.js

 import _ from 'lodash';
 import type { Dispatch } from 'redux';
 
-import { conferenceLeft, conferenceWillLeave } from '../conference';
+import {
+    conferenceLeft,
+    conferenceWillLeave,
+    getCurrentConference
+} from '../conference';
 import JitsiMeetJS, { JitsiConnectionEvents } from '../lib-jitsi-meet';
 import { parseStandardURIString } from '../util';
 
 export function disconnect() {
     return (dispatch: Dispatch<*>, getState: Function): Promise<void> => {
         const state = getState();
-        const { conference, joining } = state['features/base/conference'];
 
         // The conference we have already joined or are joining.
-        const conference_ = conference || joining;
+        const conference_ = getCurrentConference(state);
 
         // Promise which completes when the conference has been left and the
         // connection has been disconnected.

react/features/base/participants/middleware.js

 // @flow
 
 import { APP_WILL_MOUNT, APP_WILL_UNMOUNT } from '../../app';
-import { CONFERENCE_WILL_JOIN, forEachConference } from '../conference';
+import {
+    CONFERENCE_WILL_JOIN,
+    forEachConference,
+    getCurrentConference
+} from '../conference';
 import { CALLING, INVITED } from '../../presence-status';
 import { MiddlewareRegistry, StateListenerRegistry } from '../redux';
 import UIEvents from '../../../../service/UI/UIEvents';
  * with multiplying thumbnails in the filmstrip.
  */
 StateListenerRegistry.register(
-    /* selector */ state => {
-        const { conference, joining } = state['features/base/conference'];
-
-        return conference || joining;
-    },
+    /* selector */ state => getCurrentConference(state),
     /* listener */ (conference, { dispatch, getState }) => {
         for (const p of getState()['features/base/participants']) {
             !p.local

react/features/mobile/full-screen/middleware.js

     CONFERENCE_JOINED,
     CONFERENCE_LEFT,
     CONFERENCE_WILL_JOIN,
-    SET_AUDIO_ONLY
+    SET_AUDIO_ONLY,
+    getCurrentConference
 } from '../../base/conference';
 import { Platform } from '../../base/react';
 import { MiddlewareRegistry } from '../../base/redux';
     case CONFERENCE_JOINED:
     case SET_AUDIO_ONLY: {
         const result = next(action);
-        const { audioOnly, conference, joining }
-            = store.getState()['features/base/conference'];
+        const { audioOnly } = store.getState()['features/base/conference'];
+        const conference = getCurrentConference(store);
 
-        _setFullScreen(conference || joining ? !audioOnly : false);
+        _setFullScreen(conference ? !audioOnly : false);
 
         return result;
     }
     const { appState } = state['features/background'];
 
     if (appState === 'active') {
-        const { audioOnly, conference, joining }
-            = state['features/base/conference'];
-        const fullScreen = conference || joining ? !audioOnly : false;
+        const { audioOnly } = state['features/base/conference'];
+        const conference = getCurrentConference(state);
+        const fullScreen = conference ? !audioOnly : false;
 
         _setFullScreen(fullScreen);
     }