diff --git a/app/CallManager.js b/app/CallManager.js
index f3d1699..526f693 100644
--- a/app/CallManager.js
+++ b/app/CallManager.js
@@ -1,655 +1,657 @@
 import events from 'events';
 import Logger from '../Logger';
 import uuid from 'react-native-uuid';
 import { Platform, PermissionsAndroid } from 'react-native';
 import utils from './utils';
 
 const logger = new Logger('CallManager');
 import { CONSTANTS as CK_CONSTANTS } from 'react-native-callkeep';
 
 // https://github.com/react-native-webrtc/react-native-callkeep
 
 /*
 const CONSTANTS = {
   END_CALL_REASONS: {
     FAILED: 1,
     REMOTE_ENDED: 2,
     UNANSWERED: 3,
     ANSWERED_ELSEWHERE: 4,
     DECLINED_ELSEWHERE: 5,
     MISSED: 6
   }
 };
 */
 
 const options = {
     ios: {
         appName: 'Sylk',
         maximumCallGroups: 1,
         maximumCallsPerCallGroup: 2,
         supportsVideo: true,
         includesCallsInRecents: true,
         imageName: "Image-1"
     },
     android: {
         alertTitle: 'Calling account permission',
         alertDescription: 'Please allow Sylk inside All calling accounts',
         cancelButton: 'Deny',
         okButton: 'Allow',
         imageName: 'phone_account_icon',
         additionalPermissions: [PermissionsAndroid.PERMISSIONS.CAMERA, PermissionsAndroid.PERMISSIONS.RECORD_AUDIO, PermissionsAndroid.PERMISSIONS.READ_CONTACTS],
         foregroundService: {
           channelId: 'com.agprojects.sylk',
           channelName: 'Foreground service for Sylk',
           notificationTitle: 'Sylk is running in the background'
         }
     }
 };
 
 export default class CallManager extends events.EventEmitter {
     constructor(RNCallKeep, acceptFunc, rejectFunc, hangupFunc, timeoutFunc, conferenceCallFunc, startCallFromCallKeeper, muteFunc, getConnectionFunct, missedCallFunc, changeRouteFunc, respawnConnection, isUnmountedFunc) {
         //logger.debug('constructor()');
         super();
         this.setMaxListeners(Infinity);
 
         this._RNCallKeep = RNCallKeep;
 
         this._calls = new Map();
         this._pushCalls = new Map();
         this._incoming_conferences = new Map();
         this._rejectedCalls = new Map();
         this._acceptedCalls = new Map();
         this._cancelledCalls = new Map();
         this._alertedCalls = new Map();
         this._terminatedCalls = new Map();
         this.unmounted = isUnmountedFunc;
 
         this.webSocketActions = new Map();
         this.pushNotificationsActions = new Map();
         this._timeouts = new Map();
 
         this.sylkAcceptCall = acceptFunc;
         this.sylkRejectCall = rejectFunc;
         this.sylkHangupCall = hangupFunc;
         this.timeoutCall = timeoutFunc;
         this.logMissedCall = missedCallFunc;
         this.getConnection = getConnectionFunct;
         this.changeRoute = changeRouteFunc;
         this.respawnConnection = respawnConnection;
 
         this.toggleMute = muteFunc;
 
         this.conferenceCall = conferenceCallFunc;
         this.outgoingMedia = {audio: true, video: true}
 
         this.startCallFromOutside = startCallFromCallKeeper;
 
         this._boundRnAccept = this._rnAccept.bind(this);
         this._boundRnEnd = this._rnEnd.bind(this);
         this._boundRnMute = this._rnMute.bind(this);
         this._boundRnActiveAudioCall = this._rnActiveAudioSession.bind(this);
         this._boundRnDeactiveAudioCall = this._rnDeactiveAudioSession.bind(this);
         this._boundRnDTMF = this._rnDTMF.bind(this);
         this._boundRnProviderReset = this._rnProviderReset.bind(this);
         this.boundRnStartAction = this._startedCall.bind(this);
         this.boundRnDisplayIncomingCall = this._displayIncomingCall.bind(this);
 
         this._RNCallKeep.addEventListener('answerCall', this._boundRnAccept);
         this._RNCallKeep.addEventListener('endCall', this._boundRnEnd);
         this._RNCallKeep.addEventListener('didPerformSetMutedCallAction', this._boundRnMute);
         this._RNCallKeep.addEventListener('didActivateAudioSession', this._boundRnActiveAudioCall);
         this._RNCallKeep.addEventListener('didDeactivateAudioSession', this._boundRnDeactiveAudioCall);
         this._RNCallKeep.addEventListener('didPerformDTMFAction', this._boundRnDTMF);
         this._RNCallKeep.addEventListener('didResetProvider', this._boundRnProviderReset);
         this._RNCallKeep.addEventListener('didReceiveStartCallAction', this.boundRnStartAction);
         this._RNCallKeep.addEventListener('didDisplayIncomingCall', this.boundRnDisplayIncomingCall);
 
         this._RNCallKeep.setup(options);
 
         this._RNCallKeep.addEventListener('checkReachability', () => {
             this._RNCallKeep.setReachable();
         });
 
     }
 
     get callKeep() {
         return this._RNCallKeep;
     }
 
     get countCalls() {
         return this._calls.size;
     }
 
     get countPushCalls() {
         return this._pushCalls.size;
     }
 
     get waitingCount() {
         return this._timeouts.size;
     }
 
     get callUUIDS() {
         return Array.from( this._calls.keys() );
     }
 
     get calls() {
         return [...this._calls.values()];
     }
 
     setAvailable(available) {
         this.callKeep.setAvailable(available);
     }
 
     heartbeat() {
         this.callUUIDS.forEach((callUUID) => {
             //utils.timestampedLog('Callkeep: call active', callUUID);
         });
     }
 
     backToForeground() {
        utils.timestampedLog('Callkeep: bring app to the FOREGROUND');
        this.callKeep.backToForeground();
     }
 
     startOutgoingCall(callUUID, targetUri, hasVideo) {
         utils.timestampedLog('Callkeep: will start outgoing', callUUID);
         this.callKeep.startCall(callUUID, targetUri, targetUri, 'sip', hasVideo);
     }
 
     updateDisplay(callUUID, displayName, uri) {
         utils.timestampedLog('Callkeep: update display', displayName, uri);
         this.callKeep.updateDisplay(callUUID, displayName, uri);
     }
 
     sendDTMF(callUUID, digits) {
         utils.timestampedLog('Callkeep: send DTMF: ', digits);
         this.callKeep.sendDTMF(callUUID, digits);
     }
 
     setCurrentCallActive(callUUID) {
         if (Platform.OS !== 'android') {
             return;
         }
 
         utils.timestampedLog('Callkeep: active call', callUUID);
         this.callKeep.setCurrentCallActive(callUUID);
+        this.backToForeground();
+
     }
 
     endCalls() {
         utils.timestampedLog('Callkeep: end all calls');
         this.callKeep.endAllCalls();
     }
 
     endCall(callUUID, reason) {
         if (this.unmounted()) {
             return;
         }
 
         if (reason) {
             utils.timestampedLog('Callkeep: end call', callUUID, 'with reason', reason);
         } else {
             utils.timestampedLog('Callkeep: end call', callUUID);
         }
 
         if (this._pushCalls.has(callUUID)) {
             this._pushCalls.delete(callUUID);
         }
 
         if (this._rejectedCalls.has(callUUID)) {
         //    return;
         }
 
         if (this._cancelledCalls.has(callUUID)) {
             //utils.timestampedLog('Callkeep: CALL', callUUID, 'already cancelled');
             return;
         }
 
         if (reason === 2) {
             this._cancelledCalls.set(callUUID, Date.now());
         }
 
         if (reason) {
             this.callKeep.reportEndCallWithUUID(callUUID, reason);
             if (this._timeouts.has(callUUID)) {
                 clearTimeout(this._timeouts.get(callUUID));
                 this._timeouts.delete(callUUID);
             }
         }
         this.callKeep.endCall(callUUID);
     }
 
     terminateCall(callUUID) {
         //utils.timestampedLog('Callkeep: call terminated', callUUID);
 
         this._terminatedCalls.set(callUUID, Date.now());
 
         if (this._calls.has(callUUID)) {
             utils.timestampedLog('Callkeep: removed websocket call', callUUID);
             this._calls.delete(callUUID);
         }
 
         if (this._pushCalls.has(callUUID)) {
             this._pushCalls.delete(callUUID);
         }
     }
 
     _rnActiveAudioSession() {
         utils.timestampedLog('Callkeep: activated audio call');
     }
 
     _rnDeactiveAudioSession() {
         utils.timestampedLog('Callkeep: deactivated audio call');
     }
 
     _rnAccept(data) {
         let callUUID = data.callUUID.toLowerCase();
         utils.timestampedLog('---- Callkeep: accept callback', callUUID);
 
         if (this._pushCalls.has(callUUID)) {
             this._pushCalls.delete(callUUID);
         }
 
         if (this._rejectedCalls.has(callUUID)) {
             utils.timestampedLog('Callkeep: cannot accept because we already rejected', callUUID);
             //this.endCall(callUUID);
             return;
         }
 
         this.acceptCall(callUUID);
     }
 
     _rnEnd(data) {
         // this is called both when user touches Reject and when the call ends
         let callUUID = data.callUUID.toLowerCase();
         utils.timestampedLog('---- Callkeep: end callback', callUUID);
 
         if (this._terminatedCalls.has(callUUID)) {
             //utils.timestampedLog('Callkeep: call', callUUID, 'already terminated');
             return;
         }
 
         if (this._pushCalls.has(callUUID)) {
             this._pushCalls.delete(callUUID);
         }
 
         let call = this._calls.get(callUUID);
 
         if (!call && !this._incoming_conferences.has(callUUID)) {
             utils.timestampedLog('Callkeep: add call', callUUID, 'reject to the waitings list');
             this.webSocketActions.set(callUUID, 'reject');
             return;
         }
 
         if (call && call.state === 'incoming') {
             if (!this._acceptedCalls.has(callUUID)) {
                 this.rejectCall(callUUID);
             }
         } else {
             if (this._incoming_conferences.has(callUUID)) {
                 const conference = this._incoming_conferences.get(callUUID);
                 this.logMissedCall(conference.room, callUUID, direction='received', participants=[conference.from]);
                 this._incoming_conferences.delete(callUUID);
             } else {
                 this.sylkHangupCall(callUUID, 'callkeep_hangup_call');
             }
         }
     }
 
     acceptCall(callUUID) {
         if (this.unmounted()) {
             return;
         }
         const connection = this.getConnection();
 
         if (this._acceptedCalls.has(callUUID)) {
             utils.timestampedLog('Callkeep: already accepted call', callUUID, 'on web socket', connection);
             this.endCall(callUUID);
             return;
         } else {
             utils.timestampedLog('Callkeep: accept call', callUUID, 'on web socket', connection);
         }
 
         if (this._terminatedCalls.has(callUUID)) {
             utils.timestampedLog('Callkeep: call', callUUID, 'was already terminated', 'on web socket', connection);
             this.endCall(callUUID);
             return;
         }
 
         this._acceptedCalls.set(callUUID, Date.now());
 
         if (this._timeouts.has(callUUID)) {
             clearTimeout(this._timeouts.get(callUUID));
             this._timeouts.delete(callUUID);
         }
 
         if (this._incoming_conferences.has(callUUID)) {
             let conference = this._incoming_conferences.get(callUUID);
 
             utils.timestampedLog('Callkeep: accept incoming conference', callUUID);
             this.endCall(callUUID, CK_CONSTANTS.END_CALL_REASONS.ANSWERED_ELSEWHERE);
             this.backToForeground();
 
             utils.timestampedLog('Callkeep: will start conference to', conference.room);
             this.conferenceCall(conference.room, this.outgoingMedia);
             this._incoming_conferences.delete(callUUID);
 
         } else if (this._calls.has(callUUID)) {
             this.backToForeground();
             this.sylkAcceptCall(callUUID);
 
         } else {
             this.backToForeground();
             utils.timestampedLog('Callkeep: add call', callUUID, 'accept to the waitings list');
             // We accepted the call before it arrived on web socket
             this.respawnConnection();
             this.webSocketActions.set(callUUID, 'accept');
             utils.timestampedLog('Callkeep: check over 12 seconds if call', callUUID, 'arrived over web socket');
 
             setTimeout(() => {
                 const connection = this.getConnection();
                 utils.timestampedLog('Callkeep: current calls:', this.callUUIDS);
 
                 if (!this._calls.has(callUUID) && !this._terminatedCalls.has(callUUID)) {
                     utils.timestampedLog('Callkeep: call', callUUID, 'did not arrive on web socket', connection);
                     this.webSocketActions.delete(callUUID);
                     this.endCall(callUUID, CK_CONSTANTS.END_CALL_REASONS.FAILED);
                     this.sylkHangupCall(callUUID, 'timeout');
                 } else {
                     utils.timestampedLog('Callkeep: call', callUUID, 'did arrive on web socket', connection);
                 }
             }, 12000);
         }
     }
 
     rejectCall(callUUID) {
         if (this.unmounted()) {
             return;
         }
 
         const connection = this.getConnection();
         if (this._rejectedCalls.has(callUUID)) {
             utils.timestampedLog('Callkeep: already rejected call', callUUID, 'on web socket', connection);
             //this.endCall(callUUID);
             return;
         }
 
         utils.timestampedLog('Callkeep: reject call', callUUID, 'on web socket', connection);
 
         this._rejectedCalls.set(callUUID, Date.now());
 
         if (this._timeouts.has(callUUID)) {
             clearTimeout(this._timeouts.get(callUUID));
             this._timeouts.delete(callUUID);
         }
 
         this.callKeep.rejectCall(callUUID);
 
         if (this._incoming_conferences.has(callUUID)) {
             utils.timestampedLog('Callkeep: reject conference invite', callUUID);
             let room = this._incoming_conferences.get(callUUID);
             this._incoming_conferences.delete(callUUID);
 
         } else if (this._calls.has(callUUID)) {
             let call = this._calls.get(callUUID);
             if (call.state === 'incoming') {
                 this.sylkRejectCall(callUUID, 'user_reject_call');
             } else {
                 // how can we end up here for a rejected call?
                 this.sylkHangupCall(callUUID, 'user_reject_call');
             }
         } else {
             // We rejected the call before it arrived on web socket
             // from iOS push notifications
             utils.timestampedLog('Callkeep: add call', callUUID, 'reject to the waitings list');
             this.webSocketActions.set(callUUID, 'reject');
             utils.timestampedLog('Callkeep: check over 20 seconds if call', callUUID, 'arrived on web socket');
 
             setTimeout(() => {
                 if (!this._calls.has(callUUID)) {
                     utils.timestampedLog('Callkeep: call', callUUID, 'did not arrive on web socket');
                     this.webSocketActions.delete(callUUID);
                     this.endCall(callUUID);
                 }
             }, 20000);
         }
 
         //this.endCall(callUUID);
     }
 
     setMutedCall(callUUID, mute=false) {
         //utils.timestampedLog('Callkeep: set call', callUUID, 'muted =', mute);
 
         if (this._calls.has(callUUID)) {
             this.callKeep.setMutedCall(callUUID, mute);
             let call = this._calls.get(callUUID);
             const localStream = call.getLocalStreams()[0];
 
             if (mute) {
                 utils.timestampedLog('Callkeep: local stream audio track disabled');
             } else {
                 utils.timestampedLog('Callkeep: local stream audio track enabled');
             }
             localStream.getAudioTracks()[0].enabled = !mute;
         }
     }
 
     _rnMute(data) {
         utils.timestampedLog('Callkeep: mute ' + data.muted + ' for call', data.callUUID);
         this.toggleMute(data.callUUID, data.muted);
     }
 
     _rnDTMF(data) {
         utils.timestampedLog('Callkeep: got dtmf for call', data.callUUID);
         if (this._calls.has(data.callUUID.toLowerCase())) {
             let call = this._calls.get(data.callUUID.toLowerCase());
             utils.timestampedLog('sending webrtc dtmf', data.digits)
             call.sendDtmf(data.digits);
         }
     }
 
     _rnProviderReset() {
         utils.timestampedLog('Callkeep: got a provider reset, clearing down all calls');
         this._calls.forEach((call) => {
             call.terminate();
         });
     }
 
     addWebsocketCall(call) {
         if (this.unmounted()) {
             return;
         }
 
         const connection = this.getConnection();
         if (this._calls.has(call.id)) {
             return;
         }
         utils.timestampedLog('Callkeep: added websocket call', call.id, 'for web socket', connection);
         this._calls.set(call.id, call);
     }
 
     incomingCallFromPush(callUUID, from, displayName, mediaType, force=false, skipNativePanel=false) {
         if (this.unmounted()) {
             return;
         }
         utils.timestampedLog('Callkeep: incoming', mediaType, 'push call', callUUID, 'from', from);
         const hasVideo = mediaType === 'video' ? true : false;
 
         if (this._pushCalls.has(callUUID)) {
             utils.timestampedLog('Callkeep: push call already handled', callUUID);
             return;
         }
 
         this._pushCalls.set(callUUID, true);
 
         if (this._rejectedCalls.has(callUUID)) {
             utils.timestampedLog('Callkeep: call already rejected', callUUID);
             this.endCall(callUUID, CK_CONSTANTS.END_CALL_REASONS.UNANSWERED);
             return;
         }
 
         if (this._acceptedCalls.has(callUUID)) {
             utils.timestampedLog('Callkeep: call already accepted', callUUID);
             return;
         }
 
         // if user does not decide anything this will be handled later
         this._timeouts.set(callUUID, setTimeout(() => {
             utils.timestampedLog('Callkeep: incoming call', callUUID, 'timeout');
             let reason = this.webSocketActions.has(callUUID) ? CK_CONSTANTS.END_CALL_REASONS.FAILED : CK_CONSTANTS.END_CALL_REASONS.UNANSWERED;
 
             if (!this._terminatedCalls.has(callUUID) && !this._calls.has(callUUID)) {
                 const connection = this.getConnection();
                 utils.timestampedLog('Callkeep: call', callUUID, 'did not arive on web socket', connection);
                 reason = CK_CONSTANTS.END_CALL_REASONS.FAILED;
             } else if (this._calls.has(callUUID)) {
                 utils.timestampedLog('Callkeep: user did not accept or reject', callUUID);
             }
             this.endCall(callUUID, reason);
             this._timeouts.delete(callUUID);
         }, 45000));
 
         if (Platform.OS === 'ios') {
             this.showAlertPanel(callUUID, from, displayName, hasVideo);
         } else {
             if (this._calls.has(callUUID) || force) {
                 // on Android display alert panel only after websocket call arrives
                 // force is required when Android is locked, if we do not bring up the panel, the app will not wake up
                 if (!skipNativePanel || force) {
                     this.showAlertPanel(callUUID, from, displayName, hasVideo);
                 } else {
                     utils.timestampedLog('Callkeep: call', callUUID, 'skipped display of native panel');
                 }
             } else {
                 utils.timestampedLog('Callkeep: waiting for call', callUUID, 'on web socket');
                 this.showAlertPanel(callUUID, from, displayName, hasVideo);
             }
         }
     }
 
     incomingCallFromWebSocket(call, accept=false, skipNativePanel=false) {
         if (this.unmounted()) {
             return;
         }
         const connection = this.getConnection();
 
         this.addWebsocketCall(call);
 
         utils.timestampedLog('Callkeep: incoming call', call.id, 'on web socket', connection);
 
         // if the call came via push and was already accepted or rejected
         if (this.webSocketActions.get(call.id)) {
             let action = this.webSocketActions.get(call.id);
             utils.timestampedLog('Callkeep: execute action decided earlier', action);
 
             if (action === 'accept') {
                 this.sylkAcceptCall(call.id);
             } else {
                 this.sylkRejectCall(call.id);
             }
 
             this.webSocketActions.delete(call.id);
 
         } else {
             if (accept) {
                 this.acceptCall(call.id);
             } else {
                 if (Platform.OS === 'ios') {
                     this.showAlertPanelforCall(call);
                 }
             }
         }
 
         // Emit event.
         this._emitSessionsChange(true);
     }
 
     handleConference(callUUID, room, from_uri, displayName, mediaType, outgoingMedia) {
         if (this.unmounted()) {
             return;
         }
         if (this._incoming_conferences.has(callUUID)) {
             return;
         }
 
         displayName = displayName + ' and others';
         const hasVideo = mediaType === 'video' ? true : false;
 
         this._incoming_conferences.set(callUUID, {room: room, from: from_uri});
         this.outgoingMedia = outgoingMedia;
 
         utils.timestampedLog('CallKeep: handle conference', callUUID, 'from', from_uri, 'to room', room);
 
         this.showAlertPanel(callUUID, room, displayName, hasVideo);
 
         this._timeouts.set(callUUID, setTimeout(() => {
             utils.timestampedLog('Callkeep: conference timeout', callUUID);
             this.timeoutCall(callUUID, from_uri);
             this.endCall(callUUID, CK_CONSTANTS.END_CALL_REASONS.MISSED);
             this._timeouts.delete(callUUID);
         }, 45000));
 
         this._emitSessionsChange(true);
     }
 
     showAlertPanelforCall(call, force=false) {
         const hasVideo = call.mediaTypes && call.mediaTypes.video;
         this.showAlertPanel(call.id, call.remoteIdentity.uri, call.remoteIdentity.displayName, hasVideo);
     }
 
     showAlertPanel(callUUID, from, displayName, hasVideo=false) {
         if (this.unmounted()) {
             return;
         }
         if (this._alertedCalls.has(callUUID)) {
             utils.timestampedLog('Callkeep: call', callUUID, 'was already alerted');
             return;
         }
 
         let panelFrom = from;
         const username = from.split('@')[0];
         const isPhoneNumber = username.match(/^(\+|0)(\d+)$/);
         if (isPhoneNumber) {
             panelFrom = username;
         } else {
             panelFrom = from.indexOf('@guest.') > -1 ? displayName : from;
         }
 
         this._alertedCalls.set(callUUID, Date.now());
 
         const options = {supportsHolding: false,
                          supportsGrouping: false,
                          supportsUngrouping: false,
                          supportsDTMF: false}
 
         utils.timestampedLog('Callkeep: ALERT PANEL for', callUUID, 'from', from, '(', displayName, ')');
         this.callKeep.displayIncomingCall(callUUID, panelFrom, displayName, 'sip', hasVideo, options);
     }
 
    _startedCall(data) {
         //utils.timestampedLog("Callkeep: STARTED NATIVE CALL", data.callUUID);
         if (!this._calls.has(data.callUUID)) {
             // call has started from OS native dialer
             this.startCallFromOutside(data);
         }
     }
 
     _displayIncomingCall(data) {
         utils.timestampedLog('Callkeep: Incoming alert panel displayed');
     }
 
     _emitSessionsChange(countChanged) {
         this.emit('sessionschange', countChanged);
     }
 
     destroy() {
         this._RNCallKeep.removeEventListener('acceptCall', this._boundRnAccept);
         this._RNCallKeep.removeEventListener('endCall', this._boundRnEnd);
         this._RNCallKeep.removeEventListener('didPerformSetMutedCallAction', this._boundRnMute);
         this._RNCallKeep.removeEventListener('didActivateAudioSession',  this._boundRnActiveAudioCall);
         this._RNCallKeep.removeEventListener('didDeactivateAudioSession', this._boundRnDeactiveAudioCall);
         this._RNCallKeep.removeEventListener('didPerformDTMFAction', this._boundRnDTMF);
         this._RNCallKeep.removeEventListener('didResetProvider', this._boundRnProviderReset);
         this._RNCallKeep.removeEventListener('didReceiveStartCallAction', this.boundRnStartAction);
         this._RNCallKeep.removeEventListener('didDisplayIncomingCall', this.boundRnDisplayIncomingCall);
     }
 }
