diff --git a/app/app.js b/app/app.js
index bf565ad..bc10fcc 100644
--- a/app/app.js
+++ b/app/app.js
@@ -1,2750 +1,2729 @@
 import React, { Component, Fragment } from 'react';
 import { Alert, View, SafeAreaView, ImageBackground, AppState, Linking, Platform, StyleSheet, Vibration, PermissionsAndroid} from 'react-native';
 import { DeviceEventEmitter } from 'react-native';
 import { Provider as PaperProvider, DefaultTheme } from 'react-native-paper';
 import { registerGlobals } from 'react-native-webrtc';
 import { Router, Route, Link, Switch } from 'react-router-native';
 import history from './history';
 import Logger from "../Logger";
 import autoBind from 'auto-bind';
 import { firebase } from '@react-native-firebase/messaging';
 import VoipPushNotification from 'react-native-voip-push-notification';
 import uuid from 'react-native-uuid';
 import { getUniqueId, getBundleId, isTablet, getPhoneNumber} from 'react-native-device-info';
 import RNDrawOverlay from 'react-native-draw-overlay';
 import PushNotificationIOS from "@react-native-community/push-notification-ios";
 import Contacts from 'react-native-contacts';
 import BackgroundTimer from 'react-native-background-timer';
 import DeepLinking from 'react-native-deep-linking'
 
 registerGlobals();
 
 import * as sylkrtc from 'react-native-sylkrtc';
 import InCallManager from 'react-native-incall-manager';
 import RNCallKeep, { CONSTANTS as CK_CONSTANTS } from 'react-native-callkeep';
 
 import RegisterBox from './components/RegisterBox';
 import ReadyBox from './components/ReadyBox';
 import Call from './components/Call';
 import Conference from './components/Conference';
 import FooterBox from './components/FooterBox';
 import StatusBox from './components/StatusBox';
 import IncomingCallModal from './components/IncomingCallModal';
 import NotificationCenter from './components/NotificationCenter';
 import LoadingScreen from './components/LoadingScreen';
 import NavigationBar from './components/NavigationBar';
 import Preview from './components/Preview';
 import CallManager from "./CallManager";
 
 import utils from './utils';
 import config from './config';
 import storage from './storage';
 
 import styles from './assets/styles/blink/root.scss';
 const backgroundImage = require('./assets/images/dark_linen.png');
 
 const logger = new Logger("App");
 
 function checkIosPermissions() {
     return new Promise(resolve => PushNotificationIOS.checkPermissions(resolve));
   }
 
 const theme = {
     ...DefaultTheme,
     dark: true,
     roundness: 2,
     colors: {
         ...DefaultTheme.colors,
        primary: '#337ab7',
     //   accent: '#f1c40f',
     },
 };
 
 const URL_SCHEMES = [
   'sylk://',
 ];
 
 const ONE_SECOND_IN_MS = 1000;
 
 const VIBRATION_PATTERN = [
     1 * ONE_SECOND_IN_MS,
     1 * ONE_SECOND_IN_MS,
     4 * ONE_SECOND_IN_MS
   ];
 
 
 let bundleId = `${getBundleId()}`;
 const deviceId = getUniqueId();
 
 const version = '1.0.0';
 
 
 if (Platform.OS == 'ios') {
     bundleId = `${bundleId}.${__DEV__ ? 'dev' : 'prod'}`;
     //bundleId = 'com.agprojects.sylk-ios.dev';
 }
 
 const mainStyle = StyleSheet.create({
 
  MainContainer: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
    margin: 0
  }
 });
 
 
 (function() {
     if ( typeof Object.id == "undefined" ) {
         var id = 0;
 
         Object.id = function(o) {
             if ( o && typeof o.__uniqueid == "undefined" ) {
                 Object.defineProperty(o, "__uniqueid", {
                     value: ++id,
                     enumerable: false,
                     // This could go either way, depending on your
                     // interpretation of what an "id" is
                     writable: false
                 });
             }
 
             return o ? o.__uniqueid : null;
         };
     }
 })();
 
 const requestCameraPermission = async () => {
     if (Platform.OS !== 'android') {
         return;
     }
 
     try {
         const granted = await PermissionsAndroid.request(
         PermissionsAndroid.PERMISSIONS.CAMERA,
             {
             title: "Sylk camera permission",
             message:
               "Sylk needs access to your camera " +
               "so you can have video chat.",
             buttonNeutral: "Ask Me Later",
             buttonNegative: "Cancel",
             buttonPositive: "OK"
             }
         );
         if (granted === PermissionsAndroid.RESULTS.GRANTED) {
             //console.log("You can use the camera");
         } else {
             console.log("Camera permission denied");
         }
     } catch (err) {
         console.warn(err);
     }
 
     try {
         const granted = await PermissionsAndroid.request(
           PermissionsAndroid.PERMISSIONS.RECORD_AUDIO,
           {
             title: "Sylk microphone permission",
             message:
               "Sylk needs access to your microphone " +
               "so you can have audio calls.",
             buttonNeutral: "Ask Me Later",
             buttonNegative: "Cancel",
             buttonPositive: "OK"
           }
         );
         if (granted === PermissionsAndroid.RESULTS.GRANTED) {
             //console.log("You can use the microphone");
         } else {
             console.log("Microphone permission denied");
         }
     } catch (err) {
         console.warn(err);
     }
 };
 
 
 class Sylk extends Component {
     constructor() {
         super();
         autoBind(this)
         this._loaded = false;
         this._initialState = {
             appState: null,
             autoLogin: true,
             inFocus: false,
             accountId: '',
             password: '',
             displayName: '',
             account: null,
             registrationState: null,
             registrationKeepalive: false,
             incomingCall: null,
             currentCall: null,
             connection: null,
             showIncomingModal: false,
             showScreenSharingModal: false,
             status: null,
             targetUri: '',
             missedTargetUri: '',
             loading: null,
             localMedia: null,
             generatedVideoTrack: false,
             contacts: [],
             devices: {},
             speakerPhoneEnabled: null,
             orientation : 'portrait',
             Height_Layout : '',
             Width_Layout : '',
             outgoingCallUUID: null,
             incomingCallUUID: null,
             outgoingMedia: null,
             hardware: '',
             phoneNumber: '',
             isTablet: isTablet(),
             refreshHistory: false,
             myDisplayName: null,
             myPhoneNumber: null,
             localHistory: [],
             favoriteUris: [],
             blockedUris: [],
             initialUrl: null,
             reconnectingCall: false,
             muted: false,
             participantsToInvite: null,
             myInvitedParties: null,
-            defaultDomain: config.defaultDomain,
+            defaultDomain: config.defaultDomain
         };
 
         this.tokenSent = false;
         this.mustLogout = false;
         this.currentRoute = null;
         this.pushtoken = null;
         this.pushkittoken = null;
         this.intercomDtmfTone = null;
         this.registrationFailureTimer = null;
         this.contacts = [];
         this.startedByPush = false;
 
         this.cachedHistory = []; // used for caching server history
 
         this.state = Object.assign({}, this._initialState);
 
         this.myParticipants = {};
 
         this._historyConferenceParticipants = new Map(); // for saving to local history
 
         this._terminatedCalls = new Map();
 
         this.__notificationCenter = null;
 
         this.redirectTo = null;
         this.prevPath = null;
         this.shouldUseHashRouting = false;
         this.goToReadyTimer = null;
         storage.initialize();
 
         this.callKeeper = new CallManager(RNCallKeep,
                                                 this.acceptCall,
                                                 this.rejectCall,
                                                 this.hangupCall,
                                                 this.timeoutCall,
                                                 this.callKeepStartConference,
                                                 this.startCallFromCallKeeper,
                                                 this.toggleMute,
                                                 this.getConnection,
                                                 this.addConferenceHistoryEntry,
                                                 this.changeRoute,
                                                 this.respawnConnection
                                                 );
 
         if (InCallManager.recordPermission !== 'granted') {
             InCallManager.requestRecordPermission()
             .then((requestedRecordPermissionResult) => {
                 //console.log("InCallManager.requestRecordPermission() requestedRecordPermissionResult: ", requestedRecordPermissionResult);
             })
             .catch((err) => {
                 //console.log("InCallManager.requestRecordPermission() catch: ", err);
             });
         }
 
         requestCameraPermission();
 
         // Load camera/mic preferences
         storage.get('devices').then((devices) => {
             if (devices) {
                 this.setState({devices: devices});
             }
         });
 
         storage.get('history').then((history) => {
             if (history) {
                 //console.log('Loaded', history.length, 'local history entries');
                 this.setState({localHistory: history});
             } else {
                 //console.log('Loaded 0 local history entries');
             }
         });
 
         storage.get('cachedHistory').then((history) => {
             if (history) {
                 //console.log('Loaded', history.length, 'cached history entries');
                 this.cachedHistory = history;
             }
         });
 
         storage.get('myParticipants').then((myParticipants) => {
             if (myParticipants) {
                 this.myParticipants = myParticipants;
                 //console.log('My participants', this.myParticipants);
             }
         });
 
         storage.get('myInvitedParties').then((myInvitedParties) => {
             if (myInvitedParties) {
                 if (Array.isArray(myInvitedParties)) {
                     myInvitedParties = null;
                 }
                 this.myInvitedParties = myInvitedParties;
                 //console.log('My invited parties', this.myInvitedParties);
                 this.setState({myInvitedParties: this.myInvitedParties});
             }
         });
 
         storage.get('favoriteUris').then((favoriteUris) => {
             if (favoriteUris) {
                 this.setState({favoriteUris: favoriteUris});
             }
         });
 
         storage.get('blockedUris').then((blockedUris) => {
             if (blockedUris) {
                 this.setState({blockedUris: blockedUris});
                 //console.log('My blocked Uris', blockedUris);
             }
         });
 
         for (let scheme of URL_SCHEMES) {
             DeepLinking.addScheme(scheme);
         }
 
    }
 
     async loadContacts() {
         Contacts.checkPermission((err, permission) => {
             if (permission === Contacts.PERMISSION_UNDEFINED) {
               Contacts.requestPermission((err, requestedContactsPermissionResult) => {
                 if (err) {
                     console.log("Contacts.requestPermission()catch: ", err);
                 }
                 console.log("Contacts.requestPermission() requestPermission: ", requestedContactsPermissionResult);
               })
             }
           })
 
           Contacts.getAll((err, contacts) => {
             if (err === 'denied'){
                 console.log('Access to contacts denied')
             } else {
                 // contacts returned in Array
                 let contact_cards = [];
                 let name;
                 let photo;
 
                 let seen_uris = new Map();
 
                 var arrayLength = contacts.length;
                 for (var i = 0; i < arrayLength; i++) {
                     photo = null;
                     contact = contacts[i];
                     if (contact['givenName'] && contact['familyName']) {
                         name = contact['givenName'] + ' ' + contact['familyName'];
                     } else if (contact['givenName']) {
                         name = contact['givenName'];
                     } else if (contact['familyName']) {
                         name = contact['familyName'];
                     } else if (contact['company']) {
                         name = contact['company'];
                     } else {
                         continue;
                     }
 
                     if (contact.hasThumbnail) {
                         photo = contact.thumbnailPath;
                     }
 
                     //console.log(name);
                     contact['phoneNumbers'].forEach(function (number, index) {
                         let number_stripped =  number['number'].replace(/\s|\-|\(|\)/g, '');
                         if (number_stripped) {
                             if (!seen_uris.has(number_stripped)) {
                                 //console.log('   ---->    ', number['label'], number_stripped);
                                 var contact_card = {id: uuid.v4(), displayName:
                                                     name, remoteParty: number_stripped,
                                                     type: 'contact',
                                                     photo: photo,
                                                     label: number['label'],
                                                     tags: ['contact']};
                                 contact_cards.push(contact_card);
                                 seen_uris.set(number_stripped, true);
                                 var contact_card = {id: uuid.v4(),
                                                     displayName: name,
                                                     remoteParty: number_stripped,
                                                     type: 'contact',
                                                     photo: photo,
                                                     label: number['label'],
                                                     tags: ['contact']
                                                     };
                             }
                         }
                     });
 
                     contact['emailAddresses'].forEach(function (email, index) {
                         let email_stripped =  email['email'].replace(/\s|\(|\)/g, '');
                         if (!seen_uris.has(email_stripped)) {
                             //console.log(name, email['label'], email_stripped);
                             //console.log('   ---->    ', email['label'], email_stripped);
                             var contact_card = {id: uuid.v4(),
                                                 displayName: name,
                                                 remoteParty: email_stripped,
                                                 type: 'contact',
                                                 photo: photo,
                                                 label: email['label'],
                                                 tags: ['contact']
                                                 };
                             contact_cards.push(contact_card);
                             seen_uris.set(email_stripped, true);
                         }
                     });
                 }
 
               this.contacts = contact_cards;
 
               if (this.state.myPhoneNumber) {
                   var myContact = this.findObjectByKey(contact_cards, 'remoteParty', this.state.myPhoneNumber);
                   if (myContact) {
                       this.setState({myDisplayName: myContact.displayName});
                   }
               }
             }
           })
     }
 
     get _notificationCenter() {
         // getter to lazy-load the NotificationCenter ref
         if (!this.__notificationCenter) {
             this.__notificationCenter = this.refs.notificationCenter;
         }
         return this.__notificationCenter;
     }
 
     findObjectByKey(array, key, value) {
         for (var i = 0; i < array.length; i++) {
             if (array[i][key] === value) {
                 return array[i];
             }
         }
         return null;
     }
 
     _detectOrientation() {
         if(this.state.Width_Layout > this.state.Height_Layout && this.state.orientation !== 'landscape') {
             this.setState({orientation: 'landscape'});
         } else {
             this.setState({orientation: 'portrait'});
         }
      }
 
     changeRoute(route, reason) {
         if (this.currentRoute === route) {
             return;
         }
 
         if (this.currentRoute !== route) {
             utils.timestampedLog('Change route:', this.currentRoute, '->', route, reason);
         }
 
         if (route === '/ready') {
             this.startedByPush = false;
             this.setState({
                             outgoingMedia: null,
                             outgoingCallUUID: null,
                             currentCall: null,
                             incomingCall: (reason === 'accept_new_call' || reason === 'user_press_hangup') ? this.state.incomingCall: null,
                             targetUri: '',
                             reconnectingCall: false,
                             localMedia: null,
                             muted: false,
                             participantsToInvite: null
                             });
 
             if (this.currentRoute === '/call' || this.currentRoute === '/conference') {
                 if (reason !== 'user_press_hangup') {
                     this.stopRingback();
                     InCallManager.stop();
                 }
 
                 if (reason !== 'accept_new_call') {
                     this.closeLocalMedia();
                 }
 
                 if (this.state.account && reason !== 'accept_new_call' && this._loaded) {
                     setTimeout(() => {
                         this.updateServerHistory()
                     }, 1500);
                 }
             }
 
             if (reason === 'registered') {
                 setTimeout(() => {
                     this.updateServerHistory()
                 }, 1500);
             }
 
             if (reason === 'no_more_calls') {
                 this.updateServerHistory()
             }
         }
 
         this.currentRoute = route;
         history.push(route);
 
     }
 
     componentWillUnmount() {
         //console.log('App will unmount');
         AppState.removeEventListener('change', this._handleAppStateChange);
         this._loaded = false;
     }
 
     async componentDidMount() {
         this._loaded = true;
         //console.log('App did mount');
         // Start a timer that runs once after X milliseconds
         BackgroundTimer.runBackgroundTimer(() => {
             // this will be executed once after 10 seconds
             // even when app is the the background
             this.heartbeat();
         }, 5000);
 
         try {
             await RNCallKeep.supportConnectionService ();
             utils.timestampedLog('Connection service is enabled');
         } catch(err) {
             utils.timestampedLog(err);
         }
 
         try {
             await RNCallKeep.hasPhoneAccount();
             utils.timestampedLog('Phone account is enabled');
         } catch(err) {
             utils.timestampedLog(err);
         }
 
         if (Platform.OS === 'android') {
             RNDrawOverlay.askForDispalayOverOtherAppsPermission()
                  .then(res => {
                    //utils.timestampedLog("Display over other apps was granted");
                      // res will be true if permission was granted
                  })
                  .catch(e => {
                    utils.timestampedLog("Display over other apps was declined");
                      // permission was declined
                  })
         }
 
         // prime the ref
         //logger.debug('NotificationCenter ref: %o', this._notificationCenter);
 
         this._boundOnPushkitRegistered = this._onPushkitRegistered.bind(this);
         this._boundOnPushRegistered = this._onPushRegistered.bind(this);
 
         this._detectOrientation();
 
         getPhoneNumber().then(phoneNumber => {
             this.setState({myPhoneNumber: phoneNumber});
             this.loadContacts();
         });
 
         this.listenforPushNotifications();
     }
 
     listenforPushNotifications() {
         if (this.state.appState === null) {
             this.setState({appState: 'active'});
         } else {
             return;
         }
 
         utils.timestampedLog('---- Add notifications listeners');
 
         if (Platform.OS === 'android') {
             Linking.getInitialURL().then((url) => {
                 if (url) {
                      utils.timestampedLog('Initial external URL: ' + url);
                      this.eventFromUrl(url);
                       this.changeRoute('/login', 'start up');
                } else {
                       utils.timestampedLog('No Initial external URL');
                       this.changeRoute('/login', 'start up');
                 }
               }).catch(err => {
                 logger.error({ err }, 'Error getting external URL');
               });
 
 
             firebase.messaging().getToken()
             .then(fcmToken => {
                 if (fcmToken) {
                     this._onPushRegistered(fcmToken);
                 }
             });
 
             Linking.addEventListener('url', this.updateLinkingURL);
 
         } else if (Platform.OS === 'ios') {
             this.changeRoute('/login', 'start up');
 
             VoipPushNotification.addEventListener('register', this._boundOnPushkitRegistered);
             VoipPushNotification.registerVoipToken();
 
             PushNotificationIOS.addEventListener('register', this._boundOnPushRegistered);
 
             //let permissions = await checkIosPermissions();
             //if (!permissions.alert) {
                 PushNotificationIOS.requestPermissions();
             //}
         }
 
         this.boundProximityDetect = this._proximityDetect.bind(this);
 
         DeviceEventEmitter.addListener('Proximity', this.boundProximityDetect);
 
         AppState.addEventListener('change', this._handleAppStateChange);
 
         if (Platform.OS === 'ios') {
             this._boundOnNotificationReceivedBackground = this._onNotificationReceivedBackground.bind(this);
             this._boundOnLocalNotificationReceivedBackground = this._onLocalNotificationReceivedBackground.bind(this);
             utils.timestampedLog('Adding iOS push notifications listeners');
             VoipPushNotification.addEventListener('notification', this._boundOnNotificationReceivedBackground);
             VoipPushNotification.addEventListener('localNotification', this._boundOnLocalNotificationReceivedBackground);
         } else if (Platform.OS === 'android') {
             utils.timestampedLog('Adding Android push notifications listeners');
             AppState.addEventListener('focus', this._handleAndroidFocus);
             AppState.addEventListener('blur', this._handleAndroidBlur);
 
             firebase
                 .messaging()
                 .requestPermission()
                 .then(() => {
                     // User has authorised
                 })
                 .catch(error => {
                     // User has rejected permissions
                 });
 
             this.messageListener = firebase
                 .messaging()
                 .onMessage((message: RemoteMessage) => {
                     // this will just wake up the app to receive
                     // the web-socket invite handled by this.incomingCall()
                     let event = message.data.event;
                     const callUUID = message.data['session-id'];
                     const from = message.data['from_uri'];
                     const to = message.data['to_uri'];
                     const displayName = message.data['from_display_name'];
                     const outgoingMedia = {audio: true, video: message.data['media-type'] === 'video'};
 
                     if (event === 'incoming_conference_request') {
                         utils.timestampedLog('Handle Firebase', event, 'PUSH notification for call', callUUID);
                         this.incomingConference(callUUID, to, from, displayName, outgoingMedia);
                     } else if (event === 'incoming_session') {
                         utils.timestampedLog('Handle Firebase', event, 'PUSH notification for call', callUUID);
                         this.incomingCallFromPush(callUUID, from, displayName);
                     } else if (event === 'cancel') {
                         this.cancelIncomingCall(callUUID);
                     }
 
                 });
         }
     }
 
     cancelIncomingCall(callUUID) {
 
         if (this.callKeeper._acceptedCalls.has(callUUID)) {
             //utils.timestampedLog('Push call was already accepted', callUUID);
             return;
         }
 
         utils.timestampedLog('Cancelling incoming call...', callUUID);
 
         let call = this.callKeeper._calls.get(callUUID);
         if (!call) {
             utils.timestampedLog('Cancel incoming call that did not arrive on web socket', callUUID);
             this.callKeeper.endCall(callUUID, 2);
             this.startedByPush = false;
             if (this.startedByPush) {
                 this.changeRoute('/ready', 'incoming_call_cancelled');
             }
             return;
         }
 
         if (call.state === 'incoming') {
             utils.timestampedLog('Cancel incoming call that was not yet accepted', callUUID);
             this.callKeeper.endCall(callUUID, 2);
             if (this.startedByPush) {
                 this.changeRoute('/ready', 'incoming_call_cancelled');
             }
         } else {
             //utils.timestampedLog('Call on web socket was already accepted', callUUID, call.state);
         }
     }
 
     _proximityDetect(data) {
         return;
 
         if (data.isNear) {
            this.speakerphoneOff();
         } else {
            this.speakerphoneOn();
         }
     }
 
     startCallWhenReady(targetUri, options) {
         this.resetGoToReadyTimer();
 
         if (options.video) {
             this.speakerphoneOn();
         }
 
         if (options.conference) {
             this.startConference(targetUri, options);
         } else {
             this.startCall(targetUri, options);
         }
     }
     _sleep(ms) {
       return new Promise(resolve => setTimeout(resolve, ms));
     }
 
     _onPushkitRegistered(token) {
         utils.timestampedLog('Set VoIP pushkit token', token);
         this.pushkittoken = token;
     }
 
     _onPushRegistered(token) {
         utils.timestampedLog('Set background push token', token);
         this.pushtoken = token;
     }
 
     _sendPushToken() {
         if ((this.state.account && this.pushtoken && !this.tokenSent)) {
             let token = null;
 
             if (Platform.OS === 'ios') {
                 token = `${this.pushkittoken}#${this.pushtoken}`;
             } else if (Platform.OS === 'android') {
                 token = this.pushtoken;
             }
             utils.timestampedLog('Push token', 'sent to server');
             this.state.account.setDeviceToken(token, Platform.OS, deviceId, true, bundleId);
             this.tokenSent = true;
         }
     }
 
 
     _handleAndroidFocus = nextFocus => {
         //utils.timestampedLog('--- APP is in focus');
         this.setState({inFocus: true});
         this.respawnConnection();
     }
 
     _handleAndroidBlur = nextBlur => {
         //utils.timestampedLog('--- APP is out of focus');
         this.setState({inFocus: false});
     }
 
     _handleAppStateChange = nextAppState => {
 
         if (nextAppState === this.state.appState) {
             return;
         }
 
         if (this.callKeeper.countCalls === 0 && !this.state.outgoingCallUUID) {
             /*
 
             utils.timestampedLog('----- APP state changed', this.state.appState, '->', nextAppState);
 
             if (this.callKeeper.countCalls) {
                 utils.timestampedLog('- APP state changed, we have', this.callKeeper.countCalls, 'calls');
             }
 
             if (this.callKeeper.countPushCalls) {
                 utils.timestampedLog('- APP state changed, we have', this.callKeeper.countPushCalls, 'push calls');
             }
 
             if (this.startedByPush) {
                 utils.timestampedLog('- APP state changed, started by push in', nextAppState, 'state');
             }
 
             if (this.state.connection) {
                 utils.timestampedLog('- APP state changed from', this.state.appState, 'to', nextAppState, 'with connection', Object.id(this.state.connection));
             } else {
                 utils.timestampedLog('- APP state changed from', this.state.appState, 'to', nextAppState);
             }
             */
 
         }
 
         if (this.state.appState === 'background' && nextAppState === 'active') {
             this.respawnConnection(nextAppState);
         }
 
         this.setState({appState: nextAppState});
     }
 
     respawnConnection(state) {
         utils.timestampedLog('Respawn connection for', state, 'state');
         if (!this.state.connection) {
             utils.timestampedLog('Web socket does not exist');
         } else if (!this.state.connection.state) {
             utils.timestampedLog('Web socket is waiting for connection...');
         } else {
             utils.timestampedLog('Web socket', Object.id(this.state.connection), 'state is', this.state.connection.state);
             if (this.state.connection.state !== 'ready' && this.state.connection.state !== 'connecting') {
                 utils.timestampedLog('Web socket', Object.id(this.state.connection), 'reconnecting because is', this.state.connection.state);
                 this.state.connection.reconnect();
                 utils.timestampedLog('Web socket', Object.id(this.state.connection), 'new state is', this.state.connection.state);
             }
         }
 
         if (this.state.account) {
             if (!this.state.connection) {
                 utils.timestampedLog('Active account without connection removed');
                 this.setState({account: null});
             } else {
                 utils.timestampedLog('Active account', this.state.account.id);
             }
         } else {
             utils.timestampedLog('No active account');
         }
 
         if (this.state.accountId && (!this.state.connection || !this.state.account)) {
             this.handleRegistration(this.state.accountId, this.state.password);
         }
     }
 
     closeConnection(reason) {
         return;
 
         if (this.state.connection) {
             utils.timestampedLog('Web socket', Object.id(this.state.connection), 'will close');
         }
 
         utils.timestampedLog('Closing connection because', reason);
 
         if (!this.state.connection) {
             utils.timestampedLog('Connection already closed');
             return;
         }
 
         if (!this.state.account && this.state.connection) {
             //this.state.connection.removeListener('stateChanged', this.connectionStateChanged);
             this.state.connection.close();
             utils.timestampedLog('Web socket', Object.id(this.state.connection), 'will close');
             this.setState({connection: null, account: null});
         } else if (this.state.connection && this.state.account) {
             this.state.connection.removeAccount(this.state.account,
                 (error) => {
                     if (error) {
                         utils.timestampedLog('Failed to remove account:', error);
                     } else {
                         utils.timestampedLog('Account removed');
                     }
 
                     if (this.state.connection) {
                         utils.timestampedLog('Web socket', Object.id(this.state.connection), 'will close');
                         this.state.connection.close();
                     }
                     this.setState({connection: null, account: null});
                 }
             );
         } else {
             this.setState({connection: null, account: null});
         }
     }
 
     startCallFromCallKeeper(data) {
         // like from native iOS history
         //utils.timestampedLog("CallKeep started call from outside the app to", data.handle);
         // we dont have options in the tmp var, which means this likely came from the native dialer
         // for now, we only do audio calls from the native dialer.
         let callUUID = data.callUUID || uuid.v4();
         let is_conf = data.handle.search('videoconference.') === -1 ? false: true;
         if (is_conf) {
             this.callKeepStartConference(data.handle, {audio: true, video: true, callUUID: callUUID});
         } else {
             this.callKeepStartCall(data.handle, {audio: true, video: false, callUUID: callUUID});
         }
         this._notificationCenter.removeNotification();
     }
 
     connectionStateChanged(oldState, newState) {
         if (!this._loaded) {
             return;
         }
 
         if (oldState) {
             if (Object.id(this.state.connection)) {
                 utils.timestampedLog('Web socket state changed:', Object.id(this.state.connection), oldState, '->' , newState);
             } else {
                 utils.timestampedLog('Web socket state changed:', oldState, '->' , newState);
             }
         }
 
         switch (newState) {
             case 'closed':
                 if (this.state.connection) {
                     utils.timestampedLog('Web socket was terminated');
                     this.state.connection.removeListener('stateChanged', this.connectionStateChanged);
                     this._notificationCenter.postSystemNotification('Connection lost');
                 }
                 this.setState({connection: null, account: null});
                 break;
             case 'ready':
                 this._notificationCenter.removeNotification();
                 this.processRegistration(this.state.accountId, this.state.password, this.state.displayName);
                 this.callKeeper.setAvailable(true);
                 break;
             case 'disconnected':
                 if (this.registrationFailureTimer) {
                     clearTimeout(this.registrationFailureTimer);
                     this.registrationFailureTimer = null;
                 }
                 if (this.state.currentCall && this.state.currentCall.direction === 'outgoing') {
                     this.hangupCall(this.state.currentCall.id, 'outgoing_connection_failed');
                 }
 
                 if (this.state.incomingCall) {
                     this.hangupCall(this.state.incomingCall.id, 'connection_failed');
                 }
 
                 this.setState({
                     registrationState: 'failed',
                     generatedVideoTrack: false,
                     });
 
                 break;
             default:
                 if (this.state.registrationKeepalive !== true) {
                     this.setState({loading: 'Connecting...'});
                 }
                 break;
         }
     }
 
     notificationCenter() {
         return this._notificationCenter;
     }
 
     showRegisterFailure(reason) {
         utils.timestampedLog('Registration error: ' + reason);
         this.setState({
             loading     : null,
             registrationState: 'failed',
             status      : {
                 msg   : 'Sign In failed: ' + reason,
                 level : 'danger'
             }
         });
 
         if (this.startedByPush) {
             // TODO: hangup incoming call
         }
     }
 
     registrationStateChanged(oldState, newState, data) {
         if (!this._loaded) {
             return;
         }
 
         if (oldState) {
             utils.timestampedLog('Registration state changed:', oldState, '->', newState);
         }
 
         if (!this.state.account) {
             utils.timestampedLog('Account disabled');
             return;
         }
 
         if (newState === 'failed') {
             let reason = data.reason;
 
             if (reason === 904) {
                 // Sofia SIP: WAT
                 reason = 'Wrong account or password';
             } else if (reason === 408) {
                 reason = 'Timeout';
             }
 
             this.showRegisterFailure(reason);
 
             if (this.state.registrationKeepalive === true) {
                 if (this.state.connection !== null && this.state.connection.state === 'ready') {
                     utils.timestampedLog('Retry to register...');
                     this.state.account.register();
                 } else {
                     // add a timer to retry register after awhile
                     utils.timestampedLog('Retry to register after 5 seconds delay...');
                     setTimeout(this.state.account.register(), 5000);
                 }
             }
         } else if (newState === 'registered') {
             if (this.registrationFailureTimer) {
                 clearTimeout(this.registrationFailureTimer);
                 this.registrationFailureTimer = null;
             }
 
             this.setState({loading: null,
                            registrationKeepalive: true,
                            registrationState: 'registered',
                            defaultDomain: this.state.account ? this.state.account.id.split('@')[1]: null
                            });
 
             if (this.currentRoute === '/login' && (!this.startedByPush || Platform.OS === 'ios'))  {
                 this.changeRoute('/ready', 'registered');
             }
             return;
         } else {
             this.setState({status: null, registrationState: newState });
         }
 
         if (this.mustLogout) {
             this.logout();
         }
     }
 
     showInternalAlertPanel() {
         this.setState({showIncomingModal: true});
         Vibration.vibrate(VIBRATION_PATTERN, true);
     }
 
     hideInternalAlertPanel() {
         Vibration.cancel();
         this.setState({showIncomingModal: false});
     }
 
     heartbeat() {
         if (this.state.connection) {
             //console.log('Check calls in', this.state.appState, 'with connection', Object.id(this.state.connection), this.state.connection.state);
         } else {
             //console.log('Check calls in', this.state.appState, 'with no connection');
         }
 
         let callState;
         if (this.state.currentCall && this.state.incomingCall && this.state.incomingCall === this.state.currentCall) {
             //utils.timestampedLog('We have an incoming call:', this.state.currentCall ? (this.state.currentCall.id + ' ' + this.state.currentCall.state): 'None');
             callState = this.state.currentCall.state;
         } else if (this.state.incomingCall) {
             //utils.timestampedLog('We have an incoming call:', this.state.incomingCall ? (this.state.incomingCall.id + ' ' + this.state.incomingCall.state): 'None');
             callState = this.state.incomingCall.state;
         } else if (this.state.currentCall) {
             //utils.timestampedLog('We have an outgoing call:', this.state.currentCall ? (this.state.currentCall.id + ' ' + this.state.currentCall.state): 'None');
             callState = this.state.currentCall.state;
         } else if (this.state.outgoingCallUUID) {
             //utils.timestampedLog('We have a pending outgoing call:', this.state.outgoingCallUUID);
         } else {
             //utils.timestampedLog('We have no calls');
             if (this.state.appState === 'background' && this.state.connection && this.state.connection.state === 'ready') {
                 this.closeConnection('background with no calls');
             }
         }
 
         this.callKeeper.heartbeat();
-
-        /*
-
-        if (callState === 'established' || callState === 'established') {
-            const nextRoute = this.isConference() ? '/conference' : '/call';
-            this.changeRoute(nextRoute, 'correct call state');
-        }
-        */
     }
 
     stopRingback() {
         //utils.timestampedLog('Stop ringback');
         InCallManager.stopRingback();
     }
 
     resetGoToReadyTimer() {
         if (this.goToReadyTimer !== null) {
             clearTimeout(this.goToReadyTimer);
             this.goToReadyTimer = null;
         }
     }
 
     isConference(call) {
         const _call = call || this.state.currentCall;
         if (_call && _call.hasOwnProperty('_participants')) {
             return true;
         }
 
         return false;
     }
 
     callStateChanged(oldState, newState, data) {
         if (!this._loaded) {
             return;
         }
 
         // outgoing accepted: null -> progress -> accepted -> established -> terminated
         // outgoing accepted: null -> progress -> established -> accepted -> terminated (with early media)
         // incoming accepted: null -> incoming -> accepted -> established -> terminated
         // 2nd incoming call is automatically rejected by sylkrtc library
 
         /*
         utils.timestampedLog('---currentCall start:', this.state.currentCall);
         utils.timestampedLog('---incomingCall start:', this.state.incomingCall);
         */
 
         let call = this.callKeeper._calls.get(data.id);
 
         if (!call) {
             utils.timestampedLog("callStateChanged error: call", data.id, 'not found in callkeep manager');
             console.log(data);
             return;
         }
 
         let callUUID = call.id;
         utils.timestampedLog('Call', callUUID, 'state change:', oldState, '->', newState);
 
         /*
         if (newState === 'established' || newState === 'accepted') {
             // restore the correct UI state if it has transitioned illegally to /ready state
             if (call.hasOwnProperty('_participants')) {
                 this.changeRoute('/conference', 'correct call state');
             } else {
                 this.changeRoute('/call', 'correct call state');
             }
         }
         */
 
         let newCurrentCall;
         let newincomingCall;
         let direction = call.direction;
         let hasVideo = false;
         let mediaType = 'audio';
         let tracks;
         let readyDelay = 4000;
 
         if (this.state.incomingCall && this.state.currentCall) {
             if (this.state.incomingCall != this.state.currentCall) {
                 //utils.timestampedLog('Call state changed: We have two calls');
             } else {
                 //utils.timestampedLog('Call state changed: we have two calls the same');
             }
 
             if (newState === 'terminated') {
                 if (this.state.incomingCall == this.state.currentCall) {
                     //utils.timestampedLog('Call state changed:', 'incoming call is the current call');
                     newCurrentCall = null;
                     newincomingCall = null;
                 }
 
                 if (this.state.incomingCall.id === call.id) {
                     if (oldState === 'incoming') {
                         //utils.timestampedLog('Call state changed:', 'incoming call must be cancelled');
                         this.hideInternalAlertPanel();
                     }
 
                     if (oldState === 'established' || oldState === 'accepted') {
                         //utils.timestampedLog('Call state changed:', 'incoming call ended');
                         this.hideInternalAlertPanel();
                     }
                     // new call must be cancelled
                     newincomingCall = null;
                     newCurrentCall = this.state.currentCall;
                 }
 
                 if (this.state.currentCall != this.state.incomingCall && this.state.currentCall.id === call.id) {
                     if (oldState === 'established' || newState === 'accepted') {
                         //utils.timestampedLog('Call state changed:', 'outgoing call must be hangup');
                         // old call must be closed
                     }
                     newCurrentCall = null;
                     newincomingCall = this.state.incomingCall;
                 }
 
             } else if (newState === 'accepted') {
                 if (this.state.incomingCall === this.state.currentCall) {
                     newCurrentCall = this.state.incomingCall;
                     newincomingCall = this.state.incomingCall;
                 } else {
                     newCurrentCall = this.state.currentCall;
                 }
                 this.backToForeground();
             } else if (newState === 'established') {
                 if (this.state.incomingCall === this.state.currentCall) {
                     //utils.timestampedLog("Incoming call media started");
                     newCurrentCall = this.state.incomingCall;
                     newincomingCall = this.state.incomingCall;
                 } else {
                     //utils.timestampedLog("Outgoing call media started");
                     newCurrentCall = this.state.currentCall;
                 }
             } else {
                 //utils.timestampedLog('Call state changed:', 'We have two calls in unclear state');
             }
         } else if (this.state.incomingCall) {
             //this.backToForeground();
             //utils.timestampedLog('Call state changed: We have one incoming call');
             newincomingCall = this.state.incomingCall;
             newCurrentCall = this.state.incomingCall;
 
             if (this.state.incomingCall.id === call.id) {
                 if (newState === 'terminated') {
                     this.startedByPush = false;
                     //utils.timestampedLog("Incoming call was cancelled");
                     this.setState({showIncomingModal: false});
                     this.hideInternalAlertPanel();
                     newincomingCall = null;
                     newCurrentCall = null;
                     readyDelay = 10;
                 } else if (newState === 'accepted') {
                     //utils.timestampedLog("Incoming call was accepted");
                     this.hideInternalAlertPanel();
                     this.backToForeground();
                 } else if (newState === 'established') {
                     //utils.timestampedLog("Incoming call media started");
                     this.hideInternalAlertPanel();
                 }
             }
 
         } else if (this.state.currentCall) {
             //utils.timestampedLog('Call state changed: We have one current call');
             newCurrentCall = newState === 'terminated' ? null : call;
             newincomingCall = null;
             if (newState !== 'terminated') {
                 this.setState({reconnectingCall: false});
             }
         } else {
             newincomingCall = null;
             newCurrentCall = null;
         }
 
         /*
         utils.timestampedLog('---currentCall:', newCurrentCall);
         utils.timestampedLog('---incomingCall:', newincomingCall);
         */
 
         switch (newState) {
             case 'progress':
                 this.backToForeground();
 
                 this.resetGoToReadyTimer();
 
                 if (!this.isConference(call)){
                     if (Platform.OS === 'android') {
                         tracks = call.getLocalStreams()[0].getVideoTracks();
                         hasVideo = (tracks && tracks.length > 0) ? true : false;
                     }
-                    //utils.timestampedLog('Play ringback tone');
                     InCallManager.startRingback('_BUNDLE_');
                 }
 
                 break;
             case 'established':
                 this.backToForeground();
                 this.resetGoToReadyTimer();
 
                 if (direction === 'outgoing') {
                     this.stopRingback();
                 }
 
                 this.callKeeper.setCurrentCallActive(callUUID);
 
                 tracks = call.getLocalStreams()[0].getVideoTracks();
                 mediaType = (tracks && tracks.length > 0) ? 'video' : 'audio';
 
-                //utils.timestampedLog('Start InCall manager:', mediaType);
                 InCallManager.start({media: mediaType});
 
                 if (mediaType === 'video') {
                     this.speakerphoneOn();
                 } else {
                     this.speakerphoneOff();
                 }
 
                 break;
             case 'accepted':
                 this.backToForeground();
                 this.resetGoToReadyTimer();
 
                 if (direction === 'outgoing') {
                     this.stopRingback();
                 }
-
                 break;
 
             case 'terminated':
                 this._terminatedCalls.set(callUUID, true);
 
                 if (this.state.incomingCall && this.state.incomingCall.id === call.id) {
                     newincomingCall = null;
                 }
 
                 if (this.state.currentCall && this.state.currentCall.id === call.id) {
                     newCurrentCall = null;
                 }
 
                 let callSuccesfull = false;
                 let reason = data.reason;
                 let play_busy_tone = !this.isConference(call);
-
                 let CALLKEEP_REASON;
-                //utils.timestampedLog('Call state changed:', 'call', callUUID, 'terminated reason:', reason);
 
                 if (!reason || reason.match(/200/)) {
                     if (oldState === 'progress' && direction === 'outgoing') {
                         reason = 'Cancelled';
                         play_busy_tone = false;
                     } else if (oldState === 'incoming') {
                         reason = 'Cancelled';
                         play_busy_tone = false;
                         CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.UNANSWERED;
                     } else {
                         reason = 'Hangup';
                         callSuccesfull = true;
                         CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.REMOTE_ENDED;
                     }
                 } else if (reason.match(/402/)) {
                     reason = 'Payment required';
                     CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.FAILED;
                 } else if (reason.match(/403/)) {
                     reason = 'This domain is not served here';
                     CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.FAILED;
                 } else if (reason.match(/404/)) {
                     reason = 'User not found';
                     CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.FAILED;
                 } else if (reason.match(/408/)) {
                     reason = 'Timeout';
                     CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.FAILED;
                 } else if (reason.match(/480/)) {
                     reason = 'User not online';
                     CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.UNANSWERED;
                 } else if (reason.match(/486/) || reason.match(/60[036]/)) {
                     reason = 'Busy';
                     CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.REMOTE_ENDED;
                     if (direction === 'outgoing') {
                         play_busy_tone = false;
                     }
                 } else if (reason.match(/487/)) {
                     reason = 'Cancelled';
                     play_busy_tone = false;
                     CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.REMOTE_ENDED;
                 } else if (reason.match(/488/)) {
                     reason = 'Unacceptable media';
                     CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.FAILED;
                 } else if (reason.match(/5\d\d/)) {
                     reason = 'Server failure';
                     CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.FAILED;
                 } else if (reason.match(/904/)) {
                     // Sofia SIP: WAT
                     reason = 'Wrong account or password';
                     CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.FAILED;
                 } else {
                     reason = 'Connection failed';
                     CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.FAILED;
                 }
 
                 if (play_busy_tone) {
                     this.playBusyTone();
                 }
 
                 this.stopRingback();
 
                 this.callKeeper.terminateCall(callUUID);
 
                 this.callKeeper.endCall(callUUID, CALLKEEP_REASON);
 
                 if (this.state.currentCall === null) {
                     //utils.timestampedLog('Call state changed:', 'Turn off speakerphone');
                     this.speakerphoneOff();
                 }
 
                 if (play_busy_tone && oldState !== 'established' && direction === 'outgoing') {
                     this._notificationCenter.postSystemNotification('Call ended:', {body: reason});
                 }
 
                 this.updateHistoryEntry(callUUID);
 
-                /*
-                if (newState === 'established' || newState === 'accepted') {
-                    // restore the correct UI state if it has transitioned illegally to /ready state
-                    if (call.hasOwnProperty('_participants')) {
-                        this.changeRoute('/conference', 'correct call state');
-                    } else {
-                        this.changeRoute('/call', 'correct call state');
-                    }
-                }
-                */
-
                 break;
             default:
                 break;
         }
 
         /*
         utils.timestampedLog('---currentCall end:', newCurrentCall);
         utils.timestampedLog('---incomingCall end:', newincomingCall);
         */
 
         this.setState({
             currentCall: newCurrentCall,
             incomingCall: newincomingCall
         });
 
         if (this.state.currentCall || this.state.incomingCall) {
             //utils.timestampedLog('We still have calls ongoing');
         } else {
             if (!this.state.reconnectingCall) {
                 if (this.state.inFocus) {
                     utils.timestampedLog('Will go to ready in 4 seconds');
                     this.goToReadyTimer = setTimeout(() => {
                         this.changeRoute('/ready', 'no_more_calls');
                     }, readyDelay);
                 } else {
-                    this.changeRoute('/ready', 'no_more_calls');
+                    if (this.currentRoute !== '/conference') {
+                        this.changeRoute('/ready', 'no_more_calls');
+                    }
                 }
             }
         }
 
         if (this.state.currentCall) {
             //console.log('Current:', this.state.currentCall.id);
         }
         if (this.state.incomingCall) {
             //console.log('Incoming:', this.state.incomingCall.id);
         }
 
     }
 
     handleRegistration(accountId, password, remember=true) {
         utils.timestampedLog('handleRegistration for', accountId);
         if (this.state.account !== null && this.state.registrationState === 'registered' ) {
             utils.timestampedLog('We are already registered with', accountId);
             return;
         }
 
         this.setState({
             accountId : accountId,
             password  : password,
             loading   : 'Connecting...'
         });
 
         if (this.state.connection === null) {
             utils.timestampedLog('Web socket handle registration for', accountId);
 
             const userAgent = 'Sylk Mobile';
             if (this.state.phoneNumber) {
                 console.log('Phone number:', this.state.phoneNumber);
             }
 
             //let connection = sylkrtc.createConnection({server: config.wsServer, userAgent: {name: userAgent, version: version}});
             let connection = sylkrtc.createConnection({server: config.wsServer});
             utils.timestampedLog('Web socket', Object.id(connection), 'was opened');
             connection.on('stateChanged', this.connectionStateChanged);
             this.setState({connection: connection});
 
         } else {
             if (this.state.connection.state === 'ready' && this.state.registrationState !== 'registered') {
                 utils.timestampedLog('Web socket', Object.id(this.state.connection), 'handle registration for', accountId);
                 this.processRegistration(accountId, password, '');
             }
         }
     }
 
     processRegistration(accountId, password, displayName) {
         utils.timestampedLog('Process registration for', accountId);
         this.updateServerHistory();
         if (!this.state.connection) {
             utils.timestampedLog('Process registration aborted');
             return;
         }
         if (this.state.account && this.state.connection) {
             utils.timestampedLog('We already have an account, removing it');
             this.state.connection.removeAccount(this.state.account,
                 (error) => {
                     this.setState({registrationState: null, registrationKeepalive: false});
                 }
             );
         }
 
         const options = {
             account: accountId,
             password: password,
             displayName: displayName
         };
 
         if (this.state.connection._accounts.has(options.account)) {
             return;
         }
 
         this.registrationFailureTimer  = setTimeout(() => {
                 this.showRegisterFailure('Register timeout');
                 this.processRegistration(accountId, password, displayName);
         }, 10000);
 
         const account = this.state.connection.addAccount(options, (error, account) => {
             if (!error) {
                 account.on('outgoingCall', this.outgoingCall);
                 account.on('conferenceCall', this.outgoingConference);
                 account.on('registrationStateChanged', this.registrationStateChanged);
                 account.on('incomingCall', this.incomingCallFromWebSocket);
                 account.on('missedCall', this.missedCall);
                 account.on('conferenceInvite', this.conferenceInviteFromWebSocket);
                 utils.timestampedLog('Web socket account', account.id, 'is ready, registering...');
                 this.setState({account: account});
                 this._sendPushToken();
                 account.register();
                 storage.set('account', {
                     accountId: this.state.accountId,
                     password: this.state.password
                 });
             } else {
                 this.showRegisterFailure(408);
             }
         });
     }
 
     setDevice(device) {
         const oldDevices = Object.assign({}, this.state.devices);
 
         if (device.kind === 'videoinput') {
             oldDevices['camera'] = device;
         } else if (device.kind === 'audioinput') {
             oldDevices['mic'] = device;
         }
 
         this.setState({devices: oldDevices});
         storage.set('devices', oldDevices);
         sylkrtc.utils.closeMediaStream(this.state.localMedia);
         this.getLocalMedia();
     }
 
     getLocalMedia(mediaConstraints={audio: true, video: true}, nextRoute=null) {    // eslint-disable-line space-infix-ops
         let callType = mediaConstraints.video ? 'video': 'audio';
         utils.timestampedLog('Get local media for', callType);
         const constraints = Object.assign({}, mediaConstraints);
 
         if (constraints.video === true) {
             if ((nextRoute === '/conference')) {
                 constraints.video = {
                     'width': {
                         'ideal': 640
                     },
                     'height': {
                         'ideal': 480
                     }
                 };
 
             // TODO: remove this, workaround so at least safari works when joining a video conference
             } else if (nextRoute === '/conference' && isSafari) {
                 constraints.video = false;
             } else {
                 // ask for 720p video
                 constraints.video = {
                     'width': {
                         'ideal': 640
                     },
                     'height': {
                         'ideal': 480
                     }
                 };
             }
         }
 
         logger.debug('getLocalMedia(), (modified) mediaConstraints=%o', constraints);
 
         navigator.mediaDevices.enumerateDevices()
         .then((devices) => {
             devices.forEach((device) => {
                 //console.log(device);
                 if ('video' in constraints && 'camera' in this.state.devices) {
                     if (constraints.video && constraints.video !== false && (device.deviceId === this.state.devices.camera.deviceId || device.label === this.state.devices.camera.label)) {
                         constraints.video.deviceId = {
                             exact: device.deviceId
                         };
                     }
                 }
                 if ('mic' in this.state.devices) {
                     if (device.deviceId === this.state.devices.mic.deviceId || device.label === this.state.devices.mic.Label) {
                         // constraints.audio = {
                         //     deviceId: {
                         //         exact: device.deviceId
                         //     }
                         // };
                     }
                 }
             });
         })
         .catch((error) => {
             utils.timestampedLog('Error: device enumeration failed:', error);
         })
         .then(() => {
             return navigator.mediaDevices.getUserMedia(constraints)
         })
         .then((localStream) => {
             clearTimeout(this.loadScreenTimer);
             //utils.timestampedLog('Local media acquired');
             this.setState({localMedia: localStream});
             if (nextRoute !== null) {
                 this.changeRoute(nextRoute);
             }
         })
         .catch((error) => {
             utils.timestampedLog('Access to local media failed, trying audio only', error);
             navigator.mediaDevices.getUserMedia({
                 audio: true,
                 video: false
             })
             .then((localStream) => {
                 clearTimeout(this.loadScreenTimer);
 
                 if (nextRoute !== null) {
                     this.changeRoute(nextRoute, 'local media aquired');
                 }
             })
             .catch((error) => {
                 utils.timestampedLog('Access to local media failed:', error);
                 clearTimeout(this.loadScreenTimer);
                 this._notificationCenter.postSystemNotification("Can't access camera or microphone");
                 this.setState({
                     loading: null
                 });
 
                 this.changeRoute('/ready', 'local media failure');
             });
         });
     }
 
     getConnection() {
         return this.state.connection ? Object.id(this.state.connection): null;
     }
 
     callKeepStartConference(targetUri, options={audio: true, video: true, participants: null}) {
         if (!targetUri) {
             return;
         }
 
         this.resetGoToReadyTimer();
 
         let callUUID = options.callUUID || uuid.v4();
         this.callKeeper.setCurrentCallActive(callUUID);
 
         let participants = options.participants || null;
         this.addConferenceHistoryEntry(targetUri, callUUID);
 
         let participantsToInvite = [];
 
         participants.forEach((participant_uri) => {
             if (participant_uri === this.state.accountId) {
                 return;
             }
             participantsToInvite.push(participant_uri);
         });
 
         this.setState({outgoingCallUUID: callUUID,
                        outgoingMedia: options,
                        reconnectingCall: false,
                        participantsToInvite: participantsToInvite
                        });
 
         const media = options.video ? 'video' : 'audio';
 
         if (participants) {
             utils.timestampedLog('Will start', media, 'conference', callUUID, 'to', targetUri, 'with', participants);
         } else {
             utils.timestampedLog('Will start', media, 'conference', callUUID, 'to', targetUri);
         }
 
         this.respawnConnection();
         this.startCallWhenReady(targetUri, {audio: options.audio, video: options.video, conference: true, callUUID: callUUID});
     }
 
     callKeepStartCall(targetUri, options) {
         this.resetGoToReadyTimer();
         let callUUID = options.callUUID || uuid.v4();
         this.setState({outgoingCallUUID: callUUID, reconnectingCall: false});
         utils.timestampedLog('User will start call', callUUID, 'to', targetUri);
         this.respawnConnection();
         this.startCallWhenReady(targetUri, {audio: options.audio, video: options.video, callUUID: callUUID});
     }
 
     startCall(targetUri, options) {
         this.setState({targetUri: targetUri});
         this.getLocalMedia(Object.assign({audio: true, video: options.video}, options), '/call');
     }
 
     callKeepAcceptCall(callUUID) {
         // called from user interaction with Old alert panel
         // options used to be media to accept audio only but native panels do not have this feature
         utils.timestampedLog('CallKeep will answer call', callUUID);
         this.callKeeper.acceptCall(callUUID);
         this.hideInternalAlertPanel();
     }
 
     callKeepRejectCall(callUUID) {
         // called from user interaction with Old alert panel
         utils.timestampedLog('CallKeep will reject call', callUUID);
         this.callKeeper.rejectCall(callUUID);
         this.hideInternalAlertPanel();
     }
 
     acceptCall(callUUID) {
         utils.timestampedLog('User accepted call', callUUID, 'on connection', Object.id(this.state.connection));
         this.hideInternalAlertPanel();
 
         this.resetGoToReadyTimer();
 
         if (this.state.currentCall) {
             this.hangupCall(this.state.currentCall.id, 'accept_new_call');
         }
 
         let hasVideo = (this.state.incomingCall && this.state.incomingCall.mediaTypes && this.state.incomingCall.mediaTypes.video) ? true : false;
         this.getLocalMedia(Object.assign({audio: true, video: hasVideo}), '/call');
     }
 
     rejectCall(callUUID) {
         // called by Call Keep when user rejects call
         utils.timestampedLog('User rejected call', callUUID);
         this.hideInternalAlertPanel();
         if (!this.state.currentCall) {
             this.changeRoute('/ready', 'reject call');
         }
 
         if (this.state.incomingCall && this.state.incomingCall.id === callUUID) {
             this.state.incomingCall.terminate();
             utils.timestampedLog('Sylkrtc reject call', callUUID);
         }
     }
 
     timeoutCall(callUUID, uri) {
         utils.timestampedLog('Timeout answering call', callUUID);
         this.addConferenceHistoryEntry(uri, callUUID, direction='received');
         this.forceUpdate();
     }
 
     closeLocalMedia() {
         if (this.state.localMedia != null) {
             sylkrtc.utils.closeMediaStream(this.state.localMedia);
             //utils.timestampedLog('Close local media');
         }
     }
 
     hangupCall(callUUID, reason) {
         utils.timestampedLog('Hangup call', callUUID, 'reason:', reason);
 
         let call = this.callKeeper._calls.get(callUUID);
         let direction = null;
         let targetUri = null;
 
         if (call) {
             let direction = call.direction;
             targetUri = call.remoteIdentity.uri;
             call.terminate();
         }
 
         if (this.busyToneInterval) {
             clearInterval(this.busyToneInterval);
             this.busyToneInterval = null;
         }
 
         if (reason === 'outgoing_connection_failed') {
              this.setState({reconnectingCall: true,
                             outgoingCallUUID: uuid.v4()});
              return;
         }
 
         if (reason === 'user_press_hangup') {
             this.callKeeper.endCall(callUUID);
         }
 
-        if (reason === 'user_cancelled' ||
+        if (reason === 'user_cancelled_call' ||
             reason === 'timeout' ||
             reason === 'stop_preview' ||
-            reason === 'user_press_hangup' ||
+            reason === 'user_hangup_call' ||
             reason === 'accept_new_call' ||
-            reason === 'timeout'
+            reason === 'timeout' ||
+            reason === 'user_hangup_conference_confirmed'
             ) {
             this.changeRoute('/ready', reason);
+        } else if (reason === 'user_hangup_conference') {
+            utils.timestampedLog('Save conference maybe?');
+        } else if (reason === 'user_cancelled_conference') {
+            utils.timestampedLog('Save conference maybe?');
         } else {
             if (reason !== 'escalate_to_conference') {
                 setTimeout(() => {
                      //utils.timestampedLog('Will go to ready in 4 seconds');
-                     this.changeRoute('/ready', 'remote ended');
+                     this.changeRoute('/ready', 'call_ended_by_remote');
                 }, 4000);
             }
         }
     }
 
     playBusyTone() {
         //utils.timestampedLog('Play busy tone');
         InCallManager.stop({busytone: '_BUNDLE_'});
     }
 
     callKeepSendDtmf(digits) {
         utils.timestampedLog('Send DTMF', digits);
         if (this.state.currentCall) {
             this.callKeeper.sendDTMF(this.state.currentCall.id, digits);
         }
     }
 
     toggleMute(callUUID, mute) {
         utils.timestampedLog('Toggle mute for call', callUUID, ':', mute);
         this.callKeeper.setMutedCall(callUUID, mute);
         this.setState({muted: mute});
     }
 
     toggleSpeakerPhone() {
         if (this.state.speakerPhoneEnabled === true) {
             this.speakerphoneOff();
         } else {
             this.speakerphoneOn();
         }
     }
 
     speakerphoneOn() {
         //utils.timestampedLog('Speakerphone On');
         this.setState({speakerPhoneEnabled: true});
         InCallManager.setForceSpeakerphoneOn(true);
     }
 
     speakerphoneOff() {
         //utils.timestampedLog('Speakerphone Off');
         this.setState({speakerPhoneEnabled: false});
         InCallManager.setForceSpeakerphoneOn(false);
     }
 
     startGuestConference(targetUri) {
         this.setState({targetUri: targetUri});
         this.getLocalMedia({audio: true, video: true});
     }
 
     outgoingCall(call) {
         // called by sylkrtc.js when an outgoing call starts
 
         const localStreams = call.getLocalStreams();
         let mediaType = 'audio';
         let hasVideo = false;
 
         if (localStreams.length > 0) {
             const localStream = call.getLocalStreams()[0];
             mediaType = localStream.getVideoTracks().length > 0 ? 'video' : 'audio';
             hasVideo = localStream.getVideoTracks().length > 0 ? true : false;
         }
 
         this.callKeeper.startOutgoingCall(call.id, call.remoteIdentity.uri, hasVideo);
 
         utils.timestampedLog('Outgoing', mediaType, 'call', call.id, 'started to', call.remoteIdentity.uri);
         this.callKeeper.addWebsocketCall(call);
 
         call.on('stateChanged', this.callStateChanged);
         this.setState({currentCall: call});
     }
 
     outgoingConference(call) {
         // called by sylrtc.js when an outgoing conference starts
 
         const localStreams = call.getLocalStreams();
         let mediaType = 'audio';
         let hasVideo = false;
 
         if (localStreams.length > 0) {
             const localStream = call.getLocalStreams()[0];
             mediaType = localStream.getVideoTracks().length > 0 ? 'video' : 'audio';
             hasVideo = localStream.getVideoTracks().length > 0 ? true : false;
         }
 
         utils.timestampedLog('Outgoing', mediaType, 'conference', call.id, 'started to', call.remoteIdentity.uri);
         this.callKeeper.addWebsocketCall(call);
 
         call.on('stateChanged', this.callStateChanged);
         this.setState({currentCall: call});
     }
 
     _onLocalNotificationReceivedBackground(notification) {
         let notificationContent = notification.getData();
         utils.timestampedLog('Handle local iOS PUSH notification: ', notificationContent);
     }
 
     _onNotificationReceivedBackground(notification) {
         let notificationContent = notification.getData();
 
         const event = notificationContent['event'];
         const callUUID = notificationContent['session-id'];
         const to = notificationContent['to_uri'];
         const from = notificationContent['from_uri'];
         const displayName = notificationContent['from_display_name'];
         const outgoingMedia = {audio: true, video: notificationContent['media-type'] === 'video'};
 
           /*
            * Local Notification Payload
            *
            * - `alertBody` : The message displayed in the notification alert.
            * - `alertAction` : The "action" displayed beneath an actionable notification. Defaults to "view";
            * - `soundName` : The sound played when the notification is fired (optional).
            * - `category`  : The category of this notification, required for actionable notifications (optional).
            * - `userInfo`  : An optional object containing additional notification data.
            */
 
         if (event === 'incoming_session') {
             utils.timestampedLog('Incoming call PUSH mobile notification for call', callUUID);
             this.startedByPush = true;
             this.incomingCallFromPush(callUUID, from, displayName);
 
         } else if (event === 'incoming_conference_request') {
             utils.timestampedLog('Incoming conference PUSH mobile notification for call', callUUID);
             this.startedByPush = true;
             this.incomingConference(callUUID, to, from, displayName, outgoingMedia);
 
         } else if (event === 'cancel') {
             utils.timestampedLog('Cancel PUSH mobile notification for call', callUUID);
             VoipPushNotification.presentLocalNotification({alertBody:'Call cancelled'});
             this.callKeeper.endCall(callUUID, 2);
         }
 
         /*
         if (notificationContent['event'] === 'incoming_session') {
             VoipPushNotification.presentLocalNotification({
                 alertBody:'Incoming ' + notificationContent['media-type'] + ' call from ' + notificationContent['from_display_name']
             });
         }
         */
 
         if (VoipPushNotification.wakeupByPush) {
             utils.timestampedLog('We wake up by push notification');
             VoipPushNotification.wakeupByPush = false;
             VoipPushNotification.onVoipNotificationCompleted(callUUID);
         }
     }
 
     backToForeground() {
         if (this.state.appState !== 'active') {
             this.callKeeper.backToForeground();
         }
 
         if (this.state.accountId) {
             this.handleRegistration(this.state.accountId, this.state.password);
         }
     }
 
     incomingConference(callUUID, to, from, displayName, outgoingMedia={audio: true, video: true}) {
         const media = outgoingMedia.video ? 'video' : 'audio';
 
         utils.timestampedLog('Incoming', media, 'conference invite from', from, 'to room', to);
         if (this.autoRejectIncomingCall(callUUID, from)) {
             return;
         }
 
         this.setState({incomingCallUUID: callUUID});
         this.callKeeper.handleConference(callUUID, to, from, displayName, outgoingMedia);
     }
 
     startConference(targetUri, options={audio: true, video: true, participants: []}) {
         utils.timestampedLog('New outgoing conference to room', targetUri);
         this.setState({targetUri: targetUri});
         this.getLocalMedia({audio: options.audio, video: options.video}, '/conference');
     }
 
     escalateToConference(participants) {
         const uri = `${utils.generateSillyName()}@${config.defaultConferenceDomain}`;
         utils.timestampedLog('Escalate call to conference', uri, 'with participants', participants);
 
         if (this.state.currentCall) {
             this.hangupCall(this.state.currentCall.id, 'escalate_to_conference');
             this.setState({currentCall: null});
         }
 
         if (this.state.incomingCall) {
             this.hangupCall(this.state.incomingCall.id, 'escalate_to_conference');
         }
 
         this.callKeepStartConference(uri, {audio: true, video: true, participants: participants});
     }
 
     conferenceInviteFromWebSocket(data) {
         // comes from web socket
         utils.timestampedLog('Conference invite from websocket', data.id, 'from', data.originator, 'for room', data.room);
         if (this.isConference()) {
             return;
         }
         this._notificationCenter.postSystemNotification('Expecting conference invite', {body: `from ${data.originator.displayName || data.originator.uri}`});
     }
 
     updateLinkingURL = (event) => {
         // this handles the use case where the app is running in the background and is activated by the listener...
         //console.log('Updated Linking url', event.url);
         this.eventFromUrl(event.url);
         DeepLinking.evaluateUrl(event.url);
     }
 
     eventFromUrl(url) {
         url = decodeURI(url);
         utils.timestampedLog('Received event from external URL:', url);
 
         try {
             let direction;
             let event;
             let callUUID;
             let from;
             let to;
             let displayName;
 
             var url_parts = url.split("/");
             let scheme = url_parts[0];
 
             if (scheme === 'sylk:') {
                 //sylk://outgoing/call/callUUID/to/displayName - from system dialer/history
                 //sylk://incoming/conference/callUUID/from/to - when Android is asleep
                 //sylk://incoming/call/callUUID/from/to - when Android is asleep
                 //sylk://cancel/call/callUUID/from/to - when Android is asleep
 
                 direction = url_parts[2];
                 event     = url_parts[3];
                 callUUID  = url_parts[4];
                 from      = url_parts[5];
                 to        = url_parts[6];
                 displayName = url_parts[7];
                 this.setState({targetUri: from});
             } else if (scheme === 'https:') {
                 // https://webrtc.sipthor.net/conference/DaffodilFlyChill0 from external web link
                 // https://webrtc.sipthor.net/call/alice@example.com from external web link
                 direction = 'outgoing';
                 event = url_parts[3];
                 to = url_parts[4];
                 callUUID = uuid.v4();
 
                 if (to.indexOf('@') === -1 && event === 'conference') {
                     to = url_parts[4] + '@' + config.defaultConferenceDomain;
                 } else if (to.indexOf('@') === -1 && event === 'call') {
                     to = url_parts[4] + '@' + this.state.defaultDomain;
                 }
                 this.setState({targetUri: to});
             }
 
             this.startedByPush = true;
 
             if (direction === 'outgoing' && event === 'conference' && to) {
                 utils.timestampedLog('Outgoing conference to', to);
                 this.backToForeground();
                 this.callKeepStartConference(to);
 
             } else if (direction === 'incoming' && event === 'conference' && from) {
                 utils.timestampedLog('Incoming conference from', from);
                 // allow app to wake up
                 this.backToForeground();
                 this.incomingConference(callUUID, to, from, displayName);
 
             } else if (direction === 'outgoing' && event === 'call' && from) {
                 utils.timestampedLog('Outgoing call to', from);
                 this.backToForeground();
                 this.callKeepStartCall(from, {audio: true, video: false, callUUID: callUUID});
 
             } else if (direction === 'incoming' && from) {
                 this.backToForeground();
                 utils.timestampedLog('Incoming call from', from);
                 this.incomingCallFromPush(callUUID, from, displayName, true);
 
             } else if (direction === 'cancel' && callUUID) {
                 this.cancelIncomingCall(callUUID);
             } else {
                  utils.timestampedLog('Error: Invalid external URL structure', url);
             }
         } catch (err) {
             utils.timestampedLog('Error parsing URL', url, ":", err);
         }
     }
 
     autoRejectIncomingCall(callUUID, from) {
         utils.timestampedLog('Check auto reject call from', from);
         if (this.state.blockedUris && this.state.blockedUris.indexOf(from) > -1) {
             utils.timestampedLog('Reject call', callUUID, 'from blocked URI', from);
             this.callKeeper.rejectCall(callUUID);
             this._notificationCenter.postSystemNotification('Call rejected', {body: `from ${from}`});
             return true;
         }
 
         const fromDomain = '@' + from.split('@')[1]
         if (this.state.blockedUris && this.state.blockedUris.indexOf(fromDomain) > -1) {
             utils.timestampedLog('Reject call', callUUID, 'from blocked domain', fromDomain);
             this.callKeeper.rejectCall(callUUID);
             this._notificationCenter.postSystemNotification('Call rejected', {body: `from domain ${fromDomain}`});
             return true;
         }
 
         if (this.state.currentCall && this.state.incomingCall && this.state.currentCall === this.state.incomingCall && this.state.incomingCall.id !== callUUID) {
             utils.timestampedLog('Reject second incoming call');
             this.callKeeper.rejectCall(callUUID);
         }
 
         if (this.state.account && from === this.state.account.id && this.state.currentCall && this.state.currentCall.remoteIdentity.uri === from) {
             utils.timestampedLog('Reject call to myself', callUUID);
             this.callKeeper.rejectCall(callUUID);
             return true;
         }
 
         if (this._terminatedCalls.has(callUUID)) {
             utils.timestampedLog('Reject call already terminated', callUUID);
             this.cancelIncomingCall(callUUID);
             return true;
         }
 
         if (this.isConference()) {
             utils.timestampedLog('Reject call while in a conference', callUUID);
             this._notificationCenter.postSystemNotification('Missed call from', {body: from});
             this.callKeeper.rejectCall(callUUID);
             return true;
         }
 
         if (this.state.currentCall && this.state.currentCall.state === 'progress' && this.state.currentCall.remoteIdentity.uri !== from) {
             utils.timestampedLog('Reject call while outgoing in progress', callUUID);
             this.callKeeper.rejectCall(callUUID);
             this._notificationCenter.postSystemNotification('Missed call from', {body: from});
             return true;
         }
 
         return false;
     }
 
     autoAcceptIncomingCall(callUUID, from) {
         // TODO: handle ping pong where we call each other back
         if (this.state.currentCall &&
             this.state.currentCall.direction === 'outgoing' &&
             this.state.currentCall.state === 'progress' &&
             this.state.currentCall.remoteIdentity.uri === from) {
 
                 this.hangupCall(this.state.currentCall.id, 'accept_new_call');
                 this.setState({currentCall: null});
 
                 utils.timestampedLog('Auto accept incoming call from same address I am calling', callUUID);
                 return true;
         }
 
         return false;
     }
 
     incomingCallFromPush(callUUID, from, displayName, force) {
         utils.timestampedLog('Handle incoming PUSH call', callUUID, 'from', from, '(', displayName, ')');
 
         if (this.autoRejectIncomingCall(callUUID, from)) {
             return;
         }
 
         //this.showInternalAlertPanel();
 
         if (this.autoAcceptIncomingCall(callUUID, from)) {
             return;
         }
 
         this.setState({targetUri: from});
 
         let skipNativePanel = false;
 
         if (!this.callKeeper._calls.get(callUUID) || (this.state.currentCall && this.state.currentCall.direction === 'outgoing')) {
             //this._notificationCenter.postSystemNotification('Incoming call', {body: `from ${from}`});
             if (Platform.OS === 'android' && this.state.appState === 'foreground') {
                 skipNativePanel = true;
             }
         }
 
         this.callKeeper.incomingCallFromPush(callUUID, from, displayName, force, skipNativePanel);
 
     }
 
     incomingCallFromWebSocket(call, mediaTypes) {
 
         this.callKeeper.addWebsocketCall(call);
 
         const callUUID = call.id;
         const from = call.remoteIdentity.uri;
 
         utils.timestampedLog('Handle incoming web socket call', callUUID, 'from', from, 'on connection', Object.id(this.state.connection));
 
         // because of limitation in Sofia stack, we cannot have more then two calls at a time
         // we can have one outgoing call and one incoming call but not two incoming calls
         // we cannot have two incoming calls, second one is automatically rejected by sylkrtc.js
 
         if (this.autoRejectIncomingCall(callUUID, from)) {
             return;
         }
 
         const autoAccept = this.autoAcceptIncomingCall(callUUID, from);
 
         call.mediaTypes = mediaTypes;
 
         call.on('stateChanged', this.callStateChanged);
 
         this.setState({incomingCall: call});
 
         let skipNativePanel = false;
 
         if (this.state.currentCall && this.state.currentCall.direction === 'outgoing') {
             if (Platform.OS === 'android') {
                 this.showInternalAlertPanel();
                 skipNativePanel = true;
             }
         }
 
         this.callKeeper.incomingCallFromWebSocket(call, autoAccept, skipNativePanel);
     }
 
     missedCall(data) {
         utils.timestampedLog('Missed call from ' + data.originator.uri, '(', data.originator.displayName, ')');
         if (!this.state.currentCall) {
             let from = data.originator.displayName ||  data.originator.uri;
             this._notificationCenter.postSystemNotification('Missed call', {body: `from ${from}`});
             if (Platform.OS === 'ios') {
                 VoipPushNotification.presentLocalNotification({alertBody:'Missed call from ' + from});
             }
         }
 
         this.updateServerHistory()
     }
 
     updateServerHistory() {
         if (this.currentRoute === '/ready') {
             this.setState({refreshHistory: !this.state.refreshHistory});
         }
     }
 
     startPreview() {
         this.getLocalMedia({audio: true, video: true}, '/preview');
     }
 
     updateHistoryEntry(callUUID) {
         let newHistory = this.state.localHistory;
         var historyItem = this.findObjectByKey(newHistory, 'sessionId', callUUID);
         if (historyItem) {
             let current_datetime = new Date();
             let stopTime = current_datetime.getFullYear() + "-" + utils.appendLeadingZeroes(current_datetime.getMonth() + 1) + "-" + utils.appendLeadingZeroes(current_datetime.getDate()) + " " + utils.appendLeadingZeroes(current_datetime.getHours()) + ":" + utils.appendLeadingZeroes(current_datetime.getMinutes()) + ":" + utils.appendLeadingZeroes(current_datetime.getSeconds());
             historyItem.stopTime = stopTime;
             var diff = current_datetime.getTime() - historyItem.startTimeObject.getTime();
             historyItem.duration = parseInt(diff/1000);
             delete historyItem['startTimeObject'];
             if (this._historyConferenceParticipants.has(callUUID)) {
                 historyItem.participants = this._historyConferenceParticipants.get(callUUID);
             } else {
                 historyItem.participants = [];
             }
-            //console.log('Save history', historyItem);
             this.setState({localHistory: newHistory});
             storage.set('history', newHistory);
         }
     }
 
     setFavoriteUri(uri) {
         let favoriteUris = this.state.favoriteUris;
         let idx = favoriteUris.indexOf(uri);
         let ret;
 
         if (idx === -1) {
             favoriteUris.push(uri);
             ret = true;
-
         } else {
             let removed = favoriteUris.splice(idx, 1);
             ret = false;
         }
 
         storage.set('favoriteUris', favoriteUris);
         this.setState({favoriteUris: favoriteUris});
         return ret;
     }
 
     setBlockedUri(uri) {
         let blockedUris = this.state.blockedUris;
         console.log('Old blocked Uris:', blockedUris);
 
         let ret;
         let idx = blockedUris.indexOf(uri);
 
         if (idx === -1) {
             blockedUris.push(uri);
             ret = true;
         } else {
             let removed = blockedUris.splice(idx, 1);
             console.log('Removed', removed);
             ret = false;
         }
 
         console.log('New blocked Uris:', blockedUris);
         storage.set('blockedUris', blockedUris);
         this.setState({blockedUris: blockedUris});
         return ret;
     }
 
     saveParticipant(callUUID, room, uri) {
         console.log('Save participant', uri, 'for conference', room);
 
         if (this._historyConferenceParticipants.has(callUUID)) {
             let old_participants = this._historyConferenceParticipants.get(callUUID);
             if (old_participants.indexOf(uri) === -1) {
                 old_participants.push(uri);
             }
 
         } else {
             let new_participants = [uri];
             this._historyConferenceParticipants.set(callUUID, new_participants);
         }
 
         if (!this.myParticipants) {
             this.myParticipants = new Object();
         }
 
         if (this.myParticipants.hasOwnProperty(room)) {
             let old_uris = this.myParticipants[room];
             if (old_uris.indexOf(uri) === -1 && uri !== this.state.account.id && (uri + '@' + this.state.defaultDomain) !== this.state.account.id) {
                 this.myParticipants[room].push(uri);
             }
 
         } else {
             let new_uris = [];
             if (uri !== this.state.account.id && (uri + '@' + this.state.defaultDomain) !== this.state.account.id) {
                 new_uris.push(uri);
             }
 
             if (new_uris) {
                 this.myParticipants[room] = new_uris;
             }
         }
 
         storage.set('myParticipants', this.myParticipants);
     }
 
     saveInvitedParties(room, uris) {
         room = room.split('@')[0];
-        console.log('Save invited parties', uris, 'for room', room);
+        //console.log('Save invited parties', uris, 'for room', room);
 
         if (!this.myInvitedParties) {
             this.myInvitedParties = new Object();
         }
 
         if (this.myInvitedParties.hasOwnProperty(room)) {
             let old_uris = this.myInvitedParties[room];
             uris.forEach((uri) => {
                 if (old_uris.indexOf(uri) === -1 && uri !== this.state.account.id && (uri + '@' + this.state.defaultDomain) !== this.state.account.id) {
                     this.myInvitedParties[room].push(uri);
                 }
             });
 
         } else {
             let new_uris = [];
             uris.forEach((uri) => {
                 if (uri !== this.state.account.id && (uri + '@' + this.state.defaultDomain) !== this.state.account.id) {
                     new_uris.push(uri);
                 }
             });
 
             if (new_uris) {
                 this.myInvitedParties[room] = new_uris;
             }
         }
 
         storage.set('myInvitedParties', this.myInvitedParties);
         this.setState({myInvitedParties: this.myInvitedParties});
     }
 
     deleteHistoryEntry(uri) {
         let history = this.state.localHistory;
         for (var i = history.length - 1; i >= 0; --i) {
             if (history[i].remoteParty === uri) {
                 history.splice(i,1);
             }
         }
 
         storage.set('history', history);
         this.setState({localHistory: history});
     }
 
     addConferenceHistoryEntry(uri, callUUID, direction='placed', participants=[]) {
         let current_datetime = new Date();
         let startTime = current_datetime.getFullYear() + "-" + utils.appendLeadingZeroes(current_datetime.getMonth() + 1) + "-" + utils.appendLeadingZeroes(current_datetime.getDate()) + " " + utils.appendLeadingZeroes(current_datetime.getHours()) + ":" + utils.appendLeadingZeroes(current_datetime.getMinutes()) + ":" + utils.appendLeadingZeroes(current_datetime.getSeconds());
 
         let item = {
                     remoteParty: uri,
                     direction: direction,
                     type: 'history',
                     conference: true,
                     participants: participants,
                     media: ['audio', 'video'],
                     displayName: uri.split('@')[0],
                     sessionId: callUUID,
                     startTime: startTime,
                     stopTime: startTime,
                     startTimeObject: current_datetime,
                     duration: 0,
                     tags: ['history', 'local']
                     };
 
         const historyItem = Object.assign({}, item);
         let newHistory = this.state.localHistory;
         newHistory.push(historyItem);
         this.setState({localHistory: newHistory});
         storage.set('history', newHistory);
     }
 
     render() {
         //utils.timestampedLog('Render main app');
         let footerBox = <View style={styles.footer}><FooterBox /></View>;
 
         let extraStyles = {};
 
         if (this.state.localMedia || this.state.registrationState === 'registered') {
            footerBox = null;
         }
 
         return (
             <PaperProvider theme={theme}>
                 <Router history={history} ref="router">
                     <ImageBackground source={backgroundImage} style={{width: '100%', height: '100%'}}>
                                 <View style={mainStyle.MainContainer} onLayout={(event) => this.setState({
                                                                         Width_Layout : event.nativeEvent.layout.width,
                                                                         Height_Layout : event.nativeEvent.layout.height
                                                                         }, ()=> this._detectOrientation())}>
                         <SafeAreaView style={[styles.root, extraStyles]}>
                             <IncomingCallModal
                                 call={this.state.incomingCall}
                                 onAccept={this.callKeepAcceptCall}
                                 onReject={this.callKeepRejectCall}
                                 show={this.state.showIncomingModal}
                                 contacts = {this.contacts}
                             />
 
                             <LoadingScreen
                             text={this.state.loading}
                             show={this.state.loading !== null && this.currentRoute === '/login'}
                             orientation={this.state.orientation}
                             isTablet={this.state.isTablet}
                             />
                             <Switch>
                                 <Route exact path="/" component={this.main} />
                                 <Route exact path="/login" component={this.login} />
                                 <Route exact path="/logout" component={this.logout} />
                                 <Route exact path="/ready" component={this.ready} />
                                 <Route exact path="/call" component={this.call} />
                                 <Route exact path="/conference" component={this.conference} />
                                 <Route exact path="/preview" component={this.preview} />
                                 <Route component={this.notFound} />
                             </Switch>
 
                             <NotificationCenter ref="notificationCenter" />
 
                         </SafeAreaView>
                         </View>
                     </ImageBackground>
                 </Router>
             </PaperProvider>
         );
     }
 
     notFound(match) {
 
         const status = {
             title   : '404',
             message : 'Oops, the page your looking for can\'t found',
             level   : 'danger',
             width   : 'large'
         }
         return (
             <StatusBox
                 {...status}
             />
         );
     }
 
     saveHistoryForLater(history) {
         //console.log('Cache history for later', history.length)
         this.cachedHistory = history;
         storage.set('cachedHistory', history);
     }
 
     ready() {
         return (
             <Fragment>
                 <NavigationBar
                     notificationCenter = {this.notificationCenter}
                     account = {this.state.account}
                     logout = {this.logout}
                     preview = {this.startPreview}
                     connection = {this.state.connection}
                     registrationState = {this.state.registrationState}
                     orientation = {this.state.orientation}
                     isTablet = {this.state.isTablet}
                 />
                 <ReadyBox
                     account = {this.state.account}
                     password = {this.state.password}
                     config = {config}
                     startCall = {this.callKeepStartCall}
                     startConference = {this.callKeepStartConference}
                     missedTargetUri = {this.state.missedTargetUri}
                     orientation = {this.state.orientation}
                     contacts = {this.contacts}
                     isTablet = {this.state.isTablet}
                     localHistory = {this.state.localHistory}
                     refreshHistory = {this.state.refreshHistory}
                     cacheHistory = {this.saveHistoryForLater}
                     serverHistory = {this.cachedHistory}
                     myDisplayName = {this.state.myDisplayName}
                     myPhoneNumber = {this.state.myPhoneNumber}
                     deleteHistoryEntry = {this.deleteHistoryEntry}
                     saveInvitedParties = {this.saveInvitedParties}
                     myInvitedParties = {this.state.myInvitedParties}
                     setFavoriteUri = {this.setFavoriteUri}
                     setBlockedUri = {this.setBlockedUri}
                     favoriteUris = {this.state.favoriteUris}
                     blockedUris = {this.state.blockedUris}
                     defaultDomain = {this.state.defaultDomain}
                 />
             </Fragment>
         );
     }
 
     preview() {
         return (
             <Fragment>
                 <Preview
                     localMedia = {this.state.localMedia}
                     hangupCall = {this.hangupCall}
                     setDevice = {this.setDevice}
                     selectedDevices = {this.state.devices}
                 />
             </Fragment>
         );
     }
 
     call() {
         let call = this.state.currentCall || this.state.incomingCall;
 
         return (
             <Call
                 account = {this.state.account}
                 targetUri = {this.state.targetUri}
                 call = {call}
                 connection = {this.state.connection}
                 registrationState = {this.state.registrationState}
                 localMedia = {this.state.localMedia}
                 escalateToConference = {this.escalateToConference}
                 hangupCall = {this.hangupCall}
                 generatedVideoTrack = {this.state.generatedVideoTrack}
                 callKeepSendDtmf = {this.callKeepSendDtmf}
                 toggleMute = {this.toggleMute}
                 callKeepStartCall = {this.callKeepStartCall}
                 toggleSpeakerPhone = {this.toggleSpeakerPhone}
                 speakerPhoneEnabled = {this.state.speakerPhoneEnabled}
                 speakerphoneOn = {this.speakerphoneOn}
                 speakerphoneOff = {this.speakerphoneOff}
                 callUUID = {this.state.outgoingCallUUID}
                 contacts = {this.contacts}
                 intercomDtmfTone = {this.intercomDtmfTone}
                 orientation = {this.state.orientation}
                 isTablet = {this.state.isTablet}
                 reconnectingCall = {this.state.reconnectingCall}
                 muted = {this.state.muted}
             />
         )
     }
 
     conference() {
         let _previousParticipants = new Set();
 
         /*
         if (this.myParticipants) {
             let room = this.state.targetUri.split('@')[0];
             if (this.myParticipants.hasOwnProperty(room)) {
                 let uris = this.myParticipants[room];
                 if (uris) {
                     uris.forEach((uri) => {
                         if (uri.search(this.state.defaultDomain) > -1) {
                             let user = uri.split('@')[0];
                             _previousParticipants.add(user);
                         } else {
                             _previousParticipants.add(uri);
                         }
                     });
                 }
             }
         }
         */
 
         if (this.myInvitedParties) {
             let room = this.state.targetUri.split('@')[0];
             if (this.myInvitedParties.hasOwnProperty(room)) {
                 let uris = this.myInvitedParties[room];
                 if (uris) {
                     uris.forEach((uri) => {
-                        if (uri.search(this.state.defaultDomain) > -1) {
-                            let user = uri.split('@')[0];
-                            _previousParticipants.add(user);
-                        } else {
-                            _previousParticipants.add(uri);
-                        }
+                        _previousParticipants.add(uri);
                     });
                 }
             }
         }
 
         let previousParticipants = Array.from(_previousParticipants);
 
         return (
             <Conference
                 notificationCenter = {this.notificationCenter}
                 localMedia = {this.state.localMedia}
                 account = {this.state.account}
                 targetUri = {this.state.targetUri}
                 connection = {this.state.connection}
                 registrationState = {this.state.registrationState}
                 currentCall = {this.state.currentCall}
                 saveParticipant = {this.saveParticipant}
+                myInvitedParties = {this.state.myInvitedParties}
                 saveInvitedParties = {this.saveInvitedParties}
                 previousParticipants = {previousParticipants}
                 participantsToInvite = {this.state.participantsToInvite}
                 hangupCall = {this.hangupCall}
                 shareScreen = {this.switchScreensharing}
                 generatedVideoTrack = {this.state.generatedVideoTrack}
                 toggleMute = {this.toggleMute}
                 toggleSpeakerPhone = {this.toggleSpeakerPhone}
                 speakerPhoneEnabled = {this.state.speakerPhoneEnabled}
                 callUUID = {this.state.outgoingCallUUID}
                 proposedMedia = {this.state.outgoingMedia}
                 isLandscape = {this.state.orientation === 'landscape'}
                 isTablet = {this.state.isTablet}
                 muted = {this.state.muted}
                 defaultDomain = {this.state.defaultDomain}
                 startedByPush = {this.startedByPush}
                 inFocus = {this.state.inFocus}
                 reconnectingCall = {this.state.reconnectingCall}
                 contacts = {this.contacts}
+                setFavoriteUri = {this.setFavoriteUri}
+                favoriteUris = {this.state.favoriteUris}
             />
         )
     }
 
     conferenceByUri(urlParameters) {
         const targetUri = utils.normalizeUri(urlParameters.targetUri, config.defaultConferenceDomain);
         const idx = targetUri.indexOf('@');
         const uri = {};
         const pattern = /^[A-Za-z0-9\-\_]+$/g;
         uri.user = targetUri.substring(0, idx);
 
         // check if the uri.user is valid
         if (!pattern.test(uri.user)) {
             const status = {
                 title   : 'Invalid conference',
                 message : `Oops, the conference ID is invalid: ${targetUri}`,
                 level   : 'danger',
                 width   : 'large'
             }
             return (
                 <StatusBox
                     {...status}
                 />
             );
         }
 
         return (
             <ConferenceByUriBox
                 notificationCenter = {this.notificationCenter}
                 handler = {this.handleConferenceByUri}
                 targetUri = {targetUri}
                 localMedia = {this.state.localMedia}
                 account = {this.state.account}
                 currentCall = {this.state.currentCall}
                 hangupCall = {this.hangupCall}
                 shareScreen = {this.switchScreensharing}
                 generatedVideoTrack = {this.state.generatedVideoTrack}
             />
         );
     }
 
     login() {
         let registerBox;
         let statusBox;
         this.mustLogout = false;
 
         if (this.state.status !== null) {
             statusBox = (
                 <StatusBox
                     message={this.state.status.msg}
                     level={this.state.status.level}
                 />
             );
         }
 
         if (this.state.registrationState !== 'registered') {
             registerBox = (
                 <RegisterBox
                     registrationInProgress = {this.state.registrationState !== null && this.state.registrationState !== 'failed'}
                     handleRegistration = {this.handleRegistration}
                     autoLogin={this.state.autoLogin}
                     orientation = {this.state.orientation}
                     isTablet = {this.state.isTablet}
                     phoneNumber= {this.state.phoneNumber}
                 />
             );
         }
 
         return (
             <Fragment>
                 {registerBox}
                 {statusBox}
             </Fragment>
         );
     }
 
     logout() {
         this.callKeeper.setAvailable(false);
 
         if (!this.mustLogout && this.state.registrationState !== null && this.state.connection && this.state.connection.state === 'ready') {
             // remove token from server
             this.mustLogout = true;
             this.state.account.setDeviceToken('None', Platform.OS, deviceId, true, bundleId);
             this.state.account.register();
             return;
         }
 
         this.tokenSent = false;
         if (this.state.connection && this.state.account) {
             this.state.connection.removeAccount(this.state.account, (error) => {
                 if (error) {
                     logger.debug(error);
                 }
             });
         }
 
         storage.set('account', {accountId: this.state.accountId,
                                 password: this.state.password});
 
         this.serverHistory = [];
         this.setState({account: null,
                        registrationState: null,
                        registrationKeepalive: false,
                        status: null,
                        autoLogin: false,
                        history: [],
                        localHistory: [],
                        cachedHistory: [],
                        defaultDomain: config.defaultDomain
                        });
 
         this.changeRoute('/login');
         return null;
     }
 
     main() {
         return null;
     }
 }
 
 export default Sylk;
diff --git a/app/assets/styles/blink/_LocalMedia.scss b/app/assets/styles/blink/_LocalMedia.scss
index 1ef7794..15ae879 100644
--- a/app/assets/styles/blink/_LocalMedia.scss
+++ b/app/assets/styles/blink/_LocalMedia.scss
@@ -1,31 +1,60 @@
 .container {
     flex: 1;
     height: 100%;
     width: 100%;
 }
 
 .video {
 }
 
+.title {
+    padding-top: 20px;
+    font-size: 18px;
+    text-align: center;
+    color: white;
+}
+
+.description {
+    padding: 12px;
+    font-size: 16px;
+    text-align: center;
+    color: white;
+}
+
+.savebutton {
+    margin: 10px;
+    width: 150;
+}
+
+.backbutton {
+    margin: 10px;
+    width: 150;
+}
+
+.hangupbutton {
+    background-color: rgba(#a94442, .8);
+}
+
 .tabletButtonContainer {
     position: absolute;
     bottom: 60;
     width: 100%;
     z-index: 99;
     justify-content: center;
     align-items: center;
 }
 
 .buttonContainer {
     position: absolute;
-    bottom: 40;
+    bottom: 60;
     width: 100%;
     z-index: 99;
     justify-content: center;
     align-items: center;
 }
 
-.button {
-    background-color: rgba(#a94442, .8);
+.buttonRow {
+    flex-direction: row;
+    justify-content: center;
 }
 
diff --git a/app/components/AudioCallBox.js b/app/components/AudioCallBox.js
index c88ac79..fd7dce1 100644
--- a/app/components/AudioCallBox.js
+++ b/app/components/AudioCallBox.js
@@ -1,297 +1,297 @@
 import React, { Component } from 'react';
 import { View, Platform } from 'react-native';
 import { IconButton, Dialog, Text, ActivityIndicator, Colors } from 'react-native-paper';
 import PropTypes from 'prop-types';
 import autoBind from 'auto-bind';
 
 import EscalateConferenceModal from './EscalateConferenceModal';
 import CallOverlay from './CallOverlay';
 import DTMFModal from './DTMFModal';
 import UserIcon from './UserIcon';
 import styles from '../assets/styles/blink/_AudioCallBox.scss';
 import utils from '../utils';
 
 function toTitleCase(str) {
     return str.replace(
         /\w\S*/g,
         function(txt) {
             return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
         }
     );
 }
 
 
 class AudioCallBox extends Component {
     constructor(props) {
         super(props);
         autoBind(this);
 
         this.state = {
             remoteUri                   : this.props.remoteUri,
             remoteDisplayName           : this.props.remoteDisplayName,
             photo                       : this.props.photo,
             active                      : false,
             audioMuted                  : this.props.muted,
             showDtmfModal               : false,
             showEscalateConferenceModal : false,
             call                        : this.props.call,
             reconnectingCall            : this.props.reconnectingCall
         };
 
         this.remoteAudio = React.createRef();
         this.userHangup = false;
     }
 
     componentDidMount() {
         // This component is used both for as 'local media' and as the in-call component.
         // Thus, if the call is not null it means we are beyond the 'local media' phase
         // so don't call the mediaPlaying prop.
 
         if (this.state.call != null) {
             switch (this.state.call.state) {
                 case 'established':
                     this.attachStream(this.state.call);
                     break;
                 case 'incoming':
                     this.props.mediaPlaying();
                     // fall through
                 default:
                     this.state.call.on('stateChanged', this.callStateChanged);
                     break;
             }
         } else {
             this.props.mediaPlaying();
         }
     }
 
     componentWillUnmount() {
         if (this.state.call != null) {
             this.state.call.removeListener('stateChanged', this.callStateChanged);
         }
     }
 
     //getDerivedStateFromProps(nextProps, state) {
     UNSAFE_componentWillReceiveProps(nextProps) {
         if (nextProps.call !== null && nextProps.call !== this.state.call) {
             if (nextProps.call.state === 'established') {
                 this.attachStream(nextProps.call);
                 this.setState({reconnectingCall: false});
             } else if (nextProps.call.state === 'incoming') {
                 this.props.mediaPlaying();
             }
 
             nextProps.call.on('stateChanged', this.callStateChanged);
 
             if (this.state.call !== null) {
                 this.state.call.removeListener('stateChanged', this.callStateChanged);
             }
             this.setState({call: nextProps.call});
         }
 
         if (nextProps.reconnectingCall != this.state.reconnectingCall) {
             this.setState({reconnectingCall: nextProps.reconnectingCall});
         }
 
         if (nextProps.hasOwnProperty('muted')) {
             this.setState({audioMuted: nextProps.muted});
         }
 
         this.setState({remoteUri: nextProps.remoteUri,
                        remoteDisplayName: nextProps.remoteDisplayName,
                        photo: nextProps.photo
                        });
     }
 
     componentWillUnmount() {
         if (this.state.call != null) {
             this.state.call.removeListener('stateChanged', this.callStateChanged);
         }
         clearTimeout(this.callTimer);
     }
 
     callStateChanged(oldState, newState, data) {
         if (newState === 'established') {
             this.attachStream(this.state.call);
             this.setState({reconnectingCall: false});
         }
     }
 
     attachStream(call) {
         this.setState({stream: call.getRemoteStreams()[0]}); //we dont use it anywhere though as audio gets automatically piped
     }
 
     escalateToConference(participants) {
         this.props.escalateToConference(participants);
     }
 
     hangupCall(event) {
         event.preventDefault();
-        this.props.hangupCall('user_press_hangup');
+        this.props.hangupCall('user_hangup_call');
         this.userHangup = true;
     }
 
     cancelCall(event) {
         event.preventDefault();
-        this.props.hangupCall('user_cancelled');
+        this.props.hangupCall('user_cancelled_call');
     }
 
     muteAudio(event) {
         event.preventDefault();
         this.props.toggleMute(this.props.call.id, !this.state.audioMuted);
      }
 
     showDtmfModal() {
         this.setState({showDtmfModal: true});
     }
 
     hideDtmfModal() {
         this.setState({showDtmfModal: false});
     }
 
     toggleEscalateConferenceModal() {
         this.setState({
             showEscalateConferenceModal: !this.state.showEscalateConferenceModal
         });
     }
 
     render() {
         let buttonContainerClass;
         let userIconContainerClass;
 
         let remoteIdentity = {uri: this.state.remoteUri || '',
                               displayName: this.state.remoteDisplayName || '',
                               photo: this.state.photo
                               };
 
 
         let displayName = this.state.remoteUri ? toTitleCase(this.state.remoteUri.split('@')[0]) : '';
 
         if (this.state.remoteDisplayName && this.state.remoteUri !== this.state.remoteDisplayName) {
             displayName = this.state.remoteDisplayName;
         }
 
         if (this.props.isTablet) {
             buttonContainerClass = this.props.orientation === 'landscape' ? styles.tabletLandscapeButtonContainer : styles.tabletPortraitButtonContainer;
             userIconContainerClass = styles.tabletUserIconContainer;
         } else {
             buttonContainerClass = this.props.orientation === 'landscape' ? styles.landscapeButtonContainer : styles.portraitButtonContainer;
             userIconContainerClass = styles.userIconContainer;
         }
 
         const buttonSize = this.props.isTablet ? 40 : 34;
         const buttonClass = (Platform.OS === 'ios') ? styles.iosButton : styles.androidButton;
 
         return (
             <View style={styles.container}>
                 <CallOverlay style={styles.callStatus}
                     show={true}
                     remoteUri={this.state.remoteUri}
                     remoteDisplayName={this.state.remoteDisplayName}
                     call={this.state.call}
                     reconnectingCall={this.state.reconnectingCall}
                     connection={this.props.connection}
                     accountId={this.props.accountId}
                 />
                 <View style={userIconContainerClass}>
                     <UserIcon identity={remoteIdentity} large={true} active={this.state.active} />
                 </View>
 
                 <Dialog.Title style={styles.displayName}>{displayName}</Dialog.Title>
                 <Text style={styles.uri}>{this.state.remoteUri}</Text>
 
                 {this.props.orientation !== 'landscape' && this.state.reconnectingCall ?
                 <ActivityIndicator style={styles.activity} animating={true} size={'large'} color={Colors.red800} />
                 :
                 null
                 }
 
                 {this.state.call && ((this.state.call.state === 'accepted' || this.state.call.state === 'established') && !this.state.reconnectingCall) ?
                     <View style={buttonContainerClass}>
                     <IconButton
                         size={buttonSize}
                         style={buttonClass}
                         icon="account-plus"
                         onPress={this.toggleEscalateConferenceModal}
                     />
                     <IconButton
                         size={buttonSize}
                         style={buttonClass}
                         icon={this.state.audioMuted ? 'microphone-off' : 'microphone'}
                         onPress={this.muteAudio}
                     />
                     <IconButton
                         size={buttonSize}
                         style={buttonClass}
                         icon={this.props.speakerPhoneEnabled ? 'volume-high' : 'volume-off'}
                         onPress={this.props.toggleSpeakerPhone}
                     />
                     <IconButton
                         size={buttonSize}
                         style={buttonClass}
                         icon="dialpad"
                         onPress={this.showDtmfModal}
                         disabled={!(this.state.call && (this.state.call.state === 'accepted' || this.state.call.state === 'established'))}
                     />
                     <IconButton
                         size={buttonSize}
                         style={[buttonClass, styles.hangupButton]}
                         icon="phone-hangup"
                         onPress={this.hangupCall}
                     />
                     </View>
                     :
                     <View style={buttonContainerClass}>
                     <IconButton
                         size={buttonSize}
                         style={buttonClass}
                         icon={this.props.speakerPhoneEnabled ? 'volume-high' : 'volume-off'}
                         onPress={this.props.toggleSpeakerPhone}
                     />
                     <IconButton
                         size={buttonSize}
                         style={[buttonClass, styles.hangupButton]}
                         icon="phone-hangup"
                         onPress={this.cancelCall}
                     />
                     </View>
                 }
 
                 <DTMFModal
                     show={this.state.showDtmfModal}
                     hide={this.hideDtmfModal}
                     call={this.state.call}
                     callKeepSendDtmf={this.props.callKeepSendDtmf}
                 />
                 <EscalateConferenceModal
                     show={this.state.showEscalateConferenceModal}
                     call={this.state.call}
                     close={this.toggleEscalateConferenceModal}
                     escalateToConference={this.escalateToConference}
                 />
             </View>
         );
     }
 }
 
 AudioCallBox.propTypes = {
     remoteUri               : PropTypes.string,
     remoteDisplayName       : PropTypes.string,
     photo                   : PropTypes.string,
     call                    : PropTypes.object,
     connection              : PropTypes.object,
     accountId               : PropTypes.string,
     escalateToConference    : PropTypes.func,
     hangupCall              : PropTypes.func,
     mediaPlaying            : PropTypes.func,
     callKeepSendDtmf        : PropTypes.func,
     toggleMute              : PropTypes.func,
     toggleSpeakerPhone      : PropTypes.func,
     speakerPhoneEnabled     : PropTypes.bool,
     orientation             : PropTypes.string,
     isTablet                : PropTypes.bool,
     reconnectingCall        : PropTypes.bool,
     muted                   : PropTypes.bool
 
 };
 
 export default AudioCallBox;
diff --git a/app/components/CallOverlay.js b/app/components/CallOverlay.js
index d80e326..9b6300b 100644
--- a/app/components/CallOverlay.js
+++ b/app/components/CallOverlay.js
@@ -1,202 +1,199 @@
 import React from 'react';
 import { View, Text } from 'react-native';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import moment from 'moment';
 import momentFormat from 'moment-duration-format';
 import autoBind from 'auto-bind';
 import { Appbar } from 'react-native-paper';
 import Icon from  'react-native-vector-icons/MaterialCommunityIcons';
 import { Colors } from 'react-native-paper';
 import styles from '../assets/styles/blink/_AudioCallBox.scss';
 
 
 function toTitleCase(str) {
     return str.replace(
         /\w\S*/g,
         function(txt) {
             return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
         }
     );
 }
 
 
 class CallOverlay extends React.Component {
     constructor(props) {
         super(props);
         autoBind(this);
 
         this.state = {
             call: this.props.call,
             callState: this.props.call ? this.props.call.state : null,
             direction: this.props.call ? this.props.call.direction: null,
             remoteUri: this.props.remoteUri,
             remoteDisplayName: this.props.remoteDisplayName,
-            photo: this.props.photo,
             reconnectingCall: this.props.reconnectingCall
         }
 
         this.duration = null;
         this.finalDuration = null;
         this.timer = null;
         this._isMounted = true;
     }
 
     componentDidMount() {
         if (this.state.call) {
             if (this.state.call.state === 'established') {
                 this.startTimer();
             }
             this.state.call.on('stateChanged', this.callStateChanged);
             this.setState({callState: this.state.call.state});
         }
     }
 
     //getDerivedStateFromProps(nextProps, state) {
     UNSAFE_componentWillReceiveProps(nextProps) {
         if (!this._isMounted) {
             return;
         }
 
         if (nextProps.reconnectingCall != this.state.reconnectingCall) {
             this.setState({reconnectingCall: nextProps.reconnectingCall});
         }
 
         if (nextProps.call !== null && nextProps.call !== this.state.call) {
             nextProps.call.on('stateChanged', this.callStateChanged);
 
             if (this.state.call !== null) {
                 this.state.call.removeListener('stateChanged', this.callStateChanged);
             }
 
             this.setState({call: nextProps.call});
         }
 
         this.setState({remoteDisplayName: nextProps.remoteDisplayName, remoteUri: nextProps.remoteUri});
     }
 
     componentWillUnmount() {
         this._isMounted = false;
 
         if (this.state.call) {
             this.state.call.removeListener('stateChanged', this.callStateChanged);
         }
 
         clearTimeout(this.timer);
     }
 
     callStateChanged(oldState, newState, data) {
         if (newState === 'established' && this._isMounted) {
             this.startTimer();
         }
 
         if (newState === 'terminated') {
             if (this.state.call) {
                 this.state.call.removeListener('stateChanged', this.callStateChanged);
             }
 
             clearTimeout(this.timer);
             this.finalDuration = this.duration;
             this.duration = null;
             this.timer = null;
         }
 
         if (!this._isMounted) {
             return;
         }
         this.setState({callState: newState});
     }
 
     startTimer() {
         if (this.timer !== null) {
             // already armed
             return;
         }
 
         // TODO: consider using window.requestAnimationFrame
 
         const startTime = new Date();
         this.duration = moment.duration(new Date() - startTime).format('hh:mm:ss', {trim: false});
 
         this.timer = setInterval(() => {
             this.duration = moment.duration(new Date() - startTime).format('hh:mm:ss', {trim: false});
             if (this.props.show) {
                 this.forceUpdate();
             }
         }, 1000);
     }
 
     render() {
         let header = null;
 
         let displayName = this.state.remoteUri;
 
         if (this.state.remoteDisplayName && this.state.remoteDisplayName !== this.state.remoteUri) {
             displayName = this.state.remoteDisplayName;
         }
 
         if (this.props.show) {
             let callDetail;
 
             if (this.duration) {
                 callDetail = <View><Icon name="clock"/><Text>{this.duration}</Text></View>;
                 callDetail = 'Duration: ' + this.duration;
             } else {
                 if (this.state.reconnectingCall) {
                     callDetail = 'Reconnecting the call...';
                 } else if (this.state.callState === 'terminated') {
                     callDetail = this.finalDuration ? 'Call ended after ' + this.finalDuration : 'Call ended';
                 } else {
                    if (this.state.callState) {
                        if (this.state.callState === 'incoming') {
                            callDetail = 'Waiting for incoming call...';
                        } else {
                            callDetail = toTitleCase(this.state.callState);
                        }
 
                    } else if (this.state.direction) {
                        callDetail = 'Connecting', this.state.direction, 'call...';
                    } else {
                        callDetail = 'Connecting...';
                    }
                 }
             }
 
             if (this.state.remoteUri && this.state.remoteUri.search('videoconference') > -1) {
                 displayName = this.state.remoteUri.split('@')[0];
 
                 header = (
                     <Appbar.Header style={{backgroundColor: 'black'}}>
                         <Appbar.Content
                             title={`Conference: ${displayName}`} subtitle={callDetail}
                         />
                     </Appbar.Header>
                 );
             } else {
                 header = (
                     <Appbar.Header style={styles.appbarContainer}>
                         <Appbar.Content
                             title={`Call with ${displayName}`} subtitle={callDetail}
                         />
                     </Appbar.Header>
                 );
             }
         }
 
         return header
     }
 }
 
 CallOverlay.propTypes = {
     show: PropTypes.bool.isRequired,
     remoteUri: PropTypes.string,
     remoteDisplayName: PropTypes.string,
-    photo: PropTypes.object,
-    accountId: PropTypes.string,
     call: PropTypes.object,
     connection: PropTypes.object,
     reconnectingCall: PropTypes.bool
 };
 
 
 export default CallOverlay;
diff --git a/app/components/Conference.js b/app/components/Conference.js
index 0b237ed..f09e6d9 100644
--- a/app/components/Conference.js
+++ b/app/components/Conference.js
@@ -1,304 +1,395 @@
 import React from 'react';
 import { View } from 'react-native';
 import PropTypes from 'prop-types';
 import assert from 'assert';
 import debug from 'react-native-debug';
 import autoBind from 'auto-bind';
 
 import ConferenceBox from './ConferenceBox';
 import LocalMedia from './LocalMedia';
 import config from '../config';
 import utils from '../utils';
 
 const DEBUG = debug('blinkrtc:Conference');
 debug.enable('*');
 
 
 class Conference extends React.Component {
     constructor(props) {
         super(props);
         autoBind(this);
 
         this.defaultWaitInterval = 90; // until we can connect or reconnect
         this.waitCounter = 0;
         this.waitInterval = this.defaultWaitInterval;
 
         this.userHangup = false;
-        this.confCall = null;
         this.ended = false;
         this.started = false;
+        this.participants = [];
 
         this.state = {
               currentCall: null,
+              targetUri: this.props.targetUri,
               callUUID: this.props.callUUID,
               localMedia: this.props.localMedia,
               connection: this.props.connection,
               account: this.props.account,
               registrationState: this.props.registrationState,
               startedByPush: this.props.startedByPush,
-              reconnectingCall: this.props.reconnectingCall
+              reconnectingCall: this.props.reconnectingCall,
+              myInvitedParties: this.props.myInvitedParties,
+              isFavorite: this.props.favoriteUris.indexOf(this.props.targetUri) > -1
               }
 
         if (this.props.connection) {
             this.props.connection.on('stateChanged', this.connectionStateChanged);
         }
 
+        this.props.participantsToInvite.forEach((p) => {
+            if (this.participants.indexOf(p) === -1) {
+                this.participants.push(p);
+            }
+        });
     }
 
     componentWillUnmount() {
         this.ended = true;
 
         if (this.state.currentCall) {
             this.state.currentCall.removeListener('stateChanged', this.callStateChanged);
         }
 
         if (this.state.connection) {
             this.state.connection.removeListener('stateChanged', this.connectionStateChanged);
         }
     }
 
     callStateChanged(oldState, newState, data) {
         utils.timestampedLog('Conference: callStateChanged', oldState, '->', newState);
         if (newState === 'established') {
             this.setState({reconnectingCall: false});
         }
     }
 
     connectionStateChanged(oldState, newState) {
         switch (newState) {
             case 'disconnected':
                 if (oldState === 'ready') {
                     utils.timestampedLog('Conference: connection failed, reconnecting the call...');
                     this.waitInterval = this.defaultWaitInterval;
                 }
                 break;
             default:
                 break;
         }
     }
 
     //getDerivedStateFromProps(nextProps, state) {
     UNSAFE_componentWillReceiveProps(nextProps) {
         //console.log('Conference got props');
 
         if (nextProps.account !== null && nextProps.account !== this.props.account) {
             this.setState({account: nextProps.account});
         }
 
         this.setState({registrationState: nextProps.registrationState});
 
         if (nextProps.connection !== null && nextProps.connection !== this.state.connection) {
             this.setState({connection: nextProps.connection});
             nextProps.connection.on('stateChanged', this.connectionStateChanged);
         }
 
         if (nextProps.reconnectingCall !== this.state.reconnectingCall) {
             this.setState({reconnectingCall: nextProps.reconnectingCall});
         }
 
         if (nextProps.localMedia !== null && nextProps.localMedia !== this.state.localMedia) {
             this.setState({localMedia: nextProps.localMedia});
         }
 
         if (nextProps.callUUID !== null && this.state.callUUID !== nextProps.callUUID) {
             this.setState({callUUID: nextProps.callUUID,
                            reconnectingCall: true,
                            currentCall: null});
 
             this.startCallWhenReady();
         }
+
+        this.setState({myInvitedParties: nextProps.myInvitedParties,
+                       isFavorite: nextProps.favoriteUris.indexOf(this.props.targetUri) > -1
+                       });
     }
 
     mediaPlaying() {
         this.startCallWhenReady();
     }
 
     canConnect() {
         if (!this.state.localMedia) {
             console.log('Conference: no local media');
             return false;
         }
 
         if (!this.state.connection) {
             console.log('Conference: no connection yet');
             return false;
         }
 
         if (this.state.connection.state !== 'ready') {
             console.log('Conference: connection is not ready');
             return false;
         }
 
         if (!this.state.account) {
             console.log('Conference: no account yet');
             return false;
         }
 
         if (this.state.registrationState !== 'registered') {
             console.log('Conference: account not ready yet');
             return false;
         }
 
         if (this.state.currentCall) {
             console.log('Conference: call already in progress');
             return false;
         }
 
         return true;
     }
 
     async startCallWhenReady() {
         utils.timestampedLog('Conference: start conference', this.state.callUUID, 'when ready to', this.props.targetUri);
         this.waitCounter = 0;
 
         //utils.timestampedLog('Conference: waiting for connecting to the conference', this.waitInterval, 'seconds');
 
         let diff = 0;
 
         while (this.waitCounter < this.waitInterval) {
             if (this.userHangup) {
-                this.props.hangupCall(this.state.callUUID, 'user_cancelled');
+                this.props.hangupCall(this.state.callUUID, 'user_cancelled_conference');
                 return;
             }
 
             if (this.state.currentCall) {
                 return;
             }
 
             if (this.waitCounter >= this.waitInterval - 1) {
                 utils.timestampedLog('Conference: cancelling conference', this.state.callUUID);
                 this.props.hangupCall(this.state.callUUID, 'timeout');
             }
 
             if (!this.canConnect()) {
                 //console.log('Waiting', this.waitCounter);
                 await this._sleep(1000);
             } else {
                 this.waitCounter = 0;
                 this.start();
                 return;
             }
 
             this.waitCounter++;
         }
     }
 
     _sleep(ms) {
         return new Promise(resolve => setTimeout(resolve, ms));
     }
 
     start() {
         const options = {
             id: this.state.callUUID,
             pcConfig: {iceServers: config.iceServers},
             localStream: this.state.localMedia,
             audio: this.props.proposedMedia.audio,
             video: this.props.proposedMedia.video,
             offerOptions: {
                 offerToReceiveAudio: false,
                 offerToReceiveVideo: false
             },
             initialParticipants: this.props.participantsToInvite
         };
         utils.timestampedLog('Conference: Sylkrtc.js will start conference call', this.state.callUUID, 'to', this.props.targetUri.toLowerCase());
         confCall = this.state.account.joinConference(this.props.targetUri.toLowerCase(), options);
         if (confCall) {
             confCall.on('stateChanged', this.callStateChanged);
             this.setState({currentCall: confCall});
         }
     }
 
-    hangup() {
-        this.props.hangupCall(this.state.callUUID, 'user_press_hangup');
+    saveParticipant(callUUID, room, uri) {
+        console.log('Save saveParticipant', uri);
+        if (this.participants.indexOf(uri) === -1) {
+            this.participants.push(uri);
+        }
+        this.props.saveParticipant(callUUID, room, uri);
+    }
+
+    showSaveDialog() {
+        if (!this.userHangup) {
+            //console.log('No show dialog because user did not hangup')
+            return false;
+        }
+
+        if (this.state.reconnectingCall) {
+            console.log('No show dialog because call is reconnecting')
+            return false;
+        }
+
+        if (this.participants.length === 0) {
+            console.log('No show dialog because there are no participants')
+            return false;
+        }
+
+        if (this.state.isFavorite) {
+            let room = this.state.targetUri.split('@')[0];
+            let must_display = false;
+            if (this.props.myInvitedParties.hasOwnProperty(room)) {
+                let old_participants = this.state.myInvitedParties[room];
+                console.log('old participants', old_participants);
+                this.participants.forEach((p) => {
+                    if (old_participants.indexOf(p) === -1) {
+                        console.log(p, 'is not in', old_participants);
+                        must_display = true;
+                    }
+                });
+            }
+
+            return must_display;
+
+            console.log('No show dialog because is already favorite with same participants')
+            console.log('new participants', this.participants);
+        }
+
+        return true;
+    }
+
+    saveConference() {
+        if (!this.state.isFavorite) {
+            this.props.setFavoriteUri(this.props.targetUri);
+        }
+
+        let room = this.state.targetUri.split('@')[0];
+        if (this.props.myInvitedParties.hasOwnProperty(room)) {
+            let participants = this.state.myInvitedParties[room];
+            this.participants.forEach((p) => {
+                if (participants.indexOf(p) === -1) {
+                    participants.push(p);
+                }
+            });
+
+            this.props.saveInvitedParties(this.props.targetUri, participants);
+        } else {
+            this.props.saveInvitedParties(this.props.targetUri, this.participants);
+        }
+
+        this.props.hangupCall(this.state.callUUID, 'user_hangup_conference_confirmed');
+    }
+
+    hangup(reason='user_hangup_conference') {
         this.userHangup = true;
 
+        if (!this.showSaveDialog()) {
+            reason = 'user_hangup_conference_confirmed';
+        }
+
+        this.props.hangupCall(this.state.callUUID, reason);
+
         if (this.waitCounter > 0) {
             this.waitCounter = this.waitInterval;
         }
     }
 
     render() {
         let box = null;
 
         if (this.state.localMedia !== null) {
-            if (this.state.currentCall != null && this.state.currentCall.state === 'established') {
+            if (this.state.currentCall != null && (this.state.currentCall.state === 'established')) {
                 box = (
                     <ConferenceBox
                         notificationCenter = {this.props.notificationCenter}
                         call = {this.state.currentCall}
                         audioOnly = {!this.props.proposedMedia.video}
                         reconnectingCall={this.state.reconnectingCall}
                         connection = {this.state.connection}
                         hangup = {this.hangup}
-                        saveParticipant = {this.props.saveParticipant}
+                        saveParticipant = {this.saveParticipant}
                         saveInvitedParties = {this.props.saveInvitedParties}
                         previousParticipants = {this.props.previousParticipants}
                         remoteUri = {this.props.targetUri}
                         shareScreen = {this.props.shareScreen}
                         generatedVideoTrack = {this.props.generatedVideoTrack}
                         speakerPhoneEnabled = {this.props.speakerPhoneEnabled}
                         toggleMute = {this.props.toggleMute}
                         toggleSpeakerPhone = {this.props.toggleSpeakerPhone}
                         isLandscape = {this.props.isLandscape}
                         isTablet = {this.props.isTablet}
                         muted = {this.props.muted}
                         defaultDomain = {this.props.defaultDomain}
                         inFocus = {this.props.inFocus}
                         reconnectingCall={this.state.reconnectingCall}
                         contacts={this.props.contacts}
                         initialParticipants={this.props.participantsToInvite}
                    />
                 );
             } else {
                 box = (
                     <LocalMedia
                         call = {this.state.currentCall}
-                        connection = {this.state.connection}
                         remoteUri = {this.props.targetUri}
                         remoteDisplayName = {this.props.targetUri}
                         localMedia = {this.state.localMedia}
                         mediaPlaying = {this.mediaPlaying}
                         hangupCall = {this.hangup}
-                        generatedVideoTrack = {this.props.generatedVideoTrack}
+                        showSaveDialog={this.showSaveDialog}
+                        saveConference={this.saveConference}
+                        connection={this.state.connection}
+                        participants={this.participants}
                     />
                 );
             }
 
         } else {
             console.log('Error: cannot start conference without local media');
         }
 
         return box;
     }
 }
 
 Conference.propTypes = {
     notificationCenter      : PropTypes.func,
     account                 : PropTypes.object,
     connection              : PropTypes.object,
     registrationState       : PropTypes.string,
     hangupCall              : PropTypes.func,
     saveParticipant         : PropTypes.func,
     saveInvitedParties      : PropTypes.func,
     previousParticipants    : PropTypes.array,
     currentCall             : PropTypes.object,
     localMedia              : PropTypes.object,
     targetUri               : PropTypes.string,
     participantsToInvite    : PropTypes.array,
     generatedVideoTrack     : PropTypes.bool,
     toggleMute              : PropTypes.func,
     toggleSpeakerPhone      : PropTypes.func,
     callUUID                : PropTypes.string,
     proposedMedia           : PropTypes.object,
     isLandscape             : PropTypes.bool,
     isTablet                : PropTypes.bool,
     muted                   : PropTypes.bool,
     defaultDomain           : PropTypes.string,
     startedByPush           : PropTypes.bool,
     inFocus                 : PropTypes.bool,
+    setFavoriteUri          : PropTypes.func,
+    saveInvitedParties      : PropTypes.func,
     reconnectingCall        : PropTypes.bool,
-    contacts                : PropTypes.array
+    contacts                : PropTypes.array,
+    favoriteUris            : PropTypes.array
 };
 
 
 export default Conference;
diff --git a/app/components/ConferenceBox.js b/app/components/ConferenceBox.js
index ebaa80f..a86d7ac 100644
--- a/app/components/ConferenceBox.js
+++ b/app/components/ConferenceBox.js
@@ -1,1140 +1,1149 @@
 'use strict';
 
 import React, {Component, Fragment} from 'react';
 import { View, Platform, TouchableWithoutFeedback, Dimensions, SafeAreaView, ScrollView, FlatList } from 'react-native';
 import PropTypes from 'prop-types';
 import * as sylkrtc from 'react-native-sylkrtc';
 import classNames from 'classnames';
 import debug from 'react-native-debug';
 import superagent from 'superagent';
 import autoBind from 'auto-bind';
 import { RTCView } from 'react-native-webrtc';
 import { IconButton, Appbar, Portal, Modal, Surface, Paragraph } from 'react-native-paper';
 
 import config from '../config';
 import utils from '../utils';
 //import AudioPlayer from './AudioPlayer';
 import ConferenceDrawer from './ConferenceDrawer';
 import ConferenceDrawerLog from './ConferenceDrawerLog';
 // import ConferenceDrawerFiles from './ConferenceDrawerFiles';
 import ConferenceDrawerParticipant from './ConferenceDrawerParticipant';
 import ConferenceDrawerParticipantList from './ConferenceDrawerParticipantList';
 import ConferenceDrawerSpeakerSelection from './ConferenceDrawerSpeakerSelection';
 import ConferenceDrawerSpeakerSelectionWrapper from './ConferenceDrawerSpeakerSelectionWrapper';
 import ConferenceHeader from './ConferenceHeader';
 import ConferenceCarousel from './ConferenceCarousel';
 import ConferenceParticipant from './ConferenceParticipant';
 import ConferenceMatrixParticipant from './ConferenceMatrixParticipant';
 import ConferenceParticipantSelf from './ConferenceParticipantSelf';
 import InviteParticipantsModal from './InviteParticipantsModal';
 import ConferenceAudioParticipantList from './ConferenceAudioParticipantList';
 import ConferenceAudioParticipant from './ConferenceAudioParticipant';
 
 import styles from '../assets/styles/blink/_ConferenceBox.scss';
 
 const DEBUG = debug('blinkrtc:ConferenceBox');
 debug.enable('*');
 
 
 function toTitleCase(str) {
     return str.replace(
         /\w\S*/g,
         function(txt) {
             return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
         }
     );
 }
 
 class ConferenceBox extends Component {
     constructor(props) {
         super(props);
         autoBind(this);
 
         this.state = {
             callOverlayVisible: true,
+            ended: false,
             audioMuted: this.props.muted,
             videoMuted: !this.props.inFocus,
             videoMutedbyUser: false,
             participants: props.call.participants.slice(),
             showInviteModal: false,
             showDrawer: false,
             showFiles: false,
             shareOverlayVisible: false,
             showSpeakerSelection: false,
             activeSpeakers: props.call.activeParticipants.slice(),
             selfDisplayedLarge: false,
             eventLog: [],
             sharedFiles: props.call.sharedFiles.slice(),
             largeVideoStream: null,
             previousParticipants: this.props.previousParticipants,
             inFocus:  this.props.inFocus,
-            reconnectingCall: this.props.reconnectingCall
+            reconnectingCall: this.props.reconnectingCall,
+            terminated: this.props.terminated
         };
 
         const friendlyName = this.props.remoteUri.split('@')[0];
         //if (window.location.origin.startsWith('file://')) {
             this.callUrl = `${config.publicUrl}/conference/${friendlyName}`;
         //} else {
         //    this.callUrl = `${window.location.origin}/conference/${friendlyName}`;
         //}
 
         const emailMessage  = `You can join me in the conference using a Web browser at ${this.callUrl} ` +
                              'or by using the freely available Sylk WebRTC client app at http://sylkserver.com';
         const subject       = 'Join me, maybe?';
 
         this.emailLink = `mailto:?subject=${encodeURI(subject)}&body=${encodeURI(emailMessage)}`;
 
         this.overlayTimer = null;
         this.logEvent = {};
         this.haveVideo = false;
         this.uploads = [];
         this.selectSpeaker = 1;
         this.foundContacts = new Map();
         if (this.props.call) {
             this.lookupContact(this.props.call.localIdentity._uri, this.props.call.localIdentity._displayName);
         }
 
         [
             'error',
             'warning',
             'info',
             'debug'
         ].forEach((level) => {
             this.logEvent[level] = (
                 (action, messages, originator) => {
                     const log = this.state.eventLog.slice();
                     log.unshift({originator, originator, level: level, action: action, messages: messages});
                     this.setState({eventLog: log});
                 }
             );
         });
 
         this.invitedParticipants = new Map();
 
         props.initialParticipants.forEach((uri) => {
             this.invitedParticipants.set(uri, {timestamp: Date.now(), status: 'Invited'})
             this.lookupContact(uri);
         });
 
         this.participantsTimer = setInterval(() => {
              this.updateParticipantsStatus();
         }, 5000);
 
     }
 
     updateParticipantsStatus() {
         let participants_uris = [];
 
         this.state.participants.forEach((p) => {
             participants_uris.push(p.identity._uri);
         });
 
         const invitedParties = Array.from(this.invitedParticipants.keys());
         //console.log('Invited participants', invitedParties);
         //console.log('Current participants', participants_uris);
 
         let p;
         let interval;
         invitedParties.forEach((_uri) => {
             if (participants_uris.indexOf(_uri) > 0) {
                 this.invitedParticipants.delete(_uri);
             }
 
             p = this.invitedParticipants.get(_uri);
             interval = Math.floor((Date.now() - p.timestamp) / 1000);
             console.log(_uri, 'was invited', interval, 'seconds ago');
 
             if (interval >= 60) {
                 this.invitedParticipants.delete(_uri);
                 this.forceUpdate();
             }
 
             if (p.status.indexOf('Invited') > -1) {
                 if (interval > 45) {
                     p.status = 'No answer';
                 } else {
                     const dot = p.status.indexOf('.') > -1 ? '.' : ' .';
                     p.status = p.status + dot;
                 }
                 this.forceUpdate();
             }
         });
     }
 
     componentDidMount() {
         for (let p of this.state.participants) {
             p.on('stateChanged', this.onParticipantStateChanged);
             p.attach();
         }
         this.props.call.on('participantJoined', this.onParticipantJoined);
         this.props.call.on('participantLeft', this.onParticipantLeft);
         this.props.call.on('roomConfigured', this.onConfigureRoom);
         this.props.call.on('fileSharing', this.onFileSharing);
 
         if (this.state.participants.length > 1) {
             this.armOverlayTimer();
         }
 
         // attach to ourselves first if there are no other participants
         if (this.state.participants.length === 0) {
             setTimeout(() => {
                 const item = {
                     stream: this.props.call.getLocalStreams()[0],
                     identity: this.props.call.localIdentity
                 };
                 this.selectVideo(item);
             });
         } else {
             this.state.participants.forEach((p) => {
-                if (p.identity._uri.search('guest.') === -1) {
+                if (p.identity._uri.search('guest.') === -1 && p.identity._uri !== this.props.call.localIdentity._uri) {
                     // used for history item
                     this.props.saveParticipant(this.props.call.id, this.props.remoteUri.split('@')[0], p.identity._uri);
                     this.lookupContact(p.identity._uri, p.identity._displayName);
                 }
             });
             // this.changeResolution();
         }
 
         if (this.props.call.getLocalStreams()[0].getVideoTracks().length !== 0) {
             this.haveVideo = true;
         }
 
         if (this.state.videoMuted) {
             console.log('Started video muted');
             this._muteVideo();
         } else {
             console.log('Started video active');
         }
     }
 
     componentWillUnmount() {
         clearTimeout(this.overlayTimer);
         clearTimeout(this.participantsTimer);
         this.uploads.forEach((upload) => {
             this.props.notificationCenter().removeNotification(upload[1]);
             upload[0].abort();
         })
     }
 
     //getDerivedStateFromProps(nextProps, state) {
     UNSAFE_componentWillReceiveProps(nextProps) {
         if (nextProps.hasOwnProperty('muted')) {
             this.setState({audioMuted: nextProps.muted});
         }
 
         if (nextProps.inFocus !== this.state.inFocus) {
             if (nextProps.inFocus) {
                 if (!this.state.videoMutedbyUser) {
                     this._resumeVideo();
                 }
             } else {
                 this._muteVideo();
             }
             this.setState({inFocus: nextProps.inFocus});
         }
 
         if (nextProps.reconnectingCall !== this.state.reconnectingCall) {
             this.setState({reconnectingCall: nextProps.reconnectingCall});
         }
+
+        this.setState({terminated: nextProps.terminated});
     }
 
     findObjectByKey(array, key, value) {
         for (var i = 0; i < array.length; i++) {
             if (array[i][key] === value) {
                 return array[i];
             }
         }
         return null;
     }
 
     lookupContact(uri, displayName) {
         let photo;
         let username =  uri.split('@')[0];
 
         if (this.props.contacts) {
             let username = uri.split('@')[0];
             let isPhoneNumber = username.match(/^(\+|0)(\d+)$/);
 
             if (isPhoneNumber) {
                 var contact_obj = this.findObjectByKey(this.props.contacts, 'remoteParty', username);
             } else {
                 var contact_obj = this.findObjectByKey(this.props.contacts, 'remoteParty', uri);
             }
 
             if (contact_obj) {
                 displayName = contact_obj.displayName;
                 photo = contact_obj.photo;
                 if (isPhoneNumber) {
                     uri = username;
                 }
             } else {
                 if (isPhoneNumber) {
                     uri = username;
                     displayName = toTitleCase(username);
                 }
             }
         }
 
         const c = {photo: photo, displayName: displayName || toTitleCase(username)};
         this.foundContacts.set(uri, c)
     }
 
     onParticipantJoined(p) {
         DEBUG(`Participant joined: ${p.identity}`);
-        if (p.identity._uri.search('guest.') === -1 && p.identity._uri !== this.props.call.localIdentity._uri ) {
+        if (p.identity._uri.search('guest.') === -1 && p.identity._uri !== this.props.call.localIdentity._uri) {
             // used for history item
             this.props.saveParticipant(this.props.call.id, this.props.remoteUri.split('@')[0], p.identity._uri);
         }
 
         this.lookupContact(p.identity._uri, p.identity._displayName);
         if (this.invitedParticipants.has(p.identity._uri)) {
             this.invitedParticipants.delete(p.identity._uri);
         }
         // this.refs.audioPlayerParticipantJoined.play();
         p.on('stateChanged', this.onParticipantStateChanged);
         p.attach();
         this.setState({
             participants: this.state.participants.concat([p])
         });
         // this.changeResolution();
         if (this.state.participants.length > 1) {
             this.armOverlayTimer();
         } else {
             this.setState({callOverlayVisible: true});
         }
     }
 
     onParticipantLeft(p) {
         DEBUG(`Participant left: ${p.identity}`);
         // this.refs.audioPlayerParticipantLeft.play();
         const participants = this.state.participants.slice();
         const idx = participants.indexOf(p);
         if (idx !== -1) {
             participants.splice(idx, 1);
             this.setState({
                 participants: participants
             });
         }
         p.detach(true);
         // this.changeResolution();
         if (this.state.participants.length > 1) {
             this.armOverlayTimer();
         } else {
             this.setState({callOverlayVisible: true});
         }
     }
 
     onParticipantStateChanged(oldState, newState) {
         if (newState === 'established' || newState === null) {
             this.maybeSwitchLargeVideo();
         }
     }
 
     onConfigureRoom(config) {
         const newState = {};
         newState.activeSpeakers = config.activeParticipants;
         this.setState(newState);
 
         if (config.activeParticipants.length === 0) {
             this.logEvent.info('set speakers to', ['Nobody'], config.originator);
         } else {
             const speakers = config.activeParticipants.map((p) => {return p.identity.displayName || p.identity.uri});
             this.logEvent.info('set speakers to', speakers, config.originator);
         }
         this.maybeSwitchLargeVideo();
     }
 
     onFileSharing(files) {
         let stateFiles = this.state.sharedFiles;
         stateFiles = stateFiles.concat(files);
         this.setState({sharedFiles: stateFiles});
         files.forEach((file)=>{
             if (file.session !== this.props.call.id) {
                 this.props.notificationCenter().postFileShared(file, this.showFiles);
             }
         })
     }
 
     onVideoSelected(item) {
         const participants = this.state.participants.slice();
         const idx = participants.indexOf(item);
         participants.splice(idx, 1);
         participants.unshift(item);
         if (item.videoPaused) {
             item.resumeVideo();
         }
         this.setState({
             participants: participants
         });
     }
 
     changeResolution() {
         let stream = this.props.call.getLocalStreams()[0];
         if (this.state.participants.length < 2) {
             this.props.call.scaleLocalTrack(stream, 1.5);
         } else if (this.state.participants.length < 5) {
             this.props.call.scaleLocalTrack(stream, 2);
         } else {
             this.props.call.scaleLocalTrack(stream, 1);
         }
     }
 
     selectVideo(item) {
         DEBUG('Switching video to: %o', item);
         if (item.stream) {
             this.setState({selfDisplayedLarge: true, largeVideoStream: item.stream});
         }
     }
 
     maybeSwitchLargeVideo() {
         // Switch the large video to another source, maybe.
         if (this.state.participants.length === 0 && !this.state.selfDisplayedLarge) {
             // none of the participants are eligible, show ourselves
             const item = {
                 stream: this.props.call.getLocalStreams()[0],
                 identity: this.props.call.localIdentity
             };
             this.selectVideo(item);
         } else if (this.state.selfDisplayedLarge) {
             this.setState({selfDisplayedLarge: false});
         }
     }
 
     handleClipboardButton() {
         utils.copyToClipboard(this.callUrl);
         this.props.notificationCenter().postSystemNotification('Join me, maybe?', {body: 'Link copied to the clipboard'});
         this.setState({shareOverlayVisible: false});
     }
 
     handleEmailButton(event) {
         // if (navigator.userAgent.indexOf('Chrome') > 0) {
         //     let emailWindow = window.open(this.emailLink, '_blank');
         //     setTimeout(() => {
         //         emailWindow.close();
         //     }, 500);
         // } else {
         //     window.open(this.emailLink, '_self');
         // }
         this.setState({shareOverlayVisible: false});
     }
 
     handleShareOverlayEntered() {
         this.setState({shareOverlayVisible: true});
     }
 
     handleShareOverlayExited() {
         this.setState({shareOverlayVisible: false});
     }
 
     handleActiveSpeakerSelected(participant, secondVideo=false) {      // eslint-disable-line space-infix-ops
         let newActiveSpeakers = this.state.activeSpeakers.slice();
         if (secondVideo) {
             if (participant.id !== 'none') {
                 if (newActiveSpeakers.length >= 1) {
                     newActiveSpeakers[1] = participant;
                 } else {
                     newActiveSpeakers[0] = participant;
                 }
             } else {
                 newActiveSpeakers.splice(1,1);
             }
         } else {
             if (participant.id !== 'none') {
                 newActiveSpeakers[0] = participant;
             } else {
                 newActiveSpeakers.shift();
             }
         }
         this.props.call.configureRoom(newActiveSpeakers.map((element) => element.publisherId), (error) => {
             if (error) {
                 // This causes a state update, hence the drawer lists update
                 this.logEvent.error('set speakers failed', [], this.localIdentity);
             }
         });
     }
 
     handleDrop(files) {
         DEBUG('Dropped file %o', files);
         this.uploadFiles(files);
     };
 
     handleFiles(e) {
         DEBUG('Selected files %o', e.target.files);
         this.uploadFiles(e.target.files);
         event.target.value = '';
     }
 
     toggleSpeakerSelection() {
         this.setState({showSpeakerSelection: !this.state.showSpeakerSelection});
     }
 
     startSpeakerSelection(number) {
         this.selectSpeaker = number;
         this.toggleSpeakerSelection();
     }
 
     uploadFiles(files) {
         for (var key in files) {
             // is the item a File?
             if (files.hasOwnProperty(key) && files[key] instanceof File) {
                 let uploadRequest;
                 let complete = false;
                 const filename = files[key].name
                 let progressNotification = this.props.notificationCenter().postFileUploadProgress(
                     filename,
                     (notification) => {
                         if (!complete) {
                             uploadRequest.abort();
                             this.uploads.splice(this.uploads.indexOf(uploadRequest), 1);
                         }
                     }
                 );
                 uploadRequest = superagent
                 .post(`${config.fileSharingUrl}/${this.props.remoteUri}/${this.props.call.id}/${filename}`)
                 .send(files[key])
                 .on('progress', (e) => {
                     this.props.notificationCenter().editFileUploadNotification(e.percent, progressNotification);
                 })
                 .end((err, response) => {
                     complete = true;
                     this.props.notificationCenter().removeFileUploadNotification(progressNotification);
                     if (err) {
                         this.props.notificationCenter().postFileUploadFailed(filename);
                     }
                     this.uploads.splice(this.uploads.indexOf(uploadRequest), 1);
                 });
                 this.uploads.push([uploadRequest, progressNotification]);
             }
         }
     }
 
     downloadFile(filename) {
         // const a = document.createElement('a');
         // a.href = `${config.fileSharingUrl}/${this.props.remoteUri}/${this.props.call.id}/${filename}`;
         // a.target = '_blank';
         // a.download = filename;
         // const clickEvent = document.createEvent('MouseEvent');
         // clickEvent.initMouseEvent('click', true, true, window, 0,
         //     clickEvent.screenX, clickEvent.screenY, clickEvent.clientX, clickEvent.clientY,
         //     clickEvent.ctrlKey, clickEvent.altKey, clickEvent.shiftKey, clickEvent.metaKey,
         //     0, null);
         // a.dispatchEvent(clickEvent);
     }
 
     preventOverlay(event) {
         // Stop the overlay when we are the thumbnail bar
         event.stopPropagation();
     }
 
     muteAudio(event) {
         event.preventDefault();
         this.props.toggleMute(this.props.call.id, !this.state.audioMuted);
      }
 
     toggleCamera(event) {
         event.preventDefault();
         const localStream = this.props.call.getLocalStreams()[0];
         if (localStream.getVideoTracks().length > 0) {
             const track = localStream.getVideoTracks()[0];
             track._switchCamera();
         }
     }
 
     muteVideo(event) {
         event.preventDefault();
         if (this.state.videoMuted) {
             this._resumeVideo();
             this.setState({videoMutedbyUser: false});
         } else {
             this.setState({videoMutedbyUser: true});
             this._muteVideo();
         }
     }
 
     _muteVideo() {
         const localStream = this.props.call.getLocalStreams()[0];
         if (localStream && localStream.getVideoTracks().length > 0) {
             const track = localStream.getVideoTracks()[0];
             if (!this.state.videoMuted) {
                 DEBUG('Mute camera');
                 track.enabled = false;
                 this.setState({videoMuted: true});
             }
         }
     }
 
     _resumeVideo() {
         const localStream = this.props.call.getLocalStreams()[0];
         if (localStream && localStream.getVideoTracks().length > 0) {
             const track = localStream.getVideoTracks()[0];
             if (this.state.videoMuted) {
                 DEBUG('Resume camera');
                 track.enabled = true;
                 this.setState({videoMuted: false});
             }
         }
     }
 
     hangup(event) {
         event.preventDefault();
         for (let participant of this.state.participants) {
             participant.detach();
         }
-        this.props.hangup();
+        this.props.hangup('user_hangup_conference');
     }
 
     armOverlayTimer() {
         if (this.props.audioOnly) {
             return;
         }
 
         clearTimeout(this.overlayTimer);
         this.overlayTimer = setTimeout(() => {
             this.setState({callOverlayVisible: false});
         }, 4000);
     }
 
     showOverlay() {
         if (this.props.audioOnly) {
             return;
         }
         // if (!this.state.shareOverlayVisible && !this.state.showDrawer && !this.state.showFiles) {
         // if (!this.state.callOverlayVisible) {
                 this.setState({callOverlayVisible: !this.state.callOverlayVisible});
         // }
         // this.armOverlayTimer();
         // }
     }
 
     toggleInviteModal() {
         this.setState({showInviteModal: !this.state.showInviteModal});
     }
 
     toggleDrawer() {
         this.setState({callOverlayVisible: true, showDrawer: !this.state.showDrawer, showFiles: false, showSpeakerSelection: false});
         clearTimeout(this.overlayTimer);
     }
 
     toggleFiles() {
         this.setState({callOverlayVisible: true, showFiles: !this.state.showFiles, showDrawer: false});
         clearTimeout(this.overlayTimer);
     }
 
     showFiles() {
         this.setState({callOverlayVisible: true, showFiles: true, showDrawer: false});
         clearTimeout(this.overlayTimer);
     }
 
     inviteParticipants(uris) {
         this.props.call.inviteParticipants(uris);
         uris.forEach((uri) => {
+            uri = uri.replace(/ /g, '');
             if (this.props.call.localIdentity._uri === uri) {
                 return;
             }
             this.invitedParticipants.set(uri, {timestamp: Date.now(), status: 'Invited'})
+            this.props.saveParticipant(this.props.call.id, this.props.remoteUri.split('@')[0], uri);
             this.lookupContact(uri);
         });
 
         this.forceUpdate()
     }
 
     render() {
         if (this.props.call === null) {
             return (<View></View>);
         }
 
         let watermark;
 
         const largeVideoClasses = classNames({
             'animated'      : true,
             'fadeIn'        : true,
             'large'         : true,
             'mirror'        : !this.props.call.sharingScreen && !this.props.generatedVideoTrack,
             'fit'           : this.props.call.sharingScreen
         });
 
         let matrixClasses = classNames({
             'matrix'        : true
         });
 
         const containerClasses = classNames({
             'video-container': true,
             'conference': true,
             'drawer-visible': this.state.showDrawer || this.state.showFiles
         });
 
         const remoteUri = this.props.remoteUri.split('@')[0];
 
         // const shareOverlay = (
         //     <Portal>
         //         <Modal>
         //             <Surface>
         //                 <Paragraph>
         //                     Invite other online users of this service, share <strong><a href={this.callUrl} target="_blank" rel="noopener noreferrer">this link</a></strong> with others or email, so they can easily join this conference.
         //                 </Paragraph>
         //                 <View className="text-center">
         //                     <View className="btn-group">
         //                         <IconButton
         //                             size={30}
         //                             onPress={this.toggleInviteModal}
         //                             icon="account-plus"
         //                         />
         //                         <IconButton className="btn btn-primary" onPress={this.handleClipboardButton} icon="copy" />
         //                         <IconButton className="btn btn-primary" onPress={this.handleEmailButton} alt="Send email" icon="email" />
         //                     </View>
         //                 </View>
         //             </Surface>
         //         </Modal>
         //     </Portal>
         // );
 
         const buttons = {};
 
         // const commonButtonTopClasses = classNames({
         //     'btn'           : true,
         //     'btn-link'      : true
         // });
 
         // const fullScreenButtonIcons = classNames({
         //     'fa'            : true,
         //     'fa-2x'         : true,
         //     'fa-expand'     : !this.isFullScreen(),
         //     'fa-compress'   : this.isFullScreen()
         // });
 
         const topButtons = [];
 
         // if (!this.state.showFiles) {
         //     if (this.state.sharedFiles.length !== 0) {
         //         topButtons.push(
         //             <Badge badgeContent={this.state.sharedFiles.length} color="primary" classes={{badge: this.props.classes.badge}}>
         //                 <button key="fbButton" type="button" title="Open Drawer" className={commonButtonTopClasses} onPress={this.toggleFiles}> <i className="fa fa-files-o fa-2x"></i> </button>
         //             </Badge>
         //         );
         //     }
         // }
 
         if (!this.state.showDrawer) {
             topButtons.push(<Appbar.Action key="sbButton" title="Open Drawer" onPress={this.toggleDrawer} icon="menu" />);
         }
 
         buttons.top = {right: topButtons};
 
         const muteButtonIcons = this.state.audioMuted ? 'microphone-off' : 'microphone';
         const muteVideoButtonIcons = this.state.videoMuted ? 'video-off' : 'video';
         const buttonClass = (Platform.OS === 'ios') ? styles.iosButton : styles.androidButton;
 
         const bottomButtons = [];
         if (!this.state.reconnectingCall) {
             bottomButtons.push(
                 <IconButton
                     size={30}
                     style={buttonClass}
                     title="Share link to this conference"
                     icon="account-plus"
                     onPress={this.toggleInviteModal}
                     key="shareButton"
                 />
             );
         }
         if (this.haveVideo) {
             bottomButtons.push(
                 <IconButton
                     size={30}
                     style={buttonClass}
                     title="Mute/unmute video"
                     onPress={this.muteVideo}
                     icon={muteVideoButtonIcons}
                     key="muteButton"
                 />
             );
         }
         bottomButtons.push(
             <IconButton
                 size={30}
                 style={buttonClass}
                 title="Mute/unmute audio"
                 onPress={this.muteAudio}
                 icon={muteButtonIcons}
                 key="muteAudioButton"
             />
         );
+
         if (this.haveVideo) {
             bottomButtons.push(
                 <IconButton
                     size={30}
                     style={buttonClass}
                     title="Toggle camera"
                     onPress={this.toggleCamera}
                     icon='video-switch'
                     key="toggleButton"
                 />
             );
         }
+
         if (!this.state.reconnectingCall) {
             bottomButtons.push(
                 <IconButton
                     size={30}
                     style={buttonClass}
                     icon={this.props.speakerPhoneEnabled ? 'volume-high' : 'volume-off'}
                     onPress={this.props.toggleSpeakerPhone}
                     key="speakerPhoneButton"
                 />
             )
             // bottomButtons.push(
             //     <View key="shareFiles">
             //         <IconButton size={30} style={buttonClass} title="Share files" component="span" disableRipple={true} icon="upload"/>
             //     </View>
             // );
         }
 
         bottomButtons.push(
             <IconButton
                 size={30}
                 style={[buttonClass, styles.hangupButton]}
                 title="Leave conference"
                 onPress={this.hangup}
                 icon="phone-hangup"
                 key="hangupButton"
             />
         );
         buttons.bottom = bottomButtons;
 
         const audioParticipants = [];
         let _contact;
         let _identity;
         let participants_uris = [];
 
         if (this.props.audioOnly) {
             _contact = this.foundContacts.get(this.props.call.localIdentity._uri);
             _identity = {uri: this.props.call.localIdentity._uri,
                          displayName: _contact.displayName,
                          photo: _contact.photo
                         };
 
             participants_uris.push(this.props.call.localIdentity._uri);
 
             audioParticipants.push(
                 <ConferenceAudioParticipant
                     key="myself"
                     participant={null}
                     identity={_identity}
                     isLocal={true}
                 />
             );
 
             this.state.participants.forEach((p) => {
                 _contact = this.foundContacts.get(p.identity._uri);
                 _identity = {uri: p.identity._uri.indexOf('@guest') > -1 ? 'From the web': p.identity._uri,
                              displayName: (_contact && _contact.displayName != p.identity._displayName) ? _contact.displayName : p.identity._displayName,
                              photo: _contact ? _contact.photo: null
                             };
 
                 participants_uris.push(p.identity._uri);
 
                 audioParticipants.push(
                     <ConferenceAudioParticipant
                         key={p.id}
                         participant={p}
                         identity={_identity}
                         isLocal={false}
                     />
                 );
             });
 
             const invitedParties = Array.from(this.invitedParticipants.keys());
             let p;
             invitedParties.forEach((_uri) => {
                 if (participants_uris.indexOf(_uri) > 0) {
                     return;
                 }
 
                 p = this.invitedParticipants.get(_uri);
                 _contact = this.foundContacts.get(_uri);
                 _identity = {uri: _uri,
                              displayName: (_contact && _contact.displayName ) ? _contact.displayName : _uri,
                              photo: _contact ? _contact.photo: null
                             };
 
                 audioParticipants.push(
                     <ConferenceAudioParticipant
                         key={_uri}
                         identity={_identity}
                         isLocal={false}
                         status={p.status}
                     />
                 );
             });
 
             return (
                 <View style={styles.container}>
                     <View style={styles.conferenceContainer}>
                         <ConferenceHeader
                             show={true}
                             remoteUri={remoteUri}
                             participants={this.state.participants}
                             reconnectingCall={this.state.reconnectingCall}
                             buttons={buttons}
                             audioOnly={this.props.audioOnly}
                         />
                     </View>
 
                     <View style={styles.audioContainer}>
                         <ConferenceAudioParticipantList >
                             {audioParticipants}
                         </ConferenceAudioParticipantList>
                     </View>
 
                     <InviteParticipantsModal
                         show={this.state.showInviteModal && !this.state.reconnectingCall}
                         inviteParticipants={this.inviteParticipants}
                         previousParticipants={this.state.previousParticipants}
+                        alreadyInvitedParticipants={Array.from(this.invitedParticipants.keys())}
                         currentParticipants={this.state.participants.map((p) => {return p.identity.uri})}
                         close={this.toggleInviteModal}
                         room={this.props.remoteUri.split('@')[0]}
                         defaultDomain = {this.props.defaultDomain}
                         notificationCenter = {this.props.notificationCenter}
                     />
                 <ConferenceDrawer
                     show={this.state.showDrawer && !this.state.reconnectingCall}
                     close={this.toggleDrawer}
                     isLandscape={this.props.isLandscape}
                     title="Conference data"
                 >
                     <View style={this.props.isLandscape ? [{maxHeight: Dimensions.get('window').height - 60}, styles.landscapeDrawer] : styles.container}>
                         <View style={{flex: this.props.isLandscape ? 1 : 2}}>
                             <ConferenceDrawerSpeakerSelectionWrapper
                                 selectSpeaker={this.startSpeakerSelection}
                                 activeSpeakers={this.state.activeSpeakers}
                             />
                             <ConferenceDrawerParticipantList style={styles.container}>
                                 {drawerParticipants}
                             </ConferenceDrawerParticipantList>
                         </View>
                     </View>
                 </ConferenceDrawer>
                 <ConferenceDrawer
                     show={this.state.showSpeakerSelection}
                     close={this.toggleSpeakerSelection}
                     isLandscape={this.props.isLandscape}
                     showBackdrop={false}
                     title={`Select speaker ${this.selectSpeaker}`}
                 >
                     <ConferenceDrawerSpeakerSelection
                         participants={this.state.participants.concat([{id: this.props.call.id, publisherId: this.props.call.id, identity: this.props.call.localIdentity}])}
                         selected={this.handleActiveSpeakerSelected}
                         activeSpeakers={this.state.activeSpeakers}
                         selectSpeaker={this.selectSpeaker}
                         key = {this.state.activeSpeakers}
                     />
                 </ConferenceDrawer>
 
                 </View>
             );
         }
 
         const participants = [];
         const drawerParticipants = [];
 
         if (this.state.participants.length > 0) {
             if (this.state.activeSpeakers.findIndex((element) => {return element.id === this.props.call.id}) === -1) {
                 participants.push(
                     <ConferenceParticipantSelf
                         key="myself2"
                         stream={this.props.call.getLocalStreams()[0]}
                         identity={this.props.call.localIdentity}
                         audioMuted={this.state.audioMuted}
                         generatedVideoTrack={this.props.generatedVideoTrack}
                     />
                 );
             }
         }
 
         drawerParticipants.push(
             <ConferenceDrawerParticipant
                 key="myself1"
                 participant={{identity: this.props.call.localIdentity}}
                 isLocal={true}
             />
         );
 
         let videos = [];
         if (this.state.participants.length === 0) {
             videos.push(
                 <RTCView key="self" objectFit="cover" style={styles.wholePageVideo} ref="largeVideo" poster="assets/images/transparent-1px.png" streamURL={this.state.largeVideoStream ? this.state.largeVideoStream.toURL() : null} />
             );
         } else {
             const activeSpeakers = this.state.activeSpeakers;
             const activeSpeakersCount = activeSpeakers.length;
 
             if (activeSpeakersCount > 0) {
                 activeSpeakers.forEach((p) => {
                     videos.push(
                         <ConferenceMatrixParticipant
                             key={p.id}
                             participant={p}
                             pauseVideo={this.props.audioOnly}
                             large={activeSpeakers.length <= 1}
                             isLocal={p.id === this.props.call.id}
                         />
                     );
                 });
 
                 this.state.participants.forEach((p) => {
                     if (this.state.activeSpeakers.indexOf(p) === -1) {
                         participants.push(
                             <ConferenceParticipant
                                 key={p.id}
                                 participant={p}
                                 selected={() => {}}
                                 pauseVideo={true}
                                 display={false}
                             />
                         );
                     }
 
                     drawerParticipants.push(
                         <ConferenceDrawerParticipant
                             key={p.id}
                             participant={p}
                         />
                     );
 
                 });
             } else {
                 this.state.participants.forEach((p, idx) => {
                     videos.push(
                         <ConferenceMatrixParticipant
                             key = {p.id}
                             participant = {p}
                             large = {this.state.participants.length <= 1}
                             pauseVideo={(idx >= 4) || (idx >= 2 && this.props.isTablet === false)}
                             isLandscape={this.props.isLandscape}
                             isTablet={this.props.isTablet}
                             useTwoRows={this.state.participants.length > 2}
                         />
                     );
                     if (idx >= 4 || idx >= 2 && this.props.isTablet === false) {
                         participants.push(
                             <ConferenceParticipant
                                 key={p.id}
                                 participant={p}
                                 selected={this.onVideoSelected}
                                 pauseVideo={true}
                                 display={true}
                             />
                         );
                     }
                     drawerParticipants.push(
                         <ConferenceDrawerParticipant
                             key={p.id}
                             participant={p}
                         />
                     );
 
                 });
             }
         }
 
         // let filesDrawerContent = (
         //     <ConferenceDrawerFiles
         //         sharedFiles={this.state.sharedFiles}
         //         downloadFile={this.downloadFile}
         //     />
         // );
 
         return (
             <View style={styles.container}>
                 <View style={styles.conferenceContainer}>
                     <ConferenceHeader
                         show={this.state.callOverlayVisible}
                         remoteUri={remoteUri}
                         participants={this.state.participants}
                         reconnectingCall={this.state.reconnectingCall}
                         buttons={buttons}
                         audioOnly={this.props.audioOnly}
                     />
                     <TouchableWithoutFeedback onPress={this.showOverlay}>
                         <View style={[styles.videosContainer, this.props.isLandscape ? styles.landscapeVideosContainer: null]}>
                             {videos}
                         </View>
                     </TouchableWithoutFeedback>
                     <View style={styles.carouselContainer}>
                         <ConferenceCarousel align={'right'}>
                             {participants}
                         </ConferenceCarousel>
                     </View>
                 </View>
 
                 <InviteParticipantsModal
                     show={this.state.showInviteModal && !this.state.reconnectingCall}
                     inviteParticipants={this.inviteParticipants}
                     previousParticipants={this.state.previousParticipants}
                     currentParticipants={this.state.participants.map((p) => {return p.identity.uri})}
                     close={this.toggleInviteModal}
                     room={this.props.remoteUri.split('@')[0]}
                     defaultDomain = {this.props.defaultDomain}
                     notificationCenter = {this.props.notificationCenter}
                 />
                 <ConferenceDrawer
                     show={this.state.showDrawer && !this.state.reconnectingCall}
                     close={this.toggleDrawer}
                     isLandscape={this.props.isLandscape}
                     title="Conference data"
                 >
                     <View style={this.props.isLandscape ? [{maxHeight: Dimensions.get('window').height - 60}, styles.landscapeDrawer] : styles.container}>
                         <View style={{flex: this.props.isLandscape ? 1 : 2}}>
                             <ConferenceDrawerSpeakerSelectionWrapper
                                 selectSpeaker={this.startSpeakerSelection}
                                 activeSpeakers={this.state.activeSpeakers}
                             />
                             <ConferenceDrawerParticipantList style={styles.container}>
                                 {drawerParticipants}
                             </ConferenceDrawerParticipantList>
                         </View>
                     </View>
                 </ConferenceDrawer>
                 <ConferenceDrawer
                     show={this.state.showSpeakerSelection}
                     close={this.toggleSpeakerSelection}
                     isLandscape={this.props.isLandscape}
                     showBackdrop={false}
                     title={`Select speaker ${this.selectSpeaker}`}
                 >
                     <ConferenceDrawerSpeakerSelection
                         participants={this.state.participants.concat([{id: this.props.call.id, publisherId: this.props.call.id, identity: this.props.call.localIdentity}])}
                         selected={this.handleActiveSpeakerSelected}
                         activeSpeakers={this.state.activeSpeakers}
                         selectSpeaker={this.selectSpeaker}
                         key = {this.state.activeSpeakers}
                     />
                 </ConferenceDrawer>
             </View>
         );
     }
 }
 
 ConferenceBox.propTypes = {
     notificationCenter  : PropTypes.func.isRequired,
     call                : PropTypes.object,
     connection          : PropTypes.object,
     hangup              : PropTypes.func,
     saveParticipant     : PropTypes.func,
     previousParticipants: PropTypes.array,
     remoteUri           : PropTypes.string,
     generatedVideoTrack : PropTypes.bool,
     toggleMute          : PropTypes.func,
     toggleSpeakerPhone  : PropTypes.func,
     speakerPhoneEnabled : PropTypes.bool,
     isLandscape         : PropTypes.bool,
     isTablet            : PropTypes.bool,
     muted               : PropTypes.bool,
     defaultDomain       : PropTypes.string,
     inFocus             : PropTypes.bool,
     reconnectingCall    : PropTypes.bool,
     audioOnly           : PropTypes.bool,
     contacts            : PropTypes.array,
     initialParticipants : PropTypes.array
 };
 
 export default ConferenceBox;
diff --git a/app/components/ConferenceModal.js b/app/components/ConferenceModal.js
index c81f4ff..a2ad14a 100644
--- a/app/components/ConferenceModal.js
+++ b/app/components/ConferenceModal.js
@@ -1,195 +1,202 @@
 import React, { Component } from 'react';
 import PropTypes from 'prop-types';
 import { View } from 'react-native';
 
 import { Portal, Dialog, Button, Text, TextInput, Surface, Chip } from 'react-native-paper';
 import KeyboardAwareDialog from './KeyBoardAwareDialog';
 
 const DialogType = Platform.OS === 'ios' ? KeyboardAwareDialog : Dialog;
 
 import config from '../config';
 import styles from '../assets/styles/blink/_ConferenceModal.scss';
 
 class ConferenceModal extends Component {
     constructor(props) {
         super(props);
 
         this.state = {
             targetUri: props.targetUri ? props.targetUri.split('@')[0] : '',
             myInvitedParties: props.myInvitedParties,
             selectedContact: props.selectedContact,
             participants: null
         };
 
         this.handleConferenceTargetChange = this.handleConferenceTargetChange.bind(this);
         this.onHide = this.onHide.bind(this);
         this.joinAudio = this.joinAudio.bind(this);
         this.joinVideo = this.joinVideo.bind(this);
     }
 
     componentDidMount() {
         this.handleConferenceTargetChange(this.state.targetUri);
     }
 
     //getDerivedStateFromProps(nextProps, state) {
     UNSAFE_componentWillReceiveProps(nextProps) {
         let uri = '';
         if (nextProps.targetUri) {
             uri = nextProps.targetUri.split('@')[0];
         }
 
         this.setState({targetUri: uri,
                       myInvitedParties: nextProps.myInvitedParties,
-                      selectedContact: nextProps.selectedContact
+                      selectedContact: nextProps.selectedContact,
+                      participants: nextProps.participants
                       });
         this.handleConferenceTargetChange(uri);
     }
 
     handleConferenceTargetChange(value) {
         let targetUri = value;
         let participants = '';
         let sanitizedParticipants = [];
         let username;
         let domain;
 
         if (targetUri) {
             let uri = `${targetUri.replace(/[\s()-]/g, '')}@${config.defaultConferenceDomain}`;
             uri = uri.split('@')[0];
             if (this.state.myInvitedParties && this.state.myInvitedParties.hasOwnProperty(uri)) {
                 participants = this.props.myInvitedParties[uri].toString();
             } else if (this.state.selectedContact && this.state.selectedContact.participants) {
                 participants = this.state.selectedContact.participants.toString();
             }
 
             if (participants) {
                 participants.split(',').forEach((item) => {
                     item = item.trim().toLowerCase();
+
+                    if (item === this.props.accountId) {
+                        return;
+                    }
+
                     if (item.indexOf('@') === -1) {
                         item = `${item}@${this.props.defaultDomain}`;
                     }
 
                     username = item.split('@')[0];
                     domain = item.split('@')[1];
 
                     if (username && username !== ',') {
                         if (domain === this.props.defaultDomain) {
                             sanitizedParticipants.push(username);
                         } else {
                             sanitizedParticipants.push(item);
                         }
                     }
                 });
             }
         }
 
         if (targetUri) {
             this.setState({targetUri: targetUri});
         }
 
         if (sanitizedParticipants.length > 0) {
             this.setState({participants: sanitizedParticipants.toString()});
         }
     }
 
     joinAudio(event) {
         event.preventDefault();
         const uri = `${this.state.targetUri.replace(/[\s()-]/g, '')}@${config.defaultConferenceDomain}`;
         const participants = [];
 
         if (this.state.participants) {
             this.state.participants.split(',').forEach((item) => {
-                item = item.trim().toLowerCase();
+                item = item.trim().toLowerCase().replace(' ', '');
                 if (item.indexOf('@') === -1) {
                     item = `${item}@${this.props.defaultDomain}`;
                 }
                 participants.push(item);
             });
         }
 
         this.props.handleConferenceCall(uri.toLowerCase(), {audio: true, video: false, participants: participants});
     }
 
     joinVideo(event) {
         event.preventDefault();
         const uri = `${this.state.targetUri.replace(/[\s()-]/g, '')}@${config.defaultConferenceDomain}`;
         const participants = [];
 
         if (this.state.participants) {
             this.state.participants.split(',').forEach((item) => {
-                item = item.trim().toLowerCase();
+                item = item.trim().toLowerCase().replace(' ', '');
                 if (item.indexOf('@') === -1) {
                     item = `${item}@${this.props.defaultDomain}`;
                 }
                 participants.push(item);
             });
         }
 
         this.props.handleConferenceCall(uri.toLowerCase(), {audio: true, video: true, participants: participants});
     }
 
     onHide() {
         this.props.handleConferenceCall(null);
     }
 
     render() {
         const validUri = this.state.targetUri.length > 0 && this.state.targetUri.indexOf('@') === -1;
 
         return (
             <Portal>
                 <DialogType visible={this.props.show} onDismiss={this.onHide}>
                     <Surface style={styles.container}>
                         <Dialog.Title style={styles.title}>Join Conference</Dialog.Title>
                         <TextInput
                             style={styles.body}
                             mode="flat"
                             autoCapitalize="none"
                             label="Enter the room you wish to join"
                             placeholder="Conference room"
                             onChangeText={(text) => {this.handleConferenceTargetChange(text);}}
                             name="uri"
                             required
                             defaultValue={this.state.targetUri}
                         />
                         <TextInput
                             style={styles.body}
                             mode="flat"
                             autoCapitalize="none"
                             name="users"
                             label="Invite people"
                             onChangeText={(value) => {this.setState({participants: value});}}
                             value={this.state.participants}
                             placeholder="Enter accounts separated by ,"
                         />
                         <View style={styles.buttonRow}>
                         <Button
                             mode="contained"
                             style={styles.button}
                             onPress={this.joinAudio}
                             disabled={!validUri}
                             icon="speaker"
                         >Audio</Button>
                         <Button
                             mode="contained"
                             style={styles.button}
                             onPress={this.joinVideo}
                             disabled={!validUri}
                             icon="video"
                         >Video</Button>
                         </View>
                     </Surface>
                 </DialogType>
             </Portal>
         );
     }
 }
 
 ConferenceModal.propTypes = {
     show: PropTypes.bool.isRequired,
     handleConferenceCall: PropTypes.func.isRequired,
     myInvitedParties: PropTypes.object,
+    accountId: PropTypes.string,
     selectedContact: PropTypes.object,
     targetUri: PropTypes.string.isRequired,
     defaultDomain: PropTypes.string
 };
 
 export default ConferenceModal;
diff --git a/app/components/EditConferenceModal.js b/app/components/EditConferenceModal.js
index 4c4aa93..9736f90 100644
--- a/app/components/EditConferenceModal.js
+++ b/app/components/EditConferenceModal.js
@@ -1,120 +1,120 @@
 import React, { Component } from 'react';
 import PropTypes from 'prop-types';
 import autoBind from 'auto-bind';
 import { View } from 'react-native';
 import { Chip, Dialog, Portal, Text, Button, Surface, TextInput, Paragraph } from 'react-native-paper';
 import KeyboardAwareDialog from './KeyBoardAwareDialog';
 
 const DialogType = Platform.OS === 'ios' ? KeyboardAwareDialog : Dialog;
 
 import config from '../config';
 import styles from '../assets/styles/blink/_InviteParticipantsModal.scss';
 
 class EditConferenceModal extends Component {
     constructor(props) {
         super(props);
         autoBind(this);
 
         let users = '';
         if (this.props.invitedParties && this.props.invitedParties.length > 0) {
             users = this.props.invitedParties;
         } else if (this.props.selectedContact && this.props.selectedContact.participants) {
             users = this.props.selectedContact.participants;
         }
 
         this.state = {
             users: users.toString(),
             selectedContact: this.props.selectedContact,
             invitedParties: this.props.invitedParties
         }
     }
 
     UNSAFE_componentWillReceiveProps(nextProps) {
         let users = '';
         if (nextProps.invitedParties && nextProps.invitedParties.length > 0) {
             users = nextProps.invitedParties;
         } else if (nextProps.selectedContact && nextProps.selectedContact.participants) {
             users = nextProps.selectedContact.participants;
         }
 
         this.setState({
             users: users.toString(),
             selectedContact: nextProps.selectedContact,
             invitedParties: nextProps.invitedParties
         });
     }
 
     saveParticipants(event) {
         event.preventDefault();
         const uris = [];
         if (this.state.users) {
             this.state.users.split(',').forEach((item) => {
                 item = item.trim();
                 if (item.indexOf('@') === -1) {
                     item = `${item}@${this.props.defaultDomain}`;
                 }
 
                 let username = item.split('@')[0];
                 if (username && username !== ',') {
                     uris.push(item);
                 }
             });
         }
 
         if (uris) {
             this.props.saveInvitedParties(uris);
             this.setState({users: null});
         }
         this.props.close();
     }
 
     onInputChange(value) {
         this.setState({users: value});
     }
 
     render() {
         return (
             <Portal>
                 <DialogType visible={this.props.show} onDismiss={this.props.close}>
                     <Surface style={styles.container}>
                         <Dialog.Title style={styles.title}>{this.props.room}</Dialog.Title>
                           <Dialog.Content>
-                            <Paragraph>People you wish to invite automatically to the conference when you join the room:</Paragraph>
+                            <Paragraph>People you wish to invite when you join the room:</Paragraph>
                           </Dialog.Content>
                         <TextInput
                             mode="flat"
                             name="users"
                             label="People"
                             onChangeText={this.onInputChange}
                             value={this.state.users}
                             placeholder="Enter accounts separated by ,"
                             required
                             autoCapitalize="none"
                         />
 
                         <View style={styles.buttonRow}>
                         <Button
                             mode="contained"
                             style={styles.button}
                             onPress={this.saveParticipants}
                             icon="email">Save
                         </Button>
                         </View>
                     </Surface>
                 </DialogType>
             </Portal>
         );
     }
 }
 
 EditConferenceModal.propTypes = {
     show: PropTypes.bool.isRequired,
     close: PropTypes.func.isRequired,
     saveInvitedParties: PropTypes.func,
     invitedParties: PropTypes.array,
     room: PropTypes.string,
     selectedContact: PropTypes.object,
     defaultDomain: PropTypes.string
 };
 
 export default EditConferenceModal;
diff --git a/app/components/HistoryCard.js b/app/components/HistoryCard.js
index 5efd15e..9a110f3 100644
--- a/app/components/HistoryCard.js
+++ b/app/components/HistoryCard.js
@@ -1,437 +1,452 @@
 import React, { Component, Fragment} from 'react';
 import { View, SafeAreaView, FlatList } from 'react-native';
 import autoBind from 'auto-bind';
 import PropTypes from 'prop-types';
 import moment from 'moment';
 import momentFormat from 'moment-duration-format';
 import { Card, IconButton, Button, Caption, Title, Subheading, List, Text} from 'react-native-paper';
 import Icon from  'react-native-vector-icons/MaterialCommunityIcons';
 import uuid from 'react-native-uuid';
 import EditConferenceModal from './EditConferenceModal';
 import styles from '../assets/styles/blink/_HistoryCard.scss';
 import UserIcon from './UserIcon';
 
 import utils from '../utils';
 
 function toTitleCase(str) {
     return str.replace(
         /\w\S*/g,
         function(txt) {
             return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
         }
     );
 }
 
 const Item = ({ nr, uri, displayName }) => (
   <View style={styles.participantView}>
     {displayName !==  uri?
     <Text style={styles.participant}>{displayName} ({uri})</Text>
     :
     <Text style={styles.participant}>{uri}</Text>
     }
 
   </View>
 );
 
 const renderItem = ({ item }) => (
  <Item nr={item.nr} uri={item.uri} displayName={item.displayName}/>
 );
 
 function isIp(ipaddress) {
   if (/^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test(ipaddress)) {
     return (true)
   }
   return (false)
 }
 
 
 class HistoryCard extends Component {
     constructor(props) {
         super(props);
         autoBind(this);
 
         this.state = {
             id: this.props.contact.id,
             contact: this.props.contact,
             displayName: this.props.contact.displayName,
             filter: this.props.filter,
             uri: this.props.contact.remoteParty,
             invitedParties: this.props.invitedParties,
             participants: this.props.contact.participants,
             conference: this.props.contact.conference,
             type: this.props.contact.type,
             photo: this.props.contact.photo,
             label: this.props.contact.label,
             orientation: this.props.orientation,
             isTablet: this.props.isTablet,
             favorite: (this.props.contact.tags.indexOf('favorite') > -1)? true : false,
             blocked: (this.props.contact.tags.indexOf('blocked') > -1)? true : false,
             confirmed: false,
             showEditConferenceModal: false
         }
     }
 
     UNSAFE_componentWillReceiveProps(nextProps) {
         this.setState({
             id: nextProps.contact.id,
             contact: nextProps.contact,
             displayName: nextProps.contact.displayName,
             uri: nextProps.contact.remoteParty,
             invitedParties: nextProps.invitedParties,
             participants: nextProps.contact.participants,
             conference: nextProps.contact.conference,
             type: nextProps.contact.type,
             photo: nextProps.contact.photo,
             label: nextProps.contact.label,
             orientation: nextProps.orientation,
             favorite: (nextProps.contact.tags.indexOf('favorite') > -1)? true : false,
             blocked: (nextProps.contact.tags.indexOf('blocked') > -1)? true : false,
         });
     }
 
     shouldComponentUpdate(nextProps) {
         //https://medium.com/sanjagh/how-to-optimize-your-react-native-flatlist-946490c8c49b
         return true;
     }
 
     toggleEditConferenceModal() {
         this.setState({showEditConferenceModal: !this.state.showEditConferenceModal});
     }
 
+    setFavoriteUri() {
+        if (this.state.favorite) {
+            if (this.state.confirmed) {
+                let newFavoriteState = this.props.setFavoriteUri(this.state.uri);
+                this.setState({favorite: newFavoriteState, action: null, confirmed: false});
+                this.props.setTargetUri(this.state.uri);
+            } else {
+                this.setState({confirmed: true});
+            }
+        } else {
+            let newFavoriteState = this.props.setFavoriteUri(this.state.uri);
+            this.setState({favorite: newFavoriteState});
+        }
+    }
+
     saveInvitedParties(uris) {
         this.setState({invitedParties: uris});
         this.props.saveInvitedParties(this.state.uri.split('@')[0], uris);
     }
 
     handleParticipant() {
     }
 
     findObjectByKey(array, key, value) {
         for (var i = 0; i < array.length; i++) {
             if (array[i][key] === value) {
                 return array[i];
             }
         }
         return null;
     }
 
     setBlockedUri() {
         let newBlockedState = this.props.setBlockedUri(this.state.uri);
         this.setState({blocked: newBlockedState});
     }
 
     setBlockedDomain() {
         let newBlockedState = this.props.setBlockedUri('@' + this.state.uri.split('@')[1]);
         this.setState({blocked: newBlockedState});
     }
 
     editConference() {
          this.toggleEditConferenceModal();
     }
 
     deleteHistoryEntry() {
         this.props.deleteHistoryEntry(this.state.uri);
     }
 
     undo() {
         this.setState({confirmed: false, action: null});
     }
 
     setFavoriteUri() {
         if (this.state.favorite) {
             if (this.state.confirmed) {
                 let newFavoriteState = this.props.setFavoriteUri(this.state.uri);
                 this.setState({favorite: newFavoriteState, action: null, confirmed: false});
                 this.props.setTargetUri(this.state.uri);
             } else {
                 this.setState({confirmed: true});
             }
         } else {
             let newFavoriteState = this.props.setFavoriteUri(this.state.uri);
             this.setState({favorite: newFavoriteState});
         }
     }
 
     setTargetUri(uri, contact) {
         this.props.setTargetUri(uri, this.state.contact);
     }
 
     render () {
         let containerClass = styles.portraitContainer;
         let cardClass = styles.card;
 
         let showActions = this.props.contact.showActions && this.props.contact.tags.indexOf('test') === -1;
 
         let uri =  this.state.uri;
         let username =  uri.split('@')[0];
         let domain =  uri.split('@')[1];
         let isPhoneNumber = username.match(/^(\+|0)(\d+)$/);
 
         let displayName = this.state.displayName;
 
         let buttonMode = 'text';
         let showBlockButton = !this.state.conference;
         let showBlockDomainButton = false;
         let showFavoriteButton = true;
         let showUndoButton = this.state.confirmed ? true : false;
         let showDeleteButton = (this.props.contact.tags.indexOf('local') > -1 && !this.state.favorite ) ? true: false;
         let showEditButton = (this.state.conference && this.state.favorite && !this.state.confirmed ) ? true: false;
         let blockTextbutton = 'Block';
         let blockDomainTextbutton = 'Block domain';
         let editTextbutton = 'Edit';
         let favoriteTextbutton = 'Favorite';
         let undoTextbutton = 'Undo';
         let deleteTextbutton = 'Delete';
         let participantsData = [];
 
         if (this.state.favorite) {
             favoriteTextbutton = this.state.confirmed ? 'Confirm' : 'Remove';
             if (!this.state.blocked) {
                 showBlockButton = false;
             }
         }
 
         if (uri.indexOf('3333@') > -1) {
             showBlockButton = false;
         }
 
         if (uri.indexOf('4444@') > -1) {
             showBlockButton = false;
         }
 
         if (displayName === 'Myself') {
             showBlockButton = false;
         }
 
         if (this.state.blocked) {
             blockTextbutton = 'Unblock';
             showFavoriteButton = false;
         }
 
         if (this.state.isTablet) {
             containerClass = (this.state.orientation === 'landscape') ? styles.landscapeTabletContainer : styles.portraitTabletContainer;
         } else {
             containerClass = (this.state.orientation === 'landscape') ? styles.landscapeContainer : styles.portraitContainer;
         }
 
         if (showActions) {
             cardClass = styles.expandedCard;
         }
 
         let color = {};
 
         let title = displayName || username;
 
         let subtitle = uri;
         let description = this.props.contact.startTime;
 
         if (displayName === uri) {
             title = toTitleCase(username);
         }
 
        if (isPhoneNumber && isIp(domain)) {
            title = 'Tel ' + username;
            subtitle = 'From @' + domain;
            showBlockDomainButton = true;
            showFavoriteButton = false;
        }
 
         if (utils.isAnonymous(uri)) {
             //uri = 'anonymous@anonymous.invalid';
             displayName = 'Anonymous';
             if (uri.indexOf('@guest.') > -1) {
                 subtitle = 'From the Web';
             }
             showFavoriteButton = false;
             showBlockDomainButton = true;
             if (!this.state.blocked) {
                 showBlockButton = false;
             }
             blockDomainTextbutton = 'Block Web calls';
         }
 
         if (!username || username.length === 0) {
             if (isIp(domain)) {
                 title = 'IP domain';
             } else if (domain.indexOf('guest.') > -1) {
                 title = 'Calls from the Web';
             } else {
                 title = 'Domain';
             }
         }
 
         if (this.props.contact.tags.indexOf('history') > -1) {
             let duration = moment.duration(this.props.contact.duration, 'seconds').format('HH:mm:ss', {trim: false});
 
             if (this.props.contact.direction === 'received' && this.props.contact.duration === 0) {
                 color.color = '#a94442';
                 duration = 'missed';
             } else if (this.props.contact.direction === 'placed' && this.props.contact.duration === 0) {
                 duration = 'cancelled';
             }
 
             if (this.state.conference) {
                 let participants = this.state.participants;
                 if (this.state.filter === 'favorite' && this.state.invitedParties && this.state.invitedParties.length > 0 ) {
                     participants = this.state.invitedParties;
                 }
 
                 if (participants && participants.length > 0) {
                     const p_text = participants.length > 1 ? 'participants' : 'participant';
                     subtitle = 'With ' + participants.length + ' ' + p_text;
                     let i = 1;
                     let contact_obj;
                     let dn;
                     let _item;
                     participants.forEach((participant) => {
                         contact_obj = this.findObjectByKey(this.props.contacts, 'remoteParty', participant);
                         dn = contact_obj ? contact_obj.displayName : participant;
                         _item = {nr: i, id: uuid.v4(), uri: participant, displayName: dn};
                         participantsData.push(_item);
                         i = i + 1;
                     });
                 } else {
                     subtitle = 'With no participants';
                 }
 
                 let dn;
                 if (participantsData.length > 4 || participantsData.length < 2) {
                     title = username.length > 10 ? 'Conference' : 'Conference ' + toTitleCase(username);
                 } else if (participantsData.length > 1 || participantsData.length <= 4 ) {
                     let j = 0;
                     title = '';
                     participantsData.forEach((participant) => {
                         if (participant.displayName === participant.uri) {
                             dn = toTitleCase(participant.uri.split('@')[0]);
                         } else {
                             dn = participant.displayName.split(' ')[0];
                         }
                         title = title + dn;
                         if (j < participantsData.length - 1) {
                             title = title + ' & ';
                         }
                         j = j + 1;
                     });
                 }
             }
 
             if (!displayName) {
                 title = uri;
                 if (duration === 'missed') {
                     subtitle = 'Last call missed';
                 } else if (duration === 'cancelled') {
                     subtitle = 'Last call cancelled';
                 } else {
                     subtitle = 'Last call duration ' + duration ;
                 }
             }
 
             description = description + ' (' + duration + ')';
 
             return (
                 <Fragment>
 
                 <Card
                     onPress={() => {this.setTargetUri(uri, this.props.contact)}}
                     style={[containerClass, cardClass]}
                     >
                     <Card.Content style={styles.content}>
                         <View style={styles.mainContent}>
                             <Title noWrap style={color}>{title}</Title>
                             <Subheading noWrap style={color}>{subtitle}</Subheading>
                             <Caption color="textSecondary">
                                 <Icon name={this.props.contact.direction == 'received' ? 'arrow-bottom-left' : 'arrow-top-right'}/>{description}
                             </Caption>
                             {participantsData && participantsData.length && showActions ?
                             <SafeAreaView>
                               <FlatList
                                 horizontal={false}
                                 data={participantsData}
                                 renderItem={renderItem}
                                 keyExtractor={item => item.id}
                                 key={item => item.id}
                               />
                             </SafeAreaView>
                             : null}
 
                         </View>
                         <View style={styles.userAvatarContent}>
                             <UserIcon style={styles.userIcon} identity={this.state}/>
                         </View>
                     </Card.Content>
                     {showActions ?
                         <View style={styles.buttonContainer}>
                         <Card.Actions>
                            {showEditButton? <Button mode={buttonMode} style={styles.button} onPress={() => {this.editConference()}}>{editTextbutton}</Button>: null}
                            {showDeleteButton? <Button mode={buttonMode} style={styles.button} onPress={() => {this.deleteHistoryEntry()}}>{deleteTextbutton}</Button>: null}
                            {showBlockButton? <Button mode={buttonMode} style={styles.button} onPress={() => {this.setBlockedUri()}}>{blockTextbutton}</Button>: null}
                            {showBlockDomainButton? <Button mode={buttonMode} style={styles.button} onPress={() => {this.setBlockedDomain()}}>{blockDomainTextbutton}</Button>: null}
                            {showFavoriteButton?<Button mode={buttonMode} style={styles.button} onPress={() => {this.setFavoriteUri()}}>{favoriteTextbutton}</Button>: null}
                            {showUndoButton?<Button mode={buttonMode} style={styles.button} onPress={() => {this.undo()}}>{undoTextbutton}</Button>: null}
                         </Card.Actions>
                         </View>
                         : null}
                 </Card>
                 <EditConferenceModal
                     show={this.state.showEditConferenceModal}
                     room={title}
                     invitedParties={this.state.invitedParties}
                     selectedContact={this.state.contact}
                     saveInvitedParties={this.saveInvitedParties}
                     close={this.toggleEditConferenceModal}
                     defaultDomain={this.props.defaultDomain}
                 />
                 </Fragment>
 
             );
 
         } else {
 
             return (
                 <Card
                     onPress={() => {this.props.setTargetUri(uri, this.props.contact)}}
                     style={[containerClass, cardClass]}
                 >
                     <Card.Content style={styles.content}>
                         <View style={styles.mainContent}>
                             <Title noWrap style={color}>{title}</Title>
                             <Subheading noWrap style={color}>{uri}</Subheading>
                             <Caption color="textSecondary">
                                 {this.state.label}
                             </Caption>
                         </View>
                         <View style={styles.userAvatarContent}>
                             <UserIcon style={styles.userIcon} identity={this.state}/>
                         </View>
                     </Card.Content>
                     {showActions ?
                         <View style={styles.buttonContainer}>
                         <Card.Actions>
                            {showBlockButton? <Button mode={buttonMode} style={styles.button} onPress={() => {this.setBlockedUri()}}>{blockTextbutton}</Button>: null}
                            {showFavoriteButton?<Button mode={buttonMode} style={styles.button} onPress={() => {this.setFavoriteUri()}}>{favoriteTextbutton}</Button>: null}
                            {showUndoButton?<Button mode={buttonMode} style={styles.button} onPress={() => {this.undo()}}>{undoTextbutton}</Button>: null}
                         </Card.Actions>
                         </View>
                         : null}
                 </Card>
             );
         }
     }
 }
 
 HistoryCard.propTypes = {
     id             : PropTypes.string,
     contact        : PropTypes.object,
     setTargetUri   : PropTypes.func,
     setBlockedUri  : PropTypes.func,
     setFavoriteUri : PropTypes.func,
     saveInvitedParties : PropTypes.func,
     deleteHistoryEntry : PropTypes.func,
     orientation    : PropTypes.string,
     isTablet       : PropTypes.bool,
     contacts       : PropTypes.array,
     defaultDomain  : PropTypes.string
 };
 
 
 export default HistoryCard;
diff --git a/app/components/HistoryTileBox.js b/app/components/HistoryTileBox.js
index f33a227..e8baff4 100644
--- a/app/components/HistoryTileBox.js
+++ b/app/components/HistoryTileBox.js
@@ -1,582 +1,589 @@
 import React, { Component} from 'react';
 import autoBind from 'auto-bind';
 
 import PropTypes from 'prop-types';
 import { SafeAreaView, ScrollView, View, FlatList, Text } from 'react-native';
 
 import HistoryCard from './HistoryCard';
 import utils from '../utils';
 import DigestAuthRequest from 'digest-auth-request';
 import uuid from 'react-native-uuid';
 
 import moment from 'moment';
 import momenttz from 'moment-timezone';
 
 import styles from '../assets/styles/blink/_HistoryTileBox.scss';
 
 
 class HistoryTileBox extends Component {
     constructor(props) {
         super(props);
         autoBind(this);
 
         this.state = {
             serverHistory: this.props.serverHistory,
             localHistory: this.props.localHistory,
             accountId: this.props.account ? this.props.account.id : '',
             password: this.props.password,
             targetUri: this.props.targetUri,
             favoriteUris: this.props.favoriteUris,
             blockedUris: this.props.blockedUris,
             isRefreshing: false,
             myInvitedParties: this.props.myInvitedParties,
             refreshHistory: this.props.refreshHistory
         }
 
         const echoTest = {
             remoteParty: '4444@sylk.link',
             displayName: 'Echo test',
             type: 'contact',
             label: 'Call to test microphone',
             id: uuid.v4(),
             tags: ['test']
             };
 
         this.echoTest = Object.assign({}, echoTest);
 
         const videoTest = {
             remoteParty: '3333@sylk.link',
             displayName: 'Video test',
             type: 'contact',
             label: 'Call to test video',
             id: uuid.v4(),
             tags: ['test']
             };
 
         this.videoTest = Object.assign({}, videoTest);
         this.ended = false;
     }
 
     componentDidMount() {
         this.ended = false;
     }
 
     componentWillUnmount() {
         this.ended = true;
     }
 
     setTargetUri(uri, contact) {
         //console.log('Set target uri uri in history list', uri);
         this.props.setTargetUri(uri, contact);
     }
 
     deleteHistoryEntry(uri) {
         this.props.deleteHistoryEntry(uri);
         this.props.setTargetUri(uri);
     }
 
     setFavoriteUri(uri) {
         return this.props.setFavoriteUri(uri);
     }
 
     saveInvitedParties(room, uris) {
         if (this.ended) {
             return;
         }
 
         this.props.saveInvitedParties(room, uris);
         let myInvitedParties = this.state.myInvitedParties;
 
         if (myInvitedParties && myInvitedParties.hasOwnProperty(room)) {
             myInvitedParties[room] = uris;
             this.setState({myInvitedParties: myInvitedParties});
         }
     }
 
     setBlockedUri(uri) {
         return this.props.setBlockedUri(uri);
     }
 
     renderItem(item) {
 
         let invitedParties = [];
         let uri = item.item.remoteParty;
 
         let username = uri.split('@')[0];
 
         if (this.state.myInvitedParties && this.state.myInvitedParties.hasOwnProperty(username)) {
             invitedParties = this.state.myInvitedParties[username];
         }
 
         return(
             <HistoryCard
             id={item.id}
             contact={item.item}
             filter={this.props.filter}
             invitedParties={invitedParties}
             setFavoriteUri={this.setFavoriteUri}
             saveInvitedParties={this.saveInvitedParties}
             setBlockedUri={this.setBlockedUri}
             deleteHistoryEntry={this.deleteHistoryEntry}
             setTargetUri={this.setTargetUri}
             orientation={this.props.orientation}
             isTablet={this.props.isTablet}
             contacts={this.props.contacts}
             defaultDomain={this.props.defaultDomain}
             />);
     }
 
     findObjectByKey(array, key, value) {
         for (var i = 0; i < array.length; i++) {
             if (array[i][key] === value) {
                 return array[i];
             }
         }
         return null;
     }
 
     //getDerivedStateFromProps(nextProps, state) {
     UNSAFE_componentWillReceiveProps(nextProps) {
         if (this.ended) {
             return;
         }
 
         if (nextProps.myInvitedParties !== this.state.myInvitedParties) {
             this.setState({myInvitedParties: nextProps.myInvitedParties});
         }
 
         if (nextProps.account !== null && nextProps.account !== this.props.account) {
             this.setState({accountId: nextProps.account.id});
         }
 
         if (nextProps.refreshHistory !== this.state.refreshHistory) {
             this.setState({refreshHistory: nextProps.refreshHistory});
             this.getServerHistory();
         }
     }
 
     getLocalHistory() {
         let history = this.state.localHistory;
         history.sort((a, b) => (a.startTime < b.startTime) ? 1 : -1)
 
         let known = [];
         let uri;
 
         history = history.filter((elem) => {
             uri = elem.remoteParty.toLowerCase();
 
+            if (uri.indexOf('@videoconference') === -1) {
+                return;
+            }
+
             if (known.indexOf(uri) <= -1) {
                 elem.type = 'history';
                 if (!elem.tags) {
                     elem.tags = [];
                 }
                 if (elem.tags.indexOf('history') === -1) {
                     elem.tags.push('history');
                 }
                 if (elem.tags.indexOf('local') === -1) {
                     elem.tags.push('local');
                 }
 
                 known.push(uri);
                 return elem;
             }
         });
 
         return history;
     }
 
     getFavoriteContacts() {
         let favoriteContacts = [];
         let displayName;
         let label;
         let conference;
 
         let contacts= this.props.contacts
         contacts = contacts.concat(this.videoTest);
         contacts = contacts.concat(this.echoTest);
 
         //console.log('this.state.favoriteUris', this.state.favoriteUris);
         //console.log('this.state.myInvitedParties', this.state.myInvitedParties);
 
         this.state.favoriteUris.forEach((uri) => {
+            if (!uri) {
+                return;
+            }
             uri = uri.toLowerCase();
             const contact_obj = this.findObjectByKey(contacts, 'remoteParty', uri);
             displayName = contact_obj ? contact_obj.displayName : uri;
             label = contact_obj ? contact_obj.label: null;
             conference = false;
             let tags = ['favorite'];
 
             const history_obj = this.findObjectByKey(this.state.serverHistory, 'remoteParty', uri);
             const startTime = history_obj? history_obj.startTime : null;
             const stopTime = history_obj? history_obj.stopTime : null;
             const duration = history_obj? history_obj.duration : 0;
             let media = history_obj? history_obj.media : ['audio'];
             tags.push('history');
 
             if (uri.indexOf('@videoconference.') > -1) {
                 displayName = uri.split('@')[0];
                 uri = uri.split('@')[0] + '@' + this.props.config.defaultConferenceDomain;
                 conference = true;
                 media = ['audio', 'video', 'chat'];
             }
 
             const item = {
                 remoteParty: uri,
                 displayName: displayName,
                 conference: conference,
                 media: media,
                 type: 'contact',
                 startTime: startTime,
                 startTime: startTime,
                 duration: duration,
                 label: label,
                 id: uuid.v4(),
                 tags: tags
                 };
             favoriteContacts.push(item);
         });
 
         return favoriteContacts;
     }
 
     getBlockedContacts() {
         let blockedContacts = [];
         let contact_obj;
         let displayName;
         let label;
 
         let contacts= this.props.contacts
         contacts = contacts.concat(this.videoTest);
         contacts = contacts.concat(this.echoTest);
 
         this.state.blockedUris.forEach((uri) => {
             contact_obj = this.findObjectByKey(contacts, 'remoteParty', uri);
             displayName = contact_obj ? contact_obj.displayName : uri;
             label = contact_obj ? contact_obj.label: null;
 
             const item = {
                 remoteParty: uri.toLowerCase(),
                 displayName: displayName,
                 conference: false,
                 type: 'contact',
                 label: label,
                 id: uuid.v4(),
                 tags: ['blocked']
                 };
             blockedContacts.push(item);
         });
 
         return blockedContacts;
     }
 
     getServerHistory() {
         if (this.ended || !this.state.accountId || this.state.isRefreshing) {
             return;
         }
 
         this.setState({isRefreshing: true});
 
         utils.timestampedLog('Requesting call history from server');
 
         let history = [];
         let localTime;
         let hasMissedCalls = false;
 
         let getServerCallHistory = new DigestAuthRequest(
             'GET',
             `${this.props.config.serverCallHistoryUrl}?action=get_history&realm=${this.state.accountId.split('@')[1]}`,
             this.state.accountId.split('@')[0],
             this.state.password
         );
 
         // Disable logging
         getServerCallHistory.loggingOn = false;
         getServerCallHistory.request((data) => {
             if (data.success !== undefined && data.success === false) {
                 console.log('Error getting call history from server', data.error_message);
                 return;
             }
 
             if (data.received) {
                 data.received.map(elem => {elem.direction = 'received'; return elem});
                 history = history.concat(data.received);
             }
 
             if (data.placed) {
                 data.placed.map(elem => {elem.direction = 'placed'; return elem});
                 history = history.concat(data.placed);
             }
 
             history.sort((a, b) => (a.startTime < b.startTime) ? 1 : -1)
 
             if (history) {
                 const known = [];
                 history = history.filter((elem) => {
                     elem.conference = false;
 
                     if (!elem.tags) {
                         elem.tags = [];
                     }
 
                     if (elem.remoteParty.indexOf('@conference.') > -1) {
                         return null;
                     }
 
                     elem.remoteParty = elem.remoteParty.toLowerCase();
 
                     let username = elem.remoteParty.split('@')[0];
                     let isPhoneNumber = username.match(/^(\+|0)(\d+)$/);
                     let contact_obj;
 
                     if (this.props.contacts) {
                         if (isPhoneNumber) {
                             contact_obj = this.findObjectByKey(this.props.contacts, 'remoteParty', username);
                         } else {
                             contact_obj = this.findObjectByKey(this.props.contacts, 'remoteParty', elem.remoteParty);
                         }
                     }
 
                     if (contact_obj) {
                         elem.displayName = contact_obj.displayName;
                         elem.photo = contact_obj.photo;
                         if (isPhoneNumber) {
                             elem.remoteParty = username;
                         }
                         // TODO update icon here
                     } else {
                         elem.photo = null;
                     }
 
                     if (elem.remoteParty.indexOf('@guest.') > -1) {
-                        elem.remoteParty = elem.displayName.toLowerCase().replace(' ', '') + '@' + elem.remoteParty.split('@')[1];
+                        elem.remoteParty = elem.displayName.toLowerCase().replace(/ /g, '') + '@' + elem.remoteParty.split('@')[1];
                     }
 
                     if (elem.remoteParty.indexOf('@videoconference.') > -1) {
                         elem.displayName = elem.remoteParty.split('@')[0];
                         elem.remoteParty = elem.remoteParty.split('@')[0] + '@' + this.props.config.defaultConferenceDomain;
                         elem.conference = true;
                         elem.media = ['audio', 'video', 'chat'];
                     }
 
                     if (elem.remoteParty === this.state.accountId) {
                         elem.displayName = this.props.myDisplayName || 'Myself';
                     }
 
                     elem.type = 'history';
                     elem.id = uuid.v4();
 
                     if (elem.tags.indexOf('history') === -1) {
                         elem.tags.push('history');
                     }
 
                     elem.label = elem.direction;
 
                     if (!elem.displayName) {
                         elem.displayName = elem.remoteParty;
                     }
 
                     if (!elem.media || !Array.isArray(elem.media)) {
                         elem.media = ['audio'];
                     }
 
                     if (elem.remoteParty.indexOf('3333@') > -1) {
                         // see Call.js as well if we change this
                         elem.displayName = 'Video Test';
                     }
                     if (elem.remoteParty.indexOf('4444@') > -1) {
                         // see Call.js as well if we change this
                         elem.displayName = 'Echo Test';
                     }
 
                     if (elem.timezone !== undefined) {
                         localTime = momenttz.tz(elem.startTime, elem.timezone).toDate();
                         elem.startTime = moment(localTime).format('YYYY-MM-DD HH:mm:ss');
                         localTime = momenttz.tz(elem.stopTime, elem.timezone).toDate();
                         elem.stopTime = moment(localTime).format('YYYY-MM-DD HH:mm:ss');
                     }
 
                     if (known.indexOf(elem.remoteParty) <= -1) {
                         known.push(elem.remoteParty);
                         if (elem.direction === 'received' && elem.duration === 0) {
                             elem.tags.push('missed');
                             hasMissedCalls = true;
                         }
                         return elem;
                     }
                 });
 
                 this.props.cacheHistory(history);
                 if (this.ended) {
                     return;
                 }
                 this.setState({serverHistory: history, isRefreshing: false});
                 this.props.setMissedCalls(hasMissedCalls);
             }
         }, (errorCode) => {
             console.log('Error getting call history from server', errorCode);
         });
 
         this.setState({isRefreshing: false});
     }
 
     render() {
         let history = [];
         let searchExtraItems = [];
         let items = [];
         let matchedContacts = [];
 
         if (this.props.filter === 'favorite') {
             let favoriteContacts = this.getFavoriteContacts();
             items = favoriteContacts.filter(historyItem => historyItem.remoteParty.startsWith(this.props.targetUri));
         } else if (this.props.filter === 'blocked') {
             let blockedContacts = this.getBlockedContacts();
             items = blockedContacts.filter(historyItem => historyItem.remoteParty.startsWith(this.props.targetUri));
         } else if (this.props.filter === 'missed') {
             history = this.state.serverHistory;
             items = history.filter(historyItem => historyItem.remoteParty.startsWith(this.props.targetUri) && historyItem.tags.indexOf('missed') > -1);
         } else {
             history = this.getLocalHistory();
             history = history.concat(this.state.serverHistory);
 
             searchExtraItems = this.props.contacts;
             searchExtraItems.concat(this.videoTest);
             searchExtraItems.concat(this.echoTest);
 
             items = history.filter(historyItem => historyItem.remoteParty.startsWith(this.props.targetUri));
 
             if (this.props.targetUri && this.props.targetUri.length > 2 && !this.props.selectedContact) {
                 matchedContacts = searchExtraItems.filter(contact => (contact.remoteParty.toLowerCase().indexOf(this.props.targetUri) > -1 || contact.displayName.toLowerCase().indexOf(this.props.targetUri) > -1));
             } else if (this.props.selectedContact && this.props.selectedContact.type === 'contact') {
                 matchedContacts.push(this.props.selectedContact);
             }
 
             items = items.concat(matchedContacts);
         }
 
         const known = [];
         items.sort((a, b) => (a.startTime < b.startTime) ? 1 : -1)
         items = items.filter((elem) => {
             if (known.indexOf(elem.remoteParty) <= -1) {
                 known.push(elem.remoteParty);
                 if (!elem.startTime) {
                     elem.startTime = '1970-01-01 01:01:01'
                 }
                 return elem;
             }
         });
 
         if (!this.props.targetUri && !this.props.filter) {
             if (!this.findObjectByKey(items, 'remoteParty', this.echoTest.remoteParty)) {
                 items.push(this.echoTest);
             }
             if (!this.findObjectByKey(items, 'remoteParty', this.videoTest.remoteParty)) {
                 items.push(this.videoTest);
             }
         }
 
         items.forEach((item) => {
             item.showActions = false;
 
             if (!item.tags) {
                 item.tags = [];
             }
 
             if (this.state.favoriteUris.indexOf(item.remoteParty) > -1 && item.tags.indexOf('favorite') === -1) {
                 item.tags.push('favorite');
             }
 
             if (this.state.blockedUris.indexOf(item.remoteParty) > -1 && item.tags.indexOf('blocked') === -1) {
                 item.tags.push('blocked');
             }
 
             let idx = item.tags.indexOf('blocked');
             if (this.state.blockedUris.indexOf(item.remoteParty) === -1 && idx > -1) {
                 item.tags.splice(idx, 1);
             }
 
             idx = item.tags.indexOf('favorite');
 
             if (this.state.favoriteUris.indexOf(item.remoteParty) === -1 && idx > -1) {
                 item.tags.splice(idx, 1);
             }
 
             if (item.remoteParty.indexOf('@videoconference.') === -1) {
                 item.conference = false;
             }
 
         });
 
         let filteredItems = [];
         items.reverse();
 
         items.forEach((item) => {
             const fromDomain = '@' + item.remoteParty.split('@')[1];
             if (this.props.filter && item.tags.indexOf(this.props.filter) > -1) {
                 filteredItems.push(item);
             } else if (this.state.blockedUris.indexOf(item.remoteParty) === -1 && this.state.blockedUris.indexOf(fromDomain) === -1) {
                 filteredItems.push(item);
             }
         });
 
         items = filteredItems;
         items.sort((a, b) => (a.startTime < b.startTime) ? 1 : -1)
 
         if (items.length === 1) {
             items[0].showActions = true;
         }
 
         let columns = 1;
 
         if (this.props.isTablet) {
             columns = this.props.orientation === 'landscape' ? 3 : 2;
         } else {
             columns = this.props.orientation === 'landscape' ? 2 : 1;
         }
 
         return (
             <SafeAreaView style={styles.container}>
               <FlatList
                 horizontal={false}
                 numColumns={columns}
                 onRefresh={this.getServerHistory}
                 refreshing={this.state.isRefreshing}
                 data={items}
                 renderItem={this.renderItem}
                 listKey={item => item.id}
                 key={this.props.orientation}
               />
             </SafeAreaView>
         );
     }
 }
 
 HistoryTileBox.propTypes = {
     account         : PropTypes.object,
     password        : PropTypes.string.isRequired,
     config          : PropTypes.object.isRequired,
     targetUri       : PropTypes.string,
     selectedContact : PropTypes.object,
     contacts        : PropTypes.array,
     orientation     : PropTypes.string,
     setTargetUri    : PropTypes.func,
     isTablet        : PropTypes.bool,
     refreshHistory  : PropTypes.bool,
     cacheHistory    : PropTypes.func,
     serverHistory   : PropTypes.array,
     localHistory    : PropTypes.array,
     myDisplayName   : PropTypes.string,
     myPhoneNumber   : PropTypes.string,
     setFavoriteUri  : PropTypes.func,
     saveInvitedParties: PropTypes.func,
     myInvitedParties: PropTypes.object,
     setBlockedUri   : PropTypes.func,
     deleteHistoryEntry : PropTypes.func,
     favoriteUris    : PropTypes.array,
     blockedUris     : PropTypes.array,
     setMissedCalls  : PropTypes.func,
     filter          : PropTypes.string,
     defaultDomain   : PropTypes.string
 };
 
 
 export default HistoryTileBox;
diff --git a/app/components/InviteParticipantsModal.js b/app/components/InviteParticipantsModal.js
index 4965a94..87ad002 100644
--- a/app/components/InviteParticipantsModal.js
+++ b/app/components/InviteParticipantsModal.js
@@ -1,172 +1,181 @@
 import React, { Component } from 'react';
 import PropTypes from 'prop-types';
 import autoBind from 'auto-bind';
 import { View } from 'react-native';
 import { Dialog, Portal, Text, Button, Surface, TextInput, IconButton} from 'react-native-paper';
 import KeyboardAwareDialog from './KeyBoardAwareDialog';
 import { openComposer } from 'react-native-email-link';
 import Share from 'react-native-share';
 
 const DialogType = Platform.OS === 'ios' ? KeyboardAwareDialog : Dialog;
 
 import config from '../config';
 import styles from '../assets/styles/blink/_InviteParticipantsModal.scss';
 import utils from '../utils';
 
 
 class InviteParticipantsModal extends Component {
     constructor(props) {
         super(props);
         autoBind(this);
+        //console.log('currentParticipants', this.props.currentParticipants);
+        //console.log('previousParticipants', this.props.previousParticipants);
         let difference = this.props.previousParticipants.filter(x => !this.props.currentParticipants.includes(x));
+        //console.log('difference1', difference);
+        difference = difference.filter(x => !this.props.alreadyInvitedParticipants.includes(x));
+        //console.log('difference2', difference);
+        //console.log('alreadyInvitedParticipants', this.props.alreadyInvitedParticipants);
 
         this.state = {
             participants: difference.toString(),
             previousParticipants: this.props.previousParticipants,
             currentParticipants: this.props.currentParticipants,
             roomUrl: config.publicUrl + '/conference/' + this.props.room
         }
     }
 
     UNSAFE_componentWillReceiveProps(nextProps) {
         if (nextProps.hasOwnProperty('muted')) {
             this.setState({audioMuted: nextProps.muted});
         }
 
         let difference = nextProps.previousParticipants.filter(x => !nextProps.currentParticipants.includes(x));
+        difference = difference.filter(x => !nextProps.alreadyInvitedParticipants.includes(x));
         this.setState({
             participants: difference.toString(),
+            alreadyInvitedParticipants: nextProps.alreadyInvitedParticipants,
             previousParticipants: nextProps.previousParticipants,
             currentParticipants: nextProps.currentParticipants
         });
     }
 
     handleClipboardButton(event) {
         utils.copyToClipboard(this.state.roomUrl);
         this.props.notificationCenter().postSystemNotification('Join conference', {body: 'Conference address copied to clipboard'});
         this.props.close();
     }
 
     handleEmailButton(event) {
         const emailMessage = 'You can join the conference using a Web browser at ' + this.state.roomUrl +
                               ' or by using Sylk client app from https://sylkserver.com';
         const subject = 'Join conference, maybe?';
 
         openComposer({
             subject,
             body: emailMessage
         })
         this.props.close();
     }
 
     handleShareButton(event) {
         const subject = 'Join conference, maybe?';
         const message = 'You can join the conference using a Web browser at ' + this.state.roomUrl +
                         ' or by using Sylk client app from https://sylkserver.com';
 
         let options= {
             subject: subject,
             message: message
         }
 
         Share.open(options)
             .then((res) => {
                 this.props.close();
             })
             .catch((err) => {
                 this.props.close();
             });
     }
 
     invite(event) {
         event.preventDefault();
         const uris = [];
         if (this.state.participants) {
             this.state.participants.split(',').forEach((item) => {
                 item = item.trim();
                 if (item.indexOf('@') === -1) {
                     item = `${item}@${this.props.defaultDomain}`;
                 }
                 uris.push(item);
             });
         }
         if (uris) {
             this.props.inviteParticipants(uris);
             this.setState({participants: null});
         }
         this.props.close();
     }
 
     onInputChange(value) {
         this.setState({participants: value});
     }
 
     render() {
 
         return (
             <Portal>
                 <DialogType visible={this.props.show} onDismiss={this.props.close}>
                     <Surface style={styles.container}>
                         <Dialog.Title>Invite to conference</Dialog.Title>
                         <TextInput
                             mode="flat"
                             name="people"
                             label="Accounts"
                             onChangeText={this.onInputChange}
                             value={this.state.participants}
                             placeholder="Enter accounts separated by ,"
                             required
                             autoCapitalize="none"
                         />
                         <View style={styles.buttonRow}>
 
                         <Button
                             mode="contained"
                             style={styles.button}
                             onPress={this.invite}
                             icon="email">Invite
                         </Button>
                         </View>
 
                         <Text style={styles.body}>
                              Share the conference link:
                         </Text>
 
                         <View style={styles.iconContainer}>
                             <IconButton
                                 size={34}
                                 onPress={this.handleClipboardButton}
                                 icon="content-copy"
                             />
                             <IconButton
                                 size={34}
                                 onPress={this.handleEmailButton}
                                 icon="email"
                             />
                             <IconButton
                                 size={34}
                                 onPress={this.handleShareButton}
                                 icon="share-variant"
                             />
                         </View>
 
 
                     </Surface>
                 </DialogType>
             </Portal>
         );
     }
 }
 
 InviteParticipantsModal.propTypes = {
     notificationCenter : PropTypes.func.isRequired,
     show: PropTypes.bool.isRequired,
     close: PropTypes.func.isRequired,
     inviteParticipants: PropTypes.func,
     currentParticipants: PropTypes.array,
     previousParticipants: PropTypes.array,
+    alreadyInvitedParticipants: PropTypes.array,
     room: PropTypes.string,
     defaultDomain: PropTypes.string
 };
 
 export default InviteParticipantsModal;
diff --git a/app/components/LocalMedia.js b/app/components/LocalMedia.js
index 48327e8..c15b46a 100644
--- a/app/components/LocalMedia.js
+++ b/app/components/LocalMedia.js
@@ -1,97 +1,128 @@
 import React, { Component, Fragment } from 'react';
 import PropTypes from 'prop-types';
 import autoBind from 'auto-bind';
 import { View, Dimensions } from 'react-native';
 import { RTCView } from 'react-native-webrtc';
-import { IconButton } from 'react-native-paper';
+import { IconButton, Button, Text} from 'react-native-paper';
 
 import CallOverlay from './CallOverlay';
 import styles from '../assets/styles/blink/_LocalMedia.scss';
 
 
 class LocalMedia extends Component {
     constructor(props) {
         super(props);
         autoBind(this);
 
         this.localVideo = React.createRef();
 
         this.state = {
             localMedia: this.props.localMedia,
+            historyEntry: this.props.historyEntry,
+            participants: this.props.participants
         };
 
     }
 
     componentDidMount() {
         this.props.mediaPlaying();
     }
 
-    hangupCall(event) {
-        event.preventDefault();
-        this.props.hangupCall('stop_preview');
-    }
-
     //getDerivedStateFromProps(nextProps, state)
     UNSAFE_componentWillReceiveProps(nextProps) {
         if (nextProps.localMedia && nextProps.localMedia !== this.state.localMedia) {
             this.props.mediaPlaying();
         }
+
+        this.setState({historyEntry: nextProps.historyEntry, participants: nextProps.participants});
+    }
+
+    saveConference(event) {
+        event.preventDefault();
+        this.props.saveConference();
+    }
+
+    hangupCall(event) {
+        event.preventDefault();
+        this.props.hangupCall('user_hangup_conference_confirmed');
     }
 
     render() {
         let {height, width} = Dimensions.get('window');
         let videoStyle = {
             height,
             width
         };
 
         const streamUrl = this.props.localMedia ? this.props.localMedia.toURL() : null;
         const buttonSize = this.props.isTablet ? 40 : 34;
         const buttonContainerClass = this.props.isTablet ? styles.tabletButtonContainer : styles.buttonContainer;
 
         return (
             <Fragment>
                 <CallOverlay
                     show = {true}
                     remoteUri={this.props.remoteUri}
                     remoteDisplayName={this.props.remoteDisplayName}
-                    photo={this.props.photo}
                     call = {this.props.call}
                     connection={this.props.connection}
-                    accountId={this.props.accountId}
                 />
+
+                {this.props.showSaveDialog() ?
+                    <View style={styles.buttonContainer}>
+
+                    <Text style={styles.title}>Would you like to save the participants {this.state.participants.toString().replace(/,/g, ', ')} for having another conference later?</Text>
+                    <Text style={styles.description}>You can find later it by selecting Favorites. </Text>
+
+                    <View style={styles.buttonRow}>
+
+                    <Button
+                        mode="contained"
+                        style={styles.savebutton}
+                        onPress={this.saveConference}
+                        icon="content-save"
+                    >Save</Button>
+
+                    <Button
+                        mode="contained"
+                        style={styles.backbutton}
+                        onPress={this.hangupCall}
+                        icon=""
+                    > Back</Button>
+                    </View>
+                    </View>
+                :
                 <View style={buttonContainerClass}>
-                    <IconButton style={styles.button} key="hangupButton" onPress={this.hangupCall} icon="phone-hangup" size={buttonSize} />
+                <IconButton style={styles.hangupbutton} key="hangupButton" onPress={this.hangupCall} icon="phone-hangup" size={buttonSize} />
                 </View>
-
+                }
                 <View style={styles.container}>
                     <RTCView objectFit="cover"
                              style={[styles.video, videoStyle]}
                              id="localVideo"
                              ref={this.localVideo}
                              streamURL={streamUrl}
                              mirror={true}
                              />
                 </View>
             </Fragment>
         );
     }
 }
 
 LocalMedia.propTypes = {
     call                : PropTypes.object,
-    hangupCall          : PropTypes.func,
-    localMedia          : PropTypes.object.isRequired,
     remoteUri           : PropTypes.string,
     remoteDisplayName   : PropTypes.string,
-    photo               : PropTypes.string,
+    localMedia          : PropTypes.object.isRequired,
     mediaPlaying        : PropTypes.func.isRequired,
-    generatedVideoTrack : PropTypes.bool,
+    hangupCall          : PropTypes.func,
+    showSaveDialog      : PropTypes.func,
+    saveConference      : PropTypes.func,
+    reconnectingCall    : PropTypes.bool,
     connection          : PropTypes.object,
-    accountId           : PropTypes.string,
-    orientation         : PropTypes.string,
-    isTablet            : PropTypes.bool
+    participants        : PropTypes.array
 };
 
 
 export default LocalMedia;
diff --git a/app/components/ReadyBox.js b/app/components/ReadyBox.js
index 29979aa..befc797 100644
--- a/app/components/ReadyBox.js
+++ b/app/components/ReadyBox.js
@@ -1,358 +1,359 @@
 import React, { Component, Fragment } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import autoBind from 'auto-bind';
 import { View, Platform} from 'react-native';
 import { IconButton, Title, Button } from 'react-native-paper';
 
 import ConferenceModal from './ConferenceModal';
 import HistoryTileBox from './HistoryTileBox';
 import FooterBox from './FooterBox';
 import URIInput from './URIInput';
 import config from '../config';
 import utils from '../utils';
 import styles from '../assets/styles/blink/_ReadyBox.scss';
 
 
 class ReadyBox extends Component {
     constructor(props) {
         super(props);
         autoBind(this);
 
         this.state = {
             targetUri: '',
             contacts: this.props.contacts,
             selectedContact: null,
             showConferenceModal: false,
             sticky: false,
             favoriteUris: this.props.favoriteUris,
             blockedUris: this.props.blockedUris,
             historyFilter: null,
             missedCalls: false,
             participants: null,
             myInvitedParties: this.props.myInvitedParties
         };
         this.ended = false;
     }
 
     UNSAFE_componentWillReceiveProps(nextProps) {
         if (this.ended) {
             return;
         }
         this.setState({myInvitedParties: nextProps.myInvitedParties});
     }
 
     getTargetUri(uri) {
         return utils.normalizeUri(uri, this.props.defaultDomain);
     }
 
     async componentDidMount() {
         this.ended = false;
     }
 
     componentWillUnmount() {
         this.ended = true;
     }
 
     setMissedCalls(flag) {
         if (this.ended) {
             return;
         }
 
         this.setState({missedCalls: flag});
     }
 
     filterHistory(filter) {
         if (this.ended) {
             return;
         }
 
        this.setState({'historyFilter': filter});
        this.handleTargetChange('');
     }
 
     handleTargetChange(value, contact) {
         let new_value = value;
 
         if (contact) {
             if (this.state.targetUri === contact.uri) {
                 new_value = '';
             }
         }
 
         if (this.state.targetUri === value) {
             new_value = '';
         }
 
         if (new_value === '') {
             contact = null;
         }
 
         this.setState({targetUri: new_value, selectedContact: contact});
     }
 
     handleTargetSelect() {
         if (this.props.connection === null) {
             this.props._notificationCenter.postSystemNotification("Server unreachable");
             return;
         }
         // the user pressed enter, start a video call by default
 
         let uri = this.state.targetUri.toLowerCase();
 
         if (uri.endsWith(`@${config.defaultConferenceDomain}`)) {
             let participants;
             if (this.state.myInvitedParties && this.state.myInvitedParties.hasOwnProperty(uri)) {
                 participants = this.state.myInvitedParties[uri];
             }
             this.props.startConference(uri, {audio: true, video: true, participants: this.state.participants});
         } else {
             this.props.startCall(this.getTargetUri(uri), {audio: true, video: true});
         }
     }
 
     showConferenceModal(event) {
         event.preventDefault();
         this.setState({showConferenceModal: true});
         return;
     }
 
     handleAudioCall(event) {
         event.preventDefault();
         let uri = this.state.targetUri.toLowerCase();
         var uri_parts = uri.split("/");
         if (uri_parts.length === 5 && uri_parts[0] === 'https:') {
             // https://webrtc.sipthor.net/conference/DaffodilFlyChill0 from external web link
             // https://webrtc.sipthor.net/call/alice@example.com from external web link
             let event = uri_parts[3];
             uri = uri_parts[4];
             if (event === 'conference') {
                 uri = uri.split("@")[0] + '@' + config.defaultConferenceDomain;
             }
         }
 
         if (uri.endsWith(`@${config.defaultConferenceDomain}`)) {
             this.props.startConference(uri, {audio: true, video: false});
         } else {
             this.props.startCall(this.getTargetUri(uri), {audio: true, video: false});
         }
     }
 
     handleVideoCall(event) {
         event.preventDefault();
         let uri = this.state.targetUri.toLowerCase();
         var uri_parts = uri.split("/");
         if (uri_parts.length === 5 && uri_parts[0] === 'https:') {
             // https://webrtc.sipthor.net/conference/DaffodilFlyChill0 from external web link
             // https://webrtc.sipthor.net/call/alice@example.com from external web link
             let event = uri_parts[3];
             uri = uri_parts[4];
             if (event === 'conference') {
                 uri = uri.split("@")[0] + '@' + config.defaultConferenceDomain;
             }
         }
 
         if (uri.endsWith(`@${config.defaultConferenceDomain}`)) {
             this.props.startConference(uri, {audio: true, video: true});
         } else {
             this.props.startCall(this.getTargetUri(uri), {audio: true, video: true});
         }
     }
 
     handleConferenceCall(targetUri, options={audio: true, video: true, participants: []}) {
         this.props.startConference(targetUri, {audio: options.audio, video: options.video, participants: options.participants});
         this.setState({showConferenceModal: false});
     }
 
     conferenceButtonActive() {
         if (this.state.targetUri.indexOf('@guest.') > -1) {
             return false;
         }
 
         if (this.state.targetUri.indexOf('@') > -1 &&
             this.state.targetUri.indexOf(config.defaultConferenceDomain) === -1) {
             return false;
         }
 
         let uri = this.state.targetUri.toLowerCase();
         var uri_parts = uri.split("/");
         if (uri_parts.length === 5 && uri_parts[0] === 'https:') {
             // https://webrtc.sipthor.net/conference/DaffodilFlyChill0 from external web link
             // https://webrtc.sipthor.net/call/alice@example.com from external web link
             let event = uri_parts[3];
             if (event === 'call') {
                 return false;
             }
         }
 
         if (this.state.targetUri.match(/^(\+)(\d+)$/)) {
             return false;
         }
 
         return true;
     }
 
     render() {
         let uriClass = styles.portraitUriInputBox;
         let uriGroupClass = styles.portraitUriButtonGroup;
         let titleClass = styles.portraitTitle;
 
         let uri = this.state.targetUri.toLowerCase();
         var uri_parts = uri.split("/");
         if (uri_parts.length === 5 && uri_parts[0] === 'https:') {
             // https://webrtc.sipthor.net/conference/DaffodilFlyChill0 from external web link
             // https://webrtc.sipthor.net/call/alice@example.com from external web link
             let event = uri_parts[3];
             uri = uri_parts[4];
             if (event === 'conference') {
                 uri = uri.split("@")[0] + '@' + config.defaultConferenceDomain;
             }
         }
 
         const buttonClass = (Platform.OS === 'ios') ? styles.iosButton : styles.androidButton;
 
         if (this.props.isTablet) {
              titleClass = this.props.orientation === 'landscape' ? styles.landscapeTabletTitle : styles.portraitTabletTitle;
         } else {
              titleClass = this.props.orientation === 'landscape' ? styles.landscapeTitle : styles.portraitTitle;
         }
 
         if (this.props.isTablet) {
              uriGroupClass = this.props.orientation === 'landscape' ? styles.landscapeTabletUriButtonGroup : styles.portraitTabletUriButtonGroup;
         } else {
              uriGroupClass = this.props.orientation === 'landscape' ? styles.landscapeUriButtonGroup : styles.portraitUriButtonGroup;
         }
 
         if (this.props.isTablet) {
             uriClass = this.props.orientation === 'landscape' ? styles.landscapeTabletUriInputBox : styles.portraitTabletUriInputBox;
         } else {
             uriClass = this.props.orientation === 'landscape' ? styles.landscapeUriInputBox : styles.portraitUriInputBox;
         }
 
         const historyClass = this.props.orientation === 'landscape' ? styles.landscapeHistory : styles.portraitHistory;
 
         return (
             <Fragment>
                 <View style={styles.wholeContainer}>
                     <View >
                         <View style={uriGroupClass}>
                             <View style={uriClass}>
                                 <URIInput
                                     defaultValue={this.state.targetUri}
                                     onChange={this.handleTargetChange}
                                     onSelect={this.handleTargetSelect}
                                     autoFocus={false}
                                 />
                             </View>
                             <View style={styles.buttonGroup}>
                                 <IconButton
                                     style={buttonClass}
                                     size={34}
                                     disabled={this.state.targetUri.length === 0 || this.state.targetUri.indexOf('@videoconference') > -1 || this.state.targetUri.indexOf('@guest') > -1}
                                     onPress={this.handleAudioCall}
                                     icon="phone"
                                 />
                                 <IconButton
                                     style={buttonClass}
                                     size={34}
                                     disabled={this.state.targetUri.length === 0 || this.state.targetUri.indexOf('@videoconference') > -1 || this.state.targetUri.indexOf('@guest') > -1}
                                     onPress={this.handleVideoCall}
                                     icon="video"
                                 />
                                 <IconButton
                                     style={styles.conferenceButton}
                                     disabled={!this.conferenceButtonActive()}
                                     size={34}
                                     onPress={this.showConferenceModal}
                                     icon="account-group"
                                 />
                             </View>
                         </View>
                     </View>
                     <View style={historyClass}>
                         <HistoryTileBox
                             contacts={this.state.contacts}
                             targetUri={this.state.targetUri}
                             orientation={this.props.orientation}
                             setTargetUri={this.handleTargetChange}
                             selectedContact={this.state.selectedContact}
                             setMissedCalls={this.setMissedCalls}
                             isTablet={this.props.isTablet}
                             account={this.props.account}
                             password={this.props.password}
                             config={this.props.config}
                             refreshHistory={this.props.refreshHistory}
                             localHistory={this.props.localHistory}
                             cacheHistory={this.props.cacheHistory}
                             serverHistory={this.props.serverHistory}
                             myDisplayName={this.props.myDisplayName}
                             myPhoneNumber={this.props.myPhoneNumber}
                             deleteHistoryEntry={this.props.deleteHistoryEntry}
                             setFavoriteUri={this.props.setFavoriteUri}
                             saveInvitedParties={this.props.saveInvitedParties}
                             myInvitedParties = {this.state.myInvitedParties}
                             setBlockedUri={this.props.setBlockedUri}
                             favoriteUris={this.state.favoriteUris}
                             blockedUris={this.state.blockedUris}
                             filter={this.state.historyFilter}
                             defaultDomain={this.props.defaultDomain}
                         />
                     </View>
                     {((this.state.favoriteUris.length > 0 || this.state.blockedUris.length  > 0 ) ||
                       (this.state.favoriteUris.length === 0 && this.state.historyFilter === 'favorite') ||
                       (this.state.blockedUris.length === 0 && this.state.historyFilter === 'blocked') ||
                       (this.state.historyFilter === 'missed')
                       ) ?
                     <View style={styles.historyButtonGroup}>
                        {this.state.historyFilter !== null ? <Button style={styles.historyButton} onPress={() => {this.filterHistory(null)}}>Show all</Button>: null}
                        {(this.state.favoriteUris.length > 0  && this.state.historyFilter !== 'favorite')? <Button style={styles.historyButton} onPress={() => {this.filterHistory('favorite')}}>Favorites</Button> :  null}
                        {(this.state.blockedUris.length > 0 && this.state.historyFilter !== 'blocked')? <Button style={styles.historyButton} onPress={() => {this.filterHistory('blocked')}}>Blocked</Button> : null}
                        {(this.state.missedCalls && this.state.historyFilter !== 'missed')? <Button style={styles.historyButton} onPress={() => {this.filterHistory('missed')}}>Missed</Button> : null}
                     </View>
                     : null}
                     {this.props.isTablet && 0?
                     <View style={styles.footer}>
                         <FooterBox />
                     </View>
                         : null}
                 </View>
                 <ConferenceModal
                     show={this.state.showConferenceModal}
                     targetUri={uri}
                     myInvitedParties={this.state.myInvitedParties}
                     selectedContact={this.state.selectedContact}
                     handleConferenceCall={this.handleConferenceCall}
                     defaultDomain={this.props.defaultDomain}
+                    accountId={this.props.account ? this.props.account.id: null}
                 />
             </Fragment>
         );
     }
 }
 
 
 ReadyBox.propTypes = {
     account         : PropTypes.object,
     password        : PropTypes.string.isRequired,
     config          : PropTypes.object.isRequired,
     startCall       : PropTypes.func.isRequired,
     startConference : PropTypes.func.isRequired,
     contacts        : PropTypes.array,
     orientation     : PropTypes.string,
     isTablet        : PropTypes.bool,
     refreshHistory  : PropTypes.bool,
     cacheHistory    : PropTypes.func,
     serverHistory  : PropTypes.array,
     localHistory    : PropTypes.array,
     myDisplayName   : PropTypes.string,
     myPhoneNumber   : PropTypes.string,
     deleteHistoryEntry: PropTypes.func,
     setFavoriteUri  : PropTypes.func,
     myInvitedParties: PropTypes.object,
     setBlockedUri   : PropTypes.func,
     favoriteUris    : PropTypes.array,
     blockedUris     : PropTypes.array,
     defaultDomain   : PropTypes.string
 };
 
 
 export default ReadyBox;
diff --git a/app/components/VideoBox.js b/app/components/VideoBox.js
index 978ad5b..6933df8 100644
--- a/app/components/VideoBox.js
+++ b/app/components/VideoBox.js
@@ -1,382 +1,382 @@
 import React, { Component } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import dtmf from 'react-native-dtmf';
 import debug from 'react-native-debug';
 import autoBind from 'auto-bind';
 import { IconButton, ActivityIndicator, Colors } from 'react-native-paper';
 import { View, Dimensions, TouchableWithoutFeedback, Platform  } from 'react-native';
 import { RTCView } from 'react-native-webrtc';
 
 import CallOverlay from './CallOverlay';
 import EscalateConferenceModal from './EscalateConferenceModal';
 import DTMFModal from './DTMFModal';
 import config from '../config';
 import styles from '../assets/styles/blink/_VideoBox.scss';
 
 const DEBUG = debug('blinkrtc:Video');
 debug.enable('*');
 
 
 class VideoBox extends Component {
     constructor(props) {
         super(props);
         autoBind(this);
 
         this.state = {
             call: this.props.call,
             reconnectingCall: this.props.reconnectingCall,
             audioMuted: this.props.muted,
             mirror: true,
             callOverlayVisible: true,
             videoMuted: false,
             localVideoShow: true,
             remoteVideoShow: true,
             remoteSharesScreen: false,
             showEscalateConferenceModal: false,
             localStream: this.props.call.getLocalStreams()[0],
             remoteStream: this.props.call.getRemoteStreams()[0],
             showDtmfModal: false,
             doorOpened: false
         };
 
         this.overlayTimer = null;
         this.localVideo = React.createRef();
         this.remoteVideo = React.createRef();
         this.userHangup = false;
     }
 
     //getDerivedStateFromProps(nextProps, state) {
     UNSAFE_componentWillReceiveProps(nextProps) {
         if (nextProps.hasOwnProperty('muted')) {
             this.setState({audioMuted: nextProps.muted});
         }
 
         if (nextProps.call && nextProps.call !== this.state.call) {
             nextProps.call.on('stateChanged', this.callStateChanged);
 
             if (this.state.call !== null) {
                 this.state.call.removeListener('stateChanged', this.callStateChanged);
             }
             this.setState({call: nextProps.call,
                            localStream: nextProps.call.getLocalStreams()[0],
                            remoteStream: nextProps.call.getRemoteStreams()[0]
             });
         }
 
         if (nextProps.reconnectingCall != this.state.reconnectingCall) {
             this.setState({reconnectingCall: nextProps.reconnectingCall});
         }
 
     }
 
     callStateChanged(oldState, newState, data) {
         this.forceUpdate();
     }
 
     openDoor() {
         const tone = this.props.intercomDtmfTone;
         DEBUG('DTMF tone sent to intercom: ' + tone);
         this.setState({doorOpened: true});
         this.forceUpdate();
 
         dtmf.stopTone(); //don't play a tone at the same time as another
         dtmf.playTone(dtmf['DTMF_' + tone], 1000);
 
         if (this.state.call !== null && this.state.call.state === 'established') {
             this.state.call.sendDtmf(tone);
         }
     }
 
     componentDidMount() {
         if (this.state.call) {
             this.state.call.on('stateChanged', this.callStateChanged);
         }
         this.armOverlayTimer();
     }
 
     componentWillUnmount() {
         if (this.state.call != null) {
             this.state.call.removeListener('stateChanged', this.callStateChanged);
         }
     }
 
     showDtmfModal() {
         this.setState({showDtmfModal: true});
     }
 
     hideDtmfModal() {
         this.setState({showDtmfModal: false});
     }
 
     handleFullscreen(event) {
         event.preventDefault();
         // this.toggleFullscreen();
     }
 
     handleRemoteVideoPlaying() {
         this.setState({remoteVideoShow: true});
     }
 
     handleRemoteResize(event, target) {
         const resolutions = [ '1280x720', '960x540', '640x480', '640x360', '480x270','320x180'];
         const videoResolution = event.target.videoWidth + 'x' + event.target.videoHeight;
         if (resolutions.indexOf(videoResolution) === -1) {
             this.setState({remoteSharesScreen: true});
         } else {
             this.setState({remoteSharesScreen: false});
         }
     }
 
     muteAudio(event) {
         event.preventDefault();
         this.props.toggleMute(this.state.call.id, !this.state.audioMuted);
     }
 
     muteVideo(event) {
         event.preventDefault();
         const localStream = this.state.localStream;
         if (localStream.getVideoTracks().length > 0) {
             const track = localStream.getVideoTracks()[0];
             if(this.state.videoMuted) {
                 DEBUG('Unmute camera');
                 track.enabled = true;
                 this.setState({videoMuted: false});
             } else {
                 DEBUG('Mute camera');
                 track.enabled = false;
                 this.setState({videoMuted: true});
             }
         }
     }
 
     toggleCamera(event) {
         event.preventDefault();
         const localStream = this.state.localStream;
         if (localStream.getVideoTracks().length > 0) {
             const track = localStream.getVideoTracks()[0];
             track._switchCamera();
             this.setState({mirror: !this.state.mirror});
         }
     }
 
     hangupCall(event) {
         event.preventDefault();
-        this.props.hangupCall('user_press_hangup');
+        this.props.hangupCall('user_hangup_call');
         this.userHangup = true;
     }
 
     cancelCall(event) {
         event.preventDefault();
-        this.props.hangupCall('user_cancelled');
+        this.props.hangupCall('user_cancelled_call');
     }
 
     escalateToConference(participants) {
         this.props.escalateToConference(participants);
     }
 
     armOverlayTimer() {
         clearTimeout(this.overlayTimer);
         this.overlayTimer = setTimeout(() => {
             this.setState({callOverlayVisible: false});
         }, 4000);
     }
 
     toggleCallOverlay() {
         this.setState({callOverlayVisible: !this.state.callOverlayVisible});
     }
 
     toggleEscalateConferenceModal() {
         this.setState({
             callOverlayVisible          : false,
             showEscalateConferenceModal : !this.state.showEscalateConferenceModal
         });
     }
 
     render() {
         if (this.state.call === null) {
             return null;
         }
 
         // 'mirror'          : !this.state.call.sharingScreen && !this.props.generatedVideoTrack,
         // we do not want mirrored local video once the call has started, just in preview
 
         const localVideoClasses = classNames({
             'video-thumbnail' : true,
             'hidden'          : !this.state.localVideoShow,
             'animated'        : true,
             'fadeIn'          : this.state.localVideoShow || this.state.videoMuted,
             'fadeOut'         : this.state.videoMuted,
             'fit'             : this.state.call.sharingScreen
         });
 
         const remoteVideoClasses = classNames({
             'poster'        : !this.state.remoteVideoShow,
             'animated'      : true,
             'fadeIn'        : this.state.remoteVideoShow,
             'large'         : true,
             'fit'           : this.state.remoteSharesScreen
         });
 
         let buttonContainerClass;
 
         let buttons;
         const muteButtonIcons = this.state.audioMuted ? 'microphone-off' : 'microphone';
         const muteVideoButtonIcons = this.state.videoMuted ? 'video-off' : 'video';
         const buttonClass = (Platform.OS === 'ios') ? styles.iosButton : styles.androidButton;
 
         const buttonSize = this.props.isTablet ? 40 : 34;
 
         if (this.props.isTablet) {
             buttonContainerClass = this.props.orientation === 'landscape' ? styles.tabletLandscapeButtonContainer : styles.tabletPortraitButtonContainer;
             userIconContainerClass = styles.tabletUserIconContainer;
         } else {
             buttonContainerClass = this.props.orientation === 'landscape' ? styles.landscapeButtonContainer : styles.portraitButtonContainer;
         }
 
         if (this.state.callOverlayVisible) {
             let content = (<View style={buttonContainerClass}>
                 <IconButton
                     size={buttonSize}
                     style={buttonClass}
                     onPress={this.toggleEscalateConferenceModal}
                     icon="account-plus"
                 />
                 <IconButton
                     size={buttonSize}
                     style={buttonClass}
                     onPress={this.muteAudio}
                     icon={muteButtonIcons}
                 />
                 <IconButton
                     size={buttonSize}
                     style={buttonClass}
                     onPress={this.muteVideo}
                     icon={muteVideoButtonIcons}
                 />
                 <IconButton
                     size={buttonSize}
                     style={[buttonClass]}
                     icon={this.props.speakerPhoneEnabled ? 'volume-high' : 'volume-off'}
                     onPress={this.props.toggleSpeakerPhone}
                 />
                 <IconButton
                     size={buttonSize}
                     style={[buttonClass, styles.hangupButton]}
                     onPress={this.hangupCall}
                     icon="phone-hangup"
                 />
             </View>);
             if (this.props.intercomDtmfTone) {
                 content = (<View style={buttonContainerClass}>
                     <IconButton
                         size={50}
                         style={buttonClass}
                         icon={this.state.doorOpened ? "door-open": "door" }
                         onPress={this.openDoor}
                         disabled={!(this.state.call && this.state.call.state === 'accepted')}
                     />
                     <IconButton
                         size={buttonSize}
                         style={[buttonClass]}
                         icon={this.props.speakerPhoneEnabled ? 'volume-high' : 'volume-off'}
                         onPress={this.props.toggleSpeakerPhone}
                     />
                     <IconButton
                         size={50}
                         style={[styles.button, styles.hangupButton]}
                         onPress={this.hangupCall}
                         icon="phone-hangup"
                     />
                 </View>);
             }
             buttons = (<View style={styles.buttonContainer}>{content}</View>);
         }
 
         const remoteStreamUrl = this.state.remoteStream ? this.state.remoteStream.toURL() : null
         const show = this.state.callOverlayVisible || this.state.reconnectingCall;
 
         return (
             <View style={styles.container}>
                 <CallOverlay
                     show = {show}
                     remoteUri = {this.props.remoteUri}
                     remoteDisplayName = {this.props.remoteDisplayName}
                     photo={this.props.photo}
                     call = {this.state.call}
                     connection = {this.props.connection}
                     accountId = {this.props.accountId}
                 />
                 {this.state.remoteVideoShow && !this.state.reconnectingCall ?
                     <View style={[styles.container, styles.remoteVideoContainer]}>
                         <TouchableWithoutFeedback onPress={this.toggleCallOverlay}>
                             <RTCView
                                 objectFit='cover'
                                 style={[styles.video, styles.remoteVideo]}
                                 poster="assets/images/transparent-1px.png"
                                 ref={this.remoteVideo}
                                 streamURL={remoteStreamUrl}
                             />
                         </TouchableWithoutFeedback>
                     </View>
                     : null }
                 { this.state.localVideoShow ?
                     <View style={[styles.localVideoContainer]}>
                         <TouchableWithoutFeedback onPress={this.toggleCamera}>
                             <RTCView
                                 objectFit='cover'
                                 style={[styles.video, styles.localVideo]}
                                 ref={this.localVideo}
                                 streamURL={this.state.localStream ? this.state.localStream.toURL() : null}
                                 mirror={this.state.mirror}
                             />
                         </TouchableWithoutFeedback>
                     </View>
                     : null }
 
                 {this.state.reconnectingCall
                     ? <ActivityIndicator style={styles.reconnectContainer} animating={true} size={'large'} color={Colors.red800} />
                     : null
                 }
                 {buttons}
                 <DTMFModal
                     show={this.state.showDtmfModal}
                     hide={this.hideDtmfModal}
                     call={this.state.call}
                     callKeepSendDtmf={this.props.callKeepSendDtmf}
                 />
                 <EscalateConferenceModal
                     show={this.state.showEscalateConferenceModal}
                     call={this.state.call}
                     close={this.toggleEscalateConferenceModal}
                     escalateToConference={this.escalateToConference}
                 />
             </View>
         );
     }
 }
 
 VideoBox.propTypes = {
     call                    : PropTypes.object,
     connection              : PropTypes.object,
     photo                   : PropTypes.string,
     accountId               : PropTypes.string,
     remoteUri               : PropTypes.string,
     remoteDisplayName       : PropTypes.string,
     localMedia              : PropTypes.object,
     hangupCall              : PropTypes.func,
     shareScreen             : PropTypes.func,
     escalateToConference    : PropTypes.func,
     generatedVideoTrack     : PropTypes.bool,
     callKeepSendDtmf        : PropTypes.func,
     toggleMute              : PropTypes.func,
     toggleSpeakerPhone      : PropTypes.func,
     speakerPhoneEnabled     : PropTypes.bool,
     intercomDtmfTone        : PropTypes.string,
     orientation             : PropTypes.string,
     isTablet                : PropTypes.bool,
     reconnectingCall        : PropTypes.bool,
     muted                   : PropTypes.bool
 };
 
 export default VideoBox;