diff --git a/app/app.js b/app/app.js
index 06a497d..80fd46b 100644
--- a/app/app.js
+++ b/app/app.js
@@ -1,4763 +1,4780 @@
 // copyright AG Projects 2020-2021
 
 import React, { Component, Fragment } from 'react';
 import { Alert, View, SafeAreaView, ImageBackground, AppState, Linking, Platform, StyleSheet, Vibration, PermissionsAndroid} from 'react-native';
 import { DeviceEventEmitter, BackHandler } 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';
 import base64 from 'react-native-base64';
 import SoundPlayer from 'react-native-sound-player';
 import RNSimpleCrypto from "react-native-simple-crypto";
 import OpenPGP from "react-native-fast-openpgp";
 
 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 ImportPrivateKeyModal from './components/ImportPrivateKeyModal';
 import IncomingCallModal from './components/IncomingCallModal';
 import LogsModal from './components/LogsModal';
 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 SQLite from 'react-native-sqlite-storage';
 //SQLite.DEBUG(true);
 SQLite.enablePromise(true);
 
 import xss from 'xss';
 import moment from 'moment';
 import momentFormat from 'moment-duration-format';
 import utils from './utils';
 import config from './config';
 import storage from './storage';
 var randomString = require('random-string');
 
 const RNFS = require('react-native-fs');
 const logfile = RNFS.DocumentDirectoryPath + '/logs.txt';
 
 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 KeyOptions = {
   cipher: "aes256",
   compression: "zlib",
   hash: "sha512",
   RSABits: 4096,
   compressionLevel: 5
 }
 
 
 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';
 const MAX_LOG_LINES = 300;
 
 
 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: '',
             organization: '',
             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,
             hardware: '',
             phoneNumber: '',
             isTablet: isTablet(),
             refreshHistory: false,
             refreshFavorites: false,
             myPhoneNumber: null,
             localHistory: [],
             favoriteUris: [],
             blockedUris: [],
             initialUrl: null,
             reconnectingCall: false,
             muted: false,
             participantsToInvite: [],
             myInvitedParties: {},
             myContacts: {},
             defaultDomain: config.defaultDomain,
             declineReason: null,
             showLogsModal: false,
             logs: '',
             proximityEnabled: true,
             messages: {},
             selectedContact: null,
             callsState: {},
             keys: null,
             showImportPrivateKeyModal: false,
             privateKey: null,
             privateKeyImportStatus: '',
             privateKeyImportSuccess: false,
             inviteContacts: false,
             selectedContacts: [],
-            pinned: false
+            pinned: false,
+            callContact: null
         };
 
         utils.timestampedLog('Init app');
 
         this.outgoingMedia = null;
         this.participantsToInvite = [];
         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.heartbeats = 0;
 
         this._onFinishedPlayingSubscription = null
         this._onFinishedLoadingSubscription = null
         this._onFinishedLoadingFileSubscription = null
         this._onFinishedLoadingURLSubscription = null
 
         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;
         this.msg_sound_played_ts = 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,
                                                 this.isUnmounted
                                                 );
 
         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('keys').then((keys) => {
             if (keys) {
                 this.loadKeys(keys);
             }
 
         }).catch((err) => {
             console.log("PGP keys loading error:", err);
         });
 
         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 = {};
                 }
                 this.setState({myInvitedParties: myInvitedParties});
             }
         });
 
         storage.get('proximityEnabled').then((proximityEnabled) => {
             this.setState({proximityEnabled: proximityEnabled});
         });
 
         if (this.state.proximityEnabled) {
             utils.timestampedLog('Proximity sensor enabled');
         } else {
             utils.timestampedLog('Proximity sensor disabled');
         }
 
         this.loadPeople();
 
         for (let scheme of URL_SCHEMES) {
             DeepLinking.addScheme(scheme);
         }
 
         this.sqlTableVersions = {'messages': 1,
                                  'journal': 1
                                  }
 
         this.updateTableQueries = {'messages': {1: []},
                                    'journal': {1: []}
                                    };
 
         this.db = null;
         this.initSQL();
 
     }
 
    async loadKeys(keys) {
         const public_key = keys.public.replace(/\r/g,'');
         const private_key = keys.private.replace(/\r/g, '').trim();
 
         keys.publicKeyHash = await RNSimpleCrypto.SHA.sha1(public_key);
         keys.public = public_key;
         keys.private = private_key;
         this.setState({keys: keys});
         console.log("Loaded PGP public key", keys.publicKeyHash);
     }
 
     async generateKeys() {
 
         const Options = {
           comment: 'Sylk key',
           email: this.state.accountId,
           name: this.state.displayName,
           keyOptions: KeyOptions
         }
 
         console.log('Generating key pair with options', Options);
 
         await OpenPGP.generate(Options).then((keys) => {
             console.log(keys);
             const public_key = keys.publicKey.replace(/\r/g, '').trim();
             const private_key = keys.privateKey.replace(/\r/g, '').trim();
             keys.public = public_key;
             keys.private = private_key;
             console.log("PGP keypair generated");
             this.saveKeys(keys);
 
         }).catch((error) => {
             console.log("PGP keys generation error:", error);
         });
     }
 
     async saveKeys(keys) {
         const publicKeyHashCalculated = await RNSimpleCrypto.SHA.sha1(keys.public);
         storage.set('keys', keys);
         this.setState({keys: {private: keys.private,
                               publicKeyHash: publicKeyHashCalculated,
                               public: keys.public}});
     }
 
     loadPeople() {
         let blockedUris = [];
         let myContacts = {};
          let favoriteUris = [];
         let displayName = null;
 
         storage.get('displayName').then((displayName) => {
             console.log('My display name is', displayName);
             this.setState({displayName: displayName});
         }).catch((error) => {
             console.log('get displayName error:', error);
         });
 
         storage.get('organization').then((organization) => {
             console.log('My organization is', organization);
             this.setState({organization: organization});
         }).catch((error) => {
             console.log('get organization error:', error);
         });
 
         storage.get('myContacts').then((myContacts) => {
             let myContactsObjects = {};
             if (myContacts) {
                 Object.keys(myContacts).forEach((key) => {
                     if(typeof(myContacts[key]) == 'string') {
                         console.log('Convert display name object');
                         myContactsObjects[key] = {'name': myContacts[key]}
                     } else {
                         myContactsObjects[key] = myContacts[key];
                     }
                 });
                 myContacts = myContactsObjects;
             } else {
                 myContacts = {};
             }
 
             console.log('Loaded', Object.keys(myContacts).length, 'contacts');
 
             this.setState({myContacts: myContacts});
 
             storage.get('favoriteUris').then((favoriteUris) => {
                 favoriteUris = favoriteUris.filter(item => item !== null);
                 console.log('My favorites:', favoriteUris);
                 this.setState({favoriteUris: favoriteUris});
 
                 favoriteUris.forEach((uri) => {
                     if (uri in myContacts) {
                         myContacts[uri].favorite = true;
                     } else {
                         myContacts[uri] = {name: '', favorite: true};
                     }
                 });
 
                 storage.remove('favoriteUris');
                 this.saveMyContacts(myContacts);
 
             }).catch((error) => {
                 //console.log('get favoriteUris error:', error);
                 let uris = Object.keys(myContacts);
                 uris.forEach((uri) => {
                     if (myContacts[uri].favorite) {
                         favoriteUris.push(uri);
                     }
                 });
 
                 console.log('Loaded', favoriteUris.length, 'favorites');
                 this.setState({favoriteUris: favoriteUris});
             });
 
             storage.get('blockedUris').then((blockedUris) => {
                 blockedUris = blockedUris.filter(item => item !== null);
                 console.log('My blockedUris:', blockedUris);
                 this.setState({blockedUris: blockedUris});
 
                 blockedUris.forEach((uri) => {
                     if (uri in myContacts) {
                         myContacts[uri].blocked = true;
                     } else {
                         myContacts[uri] = {name: '', blocked: true};
                     }
                 });
 
                 storage.remove('blockedUris');
                 this.saveMyContacts(myContacts);
 
             }).catch((error) => {
                 //console.log('get favoriteUris error:', error);
                 let uris = Object.keys(myContacts);
                 uris.forEach((uri) => {
                     if (myContacts[uri].blocked) {
                         blockedUris.push(uri);
                     }
                 });
 
                 console.log('Loaded', blockedUris.length, 'blocked uris');
                 this.setState({blockedUris: blockedUris});
             });
 
             this.calculateHashes();
 
         }).catch((error) => {
             console.log('get myContacts error:', error);
         });
     }
 
     calculateHashes() {
         let publicKeyHash;
         let myContacts = this.state.myContacts;
         let mustUpdate = false;
         let public_key;
         Object.keys(this.state.myContacts).forEach((key) => {
             if (myContacts[key].publicKey && !myContacts[key].publicKeyHash) {
                 public_key = myContacts[key].publicKey.replace(/\r/g, '').trim();
                 RNSimpleCrypto.SHA.sha1(public_key).then((publicKeyHash) => {
                     mustUpdate = true;
                     myContacts[key].publicKeyHash = publicKeyHash;
                 }).catch((error) => {
                     console.log('SHA error:', error);
                 });
             }
         });
         if (mustUpdate) {
             this.saveMyContacts(myContacts);
         }
     }
 
     async initSQL() {
         const database_name = "sylk.db";
         const database_version = "1.0";
         const database_displayname = "Sylk Database";
         const database_size = 200000;
 
         await SQLite.openDatabase(database_name, database_version, database_displayname, database_size).then((DB) => {
             this.db = DB;
             console.log('SQL database', database_name, 'opened');
             //this.dropTables();
             this.createTables();
         }).catch((error) => {
             console.log('SQL database error:', error);
         });
     }
 
     dropTables() {
         console.log('Drop SQL tables...')
         this.ExecuteQuery("DROP TABLE if exists 'chat_uris';");
         this.ExecuteQuery("DROP TABLE if exists 'recipients';");
         this.ExecuteQuery("DROP TABLE 'messages';");
         this.ExecuteQuery("DROP TABLE 'versions';");
     }
 
     createTables() {
         console.log('Create SQL tables...')
         let create_versions_table = "CREATE TABLE IF NOT EXISTS 'versions' ( \
                                     'id' INTEGER PRIMARY KEY AUTOINCREMENT, \
                                     'table' TEXT UNIQUE, \
                                     'version' INTEGER NOT NULL );\
                                     ";
 
         this.ExecuteQuery(create_versions_table).then((success) => {
             //console.log('SQL version table created');
         }).catch((error) => {
             console.log(create_versions_table);
             console.log('SQL version table creation error:', error);
         });
 
         let create_table_messages = "CREATE TABLE IF NOT EXISTS 'messages' ( \
                                     'id' INTEGER PRIMARY KEY AUTOINCREMENT, \
                                     'msg_id' TEXT UNIQUE, \
                                     'timestamp' TEXT, \
                                     'content' BLOB, \
                                     'content_type' TEXT, \
                                     'from_uri' TEXT, \
                                     'to_uri' TEXT, \
                                     'sent' INTEGER, \
                                     'sent_timestamp' TEXT, \
                                     'encrypted' INTEGER, \
                                     'encryption_key' TEXT, \
                                     'received' INTEGER, \
                                     'received_timestamp' TEXT, \
                                     'expire_interval' INTEGER, \
                                     'deleted' INTEGER, \
                                     'pinned' INTEGER, \
                                     'pending' INTEGER, \
                                     'system' INTEGER, \
                                     'url' TEXT, \
                                     'direction' TEXT) \
                                     ";
 
         this.ExecuteQuery(create_table_messages).then((success) => {
             //console.log('SQL messages table OK');
         }).catch((error) => {
             console.log(create_table_messages);
             console.log('SQL messages table creation error:', error);
         });
 
         let create_table_journal = " CREATE TABLE IF NOT EXISTS 'journal' ( \
                                     'id' INTEGER PRIMARY KEY AUTOINCREMENT, \
                                     'timestamp' TEXT, \
                                     'msg_id' TEXT, \
                                     'uri' TEXT, \
                                     'action' TEXT, \
                                     'data' TEXT) \
                                     ";
 
         this.ExecuteQuery(create_table_journal).then((success) => {
             //console.log('SQL journal table OK');
         }).catch((error) => {
             console.log(create_table_journal);
             console.log('SQL journal table creation error:', error);
         });
 
         this.upgradeSQLTables();
     }
 
     upgradeSQLTables() {
         console.log('Upgrade SQL tables')
         let query;
         let update_queries;
         let update_sub_queries;
         let version_numbers;
 
         /*
         this.ExecuteQuery("ALTER TABLE 'messages' add column received_timestamp TEXT after received");
         this.ExecuteQuery("ALTER TABLE 'messages' add column sent_timestamp TEXT after sent");
         */
 
         query = "SELECT * FROM versions";
         let currentVersions = {};
 
         this.ExecuteQuery(query,[]).then((results) => {
             let rows = results.rows;
             for (let i = 0; i < rows.length; i++) {
                 var item = rows.item(i);
                 currentVersions[item.table] = item.version;
             }
 
             for (const [key, value] of Object.entries(this.sqlTableVersions)) {
                 if (currentVersions[key] == null) {
                     query = "INSERT INTO versions ('table', 'version') values ('" + key + "', '" + this.sqlTableVersions[key] + "')";
                     console.log(query);
                     this.ExecuteQuery(query);
                 } else {
                     if (this.sqlTableVersions[key] > currentVersions[key]) {
                         console.log('Table', key, 'must have version', value, 'and it has', currentVersions[key]);
                         update_queries = this.updateTableQueries[key];
                         version_numbers = Object.keys(update_queries);
                         version_numbers.sort(function(a, b){return a-b});
                         version_numbers.forEach((version) => {
                             if (version <= currentVersions[key]) {
                                 return;
                             }
                             update_sub_queries = update_queries[version];
                             update_sub_queries.forEach((query) => {
                                 console.log('Run query for table', key, 'version', version, ':', query);
                                 this.ExecuteQuery(query);
                             });
 
                         });
 
                         query = "update versions set version = " + this.sqlTableVersions[key] + " where \"table\" = '" + key + "';";
                         console.log(query);
                         this.ExecuteQuery(query);
 
                     } else {
                         //console.log('No upgrade required for table', key);
                     }
                 }
             }
 
         }).catch((error) => {
             console.log('SQL query:', query);
             console.log('SQL error:', error);
         });
 
     }
 
     /*
     * Execute sql queries
     *
     * @param sql
     * @param params
     *
     * @returns {resolve} results
     */
 
     ExecuteQuery = (sql, params = []) => new Promise((resolve, reject) => {
         //console.log('Execute query:', sql);
         this.db.transaction((trans) => {
           trans.executeSql(sql, params, (trans, results) => {
             resolve(results);
           },
             (error) => {
               //console.log('SQL error', error);
               reject(error);
             });
         });
       });
 
     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;
                     } else {
                         photo = null;
                     }
 
                     //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;
             }
           })
     }
 
     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) {
             if (route === '/ready' && this.state.selectedContact) {
                 this.setState({
                                 selectedContact: null,
                                 targetUri: ''
                                 });
             }
             return;
         }
 
+
         if (this.currentRoute !== route) {
             utils.timestampedLog('Change route:', this.currentRoute, '->', route, reason);
         }
 
         if (route === '/conference') {
-            this.setState({inviteContacts: false});
+           this.backToForeground();
+           this.setState({inviteContacts: false});
+        }
+
+        if (route === '/call') {
+           this.backToForeground();
         }
 
         if (route === '/ready' && reason !== 'back to home') {
             Vibration.cancel();
 
             if (reason === 'conference_really_ended' && this.callKeeper.countCalls) {
                 utils.timestampedLog('Change route cancelled because we still have calls');
                 return;
             }
 
             this.startedByPush = false;
             this.setState({
                             outgoingCallUUID: null,
                             currentCall: null,
+                            callContact: null,
                             inviteContacts: false,
                             selectedContacts: [],
                             incomingCall: (reason === 'accept_new_call' || reason === 'user_hangup_call') ? this.state.incomingCall: null,
                             reconnectingCall: false,
                             muted: false
                             });
 
             if (this.currentRoute === '/call' || this.currentRoute === '/conference') {
                 if (reason !== 'user_hangup_call') {
                     this.stopRingback();
                     InCallManager.stop();
                 }
 
                 this.closeLocalMedia();
 
                 if (reason === 'accept_new_call') {
                     if (this.state.incomingCall) {
                         // then answer the new call if any
                         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');
                     }
                 } else if (reason === 'escalate_to_conference') {
                     const uri = `${utils.generateSillyName()}@${config.defaultConferenceDomain}`;
                     const options = {audio: this.outgoingMedia ? this.outgoingMedia.audio: true,
                                      video: this.outgoingMedia ? this.outgoingMedia.video: true,
                                      participants: this.participantsToInvite}
 
                     this.callKeepStartConference(uri.toLowerCase(), options);
                 } else {
                     if (this.state.account && 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() {
         utils.timestampedLog('App will unmount');
         AppState.removeEventListener('change', this._handleAppStateChange);
 
         this._onFinishedPlayingSubscription.remove();
         this._onFinishedLoadingSubscription.remove();
         this._onFinishedLoadingURLSubscription.remove();
         this._onFinishedLoadingFileSubscription.remove();
 
         this.callKeeper.destroy();
         this.closeConnection();
         this._loaded = false;
     }
 
     get unmounted() {
         return !this._loaded;
     }
 
     isUnmounted() {
         return this.unmounted;
     }
 
     backPressed() {
         console.log('Back button pressed');
 
         if (this.currentRoute === '/call' || this.currentRoute === '/conference') {
             let call = this.state.currentCall || this.state.incomingCall;
             if (call && call.id) {
                 this.hangupCall(call.id, 'user_hangup_call');
             }
         }
 
         return true;
     }
 
     async componentDidMount() {
         utils.timestampedLog('App did mount');
         this._loaded = true;
 
         BackHandler.addEventListener('hardwareBackPress', this.backPressed);
         // 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();
         this.listenforSoundNotifications();
     }
 
     listenforSoundNotifications() {
      // Subscribe to event(s) you want when component mounted
         this._onFinishedPlayingSubscription = SoundPlayer.addEventListener('FinishedPlaying', ({ success }) => {
           //console.log('finished playing', success)
         })
         this._onFinishedLoadingSubscription = SoundPlayer.addEventListener('FinishedLoading', ({ success }) => {
           //console.log('finished loading', success)
         })
         this._onFinishedLoadingFileSubscription = SoundPlayer.addEventListener('FinishedLoadingFile', ({ success, name, type }) => {
           //console.log('finished loading file', success, name, type)
         })
         this._onFinishedLoadingURLSubscription = SoundPlayer.addEventListener('FinishedLoadingURL', ({ success, url }) => {
           //console.log('finished loading url', success, url)
         })
     }
 
     listenforPushNotifications() {
         if (this.state.appState === null) {
             this.setState({appState: 'active'});
         } else {
             return;
         }
 
         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 {
                       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);
             VoipPushNotification.addEventListener('notification', this._boundOnNotificationReceivedBackground);
             VoipPushNotification.addEventListener('localNotification', this._boundOnLocalNotificationReceivedBackground);
         } else if (Platform.OS === 'android') {
             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'};
                     const mediaType = message.data['media-type'] || 'audio';
 
                     if (this.unmounted) {
                         return;
                     }
 
                     if (event === 'incoming_conference_request') {
                         utils.timestampedLog('Push notification: incoming conference', callUUID);
                         this.incomingConference(callUUID, to, from, displayName, outgoingMedia);
                     } else if (event === 'incoming_session') {
                         utils.timestampedLog('Push notification: incoming call', callUUID);
                         this.incomingCallFromPush(callUUID, from, displayName, mediaType);
                     } else if (event === 'cancel') {
                         this.cancelIncomingCall(callUUID);
                     }
                 });
         }
     }
 
     cancelIncomingCall(callUUID) {
         if (this.unmounted) {
             return;
         }
 
         if (this.callKeeper._acceptedCalls.has(callUUID)) {
             return;
         }
 
         utils.timestampedLog('Push notification: cancel call', callUUID);
 
         let call = this.callKeeper._calls.get(callUUID);
         if (!call) {
             if (!this.callKeeper._cancelledCalls.has(callUUID)) {
                 utils.timestampedLog('Cancel incoming call that did not arrive on web socket', callUUID);
                 this.callKeeper.endCall(callUUID, CK_CONSTANTS.END_CALL_REASONS.REMOTE_ENDED);
                 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, CK_CONSTANTS.END_CALL_REASONS.REMOTE_ENDED);
             if (this.startedByPush) {
                 this.changeRoute('/ready', 'incoming_call_cancelled');
             }
         }
     }
 
     _proximityDetect(data) {
         //utils.timestampedLog('Proximity changed, isNear is', data.isNear);
         if (!this.state.proximityEnabled) {
             return;
         }
 
         if (data.isNear) {
            this.speakerphoneOff();
         } else {
            this.speakerphoneOn();
         }
     }
 
     startCallWhenReady(targetUri, options) {
         this.resetGoToReadyTimer();
 
         if (options.conference) {
             this.startConference(targetUri, options);
         } else {
             this.startCall(targetUri, options);
         }
     }
     _sleep(ms) {
       return new Promise(resolve => setTimeout(resolve, ms));
     }
 
     _onPushkitRegistered(token) {
         this.pushkittoken = token;
     }
 
     _onPushRegistered(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 in focus');
         this.setState({inFocus: true});
         this.respawnConnection();
     }
 
     _handleAndroidBlur = nextBlur => {
         //utils.timestampedLog('----- APP out of focus');
         this.setState({inFocus: false});
     }
 
     _handleAppStateChange = nextAppState => {
         //utils.timestampedLog('----- APP state changed', this.state.appState, '->', 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) {
         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 {
             /*
             if (this.state.connection.state !== 'ready' && this.state.connection.state !== 'connecting') {
                 utils.timestampedLog('Web socket', Object.id(this.state.connection), 'reconnecting because', 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('No active account');
         }
 
         if (this.state.accountId && (!this.state.connection || !this.state.account)) {
             this.handleRegistration(this.state.accountId, this.state.password);
         }
     }
 
     closeConnection(reason='unmount') {
         if (!this.state.connection) {
             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.removeListener('stateChanged', this.connectionStateChanged);
 
             this.state.account.removeListener('outgoingCall', this.outgoingCall);
             this.state.account.removeListener('conferenceCall', this.outgoingConference);
             this.state.account.removeListener('incomingCall', this.incomingCallFromWebSocket);
             this.state.account.removeListener('missedCall', this.missedCall);
             this.state.account.removeListener('conferenceInvite', this.conferenceInviteFromWebSocket);
 
             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) {
         utils.timestampedLog('Starting call from OS...');
         let callUUID = data.callUUID || uuid.v4();
         let is_conf = data.handle.search('videoconference.') === -1 ? false: true;
 
         this.backToForeground();
 
         if (is_conf) {
             this.callKeepStartConference(data.handle, {audio: true, video: data.video || true, callUUID: callUUID});
         } else {
             this.callKeepStartCall(data.handle, {audio: true, video: data.video, callUUID: callUUID});
         }
         this._notificationCenter.removeNotification();
     }
 
     selectContact(contact) {
         this.setState({selectedContact: contact});
     }
 
     connectionStateChanged(oldState, newState) {
         if (this.unmounted) {
             return;
         }
 
         const connection = this.getConnection();
 
         if (oldState) {
             utils.timestampedLog('Web socket', connection, '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});
                 this.setState({account: null});
                 break;
             case 'ready':
                 this._notificationCenter.removeNotification();
                 this.processRegistration(this.state.accountId, this.state.password);
                 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,
                     });
 
                 if (this.currentRoute === '/login') {
                     this.changeRoute('/ready');
                 }
 
                 break;
             default:
                 if (this.state.registrationKeepalive !== true) {
                     this.setState({loading: 'Connecting...'});
                 }
                 break;
         }
     }
 
     notificationCenter() {
         return this._notificationCenter;
     }
 
     showRegisterFailure(reason) {
         const connection = this.getConnection();
 
         utils.timestampedLog('Registration error: ' + reason, 'on web socket', connection);
         this.setState({
             loading     : null,
             registrationState: 'failed',
             status      : {
                 msg   : 'Sign In failed: ' + reason,
                 level : 'danger'
             }
         });
 
         if (this.startedByPush) {
             // TODO: hangup incoming call
         }
 
         if (this.currentRoute === '/login') {
             this.changeRoute('/ready');
         }
 
     }
 
     registrationStateChanged(oldState, newState, data) {
         if (this.unmounted) {
             return;
         }
 
         const connection = this.getConnection();
 
         if (oldState) {
             utils.timestampedLog('Registration state changed:', oldState, '->', newState, 'on web socket', connection);
         }
 
         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
                 if (reason >= 500 || reason === 408) {
                     utils.timestampedLog('Retry to register after 5 seconds delay...');
                     setTimeout(this.state.account.register(), 5000);
                 } else {
                     if (this.registrationFailureTimer) {
                         utils.timestampedLog('Cancel registration timer');
                         clearTimeout(this.registrationFailureTimer);
                         this.registrationFailureTimer = null;
                     }
                 }
             }
             if (this.currentRoute === '/login') {
                 this.changeRoute('/ready');
             }
 
         } 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'))  {
             // TODO if the call does not arrive, we never get back to ready
             if (this.currentRoute === '/login') {
                 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);
         setTimeout(() => {
              Vibration.cancel();
         }, 30000);
     }
 
     hideInternalAlertPanel() {
         Vibration.cancel();
         this.setState({showIncomingModal: false});
     }
 
     heartbeat() {
         if (this.unmounted) {
             return;
         }
 
         this.heartbeats = this.heartbeats + 1;
 
         if (this.heartbeats % 40 == 0) {
             this.trimLogs();
         }
 
         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();
     }
 
     stopRingback() {
         //utils.timestampedLog('Stop ringback');
         InCallManager.stopRingback();
     }
 
     resetGoToReadyTimer() {
         if (this.goToReadyTimer !== null) {
             clearTimeout(this.goToReadyTimer);
             this.goToReadyTimer = null;
         }
     }
 
     goToReadyNowAndCancelTimer() {
         if (this.goToReadyTimer !== null) {
             clearTimeout(this.goToReadyTimer);
             this.goToReadyTimer = null;
             this.changeRoute('/ready', 'cancel_timer_incoming_call');
         }
     }
 
     isConference(call) {
         const _call = call || this.state.currentCall;
         if (_call && _call.hasOwnProperty('_participants')) {
             return true;
         }
 
         return false;
     }
 
     callStateChanged(oldState, newState, data) {
         if (this.unmounted) {
             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');
             return;
         }
 
         let callUUID = call.id;
         const connection = this.getConnection();
         utils.timestampedLog('Sylkrtc call', callUUID, 'state change:', oldState, '->', newState, 'on web socket', connection);
 
         /*
         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 = 5000;
 
         if (this.state.incomingCall && this.state.currentCall) {
             if (newState === 'terminated') {
                 if (this.state.incomingCall == this.state.currentCall) {
                     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);
         */
 
         let callsState;
 
         switch (newState) {
             case 'progress':
                 this.callKeeper.setCurrentCallActive(callUUID);
                 this.backToForeground();
 
                 this.resetGoToReadyTimer();
 
                 tracks = call.getLocalStreams()[0].getVideoTracks();
                 mediaType = (tracks && tracks.length > 0) ? 'video' : 'audio';
 
                 if (mediaType === 'video') {
                     this.speakerphoneOn();
                 } else {
                     this.speakerphoneOff();
                 }
 
                 if (!this.isConference(call)){
                     InCallManager.startRingback('_BUNDLE_');
                 }
 
                 break;
 
             case 'established':
                 callsState = this.state.callsState;
                 callsState[callUUID] = {startTime: new Date()};
                 this.setState({callsState: callsState});
 
                 this.callKeeper.setCurrentCallActive(callUUID);
 
                 this.backToForeground();
                 this.resetGoToReadyTimer();
 
                 tracks = call.getLocalStreams()[0].getVideoTracks();
                 mediaType = (tracks && tracks.length > 0) ? 'video' : 'audio';
 
                 InCallManager.start({media: mediaType});
 
                 if (direction === 'outgoing') {
                     this.stopRingback();
                     if (this.state.speakerPhoneEnabled) {
                         this.speakerphoneOn();
                     } else {
                         this.speakerphoneOff();
                     }
                 } else {
                     if (mediaType === 'video') {
                         this.speakerphoneOn();
                     } else {
                         this.speakerphoneOff();
                     }
                 }
 
                 break;
             case 'accepted':
                 callsState = this.state.callsState;
                 callsState[callUUID] = {startTime: new Date()};
                 this.setState({callsState: callsState});
 
                 this.callKeeper.setCurrentCallActive(callUUID);
                 this.backToForeground();
                 this.resetGoToReadyTimer();
 
                 if (direction === 'outgoing') {
                     this.stopRingback();
                 }
                 break;
 
             case 'terminated':
                 let startTime;
                 if (callUUID in this.state.callsState) {
                     callsState = this.state.callsState;
                     startTime = callsState[callUUID].startTime;
                     delete callsState[callUUID];
                     this.setState({callsState: callsState});
                }
 
                 this._terminatedCalls.set(callUUID, true);
                 utils.timestampedLog(callUUID, direction, 'terminated with reason', data.reason);
 
 
                 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;
                 let missed = false;
 
                 if (!reason || reason.match(/200/)) {
                     if (oldState === 'progress' && direction === 'outgoing') {
                         reason = 'Cancelled';
                         play_busy_tone = false;
                     } else if (oldState === 'incoming') {
                         reason = 'Cancelled';
                         missed = true;
                         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 = 'Forbidden';
                     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 = 'Is not online';
                     CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.UNANSWERED;
                 } else if (reason.match(/486/)) {
                     reason = 'Is busy';
                     CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.REMOTE_ENDED;
                     if (direction === 'outgoing') {
                         play_busy_tone = false;
                     }
                 } else if (reason.match(/603/)) {
                     reason = 'Cannot answer now';
                     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();
                 }
 
                 if (direction === 'outgoing') {
                     this.setState({declineReason: reason});
                 }
                 this.stopRingback();
 
                 let msg;
                 let current_datetime = new Date();
                 let formatted_date = utils.appendLeadingZeroes(current_datetime.getHours()) + ":" + utils.appendLeadingZeroes(current_datetime.getMinutes()) + ":" + utils.appendLeadingZeroes(current_datetime.getSeconds());
                 if (startTime) {
                     let duration = moment.duration(new Date() - startTime);
 
                     if (duration > 3600) {
                         duration = duration.format('hh:mm:ss', {trim: false});
                     } else {
                         duration = duration.format('mm:ss', {trim: false});
                     }
 
                     msg = formatted_date + " - " + direction +" " + mediaType + " call ended after " + duration;
                 } else {
                     msg = formatted_date + " - " + direction +" " + mediaType + " call ended (" + reason + ")";
                 }
 
                 this.saveSystemMessage(call.remoteIdentity.uri.toLowerCase(), msg, direction, missed);
 
                 this.callKeeper.endCall(callUUID, CALLKEEP_REASON);
 
                 if (play_busy_tone && oldState !== 'established' && direction === 'outgoing') {
                     this._notificationCenter.postSystemNotification('Call ended:', {body: reason});
                 }
 
                 this.updateHistoryEntry(callUUID);
 
                 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) {
             this.speakerphoneOn();
 
             if (!this.state.reconnectingCall) {
                 if (this.state.inFocus) {
                     if (this.currentRoute !== '/ready') {
                         utils.timestampedLog('Will go to ready in', readyDelay/1000, 'seconds (terminated)', callUUID);
                         this.goToReadyTimer = setTimeout(() => {
                             this.changeRoute('/ready', 'no_more_calls');
                         }, readyDelay);
                     }
                 } else {
                     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);
         }
     }
 
     goBackToCall() {
         let call = this.state.currentCall || this.state.incomingCall;
         this.setState({inviteContacts: false, selectedContacts: []});
 
         if (call) {
             if (call.hasOwnProperty('_participants')) {
                 this.changeRoute('/conference', 'back to call');
             } else {
                 this.changeRoute('/call', 'back to call');
             }
         } else {
             console.log('No call to go back to');
         }
     }
 
     goBackToHome() {
         this.changeRoute('/ready', 'back to home');
     }
 
+    goBackToHomeFromCall() {
+        this.changeRoute('/ready', 'back to home');
+        if (this.state.callContact) {
+            this.setState({selectedContact: this.state.callContact});
+            this.getMessages(this.state.callContact.remoteParty);
+        }
+    }
+
     inviteContactsToConference() {
         console.log('Will invite contacts');
         this.setState({inviteContacts: true, selectedContacts: []});
         this.goBackToHome();
     }
 
     handleRegistration(accountId, password, remember=true) {
         if (this.state.account !== null && this.state.registrationState === 'registered' ) {
             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});
             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) {
         if (!displayName) {
             displayName = this.state.displayName;
         }
 
         if (!this.state.connection) {
             return;
         }
 
         this.updateServerHistory();
 
         utils.timestampedLog('Process registration for', accountId, '(', displayName, ')');
         if (this.state.account && this.state.connection) {
             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;
         }
 
         //utils.timestampedLog('Add register 10 sec timer');
         this.registrationFailureTimer  = setTimeout(() => {
                 this.showRegisterFailure('Register timeout');
                 this.processRegistration(accountId, password);
         }, 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('message', this.incomingMessage);
                 account.on('messageStateChanged', this.messageStateChanged);
                 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
                 });
 
                 if (!this.state.keys) {
                     this.generateKeys();
                 }
 
             } 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, 'call');
         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: []}) {
         if (!targetUri) {
             return;
         }
 
         this.resetGoToReadyTimer();
 
         let callUUID = options.callUUID || uuid.v4();
 
         let participants = options.participants || null;
         this.addConferenceHistoryEntry(targetUri, callUUID);
 
         let participantsToInvite = [];
 
         if (participants) {
             participants.forEach((participant_uri) => {
                 if (participant_uri === this.state.accountId) {
                     return;
                 }
                 participantsToInvite.push(participant_uri);
             });
         }
 
         this.outgoingMedia = options;
 
         this.setState({outgoingCallUUID: callUUID,
                        reconnectingCall: false,
                        participantsToInvite: participantsToInvite
                        });
 
         const media = options.video ? 'video' : 'audio';
 
         if (participantsToInvite) {
             utils.timestampedLog('Will start', media, 'conference', callUUID, 'to', targetUri, 'with', participantsToInvite);
         } 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});
     }
 
     updateSelection(uri) {
          let selectedContacts = this.state.selectedContacts;
 
          let idx = selectedContacts.indexOf(uri);
 
          if (idx === -1) {
              selectedContacts.push(uri);
          } else {
              selectedContacts.splice(idx, 1);
          }
 
          this.setState({selectedContacts: selectedContacts});
     }
 
     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.setState({targetUri: targetUri, callContact: this.state.selectedContact});
         this.getLocalMedia(Object.assign({audio: true, video: options.video}, options), '/call');
     }
 
     timeoutCall(callUUID, uri) {
         utils.timestampedLog('Timeout answering call', callUUID);
         this.addConferenceHistoryEntry(uri, callUUID, direction='received');
         this.forceUpdate();
     }
 
     closeLocalMedia() {
         if (this.state.localMedia != null) {
             utils.timestampedLog('Close local media');
             sylkrtc.utils.closeMediaStream(this.state.localMedia);
             this.setState({localMedia: null});
         }
     }
 
     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);
         this.hideInternalAlertPanel();
 
         this.resetGoToReadyTimer();
 
         if (this.state.currentCall) {
             utils.timestampedLog('Will hangup current call first');
             this.hangupCall(this.state.currentCall.id, 'accept_new_call');
             // call will continue after transition to /ready
         } else {
             utils.timestampedLog('Will get local media now');
             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', 'rejected');
         }
 
         if (this.state.incomingCall && this.state.incomingCall.id === callUUID) {
             utils.timestampedLog('Sylkrtc terminate call', callUUID, 'in', this.state.incomingCall.state, 'state');
             this.state.incomingCall.terminate();
         }
     }
 
     hangupCall(callUUID, reason) {
         utils.timestampedLog('Call', callUUID, 'hangup with reason:', reason);
 
         let call = this.callKeeper._calls.get(callUUID);
         let direction = null;
         let targetUri = null;
 
         if (call) {
             let direction = call.direction;
             utils.timestampedLog('Sylkrtc terminate call', callUUID, 'in', call.state, 'state');
             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_cancel_call' ||
             reason === 'user_hangup_call' ||
             reason === 'answer_failed' ||
             reason === 'callkeep_hangup_call' ||
             reason === 'accept_new_call' ||
             reason === 'stop_preview' ||
             reason === 'escalate_to_conference' ||
             reason === 'user_hangup_conference_confirmed' ||
             reason === 'timeout'
             ) {
             this.changeRoute('/ready', reason);
         } else if (reason === 'user_hangup_conference') {
             utils.timestampedLog('Save conference maybe?');
             setTimeout(() => {
                  this.changeRoute('/ready', 'conference_really_ended');
             }, 15000);
         } else if (reason === 'user_cancelled_conference') {
             utils.timestampedLog('Save conference maybe?');
             setTimeout(() => {
                  this.changeRoute('/ready', 'conference_really_ended');
             }, 15000);
         } else {
             utils.timestampedLog('Will go to ready in 6 seconds (hangup)');
             setTimeout(() => {
                  this.changeRoute('/ready', reason);
             }, 6000);
         }
     }
 
     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);
         }
     }
 
     toggleProximity() {
         storage.set('proximityEnabled', !this.state.proximityEnabled);
 
         if (!this.state.proximityEnabled) {
             utils.timestampedLog('Proximity sensor enabled');
         } else {
             utils.timestampedLog('Proximity sensor disabled');
         }
         this.setState({proximityEnabled: !this.state.proximityEnabled});
     }
 
     toggleMute(callUUID, mute) {
         utils.timestampedLog('Toggle mute for call', callUUID, ':', mute);
         this.callKeeper.setMutedCall(callUUID, mute);
         this.setState({muted: mute});
     }
 
     async toggleImportPrivateKeyModal() {
         if (this.state.showImportPrivateKeyModal) {
             this.setState({privateKey: null,
                            privateKeyImportStatus: '',
                            privateKeyImportSuccess: false});
         }
         this.setState({showImportPrivateKeyModal: !this.state.showImportPrivateKeyModal});
     }
 
     togglePinned() {
         this.setState({pinned: !this.state.pinned});
     }
 
     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;
         }
 
         this.callKeeper.startOutgoingCall(call.id, call.remoteIdentity.uri, hasVideo);
 
         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'};
         const mediaType = notificationContent['media-type'] || 'audio';
 
           /*
            * 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('Push notification: incoming call', callUUID);
             this.startedByPush = true;
             this.incomingCallFromPush(callUUID, from, displayName, mediaType);
 
         } else if (event === 'incoming_conference_request') {
             utils.timestampedLog('Push notification: incoming conference', callUUID);
             this.startedByPush = true;
             this.incomingConference(callUUID, to, from, displayName, outgoingMedia);
 
         } else if (event === 'cancel') {
             utils.timestampedLog('Push notification: cancel call', callUUID);
             VoipPushNotification.presentLocalNotification({alertBody:'Call cancelled'});
             this.callKeeper.endCall(callUUID, CK_CONSTANTS.END_CALL_REASONS.REMOTE_ENDED);
         }
 
         /*
         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}) {
         if (this.unmounted) {
             return;
         }
 
         const mediaType = outgoingMedia.video ? 'video' : 'audio';
 
         utils.timestampedLog('Incoming', mediaType, 'conference invite from', from, displayName, 'to room', to);
 
         if (this.state.account && from === this.state.account.id) {
             utils.timestampedLog('Reject conference call from myself', callUUID);
             this.callKeeper.rejectCall(callUUID);
             return;
         }
 
         if (this.autoRejectIncomingCall(callUUID, from, to)) {
             return;
         }
 
         this.setState({incomingCallUUID: callUUID});
         this.callKeeper.handleConference(callUUID, to, from, displayName, mediaType, 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) {
         let outgoingMedia = {audio: true, video: true};
         let mediaType = 'video';
         let call;
 
         if (this.state.currentCall) {
             call = this.state.currentCall;
         } else if (this.state.incomingCall) {
             call = this.state.currentCall;
         } else {
             console.log('No call to escalate');
             return
         }
 
         const localStreams = call.getLocalStreams();
         if (localStreams.length > 0) {
             const localStream = call.getLocalStreams()[0];
             if (localStream.getVideoTracks().length == 0) {
                 outgoingMedia.video = false;
                 mediaType = 'audio';
             }
         }
 
         this.outgoingMedia = outgoingMedia;
         this.participantsToInvite = participants;
 
         console.log('Escalate', mediaType, 'call', call.id, 'to conference with', participants.toString());
         this.hangupCall(call.id, 'escalate_to_conference');
     }
 
     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);
 
         try {
             let direction;
             let event;
             let callUUID;
             let from;
             let to;
             let displayName;
 
             var url_parts = url.split("/");
             let scheme = url_parts[0];
             //console.log(url_parts);
 
             if (scheme === 'sylk:') {
                 //sylk://conference/incoming/callUUID/from/to/media - when Android is asleep
                 //sylk://call/outgoing/callUUID/to/displayName - from system dialer/history
                 //sylk://call/incoming/callUUID/from/to/displayName - when Android is asleep
                 //sylk://call/cancel//callUUID - when Android is asleep
 
                 event       = url_parts[2];
                 direction   = url_parts[3];
                 callUUID    = url_parts[4];
                 from        = url_parts[5];
                 to          = url_parts[6];
                 displayName = url_parts[7];
                 mediaType   = url_parts[8] || 'audio';
 
                 if (event !== 'cancel' && from && from.search('@videoconference.') > -1) {
                     event = 'conference';
                     to = from;
                 }
 
                 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});
             }
 
             if (event === 'conference') {
                 utils.timestampedLog('Conference from external URL:', url);
                 this.startedByPush = true;
 
                 if (direction === 'outgoing' && to) {
                     utils.timestampedLog('Outgoing conference to', to);
                     this.backToForeground();
                     this.callKeepStartConference(to, {audio: true, video: true, callUUID: callUUID});
                 } else if (direction === 'incoming' && from) {
                     utils.timestampedLog('Incoming conference from', from);
                     // allow app to wake up
                     this.backToForeground();
                     const media = {audio: true, video: mediaType === 'video'}
                     this.incomingConference(callUUID, to, from, displayName, media);
                 }
 
             } else if (event === 'call') {
                 this.startedByPush = true;
                 if (direction === 'outgoing') {
                     utils.timestampedLog('Call from external URL:', url);
                     utils.timestampedLog('Outgoing call to', from);
                     this.backToForeground();
                     this.callKeepStartCall(from, {audio: true, video: false, callUUID: callUUID});
                 } else if (direction === 'incoming') {
                     utils.timestampedLog('Call from external URL:', url);
                     utils.timestampedLog('Incoming call from', from);
                     this.backToForeground();
                     this.incomingCallFromPush(callUUID, from, displayName, mediaType, true);
                 } else if (direction === 'cancel') {
                     this.cancelIncomingCall(callUUID);
                 }
 
 
             } else {
                  utils.timestampedLog('Error: Invalid external URL event', event);
             }
         } catch (err) {
             utils.timestampedLog('Error parsing URL', url, ":", err);
         }
     }
 
     autoRejectIncomingCall(callUUID, from, to) {
         //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);
             if (to !== this.state.targetUri) {
                 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, mediaType, force) {
         //utils.timestampedLog('Handle incoming PUSH call', callUUID, 'from', from, '(', displayName, ')');
 
         if (this.unmounted) {
             return;
         }
 
         if (this.autoRejectIncomingCall(callUUID, from)) {
             return;
         }
 
         //this.showInternalAlertPanel();
 
         if (this.autoAcceptIncomingCall(callUUID, from)) {
             return;
         }
 
         this.goToReadyNowAndCancelTimer();
 
         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, mediaType, force, skipNativePanel);
 
     }
 
     incomingCallFromWebSocket(call, mediaTypes) {
 
         if (this.unmounted) {
             return;
         }
 
         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);
 
         this.goToReadyNowAndCancelTimer();
 
         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, ')');
 
         /*
         let msg;
         let current_datetime = new Date();
         let formatted_date = utils.appendLeadingZeroes(current_datetime.getHours()) + ":" + utils.appendLeadingZeroes(current_datetime.getMinutes()) + ":" + utils.appendLeadingZeroes(current_datetime.getSeconds());
         msg = formatted_date + " - missed call";
         this.saveSystemMessage(data.originator.uri.toLowerCase(), msg, 'incoming', true);
         */
 
         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 = [];
             }
             this.setState({localHistory: newHistory});
             storage.set('history', newHistory);
         }
     }
 
     sendPublicKey(uri) {
         if (!uri) {
             console.log('Missing uri, cannot send public key');
         }
 
         if (uri === this.state.accountId) {
             return;
         }
 
         // Send outgoing messages
         if (this.state.account && this.state.keys && this.state.keys.public) {
             console.log('Sending public key to', uri);
             this.state.account.sendMessage(uri, this.state.keys.public, {}, 'text/pgp-public-key');
         } else {
             console.log('No public key available');
         }
     }
 
     async sendPrivateKey(password) {
         if (!this.state.account) {
             console.log('No account');
             return;
         }
 
         const toUtf8 = RNSimpleCrypto.utils.convertArrayBufferToUtf8;
 
         password = password.trim();
         const public_key = this.state.keys.public.replace(/\r/g, '').trim();
         const private_key = this.state.keys.private.replace(/\r/g, '').trim();
 
         const publicKeyHash = await RNSimpleCrypto.SHA.sha1(public_key);
         const privateKeyHash = await RNSimpleCrypto.SHA.sha1(private_key);
 
         const publicKeyHashContainer  = "--PUBLIC KEY SHA1 CHECKSUM--" + publicKeyHash + "--";
         const privateKeyHashContainer = "--PRIVATE KEY SHA1 CHECKSUM--" + privateKeyHash + "--";
 
         const keyPair = 'THIS IS THE KEY PAIR:\n' + this.state.keys.public + '\n' + this.state.keys.private + '\n' + publicKeyHashContainer + '\n' + privateKeyHashContainer;
 
         await OpenPGP.encryptSymmetric(keyPair, password, KeyOptions).then((encryptedBuffer) => {
             utils.timestampedLog('Sending encrypted private key');
             this.state.account.sendMessage(this.state.account.id, encryptedBuffer, {}, 'text/pgp-private-key');
         }).catch((error) => {
             console.log('Error encrypting private key:', error);
         });
     }
 
     async savePrivateKey(password) {
         utils.timestampedLog('Save encrypted private key');
         password = password.trim();
         await RNSimpleCrypto.AES.decrypt(this.state.privateKey, password).then((keyPair) => {
             utils.timestampedLog('Decrypted PGP key pair', keyPair);
             this.processPrivateKey(keyPair);
         }).catch((error) => {
             console.log('Error decrypting PGP private key:', error);
             return
         });
     }
 
     async processPrivateKey(keyPair) {
         utils.timestampedLog('Process key');
         keyPair = keyPair.replace(/\r/g, '').trim();
 
         let public_key;
         let private_key;
         let privateKeyHash;
         let publicKeyHash;
 
         let regexp;
         let match;
 
         regexp = /(-----BEGIN PGP PUBLIC KEY BLOCK-----[^]*-----END PGP PUBLIC KEY BLOCK-----)/ig;
         match = keyPair.match(regexp);
         if (match.length === 1) {
             public_key = match[0];
         }
 
         regexp = /(-----BEGIN PGP PRIVATE KEY BLOCK-----[^]*-----END PGP PRIVATE KEY BLOCK-----)/ig;
         match = keyPair.match(regexp);
         if (match.length === 1) {
             private_key = match[0];
         }
 
         regexp = /--PUBLIC KEY SHA1 CHECKSUM--(\w*)--/ig;
         match = keyPair.match(regexp);
         if (match.length === 1) {
             publicKeyHash = match[0];
         }
 
         regexp = /--PRIVATE KEY SHA1 CHECKSUM--(\w*)--/ig;
         match = keyPair.match(regexp);
         if (match.length === 1) {
             privateKeyHash = match[0];
         }
 
         const privateKeyHashCalculated = await RNSimpleCrypto.SHA.sha1(private_key);
         const publicKeyHashCalculated = await RNSimpleCrypto.SHA.sha1(public_key);
 
         if (public_key && publicKeyHash.indexOf(publicKeyHashCalculated) > -1 && private_key && privateKeyHash.indexOf(privateKeyHashCalculated) > -1) {
             console.log("Private key copied from another device");
 
             let keys = this.state.keys;
             keys.private = private_key;
             keys.public = public_key;
             keys.publicKeyHash = publicKeyHashCalculated;
             storage.set('keys', keys);
             this.setState({keys: keys});
 
             let status = (keys.private !== private_key && keys.public !== public_key) ? 'Private key copied successfully' : 'Private key is the same';
             this.setState({privateKeyImportStatus: status,
                            privateKeyImportSuccess: true});
         } else {
             this.setState({privateKeyImportStatus: 'Incorrect password!',
                            privateKeyImportSuccess: false});
 
             //console.log('public_key', public_key);
             //console.log('private_key', private_key);
             //console.log('public_key_sha1', publicKeyHash);
             //console.log('private_key_sha1', privateKeyHash);
         }
     }
 
     async savePublicKey(uri, key) {
         if (!key) {
             console.log('Missing key');
             return;
         }
 
         key = key.replace(/\r/g, '').trim();
 
         if (!key.endsWith("-----END PGP PUBLIC KEY BLOCK-----")) {
             console.log('Cannot find the end of PGP public key');
             return;
         }
 
         if (!key.startsWith("-----BEGIN PGP PUBLIC KEY BLOCK-----")) {
             console.log('Cannot find the beginning of PGP public key');
             return;
         }
 
         if (key.indexOf('Max-Forwards:') > -1) {
             // TODO temporary fix for message corruption inside Janus
             return;
         }
 
         let myContacts = this.state.myContacts;
 
         if (uri in myContacts) {
             //
         } else {
             myContacts[uri] = {};
         }
 
         if (myContacts[uri].publicKey === key) {
             console.log('Public key of', uri, 'did not change');
             return;
         }
 
         console.log('Public key of', uri, 'saved');
 
         const publicKeyHash = await RNSimpleCrypto.SHA.sha1(key);
         this.saveSystemMessage(uri, 'Public key received', 'incoming');
         this.saveSystemMessage(uri, 'Key id ' + publicKeyHash, 'incoming');
 
         myContacts[uri].publicKey = key;
         myContacts[uri].publicKeyHash = publicKeyHash;
         this.saveMyContacts(myContacts);
 
         this.sendPublicKey(uri);
     }
 
     _sendMessage(uri, text, id) {
         // Send outgoing messages
         if (this.state.account && text) {
             console.log('Sending outgoing message', id);
             this.state.account.sendMessage(uri, text, {id: id});
         } else {
             console.log('Cannot send message');
         }
     }
 
     async sendMessage(uri, message) {
         message.sent = false;
         message.received = false;
         message.direction = 'outgoing';
 
         if (this.state.account) {
             message.pending = true;
         } else {
             message.pending = false;
         }
 
         this.saveOutgoingMessage(uri, message);
 
         let renderMessages = this.state.messages;
         if (Object.keys(renderMessages).indexOf(uri) === -1) {
             renderMessages[uri] = [];
         }
 
         renderMessages[uri].push(message);
         this.setState({messages: renderMessages});
 
         if (uri in  this.state.myContacts && this.state.myContacts[uri].publicKey && message.contentType !== 'text/pgp-public-key') {
             await OpenPGP.encrypt(message.text, this.state.myContacts[uri].publicKey).then((encryptedMessage) => {
                 console.log('Outgoing encrypted message to', uri);
                 this._sendMessage(uri, encryptedMessage, message._id);
             }).catch((error) => {
                 console.log('Failed to encrypt message:', error);
             });
         } else {
             console.log('Outgoing non-encrypted message to', uri);
             this._sendMessage(uri, message.text, message._id);
         }
     }
 
     async reSendMessage(message, uri) {
         await this.deleteMessage(message._id, uri).then((result) => {
             message._id = uuid.v4();
             message.createdAt = new Date();
             this.sendMessage(uri, message);
         }).catch((error) => {
             console.log('Failed to delete old messages');
         });
     }
 
     async saveOutgoingMessage(uri, message) {
         this.saveOutgoingChatUri(uri, message.text);
 
         let query = "INSERT INTO messages (msg_id, timestamp, content, content_type, from_uri, to_uri, "
             + " direction, pending, sent, received) VALUES ('"
             + message._id
             + "', '"
             + message.createdAt
             + "', '"
             + base64.encode(message.text)
             + "', '"
             + 'text/plain'
             + "', '"
             + this.state.account.id
             + "', '"
             + uri
             + "', '"
             + 'outgoing'
             + "', "
             + "0, 0, 0"
             + ")";
 
         //console.log(query);
 
         await this.ExecuteQuery(query).then((result) => {
             //console.log('SQL insert message OK');
         }).catch((error) => {
             console.log('SQL query:', query);
             console.log('SQL error:', error);
         });
     }
 
     async saveConferenceMessage(uri, message) {
         let query = "INSERT INTO messages (msg_id, timestamp, content, content_type, from_uri, to_uri, "
             + " direction, pending, sent, received) VALUES ('"
             + message._id
             + "', '"
             + message.createdAt
             + "', '"
             + base64.encode(message.text)
             + "', '"
             + 'text/plain'
             + "', '"
             + this.state.account.id
             + "', '"
             + uri
             + "', '"
             + 'outgoing'
             + "', '"
             + (message.pending ? 1: 0)
             + "', '"
             + (message.sent ? 1: 0)
             + "', '"
             + (message.received ? 1: 0)
             + "')";
 
         //console.log(query);
 
         await this.ExecuteQuery(query).then((result) => {
             //console.log('SQL insert message OK');
         }).catch((error) => {
             console.log('SQL query:', query);
             console.log('SQL error:', error);
         });
     }
 
     async messageStateChanged(obj) {
         // valid API states: pending -> accepted -> delivered -> displayed,
         // error, failed or forbidden
         // valid UI render states: pending, read, received
 
         let id = obj.messageId;
         let state = obj.state;
         let uri;
 
         utils.timestampedLog('Message state changed for message', id, state);
 
         let query;
 
         if (state == 'accepted') {
             query = "UPDATE messages set pending = 0 where msg_id = '" + id + "'";
         } else if (state == 'delivered') {
             query = "UPDATE messages set sent = 1 where msg_id = '" + id + "'";
         } else if (state == 'displayed') {
             query = "UPDATE messages set received = 1 where msg_id = '" + id + "'";
         } else if (state == 'failed') {
             query = "UPDATE messages set received = 0, sent = 1, pending = 0 where msg_id = '" + id + "'";
         } else if (state == 'error') {
             query = "UPDATE messages set received = 0, sent = 1, pending = 0 where msg_id = '" + id + "'";
         } else if (state == 'forbidden') {
             query = "UPDATE messages set received = 0, sent = 1, pending = 0 where msg_id = '" + id + "'";
         }
 
         //console.log(query);
         await this.ExecuteQuery(query).then((results) => {
             this.updateRenderMessage(id, state);
             // console.log('SQL update OK');
         }).catch((error) => {
             console.log('SQL query:', query);
             console.log('SQL error:', error);
         });
     }
 
     async deleteMessage(id, uri) {
         utils.timestampedLog('Delete message', id);
         let query;
         // TODO send request to server
         query = "DELETE from messages where msg_id = '" + id + "'";
         //console.log(query);
         this.addJournal(id, 'delete');
         await this.ExecuteQuery(query).then((results) => {
             this.deleteRenderMessage(id, uri);
             // console.log('SQL update OK');
         }).catch((error) => {
             console.log('SQL query:', query);
             console.log('SQL error:', error);
         });
     }
 
     async expireMessage(id, duration=300) {
         utils.timestampedLog('Expire message', id, 'in', duration, 'seconds after read');
         // TODO expire message
     }
 
     async deleteRenderMessage(id, uri) {
         if (uri.indexOf('@videoconference.') > -1) {
             uri = uri.split('@')[0];
         }
 
         let changes = false;
         let renderedMessages = this.state.messages;
         let newRenderedMessages = [];
         if (uri in this.state.messages) {
             renderedMessages[uri].forEach((m) => {
                 if (m._id !== id) {
                     newRenderedMessages.push(m);
                 } else {
                     changes = true;
                 }
             });
 
             renderedMessages[uri] = newRenderedMessages;
         }
         if (changes) {
             this.setState({messages: renderedMessages});
         }
     }
 
     async updateRenderMessage(id, state) {
         let query;
         let uri;
         let changes = false;
 
         query = "SELECT * from messages where msg_id = '" + id + "';";
         //console.log(query);
         await this.ExecuteQuery(query,[]).then((results) => {
             let rows = results.rows;
             if (rows.length === 1) {
                 var item = rows.item(0);
                 uri = item.direction === 'outgoing' ? item.to_uri : item.from_uri;
                 //console.log('Message uri', uri, 'new state', state);
                 if (uri in this.state.messages) {
                     let renderedMessages = this.state.messages;
 
                     renderedMessages[uri].forEach((m) => {
                         if (m._id === id) {
                             if (state === 'accepted') {
                                 m.pending = false;
                                 changes = true;
                             }
 
                             if (state === 'delivered') {
                                 m.sent = true;
                                 m.pending = false;
                                 changes = true;
                             }
 
                             if (state === 'displayed') {
                                 m.received = true;
                                 m.sent = true;
                                 m.pending = false;
                                 changes = true;
                             }
 
                             if (state === 'failed') {
                                 m.received = false;
                                 m.sent = false;
                                 m.pending = false;
                                 m.failed = true;
                                 changes = true;
                             }
 
                             if (state === 'pinned') {
                                 m.pinned = true;
                                 changes = true;
                             }
 
                             if (state === 'unpinned') {
                                 m.pinned = false;
                                 changes = true;
                             }
                         }
                     });
 
                     if (changes) {
                         console.log('Message', id, 'updated');
                         this.setState({messages: renderedMessages});
                     }
                 } else {
                     //console.log('Messages for', uri, 'are not rendered now');
                 }
             }
 
         }).catch((error) => {
             console.log('SQL query:', query);
             console.log('SQL error:', error);
         });
     }
 
     async saveOutgoingChatUri(uri, content='') {
         //console.log('saveOutgoingChatUri', uri);
         let current_datetime = new Date();
         let formatted_date = 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 query;
 
         let myContacts = this.state.myContacts;
 
         if (uri in myContacts) {
             //
         } else {
             myContacts[uri] = {};
         }
 
         myContacts[uri].timestamp = formatted_date;
         myContacts[uri].unread = 0;
         myContacts[uri].lastMessage = content.substring(0, 25);
 
         this.saveMyContacts(myContacts);
     }
 
      pinMessage(id) {
         let query;
         query = "UPDATE messages set pinned = 1 where msg_id ='" + id + "'";
         //console.log(query);
         this.ExecuteQuery(query).then((results) => {
             console.log('Message', id, 'pinned');
             this.updateRenderMessage(id, 'pinned')
             this.addJournal(id, 'pinned');
         }).catch((error) => {
             console.log('SQL query:', query);
             console.log('SQL error:', error);
         });
      }
 
      unpinMessage(id) {
         let query;
         query = "UPDATE messages set pinned = 0 where msg_id ='" + id + "'";
         //console.log(query);
         this.ExecuteQuery(query).then((results) => {
             this.updateRenderMessage(id, 'unpinned')
             this.addJournal(id, 'unpinned');
             console.log('Message', id, 'unpinned');
         }).catch((error) => {
             console.log('SQL query:', query);
             console.log('SQL error:', error);
         });
      }
 
      async addJournal(id, action, data={}) {
          //console.log('Add journal entry:', action, id);
      }
 
      async confirmRead(uri){
         if (uri.indexOf('@') === -1) {
             return;
         }
 
         console.log('Confirm read messages for', uri);
         let query;
         let displayed = [];
 
         query = "SELECT * FROM messages where from_uri = '" + uri + "' and received = 0 and system is NULL";
         //console.log(query);
 
         await this.ExecuteQuery(query).then((results) => {
             let rows = results.rows;
             if (rows.length > 0) {
                 console.log('We must confirm read of', rows.length, 'messages');
             }
             for (let i = 0; i < rows.length; i++) {
                 var item = rows.item(i);
                 if (this.sendDispositionNotification(item)) {
                     displayed.push(item.msg_id);
                 }
             }
 
             if (displayed.length > 0) {
                 let sql_ids = '';
                 let i = 1;
                 displayed.forEach((msg_id) => {
                     sql_ids = sql_ids + "'" + msg_id + "'";
                     if (i < displayed.length) {
                         sql_ids = sql_ids + ', ';
                     }
                     i = i + 1;
                 });
 
                 query = "UPDATE messages set received = 1 where msg_id in (" + sql_ids + ")";
                 //console.log(query);
                 this.ExecuteQuery(query).then((results) => {
                     //console.log('Sent disposition saved for', displayed.length, 'messages');
                 }).catch((error) => {
                     console.log('SQL query:', query);
                     console.log('SQL error:', error);
                 });
             }
 
         }).catch((error) => {
             console.log('SQL query:', query);
             console.log('SQL error:', error);
         });
 
         this.resetUnreadCount(uri);
     }
 
     async resetUnreadCount(uri) {
         console.log('Reset read count for', uri);
         let myContacts = this.state.myContacts;
         if (uri in myContacts && myContacts[uri].unread > 0) {
             myContacts[uri].unread = 0;
             this.saveMyContacts(myContacts);
         }
     }
 
     async sendDispositionNotification(message) {
         console.log('Confirm read message', message.msg_id);
         let query;
         let result = {};
 
         this.state.account.sendDispositionNotification(message.from_uri, message.msg_id, message.timestamp, 'displayed',(error) => {
             if (!error) {
                 console.log('Displayed notification for message', message.msg_id, 'was sent');
                 return true;
             } else {
                 console.log('Displayed notification for message', message.msg_id, 'failed');
                 return false;
             }
         });
      }
 
      async getMessages(uri, limit=200){
         console.log('Get messages with', uri);
         let messages = this.state.messages;
         let msg;
         let query;
 
         query = "SELECT * FROM messages where from_uri = '"
             + uri
             + "' or to_uri = '"
             + uri
             + "' order by id desc limit "
             + limit
             + ";";
 
         // TODO add pagination, reload older messages
 
         //console.log(query);
         await this.ExecuteQuery(query).then((results) => {
             //console.log('SQL get messages OK');
             let myContacts = this.state.myContacts;
 
             let rows = results.rows;
             messages[uri] = [];
             let content;
             let image;
 
             /*
             if (uri in this.state.myContacts && this.state.myContacts[uri].publicKeyHash) {
                 msg = {
                     _id: uuid.v4(),
                     createdAt: new Date(),
                     text: 'Public key ' + this.state.myContacts[uri].publicKeyHash,
                     system: 1
                     }
                 messages[uri].push(msg);
             }
             */
 
             for (let i = 0; i < rows.length; i++) {
                 var item = rows.item(i);
                 //console.log(item);
                 content = base64.decode(item.content);
                 if (item.content_type === 'text/html') {
                     content = xss(content, {
                         whiteList: [], // empty, means filter out all tags
                         stripIgnoreTag: true, // filter out all HTML not in the whitelist
                         stripIgnoreTagBody: ["script"] // the script tag is a special case, we need
                         // to filter out its content
                     });
                     content = utils.escapeHtml(content);
                 } else if (item.content_type === 'text/plain') {
                     content = content;
                 } else if (item.content_type.indexOf('image/') > -1) {
                     image = `data:${item.content_type};base64,${btoa(content)}`
                 } else {
                     content = 'Unknown message type received ' + item.content_type;
                 }
 
                 if (i == 0 && !image && item.to_uri in myContacts && !myContacts[item.to_uri].lastMessage) {
                     myContacts[item.to_uri].lastMessage = content.substring(0, 25);
                     this.saveMyContacts(myContacts);
                 }
 
                 let failed = (item.pending === 0 && item.received === 0 && item.sent === 1) ? true: false,
 
                 msg = {
                     _id: item.msg_id,
                     text: content,
                     image: image,
                     createdAt: item.timestamp,
                     sent: ((item.sent === 1 || item.received === 1) && !failed) ? true : false,
                     direction: item.direction,
                     received: item.received === 1 ? true : false,
                     pending: (item.pending === 1 && item.sent !== 1) ? true : false,
                     system: item.system === 1 ? true : false,
                     failed: (item.pending === 0 && item.received === 0 && item.sent === 1) ? true: false,
                     pinned: (item.pinned === 1) ? true: false,
                     user: item.direction == 'incoming' ? {_id: item.from_uri, name: item.from_name} : {}
                     }
                 messages[uri].push(msg)
             }
 
             messages[uri].reverse();
 
             if (messages[uri].length > 0) {
                 console.log('Got', messages[uri].length, 'messages for', uri);
                 //console.log(messages[uri]);
             }
 
             this.setState({messages: messages});
 
         }).catch((error) => {
             console.log('SQL query:', query);
             console.log('SQL error:', error);
         });
     }
 
     async deleteMessages(uri, period="0", deleteRemote=false) {
         console.log('Purge messages with', uri, 'for', period, 'hours');
         let query;
         this.addJournal(uri, 'delete_messages');
         query = "DELETE FROM messages where (from_uri = '"
             + uri
             + "' or to_uri = '"
             + uri
             + "')";
 
         if (period && period !== "0") {
             query = query + " and timestamp >= date('now', '-" + period + " hour') ";
         }
 
         await this.ExecuteQuery(query).then((result) => {
             console.log('SQL delete messages OK', query);
             if (!period || period === "0") {
                 console.log('Remove all messages');
                 if (uri in this.state.myContacts) {
                     let myContacts = this.state.myContacts;
                     myContacts[uri].read = 0;
                     myContacts[uri].lastMessage = null;
                     myContacts[uri].timestamp = '';
                     this.saveMyContacts(myContacts);
                 }
                 let messages = this.state.messages;
                 delete messages[uri];
                 this.setState({messages: messages});
             } else {
                 this.getMessages(uri);
             }
 
         }).catch((error) => {
             console.log('SQL query:', query);
             console.log('SQL error:', error);
         });
 
         // TODO deleteRemote
 
     }
 
     playIncomingSound() {
         let must_play_sound = true;
 
         if (this.msg_sound_played_ts) {
             let diff = (Date.now() - this.msg_sound_played_ts)/ 1000;
             if (diff < 10) {
                 must_play_sound = false;
             }
         }
 
         this.msg_sound_played_ts = Date.now();
 
         if (must_play_sound) {
             try {
               if (Platform.OS === 'ios') {
                   SoundPlayer.setSpeaker(true);
               }
               SoundPlayer.playSoundFile('message_received', 'wav');
             } catch (e) {
               console.log('Cannot play message_received.wav', e);
             }
         }
     }
 
     async incomingMessage(message) {
         // Handle incoming messages
         if (message.content.indexOf('?OTRv3') > -1) {
             return;
         }
 
         if (message.contentType === 'text/pgp-public-key') {
             this.savePublicKey(message.sender.uri, message.content);
             return;
         }
 
         if (message.contentType === 'text/pgp-private-key' && message.sender.uri === this.state.account.id) {
             console.log('Received my own PGP private key');
             this.setState({showImportPrivateKeyModal: true,
                            privateKey: message.content});
             return;
         }
 
         const is_encrypted =  message.content.indexOf('-----BEGIN PGP MESSAGE-----') > -1 && message.content.indexOf('-----END PGP MESSAGE-----') > -1;
 
         if (is_encrypted) {
             if (!this.state.keys || !this.state.keys.private) {
                 console.log('Missing private key, cannot decrypt message');
                 this.saveSystemMessage(message.sender.uri, 'Cannot decrypt: no private key', 'incoming');
             } else {
                 await OpenPGP.decrypt(message.content, this.state.keys.private).then((decryptedBody) => {
                     console.log('Incoming message decrypted');
                     this.handleIncomingMessage(message, decryptedBody);
                 }).catch((error) => {
                     console.log('Failed to decrypt message:', error);
                     this.saveSystemMessage(message.sender.uri, 'Cannot decrypt: wrong public key', 'incoming');
                 });
             }
         } else {
             //console.log('Incoming message is not encrypted');
             this.handleIncomingMessage(message, message.content);
         }
     }
 
     handleIncomingMessage(message, decryptedBody) {
 
         let content = decryptedBody || message.content;
 
         if (content.indexOf('Max-Forwards:') > -1) {
             // TODO temporary fix for message corruption inside Janus
             return;
         }
 
         this.playIncomingSound();
 
         this.saveIncomingMessage(message.sender.uri, message, decryptedBody);
 
         let renderMessages = this.state.messages;
         if (Object.keys(renderMessages).indexOf(message.sender.uri) === -1) {
             renderMessages[message.sender.uri] = [];
         }
 
         renderMessages[message.sender.uri].push(utils.sylkToRenderMessage(message, decryptedBody));
         this.setState({messages: renderMessages});
     }
 
     async saveSystemMessage(uri, content, direction, missed=false) {
         let timestamp = new Date();
 
         let query = "INSERT INTO messages (msg_id, timestamp, content, content_type, from_uri, to_uri, pending, system, direction) VALUES ('"
             + uuid.v4()
             + "', '"
             + timestamp
             + "', '"
             + base64.encode(content)
             + "', '"
             + 'text/plain'
             + "', '"
             + (direction === 'incoming' ? uri : this.state.account.id)
             + "', '"
             + (direction === 'outgoing' ? uri : this.state.account.id)
             + "', 0, 1, '"
             + direction
             + "')";
 
         //console.log(query);
 
         await this.ExecuteQuery(query).then((result) => {
             if (missed) {
                 this.updateUnreadMessages(uri);
             }
         }).catch((error) => {
             console.log('SQL query:', query);
             console.log('SQL error:', error);
         });
     }
 
     async saveIncomingMessage(uri, message, decryptedBody=null) {
         var content = decryptedBody || message.content;
 
         let query = "INSERT INTO messages (msg_id, timestamp, content, content_type, from_uri, to_uri, direction, received) VALUES ('"
             + message.id
             + "', '"
             + message.timestamp
             + "', '"
             + base64.encode(content)
             + "', '"
             + message.contentType
             + "', '"
             + message.sender.uri
             + "', '"
             + this.state.account.id
             + "', 'incoming', 0"
             + ")";
 
         //console.log(query);
         await this.ExecuteQuery(query).then((result) => {
             this.updateUnreadMessages(uri, message.sender.toString(), content);
         }).catch((error) => {
             console.log('SQL query:', query);
             console.log('SQL error:', error);
         });
     }
 
     async updateUnreadMessages(uri, name='', content='') {
         let current_datetime = new Date();
         let formatted_date = 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 myContacts = this.state.myContacts;
 
         if (uri in myContacts) {
             //
         } else {
             myContacts[uri] = {'name': name};
         }
 
         if (myContacts[uri].unread >= 1) {
             myContacts[uri].unread = myContacts[uri].unread + 1;
         } else {
             myContacts[uri].unread = 1;
         }
 
         myContacts[uri].lastMessage = content.substring(0, 25);
         myContacts[uri].timestamp = formatted_date;
         console.log(uri, 'has', myContacts[uri].unread, 'unread messages');
 
         this.saveMyContacts(myContacts);
     }
 
     saveParticipant(callUUID, room, uri) {
         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);
     }
 
     deleteContact(uri) {
         uri = uri.trim().toLowerCase();
 
         if (uri.indexOf('@') === -1) {
             uri = uri + '@' + this.state.defaultDomain;
         }
 
         let myContacts = this.state.myContacts;
 
         if (uri in myContacts) {
             console.log('Delete contact', uri);
             this.deleteMessages(uri),
             delete myContacts[uri];
             this.saveMyContacts(myContacts);
         }
         this.setState({selectedContact: null, target_uri: ''});
     }
 
     deletePublicKey(uri) {
         uri = uri.trim().toLowerCase();
 
         if (uri.indexOf('@') === -1) {
             uri = uri + '@' + this.state.defaultDomain;
         }
 
         let myContacts = this.state.myContacts;
 
         if (uri in myContacts) {
             myContacts[uri].publicKey = null;
             myContacts[uri].publicKeyHash = null;
             console.log('Public key of', uri, 'deleted');
             this.saveMyContacts(myContacts);
             //
         }
     }
 
     saveContact(uri, displayName, organization='') {
         displayName = displayName.trim();
         uri = uri.trim().toLowerCase();
 
         if (uri.indexOf('@') === -1) {
             uri = uri + '@' + this.state.defaultDomain;
         }
 
         console.log('Save contact', displayName, 'with uri', uri, 'and organization', organization);
 
         let myContacts = this.state.myContacts;
 
         if (uri in myContacts) {
             //
         } else {
             myContacts[uri] = {};
             let current_datetime = new Date();
             let formatted_date = 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());
             myContacts[uri].timestamp = formatted_date;
         }
 
         myContacts[uri].name = displayName;
         myContacts[uri].organization = organization;
         myContacts[uri].name = displayName;
         myContacts[uri].favorite = false;
         myContacts[uri].blocked = false;
 
         this.saveMyContacts(myContacts);
 
         let selectedContact = this.state.selectedContact;
         if (selectedContact && selectedContact.remoteParty === uri) {
             selectedContact.displayName = displayName;
             selectedContact.organization = organization;
             this.setState({selectedContact: selectedContact});
         }
 
         if (uri === this.state.accountId) {
             storage.set('displayName', displayName);
             storage.set('organization', organization);
             this.setState({displayName: displayName, organization: organization});
             if (this.state.account && displayName !== this.state.account.displayName) {
                 this.processRegistration(this.state.accountId, this.state.password, displayName);
             }
         }
     }
 
     toggleFavorite(uri) {
         let favoriteUris = this.state.favoriteUris;
         let idx = favoriteUris.indexOf(uri);
         let favorite;
 
         if (idx === -1) {
             favoriteUris.push(uri);
             favorite = true;
             console.log(uri, 'is favorite');
         } else {
             let removed = favoriteUris.splice(idx, 1);
             favorite = false;
             console.log(uri, 'is not favorite');
         }
 
         storage.set('favoriteUris', favoriteUris);
 
         let myContacts = this.state.myContacts;
         if (uri in myContacts) {
             myContacts[uri].favorite = favorite;
         } else {
             myContacts[uri] = {};
             myContacts[uri].name = '';
             myContacts[uri].favorite = favorite;
         }
 
         let selectedContact;
         if (this.state.selectedContact) {
             selectedContact = this.state.selectedContact;
             idx = selectedContact.tags.indexOf('favorite');
             if (idx > -1) {
                  selectedContact.tags.splice(idx, 1);
             } else {
                 selectedContact.tags.push('favorite');
             }
         }
 
         this.setState({favoriteUris: favoriteUris,
                        selectedContact: selectedContact,
                        refreshFavorites: !this.state.refreshFavorites});
 
         this.saveMyContacts(myContacts);
         return favorite;
     }
 
     toggleBlocked(uri) {
         let blockedUris = this.state.blockedUris;
 
         let blocked;
         let idx = blockedUris.indexOf(uri);
 
         if (idx === -1) {
             blockedUris.push(uri);
             blocked = true;
             console.log(uri, 'is blocked');
         } else {
             let removed = blockedUris.splice(idx, 1);
             blocked = false;
             console.log(uri, 'is not blocked');
         }
 
         storage.set('blockedUris', blockedUris);
         this.setState({blockedUris: blockedUris, selectedContact: null});
 
         let myContacts = this.state.myContacts;
         if (uri in myContacts) {
             myContacts[uri].blocked = blocked;
         } else {
             myContacts[uri] = {};
             myContacts[uri].name = uri;
             myContacts[uri].blocked = blocked;
         }
 
         this.saveMyContacts(myContacts);
 
         return blocked;
     }
 
     saveMyContacts(myContacts) {
         console.log('Save myContacts');
         storage.set('myContacts', myContacts);
         this.setState({myContacts: myContacts});
     }
 
     appendInvitedParties(room, uris) {
         room = room.split('@')[0];
         console.log('Save invited parties', uris, 'for room', room);
         let myInvitedParties = this.state.myInvitedParties;
 
         if (!myInvitedParties) {
             myInvitedParties = new Object();
         }
 
         let current_uris = myInvitedParties.hasOwnProperty(room) ? myInvitedParties[room] : [];
         uris.forEach((uri) => {
             let idx = current_uris.indexOf(uri);
             if (idx === -1) {
                 if (uri.indexOf('@') === -1) {
                     uri =  uri + '@' + this.state.defaultDomain;
                 }
 
                 if (uri !== this.state.account.id) {
                     current_uris.push(uri);
                     console.log('Added', uri, 'to room', room);
                 }
             }
         });
 
         this.saveInvitedParties(room, uris);
     }
 
     saveInvitedParties(room, uris) {
         room = room.split('@')[0];
         console.log('Save invited parties', uris, 'for room', room);
         let myInvitedParties = this.state.myInvitedParties;
 
         if (!myInvitedParties) {
             myInvitedParties = new Object();
         }
 
         let new_uris = [];
         uris.forEach((uri) => {
             if (uri.indexOf('@') === -1) {
                 uri =  uri + '@' + this.state.defaultDomain;
             }
 
             if (uri !== this.state.account.id) {
                 new_uris.push(uri);
                 console.log('Added', uri, 'to room', room);
             }
         });
 
         myInvitedParties[room] = new_uris;
 
         console.log('Save invited parties', myInvitedParties);
         storage.set('myInvitedParties', myInvitedParties);
         this.setState({myInvitedParties: 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() {
         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}
                             />
 
                             <LogsModal
                                 logs={this.state.logs}
                                 show={this.state.showLogsModal}
                                 refresh={this.showLogs}
                                 close={this.hideLogsModal}
                                 purgeLogs={this.purgeLogs}
                                 orientation={this.state.orientation}
                             />
 
                             <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);
     }
 
     hideLogsModal() {
        this.setState({showLogsModal: false});
     }
 
     purgeLogs() {
         RNFS.unlink(logfile)
           .then(() => {
             utils.timestampedLog('Log file initialized');
             this.showLogs();
           })
           // `unlink` will throw an error, if the item to unlink does not exist
           .catch((err) => {
             console.log(err.message);
           });
     }
 
     showLogs() {
        this.setState({showLogsModal: true});
        RNFS.readFile(logfile, 'utf8').then((content) => {
            console.log('Read', content.length, 'bytes from', logfile);
            const lastlines = content.split('\n').slice(-MAX_LOG_LINES).join('\n');
            this.setState({logs: lastlines});
        });
     }
 
     trimLogs() {
        RNFS.readFile(logfile, 'utf8').then((content) => {
            const lines = content.split('\n');
            //console.log('Read', lines.length, 'lines and', content.length, 'bytes from', logfile);
            if (lines.length > (MAX_LOG_LINES + 50) || content.length > 100000) {
                const text = lines.slice(-MAX_LOG_LINES).join('\n');
                RNFS.writeFile(logfile, text + '\r\n', 'utf8')
                    .then((success) => {
                    //console.log('Trimmed logs to', MAX_LOG_LINES, 'lines and', text.length, 'bytes');
                })
                .catch((err) => {
                    console.log(err.message);
                });
            }
        });
     }
 
     ready() {
         let publicKeyHash;
         let publicKey;
         let call = this.state.currentCall || this.state.incomingCall;
 
         if (this.state.selectedContact) {
             const uri = this.state.selectedContact.remoteParty;
             if (uri in this.state.myContacts && this.state.myContacts[uri].publicKeyHash) {
                 publicKeyHash = this.state.myContacts[uri].publicKeyHash;
                 publicKey = this.state.myContacts[uri].publicKey;
             }
         } else {
             publicKeyHash = this.state.keys ? this.state.keys.publicKeyHash : null;
         }
 
         return (
             <Fragment>
                 <NavigationBar
                     notificationCenter = {this.notificationCenter}
                     account = {this.state.account}
                     accountId = {this.state.accountId}
                     logout = {this.logout}
                     inCall = {(this.state.incomingCall || this.state.currentCall) ? true: false}
                     toggleSpeakerPhone = {this.toggleSpeakerPhone}
                     toggleProximity = {this.toggleProximity}
                     proximity = {this.state.proximityEnabled}
                     preview = {this.startPreview}
                     showLogs = {this.showLogs}
                     goBackFunc = {this.goBackToHome}
                     connection = {this.state.connection}
                     registrationState = {this.state.registrationState}
                     orientation = {this.state.orientation}
                     isTablet = {this.state.isTablet}
                     displayName = {this.state.displayName}
                     organization = {this.state.organization}
                     selectedContact = {this.state.selectedContact}
                     replicateKey = {this.sendPrivateKey}
                     publicKeyHash = {publicKeyHash}
                     publicKey = {publicKey}
                     deleteMessages = {this.deleteMessages}
                     toggleFavorite = {this.toggleFavorite}
                     toggleBlocked = {this.toggleBlocked}
                     togglePinned = {this.togglePinned}
                     myInvitedParties={this.state.myInvitedParties}
                     saveInvitedParties={this.saveInvitedParties}
                     defaultDomain = {this.state.defaultDomain}
                     favoriteUris = {this.state.favoriteUris}
                     startCall = {this.callKeepStartCall}
                     saveContact = {this.saveContact}
                     deleteContact = {this.deleteContact}
                     sendPublicKey = {this.sendPublicKey}
                     deletePublicKey = {this.deletePublicKey}
 
                 />
                 <ReadyBox
                     account = {this.state.account}
                     password = {this.state.password}
                     config = {config}
                     inCall = {(this.state.incomingCall || this.state.currentCall) ? true: false}
                     startCall = {this.callKeepStartCall}
                     startConference = {this.callKeepStartConference}
                     missedTargetUri = {this.state.missedTargetUri}
                     orientation = {this.state.orientation}
                     contacts = {this.contacts}
                     isTablet = {this.state.isTablet}
                     isLandscape = {this.state.orientation === 'landscape'}
                     refreshHistory = {this.state.refreshHistory}
                     refreshFavorites = {this.state.refreshFavorites}
                     cacheHistory = {this.saveHistoryForLater}
                     localHistory = {this.state.localHistory}
                     serverHistory = {this.cachedHistory}
                     myDisplayName = {this.state.displayName}
                     myPhoneNumber = {this.state.myPhoneNumber}
                     deleteHistoryEntry = {this.deleteHistoryEntry}
                     saveInvitedParties = {this.saveInvitedParties}
                     myInvitedParties = {this.state.myInvitedParties}
                     toggleFavorite = {this.toggleFavorite}
                     toggleBlocked = {this.toggleBlocked}
                     favoriteUris = {this.state.favoriteUris}
                     blockedUris = {this.state.blockedUris}
                     defaultDomain = {this.state.defaultDomain}
                     saveContact = {this.saveContact}
                     myContacts = {this.state.myContacts}
                     lookupContacts = {this.lookupContacts}
                     confirmRead = {this.confirmRead}
                     selectedContact = {this.state.selectedContact}
                     call = {this.state.incomingCall || this.state.currentCall}
                     goBackFunc = {this.goBackToCall}
                     messages = {this.state.messages}
                     deleteMessages = {this.deleteMessages}
                     sendMessage = {this.sendMessage}
                     expireMessage = {this.expireMessage}
                     reSendMessage = {this.reSendMessage}
                     deleteMessage = {this.deleteMessage}
                     getMessages = {this.getMessages}
                     pinMessage = {this.pinMessage}
                     unpinMessage = {this.unpinMessage}
                     selectContact = {this.selectContact}
                     sendPublicKey = {this.sendPublicKey}
                     inviteContacts = {this.state.inviteContacts}
                     selectedContacts = {this.state.selectedContacts}
                     updateSelection = {this.updateSelection}
                     togglePinned = {this.togglePinned}
                     pinned = {this.state.pinned}
                 />
 
                 <ImportPrivateKeyModal
                     show={this.state.showImportPrivateKeyModal}
                     close={this.toggleImportPrivateKeyModal}
                     saveFunc={this.savePrivateKey}
                     status={this.state.privateKeyImportStatus}
                     success={this.state.privateKeyImportSuccess}
                 />
             </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;
         let callState;
 
         if (call && call.id in this.state.callsState) {
             callState = this.state.callsState[call.id];
         }
 
         return (
             <Call
                 account = {this.state.account}
                 targetUri = {this.state.targetUri}
                 call = {call}
                 callState = {callState}
                 connection = {this.state.connection}
                 registrationState = {this.state.registrationState}
                 localMedia = {this.state.localMedia}
                 escalateToConference = {this.escalateToConference}
                 hangupCall = {this.hangupCall}
                 showLogs = {this.showLogs}
                 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}
                 myContacts = {this.state.myContacts}
                 declineReason = {this.state.declineReason}
-                goBackFunc={this.goBackToHome}
+                goBackFunc={this.goBackToHomeFromCall}
                 messages = {this.state.messages}
                 sendMessage={this.sendMessage}
                 reSendMessage={this.reSendMessage}
                 expireMessage = {this.expireMessage}
                 deleteMessage = {this.deleteMessage}
                 getMessages = {this.getMessages}
                 pinMessage = {this.pinMessage}
                 unpinMessage = {this.unpinMessage}
                 confirmRead = {this.confirmRead}
+                selectedContact={this.state.selectedContact}
             />
         )
     }
 
     conference() {
         let _previousParticipants = new Set();
 
         let call = this.state.currentCall || this.state.incomingCall;
         let callState;
 
         if (call && call.id in this.state.callsState) {
             callState = this.state.callsState[call.id];
         }
 
         /*
         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.state.myInvitedParties) {
             let room = this.state.targetUri.split('@')[0];
             if (this.state.myInvitedParties.hasOwnProperty(room)) {
                 let uris = this.state.myInvitedParties[room];
                 if (uris) {
                     uris.forEach((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}
                 saveMessage = {this.saveConferenceMessage}
                 myInvitedParties = {this.state.myInvitedParties}
                 saveInvitedParties = {this.appendInvitedParties}
                 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.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}
                 toggleFavorite = {this.toggleFavorite}
                 favoriteUris = {this.state.favoriteUris}
                 myContacts = {this.state.myContacts}
                 lookupContacts={this.lookupContacts}
                 goBackFunc={this.goBackToHome}
                 inviteToConferenceFunc={this.inviteContactsToConference}
                 selectedContacts={this.state.selectedContacts}
                 callState={callState}
             />
         )
     }
 
     matchContact(contact, filter='', matchDisplayName=true) {
         if (contact.remoteParty.toLowerCase().startsWith(filter.toLowerCase())) {
             return true;
         }
 
         if (matchDisplayName && contact.displayName && contact.displayName.toLowerCase().indexOf(filter.toLowerCase()) > -1) {
             return true;
         }
 
         return false;
     }
 
     lookupContacts(text, addressbook=true, favorites=true, localHistory=true, serverHistory=true) {
         let contacts = [];
 
         if (addressbook) {
             const addressbook_contacts = this.contacts.filter(contact => this.matchContact(contact, text));
             addressbook_contacts.forEach((c) => {
                 const existing_contacts = contacts.filter(contact => this.matchContact(contact, c.remoteParty.toLowerCase(), false));
                 if (existing_contacts.length === 0) {
                     contacts.push(c);
                 }
             });
         }
 
         if (favorites) {
             const favorite_contacts = this.favoritesContacts.filter(contact => this.matchContact(contact, text));
             favorite_contacts.forEach((c) => {
                 const existing_contacts = contacts.filter(contact => this.matchContact(contact, c.remoteParty.toLowerCase(), false));
                 if (existing_contacts.length === 0) {
                     contacts.push(c);
                 }
             });
         }
 
         if (localHistory) {
             const local_history_contacts = this.state.localHistory.filter(contact => this.matchContact(contact, text));
             local_history_contacts.forEach((c) => {
                 const existing_contacts = contacts.filter(contact => this.matchContact(contact, c.remoteParty.toLowerCase(), false));
                 if (c.remoteParty.toLowerCase().indexOf('@guest.')) {
                 }
                 if (c.remoteParty.toLowerCase().indexOf('@conference.')) {
                 }
                 if (c.remoteParty.toLowerCase().indexOf('@videoconference.')) {
                 }
                 if (existing_contacts.length === 0) {
                     contacts.push(c);
                 }
             });
         }
 
         if (serverHistory) {
             const server_history_contacts = this.cachedHistory.filter(contact => this.matchContact(contact, text));
             server_history_contacts.forEach((c) => {
                 const existing_contacts = contacts.filter(contact => this.matchContact(contact, c.remoteParty.toLowerCase(), false));
                 if (c.remoteParty.toLowerCase().indexOf('@guest.')) {
                 }
                 if (c.remoteParty.toLowerCase().indexOf('@conference.')) {
                 }
                 if (existing_contacts.length === 0) {
                     contacts.push(c);
                 }
             });
         }
 
         return contacts;
     }
 
     get favoritesContacts() {
         let favoriteContacts = [];
         let displayName = '';
         let conference = false;
 
         this.state.favoriteUris.forEach((uri) => {
 
             if (!uri) {
                 return;
             }
 
             uri = uri.toLowerCase();
 
             displayName = '';
 
             if (this.state.myContacts && this.state.myContacts.hasOwnProperty(uri)) {
                 displayName = this.state.myContacts[uri].name;
             }
 
             conference = false;
 
             let tags = ['favorite'];
 
             if (uri.indexOf('@videoconference.') > -1) {
                 displayName = uri.split('@')[0];
                 const room = uri.split('@')[0];
                 uri = room + '@' + config.defaultConferenceDomain;
                 conference = true;
                 tags.push('conference');
             }
 
             const item = {
                 remoteParty: uri,
                 displayName: displayName,
                 conference: conference,
                 type: 'contact',
                 id: uuid.v4(),
                 tags: tags
                 };
 
             favoriteContacts.push(item);
         });
 
         return favoriteContacts;
     }
 
 
     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;
         } else if (this.mustLogout && this.state.connection && this.state.account) {
             this.state.account.unregister();
         }
 
         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/components/AudioCallBox.js b/app/components/AudioCallBox.js
index 915e32b..407a2d7 100644
--- a/app/components/AudioCallBox.js
+++ b/app/components/AudioCallBox.js
@@ -1,374 +1,375 @@
 import React, { Component } from 'react';
 import { View, Platform, TouchableWithoutFeedback } 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';
 
 import TrafficStats from './BarChart';
 
 
 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,
             info                        : this.props.info,
             packetLossQueue             : [],
             audioBandwidthQueue         : [],
             latencyQueue                : [],
             declineReason               : this.props.declineReason
         };
 
         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;
             }
         }
     }
 
     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});
             }
 
             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});
         }
 
         if (nextProps.hasOwnProperty('info')) {
             this.setState({info: nextProps.info});
         }
 
         if (nextProps.hasOwnProperty('packetLossQueue')) {
             this.setState({packetLossQueue: nextProps.packetLossQueue});
         }
 
         if (nextProps.hasOwnProperty('audioBandwidthQueue')) {
             this.setState({audioBandwidthQueue: nextProps.audioBandwidthQueue});
         }
 
         if (nextProps.hasOwnProperty('latencyQueue')) {
             this.setState({latencyQueue: nextProps.latencyQueue});
         }
 
         this.setState({remoteUri: nextProps.remoteUri,
                        remoteDisplayName: nextProps.remoteDisplayName,
                        photo: nextProps.photo,
                        declineReason: nextProps.declineReason
                        });
     }
 
     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_hangup_call');
         this.userHangup = true;
     }
 
     cancelCall(event) {
         event.preventDefault();
         this.props.hangupCall('user_cancel_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
         });
     }
 
     handleDoubleTap() {
         const now = Date.now();
         const DOUBLE_PRESS_DELAY = 300;
         if (this.lastTap && now - this.lastTap < DOUBLE_PRESS_DELAY) {
           this.props.showLogs();
         } else {
           this.lastTap = now;
         }
     }
 
     render() {
+
         let buttonContainerClass;
         let userIconContainerClass;
 
         let remoteIdentity = {uri: this.state.remoteUri || '',
                               displayName: this.state.remoteDisplayName || '',
                               photo: this.state.photo
                               };
 
         const username = this.state.remoteUri.split('@')[0];
         const isPhoneNumber = username.match(/^(\+|0)(\d+)$/);
 
         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;
         const chatButtonClass = (Platform.OS === 'ios') ? styles.iosChatButton : styles.androidChatButton;
 
         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}
                     media='audio'
                     declineReason={this.state.declineReason}
                     goBackFunc={this.props.goBackFunc}
                     callState={this.props.callState}
                 />
                 <View style={userIconContainerClass}>
                     <UserIcon identity={remoteIdentity} large={true} active={this.state.active} />
                 </View>
 
                 <Dialog.Title style={styles.displayName}>{displayName}</Dialog.Title>
                 <TouchableWithoutFeedback onPress={this.handleDoubleTap}>
                 <Text style={styles.uri}>{this.state.remoteUri}</Text>
                 </TouchableWithoutFeedback>
 
                 {this.props.orientation !== 'landscape' && this.state.reconnectingCall ?
                 <ActivityIndicator style={styles.activity} animating={true} size={'large'} color={Colors.red800} />
                 :
                 null
                 }
 
                 <TrafficStats
                     packetLossQueue = {this.state.packetLossQueue}
                     latencyQueue = {this.state.latencyQueue}
                     audioBandwidthQueue = {this.state.audioBandwidthQueue}
                     videoBandwidthQueue = {this.state.videoBandwidthQueue}
                     isTablet = {this.props.isTablet}
                     orientation = {this.props.orientation}
                     media = 'audio'
                 />
 
                 {this.state.call && ((this.state.call.state === 'accepted' || this.state.call.state === 'established') && !this.state.reconnectingCall) ?
                     <View style={buttonContainerClass}>
                     <IconButton
                         size={buttonSize}
                         style={chatButtonClass}
                         icon="chat"
                         onPress={this.props.goBackFunc}
                     />
                     <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}
                     />
                     {isPhoneNumber ?
                     <IconButton
                         size={buttonSize}
                         style={buttonClass}
                         icon="dialpad"
                         onPress={this.showDtmfModal}
                         disabled={!(this.state.call && (this.state.call.state === 'accepted' || this.state.call.state === 'established'))}
                     />
                     : null
                     }
                     <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,
     info                    : PropTypes.string,
     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,
     packetLossQueue         : PropTypes.array,
     videoBandwidthQueue     : PropTypes.array,
     audioBandwidthQueue     : PropTypes.array,
     latencyQueue            : PropTypes.array,
     declineReason           : PropTypes.string,
     showLogs                : PropTypes.func,
     goBackFunc              : PropTypes.func,
     callState               : PropTypes.object,
     messages                : PropTypes.object,
     sendMessage             : PropTypes.func,
     reSendMessage           : PropTypes.func,
     confirmRead             : PropTypes.func,
     deleteMessage           : PropTypes.func,
     expireMessage           : PropTypes.func,
     getMessages             : PropTypes.func,
     pinMessage              : PropTypes.func,
     unpinMessage            : PropTypes.func,
     selectedContact         : PropTypes.object
 };
 
 export default AudioCallBox;
diff --git a/app/components/Call.js b/app/components/Call.js
index 8102847..37838be 100644
--- a/app/components/Call.js
+++ b/app/components/Call.js
@@ -1,1009 +1,1011 @@
 import React, { Component } 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 uuid from 'react-native-uuid';
 
 import AudioCallBox from './AudioCallBox';
 import LocalMedia from './LocalMedia';
 import VideoBox from './VideoBox';
 import config from '../config';
 import utils from '../utils';
 
 
 function randomIntFromInterval(min,max)
 {
     return Math.floor(Math.random()*(max-min+1)+min);
 }
 
 function FixedQueue( size, initialValues ){
 
     // If there are no initial arguments, default it to
     // an empty value so we can call the constructor in
     // a uniform way.
     initialValues = (initialValues || []);
 
     // Create the fixed queue array value.
     var queue = Array.apply( null, initialValues );
 
     // Store the fixed size in the queue.
     queue.fixedSize = size;
 
     // Add the class methods to the queue. Some of these have
     // to override the native Array methods in order to make
     // sure the queue lenght is maintained.
     queue.push = FixedQueue.push;
     queue.splice = FixedQueue.splice;
     queue.unshift = FixedQueue.unshift;
 
     // Trim any initial excess from the queue.
     FixedQueue.trimTail.call( queue );
 
     // Return the new queue.
     return( queue );
 
 }
 
 
 // I trim the queue down to the appropriate size, removing
 // items from the beginning of the internal array.
 FixedQueue.trimHead = function(){
 
     // Check to see if any trimming needs to be performed.
     if (this.length <= this.fixedSize){
 
         // No trimming, return out.
         return;
 
     }
 
     // Trim whatever is beyond the fixed size.
     Array.prototype.splice.call(
         this,
         0,
         (this.length - this.fixedSize)
     );
 
 };
 
 
 // I trim the queue down to the appropriate size, removing
 // items from the end of the internal array.
 FixedQueue.trimTail = function(){
 
     // Check to see if any trimming needs to be performed.
     if (this.length <= this.fixedSize){
 
         // No trimming, return out.
         return;
 
     }
 
     // Trim whatever is beyond the fixed size.
     Array.prototype.splice.call(
         this,
         this.fixedSize,
         (this.length - this.fixedSize)
     );
 
 };
 
 
 // I synthesize wrapper methods that call the native Array
 // methods followed by a trimming method.
 FixedQueue.wrapMethod = function( methodName, trimMethod ){
 
     // Create a wrapper that calls the given method.
     var wrapper = function(){
 
         // Get the native Array method.
         var method = Array.prototype[ methodName ];
 
         // Call the native method first.
         var result = method.apply( this, arguments );
 
         // Trim the queue now that it's been augmented.
         trimMethod.call( this );
 
         // Return the original value.
         return( result );
 
     };
 
     // Return the wrapper method.
     return( wrapper );
 
 };
 
 
 // Wrap the native methods.
 FixedQueue.push = FixedQueue.wrapMethod(
     "push",
     FixedQueue.trimHead
 );
 
 FixedQueue.splice = FixedQueue.wrapMethod(
     "splice",
     FixedQueue.trimTail
 );
 
 FixedQueue.unshift = FixedQueue.wrapMethod(
     "unshift",
     FixedQueue.trimTail
 );
 
 
 class Call extends Component {
     constructor(props) {
         super(props);
         autoBind(this);
 
         this.samples = 30;
         this.sampleInterval = 3;
 
         this.defaultWaitInterval = 60; // until we can connect or reconnect
         this.waitCounter = 0;
         this.waitInterval = this.defaultWaitInterval;
 
         this.videoBytesSent = 0;
         this.audioBytesSent = 0;
 
         this.videoBytesReceived = 0;
         this.audioBytesReceived = 0;
 
         this.packetLoss = 0;
 
         this.packetLossQueue = FixedQueue(this.samples);
         this.latencyQueue = FixedQueue(this.samples);
         this.audioBandwidthQueue = FixedQueue(this.samples);
         this.videoBandwidthQueue = FixedQueue(this.samples);
 
         this.mediaLost = false;
 
         let callUUID;
         let remoteUri = '';
         let remoteDisplayName = '';
         let callState = null;
         let direction = null;
         let callEnded = false;
         this.mediaIsPlaying = false;
         this.ended = false;
         this.answering = false;
 
         if (this.props.call) {
             // If current call is available on mount we must have incoming
             this.props.call.on('stateChanged', this.callStateChanged);
             remoteUri = this.props.call.remoteIdentity.uri;
             callState = this.props.call.state;
             remoteDisplayName = this.props.call.remoteIdentity.displayName || this.props.call.remoteIdentity.uri;
             direction = this.props.call.direction;
             callUUID = this.props.call.id;
         } else {
             remoteUri = this.props.targetUri;
             remoteDisplayName = this.props.targetUri;
             callUUID = this.props.callUUID;
             direction = callUUID ? 'outgoing' : 'incoming';
         }
 
         if (this.props.connection) {
             this.props.connection.on('stateChanged', this.connectionStateChanged);
         }
 
         let audioOnly = false;
         if (this.props.localMedia && this.props.localMedia.getVideoTracks().length === 0) {
             audioOnly = true;
         }
 
         this.state = {
                       call: this.props.call,
                       targetUri: this.props.targetUri,
                       audioOnly: audioOnly,
                       boo: false,
                       remoteUri: remoteUri,
                       remoteDisplayName: remoteDisplayName,
                       localMedia: this.props.localMedia,
                       connection: this.props.connection,
                       accountId: this.props.account ? this.props.account.id : null,
                       callState: callState,
                       direction: direction,
                       callUUID: callUUID,
                       reconnectingCall: this.props.reconnectingCall,
                       info: '',
                       packetLossQueue: [],
                       audioBandwidthQueue: [],
                       videoBandwidthQueue: [],
                       latencyQueue: [],
                       declineReason: this.props.declineReason,
-                      messages: this.props.messages
+                      messages: this.props.messages,
+                      selectedContact: this.props.selectedContact
                       }
 
         this.statisticsTimer = setInterval(() => {
              this.getConnectionStats();
         }, this.sampleInterval * 1000);
 
     }
 
     componentDidMount() {
         this.resetStats();
 
         this.lookupContact();
 
         if (this.state.direction === 'outgoing' && this.state.callUUID && this.state.callState !== 'established') {
             utils.timestampedLog('Call: start call', this.state.callUUID, 'when ready to', this.state.targetUri);
             this.startCallWhenReady(this.state.callUUID);
         }
 
         if (this.state.call === null) {
             this.mediaPlaying();
         }
     }
 
     componentWillUnmount() {
         this.ended = true;
         this.answering = false;
 
         if (this.state.call) {
             this.state.call.removeListener('stateChanged', this.callStateChanged);
         }
 
         if (this.state.connection) {
             this.state.connection.removeListener('stateChanged', this.connectionStateChanged);
         }
     }
 
     resetStats() {
          if (this.ended) {
              return;
          }
 
          this.setState({
                       bandwidth: '',
                       packetLossQueue: [],
                       audioBandwidthQueue: [],
                       videoBandwidthQueue: [],
                       latencyQueue: []
                       });
     }
 
     //getDerivedStateFromProps(nextProps, state) {
     UNSAFE_componentWillReceiveProps(nextProps) {
         // Needed for switching to incoming call while in a call
         if (this.ended) {
             return;
         }
 
         this.setState({connection: nextProps.connection,
                        accountId: nextProps.account ? nextProps.account.id : null});
 
         if (this.state.call === null && nextProps.call !== null) {
             //utils.timestampedLog('Call: Sylkrtc call has been set');
             nextProps.call.on('stateChanged', this.callStateChanged);
 
             this.setState({
                            call: nextProps.call,
                            remoteUri: nextProps.call.remoteIdentity.uri,
                            direction: nextProps.call.direction,
                            callUUID: nextProps.call.id,
                            remoteDisplayName: nextProps.call.remoteIdentity.displayName
                            });
 
             this.lookupContact();
         } else {
             if (nextProps.callUUID !== null && this.state.callUUID !== nextProps.callUUID) {
                 this.setState({'callUUID': nextProps.callUUID,
                                'direction': 'outgoing',
                                'call': null
                                });
 
                 this.startCallWhenReady(nextProps.callUUID);
             }
         }
 
         if (nextProps.reconnectingCall !== this.state.reconnectingCall) {
             this.setState({reconnectingCall: nextProps.reconnectingCall});
         }
 
         if (nextProps.targetUri !== this.state.targetUri && this.state.direction === 'outgoing') {
             this.setState({targetUri: nextProps.targetUri});
         }
 
         this.setState({registrationState: nextProps.registrationState,
                        declineReason: nextProps.declineReason});
 
         if (nextProps.localMedia !== null && nextProps.localMedia !== this.state.localMedia && this.state.direction === 'outgoing') {
             utils.timestampedLog('Call: media for outgoing call has been changed');
 
             let audioOnly = false;
 
             if (nextProps.localMedia.getVideoTracks().length === 0) {
                 audioOnly = true;
             }
 
             this.setState({localMedia: nextProps.localMedia,
                            audioOnly: audioOnly});
 
             //this.mediaPlaying(nextProps.localMedia);
         }
 
         this.setState({messages: nextProps.messages});
     }
 
     getConnectionStats() {
          if (this.ended) {
              return;
          }
 
          let speed = 0;
          let diff = 0;
 
          let delay = 0;
 
          let audioPackets = 0;
          let videoPackets = 0;
 
          let audioPacketsLost = 0;
          let videoPacketsLost = 0;
 
          let audioPacketLoss = 0;
          let videoPacketLoss = 0;
 
          let bandwidthUpload = 0;
          let bandwidthDownload = 0;
 
          let mediaType;
          let foundVideo = false;
 
          if (!this.state.call || !this.state.call._pc) {
              this.resetStats();
              return;
          }
 
          this.state.call._pc.getStats(null).then(stats => {
              stats.forEach(report => {
 
              if (report.type === "ssrc") {
                  report.values.forEach(object => { if (object.mediaType) {
                          mediaType = object.mediaType;
                      }
                  });
 
                  report.values.forEach(object => {
                      if (object.bytesReceived) {
                          const bytesReceived = Math.floor(object.bytesReceived);
                          if (mediaType === 'audio') {
                              if (this.audioBytesReceived > 0 && this.audioBytesReceived < bytesReceived) {
                                  diff = bytesReceived - this.audioBytesReceived;
                                  diff = bytesReceived - this.audioBytesReceived;
                                  speed = Math.floor(diff / this.sampleInterval * 8 / 1000);
                                  //console.log('Audio bandwidth received', speed, 'kbit/s');
                                  bandwidthDownload = bandwidthDownload + speed;
                                  if (this.audioBandwidthQueue.length < this.samples) {
                                      var n = this.samples;
                                      while (n > 0) {
                                          this.audioBandwidthQueue.push(0);
                                          n = n - 1;
                                      }
                                  }
 
                                  this.audioBandwidthQueue.push(speed);
                              }
                              this.audioBytesReceived = bytesReceived;
                          } else if (mediaType === 'video') {
                              foundVideo = true;
                              if (this.videoBytesReceived > 0 && this.videoBytesReceived < bytesReceived) {
                                  diff = bytesReceived - this.videoBytesReceived;
                                  speed = Math.floor(diff / this.sampleInterval * 8 / 1000);
                                  //console.log('Video bandwidth received', speed, 'kbit/s');
                                  bandwidthDownload = bandwidthDownload + speed;
                                  if (this.videoBandwidthQueue.length < this.samples) {
                                      var n = this.samples;
                                      while (n > 0) {
                                          this.videoBandwidthQueue.push(0);
                                          n = n - 1;
                                      }
                                  }
                                  this.videoBandwidthQueue.push(speed)
                              }
                              this.videoBytesReceived = bytesReceived;
                          }
                      } else if (object.bytesSent) {
                          const bytesSent = Math.floor(object.bytesSent);
                          if (mediaType === 'audio') {
                              if (this.audioBytesSent > 0 && bytesSent > this.audioBytesSent) {
                                  const diff = bytesSent - this.audioBytesSent;
                                  const speed = Math.floor(diff / this.sampleInterval * 8 / 1000);
                                  bandwidthUpload = bandwidthUpload + speed;
                                  //console.log('Audio bandwidth sent', speed, 'kbit/s');
                              }
                              this.audioBytesSent = bytesSent;
                          } else if (mediaType === 'video') {
                              foundVideo = true;
                              if (this.videoBytesSent > 0 && bytesSent > this.videoBytesSent) {
                                  const diff = bytesSent - this.videoBytesSent;
                                  const speed = Math.floor(diff / this.sampleInterval * 8 / 1000);
                                  bandwidthUpload = bandwidthUpload + speed;
                                  //console.log('Video bandwidth sent', speed, 'kbit/s');
                              }
                              this.videoBytesSent = bytesSent;
                          }
 
                      } else if (object.packetsLost) {
                          if (mediaType === 'audio') {
                              audioPackets = audioPackets + Math.floor(object.packetsLost);
                              audioPacketsLost =  audioPacketsLost + Math.floor(object.packetsLost);
                          } else if (mediaType === 'video') {
                              videoPackets = videoPackets + Math.floor(object.packetsLost);
                              videoPacketsLost = videoPacketsLost + Math.floor(object.packetsLost);
                          }
                      } else if (object.packetsReceived) {
                          if (mediaType === 'audio') {
                              audioPackets = audioPackets + Math.floor(object.packetsReceived);
                          } else if (mediaType === 'video') {
                              videoPackets = videoPackets + Math.floor(object.packetsReceived);
                          }
                      } else if (object.googCurrentDelayMs) {
                          delay = object.googCurrentDelayMs;
                      }
                      //console.log(object);
                  });
 
              }});
 
          // packet loss
 
          videoPacketLoss = 0;
          if (videoPackets > 0) {
              videoPacketLoss = Math.floor(videoPacketsLost / videoPackets * 100);
              if (videoPacketLoss > 1) {
                  //console.log('Video packet loss', videoPacketLoss, '%');
              }
          }
 
          audioPacketLoss = 0;
          if (audioPackets > 0) {
              audioPacketLoss = Math.floor(audioPacketsLost / audioPackets * 100);
              if (audioPacketLoss > 3) {
                  //console.log('Audio packet loss', audioPacketLoss, '%');
              }
          }
 
          this.packetLoss = videoPacketLoss > audioPacketLoss ? videoPacketLoss : audioPacketLoss;
 
          //this.packetLoss = randomIntFromInterval(2, 10);
 
          if (this.packetLoss < 3) {
              this.packetLoss = 0;
          }
 
          if (this.packetLossQueue.length < this.samples) {
              var n = this.samples;
              while (n > 0) {
                  this.packetLossQueue.push(0);
                  n = n - 1;
              }
          }
 
          if (this.latencyQueue.length < this.samples) {
              var n = this.samples;
              while (n > 0) {
                  this.latencyQueue.push(0);
                  n = n - 1;
              }
          }
 
          this.latencyQueue.push(Math.ceil(delay));
 
          this.packetLossQueue.push(this.packetLoss);
 
          this.audioPacketLoss = audioPacketLoss;
          this.videoPacketLoss = videoPacketLoss;
 
         let info = '';
         let suffix = 'kbit/s';
 
         if (foundVideo && (bandwidthUpload > 0 || bandwidthDownload > 0)) {
             suffix = 'Mbit/s';
             bandwidthUpload = Math.ceil(bandwidthUpload / 1000 * 100) / 100;
             bandwidthDownload = Math.ceil(bandwidthDownload / 1000 * 100) / 100;
         }
 
         if (bandwidthDownload && bandwidthUpload) {
             if (bandwidthDownload > 0 && bandwidthUpload > 0) {
                 info = '⇣' + bandwidthDownload + ' ⇡' + bandwidthUpload;
             } else if (bandwidthDownload > 0) {
                 info = '⇣' + bandwidthDownload;
             } else if (bandwidthUpload > 0) {
                 info = '⇡' + this.bandwidthUpload;
             }
 
             if (info) {
                 info = info + ' ' + suffix;
             }
         }
 
 
         if (this.packetLoss > 2) {
             info = info + ' - ' + Math.ceil(this.packetLoss) + '% loss';
         }
 
         if (delay > 150) {
             info = info + ' - ' + Math.ceil(delay) + ' ms';
         }
 
         this.setState({packetLossQueue: this.packetLossQueue,
                        latencyQueue: this.latencyQueue,
                        videoBandwidthQueue: this.videoBandwidthQueue,
                        audioBandwidthQueue: this.audioBandwidthQueue,
                        info: info
                         });
          });
      };
 
     mediaPlaying(localMedia) {
         if (this.state.direction === 'incoming') {
             const media = localMedia ? localMedia : this.state.localMedia;
             this.answerCall(media);
         } else {
             this.mediaIsPlaying = true;
         }
     }
 
     answerCall(localMedia) {
         const media = localMedia ? localMedia : this.state.localMedia;
         if (this.state.call && this.state.call.state === 'incoming' && media) {
             let options = {pcConfig: {iceServers: config.iceServers}};
             options.localStream = media;
             if (!this.answering) {
                 this.answering = true;
                 const connectionState = this.state.connection.state ? this.state.connection.state : null;
                 utils.timestampedLog('Call: answering call', this.state.call.id, 'in connection state', connectionState);
                 try {
                     this.state.call.answer(options);
                     utils.timestampedLog('Call: answered');
                 } catch (error) {
                     utils.timestampedLog('Call: failed to answer', error);
                     this.hangupCall('answer_failed')
                 }
             } else {
                 utils.timestampedLog('Call: answering call in progress...');
             }
         } else {
             if (!this.state.call) {
                 utils.timestampedLog('Call: no Sylkrtc call present');
                 this.hangupCall('answer_failed');
             }
 
             if (this.state.call && this.state.call.state !== 'incoming') {
                 utils.timestampedLog('Call: state is not incoming');
             }
 
             if (!media) {
                 utils.timestampedLog('Call: waiting for local media');
             }
         }
     }
 
     lookupContact() {
         let photo = null;
         let remoteUri = this.state.remoteUri || '';
         let remoteDisplayName = this.state.remoteDisplayName || '';
 
         if (!remoteUri) {
             return;
         }
 
         if (remoteUri.indexOf('3333@') > -1) {
             remoteDisplayName = 'Video Test';
         } else if (remoteUri.indexOf('4444@') > -1) {
             remoteDisplayName = 'Echo Test';
         } else if (this.props.myContacts.hasOwnProperty(remoteUri) && this.props.myContacts[remoteUri].name) {
             remoteDisplayName = this.props.myContacts[remoteUri].name;
         } else if (this.props.contacts) {
             let username = remoteUri.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', remoteUri);
             }
 
             if (contact_obj) {
                 remoteDisplayName = contact_obj.displayName;
                 photo = contact_obj.photo;
                 if (isPhoneNumber) {
                     remoteUri = username;
                 }
             } else {
                 if (isPhoneNumber) {
                     remoteUri = username;
                     remoteDisplayName = username;
                 }
             }
         }
 
         this.setState({remoteDisplayName: remoteDisplayName,
                        remoteUri: remoteUri,
                        photo: photo
                        });
     }
 
     callStateChanged(oldState, newState, data) {
         //console.log('Call: callStateChanged', oldState, '->', newState);
         if (this.ended) {
             return;
         }
 
         let remoteHasNoVideoTracks;
         let remoteIsRecvOnly;
         let remoteIsInactive;
         let remoteStreams;
 
         this.answering = false;
 
         if (newState === 'established') {
             this.setState({reconnectingCall: false});
             const currentCall = this.state.call;
 
             if (currentCall) {
                 remoteStreams = currentCall.getRemoteStreams();
                 if (remoteStreams) {
                     if (remoteStreams.length > 0) {
                         const remotestream = remoteStreams[0];
                         remoteHasNoVideoTracks = remotestream.getVideoTracks().length === 0;
                         remoteIsRecvOnly = currentCall.remoteMediaDirections.video[0] === 'recvonly';
                         remoteIsInactive = currentCall.remoteMediaDirections.video[0] === 'inactive';
                     }
                 }
             }
 
             if (remoteStreams && (remoteHasNoVideoTracks || remoteIsRecvOnly || remoteIsInactive) && !this.state.audioOnly) {
                 //console.log('Media type changed to audio');
                 // Stop local video
                 if (this.state.localMedia.getVideoTracks().length !== 0) {
                     currentCall.getLocalStreams()[0].getVideoTracks()[0].stop();
                 }
                 this.setState({audioOnly: true});
             } else {
                 this.forceUpdate();
             }
 
         } else if (newState === 'accepted') {
             // Switch if we have audioOnly and local videotracks. This means
             // the call object switched and we are transitioning to an
             // incoming call.
             if (this.state.audioOnly &&  this.state.localMedia && this.state.localMedia.getVideoTracks().length !== 0) {
                 //console.log('Media type changed to video on accepted');
                 this.setState({audioOnly: false});
             }
         }
 
         this.forceUpdate();
     }
 
     connectionStateChanged(oldState, newState) {
         switch (newState) {
             case 'closed':
                 break;
             case 'ready':
                 break;
             case 'disconnected':
                 if (oldState === 'ready' && this.state.direction === 'outgoing') {
                     utils.timestampedLog('Call: reconnecting the call...');
                     this.waitInterval = this.defaultWaitInterval;
                 }
                 break;
             default:
                 break;
         }
     }
 
     findObjectByKey(array, key, value) {
         for (var i = 0; i < array.length; i++) {
             if (array[i][key] === value) {
                 return array[i];
             }
         }
         return null;
     }
 
     canConnect() {
         if (!this.state.connection) {
             console.log('Call: no connection yet');
             return false;
         }
 
         if (this.state.connection.state !== 'ready') {
             console.log('Call: connection is not ready');
             return false;
         }
 
         if (this.props.registrationState !== 'registered') {
             console.log('Call: account not ready yet');
             return false;
         }
 
         if (!this.mediaIsPlaying) {
             if (this.waitCounter > 0) {
                 console.log('Call: media is not yet playing');
             }
             return false;
         }
 
         return true;
     }
 
     async startCallWhenReady(callUUID) {
         this.waitCounter = 0;
 
         let diff = 0;
 
         while (this.waitCounter < this.waitInterval) {
             if (this.waitCounter === 1) {
                 utils.timestampedLog('Call: waiting for establishing call', this.waitInterval, 'seconds');
             }
 
             if (this.userHangup) {
                 this.hangupCall('user_cancelled');
                 return;
             }
 
             if (this.ended) {
                 return;
             }
 
             if (this.waitCounter >= this.waitInterval - 1) {
                 this.hangupCall('timeout');
             }
 
             if (!this.canConnect()) {
                 //utils.timestampedLog('Call: waiting for connection', this.waitInterval - this.waitCounter, 'seconds');
                 if (this.state.call && this.state.call.id === callUUID && this.state.call.state !== 'terminated') {
                     return;
                 }
 
                 if (this.waitCounter > 0) {
                     console.log('Wait', 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() {
         utils.timestampedLog('Call: starting call', this.state.callUUID);
 
         if (this.state.localMedia === null)  {
             console.log('Call: cannot create new call without local media');
             return;
         }
 
         let options = {pcConfig: {iceServers: config.iceServers}, id: this.state.callUUID};
         options.localStream = this.state.localMedia;
 
         let call = this.props.account.call(this.state.targetUri, options);
         if (call) {
             call.on('stateChanged', this.callStateChanged);
         }
     }
 
     hangupCall(reason) {
         let callUUID = this.state.call ? this.state.call.id : this.state.callUUID;
         this.waitInterval = this.defaultWaitInterval;
 
         if (this.state.call) {
             this.state.call.removeListener('stateChanged', this.callStateChanged);
         }
 
         if (this.props.connection) {
             this.props.connection.removeListener('stateChanged', this.connectionStateChanged);
         }
 
         if (this.waitCounter > 0) {
             this.waitCounter = this.waitInterval;
         }
 
         this.props.hangupCall(callUUID, reason);
     }
 
     render() {
 
         let box = null;
         if (this.state.localMedia !== null) {
             if (this.state.audioOnly) {
 
                 box = (
                     <AudioCallBox
                         remoteUri = {this.state.remoteUri}
                         remoteDisplayName = {this.state.remoteDisplayName}
                         photo = {this.state.photo}
                         hangupCall = {this.hangupCall}
                         call = {this.state.call}
                         accountId={this.state.accountId}
                         connection = {this.props.connection}
                         mediaPlaying = {this.mediaPlaying}
                         escalateToConference = {this.props.escalateToConference}
                         callKeepSendDtmf = {this.props.callKeepSendDtmf}
                         toggleMute = {this.props.toggleMute}
                         speakerPhoneEnabled = {this.props.speakerPhoneEnabled}
                         toggleSpeakerPhone = {this.props.toggleSpeakerPhone}
                         orientation = {this.props.orientation}
                         isTablet = {this.props.isTablet}
                         reconnectingCall = {this.state.reconnectingCall}
                         muted = {this.props.muted}
                         packetLossQueue = {this.state.packetLossQueue}
                         videoBandwidthQueue = {this.state.videoBandwidthQueue}
                         audioBandwidthQueue = {this.state.audioBandwidthQueue}
                         latencyQueue = {this.state.latencyQueue}
                         info = {this.state.info}
                         declineReason = {this.state.declineReason}
                         showLogs = {this.props.showLogs}
                         goBackFunc = {this.props.goBackFunc}
                         callState = {this.props.callState}
                         messages = {this.state.messages}
                         deleteMessages = {this.props.deleteMessages}
                         sendMessage = {this.props.sendMessage}
                         expireMessage = {this.props.expireMessage}
                         reSendMessage = {this.props.reSendMessage}
                         deleteMessage = {this.props.deleteMessage}
                         getMessages = {this.props.getMessages}
                         pinMessage = {this.props.pinMessage}
                         unpinMessage = {this.props.unpinMessage}
-                        selectContact = {this.props.selectContact}
+                        selectedContact = {this.state.selectedContact}
                     />
                 );
             } else {
                 if (this.state.call !== null && (this.state.call.state === 'established' || (this.state.call.state === 'terminated' && this.state.reconnectingCall))) {
 
                     box = (
                         <VideoBox
                             remoteUri = {this.state.remoteUri}
                             remoteDisplayName = {this.state.remoteDisplayName}
                             photo = {this.state.photo}
                             hangupCall = {this.hangupCall}
                             call = {this.state.call}
                             accountId={this.state.accountId}
                             connection = {this.props.connection}
                             localMedia = {this.state.localMedia}
                             shareScreen = {this.props.shareScreen}
                             escalateToConference = {this.props.escalateToConference}
                             generatedVideoTrack = {this.props.generatedVideoTrack}
                             callKeepSendDtmf = {this.props.callKeepSendDtmf}
                             toggleMute = {this.props.toggleMute}
                             speakerPhoneEnabled = {this.props.speakerPhoneEnabled}
                             toggleSpeakerPhone = {this.props.toggleSpeakerPhone}
                             intercomDtmfTone = {this.props.intercomDtmfTone}
                             orientation = {this.props.orientation}
                             isTablet = {this.props.isTablet}
                             reconnectingCall = {this.state.reconnectingCall}
                             muted = {this.props.muted}
                             info = {this.state.info}
                             showLogs = {this.props.showLogs}
                             goBackFunc = {this.props.goBackFunc}
                             callState = {this.props.callState}
                             messages = {this.state.messages}
                             deleteMessages = {this.props.deleteMessages}
                             sendMessage = {this.props.sendMessage}
                             expireMessage = {this.props.expireMessage}
                             reSendMessage = {this.props.reSendMessage}
                             deleteMessage = {this.props.deleteMessage}
                             getMessages = {this.props.getMessages}
                             pinMessage = {this.props.pinMessage}
                             unpinMessage = {this.props.unpinMessage}
-                            selectContact = {this.props.selectContact}
+                            selectedContact = {this.props.selectedContact}
                         />
                     );
                 } else {
                     if (this.state.call && this.state.call.state === 'terminated' && this.state.reconnectingCall) {
                         //console.log('Skip render local media because we will reconnect');
                     } else {
                         box = (
                             <LocalMedia
                                 call = {this.state.call}
                                 remoteUri = {this.state.remoteUri}
                                 remoteDisplayName = {this.state.remoteDisplayName}
                                 photo = {this.state.photo}
                                 localMedia = {this.state.localMedia}
                                 mediaPlaying = {this.mediaPlaying}
                                 hangupCall = {this.hangupCall}
                                 generatedVideoTrack = {this.props.generatedVideoTrack}
                                 accountId = {this.state.accountId}
                                 connection = {this.props.connection}
                                 orientation = {this.props.orientation}
                                 isTablet = {this.props.isTablet}
                                 media = 'video'
                                 declineReason = {this.state.declineReason}
                                 showLogs = {this.props.showLogs}
                                 goBackFunc = {this.props.goBackFunc}
                             />
                         );
                     }
                 }
             }
         } else {
             box = (
                 <AudioCallBox
                     remoteUri = {this.state.remoteUri}
                     remoteDisplayName = {this.state.remoteDisplayName}
                     photo = {this.state.photo}
                     hangupCall = {this.hangupCall}
                     call = {this.state.call}
                     accountId = {this.state.accountId}
                     connection = {this.props.connection}
                     mediaPlaying = {this.mediaPlaying}
                     escalateToConference = {this.props.escalateToConference}
                     callKeepSendDtmf = {this.props.callKeepSendDtmf}
                     toggleMute = {this.props.toggleMute}
                     speakerPhoneEnabled = {this.props.speakerPhoneEnabled}
                     toggleSpeakerPhone = {this.props.toggleSpeakerPhone}
                     orientation = {this.props.orientation}
                     isTablet = {this.props.isTablet}
                     reconnectingCall = {this.state.reconnectingCall}
                     muted = {this.props.muted}
                     info = {this.state.info}
                     declineReason = {this.state.declineReason}
                     showLogs = {this.props.showLogs}
                     goBackFunc = {this.props.goBackFunc}
+                    selectedContact = {this.state.selectedContact}
                 />
             );
 
         }
         return box;
     }
 }
 
 Call.propTypes = {
     targetUri               : PropTypes.string,
     account                 : PropTypes.object,
     hangupCall              : PropTypes.func,
     connection              : PropTypes.object,
     registrationState       : PropTypes.string,
     call                    : PropTypes.object,
     localMedia              : PropTypes.object,
     shareScreen             : PropTypes.func,
     escalateToConference    : PropTypes.func,
     generatedVideoTrack     : PropTypes.bool,
     callKeepSendDtmf        : PropTypes.func,
     toggleMute              : PropTypes.func,
     toggleSpeakerPhone      : PropTypes.func,
     speakerPhoneEnabled     : PropTypes.bool,
     callUUID                : PropTypes.string,
     contacts                : PropTypes.array,
     intercomDtmfTone        : PropTypes.string,
     orientation             : PropTypes.string,
     isTablet                : PropTypes.bool,
     reconnectingCall        : PropTypes.bool,
     muted                   : PropTypes.bool,
     myContacts              : PropTypes.object,
     declineReason           : PropTypes.string,
     showLogs                : PropTypes.func,
     goBackFunc              : PropTypes.func,
     callState               : PropTypes.object,
     messages                : PropTypes.object,
     sendMessage             : PropTypes.func,
     reSendMessage           : PropTypes.func,
     confirmRead             : PropTypes.func,
     deleteMessage           : PropTypes.func,
     expireMessage           : PropTypes.func,
     getMessages             : PropTypes.func,
     pinMessage              : PropTypes.func,
     unpinMessage            : PropTypes.func,
     selectedContact         : PropTypes.object
 };
 
 
 export default Call;
diff --git a/app/components/HistoryCard.js b/app/components/HistoryCard.js
index b5b2030..087e4d4 100644
--- a/app/components/HistoryCard.js
+++ b/app/components/HistoryCard.js
@@ -1,442 +1,443 @@
 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, Menu} from 'react-native-paper';
 import Icon from  'react-native-vector-icons/MaterialCommunityIcons';
 import uuid from 'react-native-uuid';
 import styles from '../assets/styles/blink/_HistoryCard.scss';
 import UserIcon from './UserIcon';
 import { GiftedChat } from 'react-native-gifted-chat'
 
 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,
             organization: this.props.contact.organization,
             filter: this.props.filter,
             uri: this.props.contact.remoteParty,
             duration: this.props.contact.duration,
             direction: this.props.contact.direction,
             invitedParties: this.props.invitedParties,
             participants: this.props.contact.participants,
             conference: this.props.contact.conference,
             selected: this.props.contact.selected,
             type: this.props.contact.type,
             photo: this.props.contact.photo,
             label: this.props.contact.label,
             orientation: this.props.orientation,
             lastMessage: this.props.contact.lastMessage,
             isTablet: this.props.isTablet,
             isLandscape: this.props.isLandscape,
             favorite: (this.props.contact.tags.indexOf('favorite') > -1)? true : false,
             blocked: (this.props.contact.tags.indexOf('blocked') > -1)? true : false,
             confirmRemoveFavorite: false,
             confirmPurgeChat: false,
             messages: this.props.messages,
             unread: this.props.unread,
             chat: this.props.chat,
             pinned: this.props.pinned,
             publicKey: this.props.contact.publicKey,
             publicKeyHash: this.props.contact.publicKeyHash,
             menuVisible: false
         }
 
         this.menuRef = React.createRef();
     }
 
     UNSAFE_componentWillReceiveProps(nextProps) {
         this.setState({
             id: nextProps.contact.id,
             isLandscape: nextProps.isLandscape,
             direction: nextProps.contact.direction,
             duration: nextProps.contact.duration,
             contact: nextProps.contact,
             displayName: nextProps.contact.displayName,
             organization: nextProps.contact.organization,
             uri: nextProps.contact.remoteParty,
             duration: nextProps.contact.duration,
             invitedParties: nextProps.invitedParties,
             participants: nextProps.contact.participants,
             conference: nextProps.contact.conference,
             type: nextProps.contact.type,
             selected: nextProps.contact.selected,
             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,
             chat: nextProps.chat,
             pinned: nextProps.pinned,
             messages: nextProps.messages,
             lastMessage: nextProps.contact.lastMessage,
             unread: nextProps.chat ? "0": nextProps.unread || "0"
         });
     }
 
     shouldComponentUpdate(nextProps) {
         //https://medium.com/sanjagh/how-to-optimize-your-react-native-flatlist-946490c8c49b
         return true;
     }
 
     handleParticipant() {
     }
 
     findObjectByKey(array, key, value) {
         for (var i = 0; i < array.length; i++) {
             if (array[i][key] === value) {
                 return array[i];
             }
         }
         return null;
     }
 
     toggleBlocked() {
         this.props.toggleBlocked(this.state.uri);
     }
 
     setBlockedDomain() {
         let newBlockedState = this.props.toggleBlocked('@' + this.state.uri.split('@')[1]);
         this.setState({blocked: newBlockedState});
     }
 
     undo() {
         this.setState({confirmRemoveFavorite: false,
                        confirmDeleteChat: false,
                        action: null});
     }
 
     onSendMessage(messages) {
         messages.forEach((message) => {
             // TODO send messages using account API
         });
         this.setState({messages: GiftedChat.append(this.state.messages, messages)});
     }
 
     setTargetUri(uri, contact) {
         this.props.setTargetUri(uri, this.state.contact);
     }
 
     renderChatComposer () {
         return null;
     }
 
     render () {
         let showActions = this.props.contact.showActions &&
                           this.props.contact.tags.indexOf('test') === -1 &&
                           this.props.contact.tags.toString() !== "syntetic";
 
 
         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;
         if (this.state.organization) {
             //displayName = displayName + ' (' + this.state.organization + ')';
         }
 
         let showBlockButton = !this.state.conference && !this.state.chat;
         let showBlockDomainButton = false;
         let blockTextbutton = 'Block';
         let blockDomainTextbutton = 'Block domain';
 
         let participantsData = [];
 
         if (this.state.favorite) {
             if (!this.state.blocked) {
                 showBlockButton = false;
             }
         }
 
         if (username.indexOf('3333@') > -1) {
             showBlockButton = false;
         }
 
         if (username.indexOf('4444@') > -1) {
             showBlockButton = false;
         }
 
         if (displayName === 'Myself') {
             showBlockButton = false;
         }
 
         if (this.state.blocked) {
             blockTextbutton = 'Unblock';
         }
 
         let color = {};
 
         let title = displayName || username;
         let subtitle = uri;
         let description;
 
         if (this.props.contact.startTime && this.props.contact.startTime.indexOf("1970-01-01") === -1) {
             description = moment(this.props.contact.startTime).format('MMM D HH:mm');
         }
 
         if (displayName === uri) {
             title = toTitleCase(username);
         }
 
        if (isPhoneNumber && isIp(domain)) {
            title = 'Tel ' + username;
            subtitle = 'From @' + domain;
            showBlockDomainButton = true;
        }
 
         if (utils.isAnonymous(uri)) {
             //uri = 'anonymous@anonymous.invalid';
-            displayName = 'Anonymous';
             if (uri.indexOf('@guest.') > -1) {
                 subtitle = 'From the Web';
+            } else {
+                displayName = 'Anonymous';
             }
             showBlockDomainButton = true;
             if (!this.state.blocked) {
                 showBlockButton = false;
             }
-            blockDomainTextbutton = 'Block Web calls';
+            blockDomainTextbutton = 'Block Web callers';
         }
 
         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';
             }
         }
 
         let cardContainerClass = styles.portraitContainer;
 
         if (this.state.isTablet) {
             cardContainerClass = (this.state.orientation === 'landscape') ? styles.cardLandscapeTabletContainer : styles.cardPortraitTabletContainer;
         } else {
             cardContainerClass = (this.state.orientation === 'landscape') ? styles.cardLandscapeContainer : styles.cardPortraitContainer;
         }
 
         let cardHeight = 85;
 
         let duration;
 
         if (this.props.contact.tags.indexOf('history') > -1) {
             duration = moment.duration(this.state.duration, 'seconds').format('HH:mm:ss', {trim: false});
 
             if (this.state.direction === 'received' && this.state.duration === 0) {
                 duration = 'missed';
             } else if (this.state.direction === 'placed' && this.state.duration === 0) {
                 duration = 'cancelled';
             }
         }
 
         if (this.state.conference) {
             let participants = this.state.participants;
             if (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;
                     if (participant === dn && this.props.myDisplayNames && this.props.myDisplayNames.hasOwnProperty(participant)) {
                         dn = this.props.myDisplayNames[participant].name;
                     }
                     _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' : toTitleCase(username);
             } else if (participantsData.length > 1 || participantsData.length <= 4 ) {
                 let j = 0;
                 if (username.length < 10) {
                     title = toTitleCase(username);
                 } else {
                     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 ;
             }
         }
 
         if (duration && duration !== "00:00:00") {
             description = description + ' (' + duration + ')';
         }
 
         const container = this.state.isLandscape ? styles.containerLandscape : styles.containerPortrait;
         const chatContainer = this.state.isLandscape ? styles.chatLandscapeContainer : styles.chatPortraitContainer;
 
         if (showActions && participantsData.length > 0) {
             cardHeight = cardHeight + 20 * participantsData.length + 10;
         }
 
         let showSubtitle = (showActions || this.state.isTablet || !description);
         let label = this.state.label ? (" (" +this.state.label + ")" ) : '';
         if (this.state.lastMessage) {
             subtitle = this.state.lastMessage;
             //description = description + ': ' + this.state.lastMessage;
         } else {
             subtitle = subtitle + label;
         }
 
         return (
             <Fragment>
                 <Card style={[cardContainerClass, {height: cardHeight}]}
                     onPress={() => {this.setTargetUri(uri, this.props.contact)}}
                     >
 
                 <View style={styles.rowContent}>
                     <Card.Content style={styles.cardContent}>
                         <View style={styles.avatarContent}>
                             <UserIcon style={styles.userIcon} identity={this.state} unread={this.state.unread}/>
                         </View>
 
                         <View style={styles.mainContent}>
                             <Title noWrap style={styles.title}>{title}</Title>
                             <Subheading style={styles.subtitle}>{subtitle}</Subheading>
 
                             <Caption style={styles.description}>
                                 {this.state.direction ?
                                 <Icon name={this.state.direction == 'received' ? 'arrow-bottom-left' : 'arrow-top-right'}/>
                                 : null}
                                 {description}
 
                             </Caption>
 
                             {participantsData && participantsData.length && showActions ?
 
                             <View style={styles.participants}>
                                 <SafeAreaView style={styles.participant}>
                                   <FlatList
                                     horizontal={false}
                                     data={participantsData}
                                     renderItem={renderItem}
                                     listKey={item => item.id}
                                     key={item => item.id}
                                   />
                                 </SafeAreaView>
                             </View>
                             : null}
                         </View>
                     </Card.Content>
                     <View style={styles.rightContent}>
                         { this.state.selected ?
                         <Icon name='check-circle' size={30} />
                         :
                         null
                         }
                     </View>
                 </View>
 
                     {showActions && false ?
                             <View style={styles.buttonContainer}>
                             <Card.Actions>
                                {showBlockButton? <Button mode={buttonMode} style={styles.button} onPress={() => {this.toggleBlocked()}}>{blockTextbutton}</Button>: null}
                                {showBlockDomainButton? <Button mode={buttonMode} style={styles.button} onPress={() => {this.setBlockedDomain()}}>{blockDomainTextbutton}</Button>: null}
                             </Card.Actions>
                             </View>
                         : null}
                 </Card>
 
             </Fragment>
         );
     }
 }
 
 HistoryCard.propTypes = {
     id             : PropTypes.string,
     contact        : PropTypes.object,
     setTargetUri   : PropTypes.func,
     chat           : PropTypes.bool,
     orientation    : PropTypes.string,
     isTablet       : PropTypes.bool,
     isLandscape    : PropTypes.bool,
     contacts       : PropTypes.array,
     defaultDomain  : PropTypes.string,
     accountId      : PropTypes.string,
     favoriteUris   : PropTypes.array,
     myDisplayNames : PropTypes.object,
     messages       : PropTypes.array,
     pinned         : PropTypes.bool,
     unread         : PropTypes.string,
     toggleBlocked  : PropTypes.func,
     sendPublicKey  : PropTypes.func
 };
 
 
 export default HistoryCard;
diff --git a/app/components/ReadyBox.js b/app/components/ReadyBox.js
index f5bf584..cd83732 100644
--- a/app/components/ReadyBox.js
+++ b/app/components/ReadyBox.js
@@ -1,560 +1,560 @@
 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: this.props.selectedContact,
             showConferenceModal: false,
             sticky: false,
             favoriteUris: this.props.favoriteUris,
             blockedUris: this.props.blockedUris,
             historyFilter: null,
             missedCalls: false,
             isLandscape: this.props.isLandscape,
             participants: null,
             myInvitedParties: this.props.myInvitedParties,
             messages: this.props.messages,
             myDisplayName: this.props.myDisplayName,
-            chat: this.props.selectedContact && this.props.call,
+            chat: (this.props.selectedContact !== null) && (this.props.call !== null),
             call: this.props.call,
             inviteContacts: this.props.inviteContacts,
             selectedContacts: this.props.selectedContacts,
             pinned: this.props.pinned
         };
         this.ended = false;
     }
 
     UNSAFE_componentWillReceiveProps(nextProps) {
         if (this.ended) {
             return;
         }
 
         if (this.state.selectedContact && nextProps.selectedContact === null) {
             this.setState({targetUri: '',
                            chat: false});
         }
 
         if (this.state.selectedContact !== nextProps.selectedContact && nextProps.selectedContact) {
             this.setState({chat: !this.chatDisabledForUri(nextProps.selectedContact.remoteParty)});
         }
 
         this.setState({myInvitedParties: nextProps.myInvitedParties,
                         messages: nextProps.messages,
                         myDisplayName: nextProps.myDisplayName,
                         call: nextProps.call,
                         inviteContacts: nextProps.inviteContacts,
                         selectedContacts: nextProps.selectedContacts,
                         selectedContact: nextProps.selectedContact,
                         pinned: nextProps.pinned,
                         isLandscape: nextProps.isLandscape});
     }
 
     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('');
     }
 
     chatDisabledForUri(uri) {
         if (uri.indexOf('@videoconference') > -1) {
             return true;
         }
         if (uri.indexOf('@guest') > -1) {
             return true;
         }
 
         if (uri.indexOf('3333@') > -1) {
             return true;
         }
 
         if (uri.indexOf('4444@') > -1) {
             return true;
         }
 
         return false;
     }
 
     get showSearchBar() {
         if (this.props.isTablet || this.props.isLandscape) {
             return true;
         }
 
         if (this.state.call) {
             return false;
         }
 
         return (this.state.selectedContact ===  null);
     }
 
     get showButtonsBar() {
         if (this.props.isTablet) {
             return true;
         }
 
         if (this.state.call) {
             return true;
         }
 
         if (this.state.chat && this.state.selectedContact) {
             return false;
         }
 
         return true;
     }
 
     handleTargetChange(value, contact) {
         if (this.state.inviteContacts && contact) {
              const uri = contact.remoteParty;
              this.props.updateSelection(uri);
              return;
         }
 
         if (this.state.selectedContact === contact) {
             if (this.state.chat) {
                 this.setState({chat: false});
             }
             return;
         } else {
             this.setState({chat: false});
         }
 
         let new_value = value;
 
         if (contact) {
             if (this.state.targetUri === contact.uri) {
                 new_value = '';
             }
         } else {
             contact = null;
         }
 
         if (this.state.targetUri === value) {
             new_value = '';
         }
 
         if (new_value === '') {
             contact = null;
         }
 
         new_value = new_value.replace(' ','');
 
         this.props.selectContact(contact);
         this.setState({targetUri: new_value});
     }
 
     handleTargetSelect() {
         if (this.props.connection === null) {
             this.props._notificationCenter.postSystemNotification("Server unreachable");
             return;
         }
 
         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;
     }
 
     handleChat(event) {
         event.preventDefault();
         if (!this.state.chat && !this.state.selectedContact && this.state.targetUri.toLowerCase().indexOf('@') === -1) {
            this.setState({targetUri: this.getTargetUri(this.state.targetUri)});
         }
 
         let uri = this.state.targetUri.toLowerCase();
         this.setState({chat: !this.state.chat});
     }
 
     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;
     }
 
     get chatButtonDisabled() {
         let uri = this.state.targetUri.trim();
         if (this.chatDisabledForUri(uri)) {
             return true;
         }
 
         return this.callButtonDisabled;
     }
 
     get callButtonDisabled() {
         let uri = this.state.targetUri.trim();
         if (uri.indexOf(' ') > -1) {
             return true;
         }
         if (uri.length === 0 ||
             uri.indexOf('@videoconference') > -1 ||
             uri.indexOf('@guest') > -1
             ) {
             return true;
             }
         return false;
     }
 
     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 historyContainer = this.props.orientation === 'landscape' ? styles.historyLandscapeContainer : styles.historyPortraitContainer;
         const buttonGroupClass = this.props.orientation === 'landscape' ? styles.landscapeButtonGroup : styles.buttonGroup;
         const borderClass = this.state.chat ? null : styles.historyBorder;
         let callType = 'Back to call';
         if (this.state.call && this.state.call.hasOwnProperty('_participants')) {
             callType = this.state.selectedContacts.length > 0 ? 'Invite people' : 'Back to conference';
         }
 
         return (
             <Fragment>
                 <View style={styles.container}>
                     <View >
                         {this.showButtonsBar ?
                         <View style={uriGroupClass}>
                             {this.showSearchBar ?
                             <View style={uriClass}>
                                 <URIInput
                                     defaultValue={this.state.targetUri}
                                     onChange={this.handleTargetChange}
                                     onSelect={this.handleTargetSelect}
                                     autoFocus={false}
                                 />
                             </View>
                             : null}
 
-                            {!this.state.call ?
+                            {( this.state.call && this.state.call.state == 'established') ?
+                            <View style={buttonGroupClass}>
+
+                                <Button
+                                    mode="contained"
+                                    style={styles.backButton}
+                                    onPress={this.props.goBackFunc}
+                                    accessibilityLabel={callType}
+                                    >{callType}
+                                </Button>
+                            </View>
+                                :
                             <View style={buttonGroupClass}>
                                 <IconButton
                                     style={buttonClass}
                                     size={32}
                                     disabled={this.chatButtonDisabled}
                                     onPress={this.handleChat}
                                     icon="chat"
                                 />
                                 <IconButton
                                     style={buttonClass}
                                     size={32}
                                     disabled={this.callButtonDisabled}
                                     onPress={this.handleAudioCall}
                                     icon="phone"
                                 />
                                 <IconButton
                                     style={buttonClass}
                                     size={32}
                                     disabled={this.callButtonDisabled}
                                     onPress={this.handleVideoCall}
                                     icon="video"
                                 />
                                 <IconButton
                                     style={styles.conferenceButton}
                                     disabled={!this.conferenceButtonActive()}
                                     size={32}
                                     onPress={this.showConferenceModal}
                                     icon="account-group"
                                 />
-                            </View>
-                                :
-                            <View style={buttonGroupClass}>
-
-                                <Button
-                                    mode="contained"
-                                    style={styles.backButton}
-                                    onPress={this.props.goBackFunc}
-                                    accessibilityLabel={callType}
-                                    >{callType}
-                                </Button>
                             </View>
                                 }
 
                         </View>
                                 : null}
                     </View>
                     <View style={[historyContainer, borderClass]}>
                         <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}
                             chat={this.state.chat}
                             isLandscape={this.state.isLandscape}
                             account={this.props.account}
                             password={this.props.password}
                             config={this.props.config}
                             refreshHistory={this.props.refreshHistory}
                             refreshFavorites={this.props.refreshFavorites}
                             localHistory={this.props.localHistory}
                             cacheHistory={this.props.cacheHistory}
                             serverHistory={this.props.serverHistory}
                             myDisplayName={this.state.myDisplayName}
                             myPhoneNumber={this.props.myPhoneNumber}
                             deleteHistoryEntry={this.props.deleteHistoryEntry}
                             saveInvitedParties={this.props.saveInvitedParties}
                             myInvitedParties = {this.state.myInvitedParties}
                             favoriteUris={this.props.favoriteUris}
                             blockedUris={this.props.blockedUris}
                             filter={this.state.historyFilter}
                             defaultDomain={this.props.defaultDomain}
                             saveContact={this.props.saveContact}
                             myContacts = {this.props.myContacts}
                             messages = {this.state.messages}
                             sendMessage = {this.props.sendMessage}
                             reSendMessage = {this.props.reSendMessage}
                             deleteMessages = {this.props.deleteMessages}
                             expireMessage = {this.props.expireMessage}
                             deleteMessage = {this.props.deleteMessage}
                             getMessages = {this.props.getMessages}
                             pinMessage = {this.props.pinMessage}
                             unpinMessage = {this.props.unpinMessage}
                             confirmRead = {this.props.confirmRead}
                             sendPublicKey = {this.props.sendPublicKey}
                             inviteContacts = {this.state.inviteContacts}
                             selectedContacts = {this.state.selectedContacts}
                             toggleFavorite={this.props.toggleFavorite}
                             toggleBlocked={this.props.toggleBlocked}
                             togglePinned = {this.props.togglePinned}
                             pinned = {this.state.pinned}
                         />
                     </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')) &&
                       !this.state.chat) ?
                     <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}
                     lookupContacts={this.props.lookupContacts}
                 />
             </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,
     isLandscape     : PropTypes.bool,
     refreshHistory  : PropTypes.bool,
     refreshFavorites: PropTypes.bool,
     cacheHistory    : PropTypes.func,
     serverHistory   : PropTypes.array,
     localHistory    : PropTypes.array,
     myDisplayName   : PropTypes.string,
     myPhoneNumber   : PropTypes.string,
     deleteHistoryEntry: PropTypes.func,
     toggleFavorite  : PropTypes.func,
     myInvitedParties: PropTypes.object,
     toggleBlocked   : PropTypes.func,
     favoriteUris    : PropTypes.array,
     blockedUris     : PropTypes.array,
     defaultDomain   : PropTypes.string,
     saveContact     : PropTypes.func,
     selectContact   : PropTypes.func,
     lookupContacts  : PropTypes.func,
     call            : PropTypes.object,
     goBackFunc      : PropTypes.func,
     messages        : PropTypes.object,
     sendMessage     : PropTypes.func,
     reSendMessage   : PropTypes.func,
     confirmRead     : PropTypes.func,
     deleteMessage   : PropTypes.func,
     expireMessage   : PropTypes.func,
     getMessages     : PropTypes.func,
     deleteMessages  : PropTypes.func,
     pinMessage      : PropTypes.func,
     unpinMessage    : PropTypes.func,
     sendPublicKey   : PropTypes.func,
     inviteContacts  : PropTypes.bool,
     selectedContacts: PropTypes.array,
     updateSelection : PropTypes.func
 };
 
 
 export default ReadyBox;