diff --git a/app/CallManager.js b/app/CallManager.js index 408e237..abfa946 100644 --- a/app/CallManager.js +++ b/app/CallManager.js @@ -1,462 +1,470 @@ 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] } }; export default class CallManager extends events.EventEmitter { - constructor(RNCallKeep, acceptFunc, rejectFunc, hangupFunc, timeoutFunc, conferenceCallFunc, startCallFromCallKeeper) { + constructor(RNCallKeep, acceptFunc, rejectFunc, hangupFunc, timeoutFunc, conferenceCallFunc, startCallFromCallKeeper, muteFunc) { //logger.debug('constructor()'); super(); this.setMaxListeners(Infinity); this._RNCallKeep = RNCallKeep; this._calls = new Map(); this._conferences = new Map(); this._rejectedCalls = new Map(); this._acceptedCalls = new Map(); this._alertedCalls = new Map(); this.webSocketActions = new Map(); this._timeouts = new Map(); this.sylkAcceptCall = acceptFunc; this.sylkRejectCall = rejectFunc; this.sylkHangupCall = hangupFunc; this.timeoutCall = timeoutFunc; + this.toggleMute = muteFunc; this.conferenceCall = conferenceCallFunc; 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.bind(this)); 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 count() { return this._calls.size; } get waitingCount() { return this._timeouts.size; } get callUUIDS() { return Array.from( this._calls.keys() ); } get calls() { return [...this._calls.values()]; } get activeCall() { for (let call of this.calls) { if (call.active) { return call; } } } setAvailable(available) { this.callKeep.setAvailable(available); } backToForeground() { //utils.timestampedLog('Callkeep: bring app to the foreground'); this.callKeep.backToForeground(); } - setMutedCall(callUUID, mute) { - utils.timestampedLog('Callkeep: set call', callUUID, 'muted =', mute); - this.callKeep.setMutedCall(callUUID, mute); - } - startCall(callUUID, targetUri, hasVideo) { utils.timestampedLog('Callkeep: start outgoing call', callUUID); if (Platform.OS === 'ios') { this.callKeep.startCall(callUUID, targetUri, targetUri, 'email', hasVideo); } else if (Platform.OS === 'android') { this.callKeep.startCall(callUUID, targetUri, targetUri); } this.backToForeground(); } 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) { utils.timestampedLog('Callkeep: set call active', callUUID); this.callKeep.setCurrentCallActive(callUUID); this.backToForeground(); } endCalls() { utils.timestampedLog('Callkeep: end all calls'); this.callKeep.endAllCalls(); } endCall(callUUID, reason) { utils.timestampedLog('Callkeep: end call', callUUID, 'with reason', reason); if (reason) { this.callKeep.reportEndCallWithUUID(callUUID, reason); } else { this.callKeep.endCall(callUUID); } this._calls.delete(callUUID); } _rnActiveAudioSession() { utils.timestampedLog('Callkeep: activated audio call'); } _rnDeactiveAudioSession() { utils.timestampedLog('Callkeep: deactivated audio call'); } _rnAccept(data) { let callUUID = data.callUUID.toLowerCase(); if (!this._rejectedCalls.has(callUUID)) { utils.timestampedLog('Callkeep: accept callback', callUUID); this.acceptCall(callUUID); } } _rnEnd(data) { // this is called both when user touches Reject and when the call ends let callUUID = data.callUUID.toLowerCase(); if (!this._acceptedCalls.has(callUUID)) { utils.timestampedLog('Callkeep: end callback', callUUID); this.rejectCall(callUUID); } } acceptCall(callUUID) { if (this._acceptedCalls.has(callUUID)) { utils.timestampedLog('Callkeep: already accepted call', callUUID); return; } utils.timestampedLog('Callkeep: accept call', callUUID); this._acceptedCalls.set(callUUID, true); if (this._timeouts.has(callUUID)) { clearTimeout(this._timeouts.get(callUUID)); this._timeouts.delete(callUUID); } this.backToForeground(); if (this._conferences.has(callUUID)) { let room = this._conferences.get(callUUID); utils.timestampedLog('Callkeep: accept incoming conference', callUUID); this.endCall(callUUID, 4); this._conferences.delete(callUUID); utils.timestampedLog('Callkeep: will start conference to', room); this.conferenceCall(room); } else if (this._calls.has(callUUID)) { this.sylkAcceptCall(); } else { // We accepted the call before it arrived on web socket this.webSocketActions.set(callUUID, 'accept'); } } rejectCall(callUUID) { if (this._rejectedCalls.has(callUUID)) { utils.timestampedLog('Callkeep: already rejected call', callUUID); return; } utils.timestampedLog('Callkeep: reject call', callUUID); this._rejectedCalls.set(callUUID, true); if (this._timeouts.has(callUUID)) { clearTimeout(this._timeouts.get(callUUID)); this._timeouts.delete(callUUID); } this.backToForeground(); this.callKeep.rejectCall(callUUID); if (this._conferences.has(callUUID)) { utils.timestampedLog('Callkeep: reject conference invite', callUUID); let room = this._conferences.get(callUUID); this._conferences.delete(callUUID); } else if (this._calls.has(callUUID)) { let call = this._calls.get(callUUID); if (call.state === 'incoming') { utils.timestampedLog('Callkeep: reject call', callUUID); this.sylkRejectCall(callUUID); } else { utils.timestampedLog('Callkeep: hangup call', callUUID); this.sylkHangupCall(callUUID); } } else { // We rejected the call before it arrived on web socket // from iOS push notifications utils.timestampedLog('Callkeep: add call', callUUID, 'to the waitings list'); this.webSocketActions.set(callUUID, 'reject'); } } - _rnMute(data) { - utils.timestampedLog('Callkeep: mute ' + data.muted + ' for call', data.callUUID); - //get the uuid, find the call with that uuid and mute/unmute it - if (this._calls.has(data.callUUID.toLowerCase())) { - let call = this._calls.get(data.callUUID.toLowerCase()); + 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]; - localStream.getAudioTracks()[0].enabled = !data.muted; + + 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(); }) } incomingCallFromPush(callUUID, from) { utils.timestampedLog('Callkeep: handle incoming push call', callUUID); // call is received by push notification if (this._rejectedCalls.has(callUUID)) { this.endCall(callUUID, CK_CONSTANTS.END_CALL_REASONS.UNANSWERED); return; } if (Platform.OS === 'ios') { if (this._calls.has(callUUID)) { utils.timestampedLog('Callkeep: call', callUUID, 'already received on web socket'); } } else { this.showAlertPanelforPush(callUUID, from); } let reason = this.webSocketActions.has(callUUID) ? CK_CONSTANTS.END_CALL_REASONS.FAILED : CK_CONSTANTS.END_CALL_REASONS.UNANSWERED; // if user does not decide anything this will be handled later this._timeouts.set(callUUID, setTimeout(() => { utils.timestampedLog('Callkeep: end call because user did not accept or reject', callUUID); this.endCall(callUUID, reason); this._timeouts.delete(callUUID); }, 45000)); } incomingCallFromWebSocket(call) { call._callkeepUUID = call.id; this._calls.set(call._callkeepUUID, call); utils.timestampedLog('Callkeep: handle incoming websocket call', call._callkeepUUID); // if the call came via push and was already accepted or rejected if (this.webSocketActions.get(call._callkeepUUID)) { let action = this.webSocketActions.get(call._callkeepUUID); utils.timestampedLog('Callkeep: execute action decided earlier', action); if (action === 'accept') { this.sylkAcceptCall(call.id); } else { this.sylkRejectCall(call.id); } this.webSocketActions.delete(call._callkeepUUID); if (this._timeouts.has(call.id)) { clearTimeout(this._timeouts.get(call.id)); this._timeouts.delete(call.id); } } else { // iOS invite push does not arrive if app is in the foreground // If the push arrived, we would be above this else if (Platform.OS === 'ios') { this.showAlertPanelforCall(call); } else { // Andoid always receives the invite push and we must show the alert // at that time, if we do it here, the previously shown alert panel // will vanish and the app will go to the foregound leaving the user confused // the alert panel is hidden somewhere in the notifications bar } } // Emit event. this._emitSessionsChange(true); } handleOutgoingCall(call) { // this is an outgoing call call._callkeepUUID = call.id; this._calls.set(call._callkeepUUID, call); utils.timestampedLog('Callkeep: start outgoing call', call._callkeepUUID); // Emit event. this._emitSessionsChange(true); } handleConference(callUUID, room, from_uri) { if (this._conferences.has(callUUID)) { return; } this._conferences.set(callUUID, room); utils.timestampedLog('CallKeep: handle conference', callUUID, 'from', from_uri, 'to room', room); this.showAlertPanelforPush(callUUID, from_uri); 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); } showAlertPanelforPush(callUUID, uri) { utils.timestampedLog('Callkeep: show alert panel for push', callUUID, 'from', uri); if (Platform.OS === 'ios') { this.callKeep.displayIncomingCall(callUUID, uri, uri, 'email', true); } else if (Platform.OS === 'android') { this.callKeep.displayIncomingCall(callUUID, uri, uri); } } _startedCall(data) { utils.timestampedLog("Callkeep: started call", data.callUUID); this.startCallFromOutside(data); } _displayIncomingCall(data) { utils.timestampedLog('Incoming alert panel displayed'); this._alertedCalls.set(data.callUUID.toLowerCase(), true); } showAlertPanelforCall(call, force=false) { if (this._alertedCalls.has(call._callkeepUUID) && !force) { utils.timestampedLog('Callkeep: alert panel was already shown for call', call._callkeepUUID); return; } utils.timestampedLog('Callkeep: show alert panel for call', call._callkeepUUID); let hasVideo = call.mediaTypes && call.mediaTypes.video; if (Platform.OS === 'ios') { this.callKeep.displayIncomingCall(call._callkeepUUID, call.remoteIdentity.uri, call.remoteIdentity.displayName, 'email', hasVideo); } else if (Platform.OS === 'android') { this.callKeep.displayIncomingCall(call._callkeepUUID, call.remoteIdentity.uri, call.remoteIdentity.displayName); } } _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 958042d..71e362d 100644 --- a/app/app.js +++ b/app/app.js @@ -1,2198 +1,2197 @@ import React, { Component, Fragment } from 'react'; import { Alert, View, SafeAreaView, ImageBackground, AppState, Linking, Platform, StyleSheet} from 'react-native'; import { DeviceEventEmitter } from 'react-native'; import { Provider as PaperProvider, DefaultTheme } from 'react-native-paper'; import { registerGlobals } from 'react-native-webrtc'; import { Router, Route, Link, Switch } from 'react-router-native'; import history from './history'; import Logger from "../Logger"; import autoBind from 'auto-bind'; import { firebase } from '@react-native-firebase/messaging'; import VoipPushNotification from 'react-native-voip-push-notification'; import uuid from 'react-native-uuid'; import { getUniqueId, getBundleId, isTablet, getPhoneNumber} from 'react-native-device-info'; import RNDrawOverlay from 'react-native-draw-overlay'; import PushNotificationIOS from "@react-native-community/push-notification-ios"; import Contacts from 'react-native-contacts'; 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 CallByUriBox from './components/CallByUriBox'; import Conference from './components/Conference'; import ConferenceByUriBox from './components/ConferenceByUriBox'; // import AudioPlayer from './components/AudioPlayer'; // import ErrorPanel from './components/ErrorPanel'; import FooterBox from './components/FooterBox'; import StatusBox from './components/StatusBox'; import IncomingCallModal from './components/IncomingCallModal'; import NotificationCenter from './components/NotificationCenter'; import LoadingScreen from './components/LoadingScreen'; import NavigationBar from './components/NavigationBar'; import Preview from './components/Preview'; import CallManager from "./CallManager"; import utils from './utils'; import config from './config'; import storage from './storage'; import styles from './assets/styles/blink/root.scss'; const backgroundImage = require('./assets/images/dark_linen.png'); const logger = new Logger("App"); function checkIosPermissions() { return new Promise(resolve => PushNotificationIOS.checkPermissions(resolve)); } const theme = { ...DefaultTheme, dark: true, roundness: 2, colors: { ...DefaultTheme.colors, primary: '#337ab7', // accent: '#f1c40f', }, }; let bundleId = `${getBundleId()}`; const deviceId = getUniqueId(); const version = '1.0.0'; if (Platform.OS == 'ios') { bundleId = `${bundleId}.${__DEV__ ? 'dev' : 'prod'}`; // bundleId = `${bundleId}.dev`; } const mainStyle = StyleSheet.create({ MainContainer: { flex: 1, justifyContent: 'center', alignItems: 'center', margin: 0 } }); // Application modes const MODE_NORMAL = Symbol('mode-normal'); const MODE_PRIVATE = Symbol('mode-private'); const MODE_GUEST_CALL = Symbol('mode-guest-call'); const MODE_GUEST_CONFERENCE = Symbol('mode-guest-conference'); class Sylk extends Component { constructor() { super(); autoBind(this) this._loaded = false; this._initialSstate = { accountId: '', password: '', displayName: '', account: null, registrationState: null, registrationKeepalive: false, incomingCall: null, currentCall: null, isConference: false, connection: null, showIncomingModal: false, showScreenSharingModal: false, status: null, targetUri: '', missedTargetUri: '', loading: null, mode: MODE_PRIVATE, localMedia: null, generatedVideoTrack: false, contacts: [], devices: {}, speakerPhoneEnabled: null, orientation : 'portrait', Height_Layout : '', Width_Layout : '', outgoingCallUUID: null, outgoingMedia: null, hardware: '', phoneNumber: '', isTablet: isTablet(), refreshHistory: false, myDisplayName: null, myPhoneNumber: null, localHistory: [], favoriteUris: [], blockedUris: [], initialUrl: null, - reconnectingCall: false + reconnectingCall: false, + muted: false }; this.currentRoute = null; this.pushtoken = null; this.pushkittoken = null; this.intercomDtmfTone = null; this.registrationFailureTimer = null; this.contacts = []; this.cachedHistory = []; // used for caching server history this.state = Object.assign({}, this._initialSstate); this.myParticipants = {}; this.myInvitedParties = {}; this._historyConferenceParticipants = new Map(); // for saving to local history this.__notificationCenter = null; this.participantsToInvite = null; this.redirectTo = null; this.prevPath = null; this.shouldUseHashRouting = false; - this.muteIncoming = false; this.goToReadyTimer = null; storage.initialize(); - this._callKeepManager = new CallManager(RNCallKeep, this.acceptCall, this.rejectCall, this.hangupCall, this.timeoutCall, this.callKeepStartConference, this.startCallFromCallKeeper); + this._callKeepManager = new CallManager(RNCallKeep, this.acceptCall, this.rejectCall, this.hangupCall, this.timeoutCall, this.callKeepStartConference, this.startCallFromCallKeeper, this.toggleMute); if (InCallManager.recordPermission !== 'granted') { InCallManager.requestRecordPermission() .then((requestedRecordPermissionResult) => { console.log("InCallManager.requestRecordPermission() requestedRecordPermissionResult: ", requestedRecordPermissionResult); }) .catch((err) => { console.log("InCallManager.requestRecordPermission() catch: ", err); }); } // Load camera/mic preferences storage.get('devices').then((devices) => { if (devices) { this.setState({devices: devices}); } }); storage.get('history').then((history) => { if (history) { console.log('Loaded', history.length, 'local history entries'); this.setState({localHistory: history}); } else { console.log('Loaded 0 local history entries'); } }); storage.get('cachedHistory').then((history) => { if (history) { console.log('Loaded', history.length, 'cached history entries'); this.cachedHistory = history; } }); storage.get('myParticipants').then((myParticipants) => { if (myParticipants) { this.myParticipants = myParticipants; console.log('My participants', this.myParticipants); } }); storage.get('myInvitedParties').then((myInvitedParties) => { if (myInvitedParties) { this.myInvitedParties = myInvitedParties; console.log('My invited parties', this.myInvitedParties); } }); storage.get('favoriteUris').then((favoriteUris) => { if (favoriteUris) { this.setState({favoriteUris: favoriteUris}); console.log('My favorite Uris', favoriteUris); } }); storage.get('blockedUris').then((blockedUris) => { if (blockedUris) { this.setState({blockedUris: blockedUris}); console.log('My blocked Uris', blockedUris); } }); } async loadContacts() { Contacts.checkPermission((err, permission) => { if (permission === Contacts.PERMISSION_UNDEFINED) { Contacts.requestPermission((err, requestedContactsPermissionResult) => { if (err) { console.log("Contacts.requestPermission()catch: ", err); } console.log("Contacts.requestPermission() requestPermission: ", requestedContactsPermissionResult); }) } }) Contacts.getAll((err, contacts) => { if (err === 'denied'){ console.log('Access to contacts denied') } else { // contacts returned in Array let contact_cards = []; let name; let photo; let seen_uris = new Map(); var arrayLength = contacts.length; for (var i = 0; i < arrayLength; i++) { photo = null; contact = contacts[i]; if (contact['givenName'] && contact['familyName']) { name = contact['givenName'] + ' ' + contact['familyName']; } else if (contact['givenName']) { name = contact['givenName']; } else if (contact['familyName']) { name = contact['familyName']; } else if (contact['company']) { name = contact['company']; } else { continue; } if (contact.hasThumbnail) { photo = contact.thumbnailPath; } //console.log(name); contact['phoneNumbers'].forEach(function (number, index) { let number_stripped = number['number'].replace(/\s|\-|\(|\)/g, ''); if (number_stripped) { if (!seen_uris.has(number_stripped)) { //console.log(' ----> ', number['label'], number_stripped); var contact_card = {id: uuid.v4(), displayName: name, remoteParty: number_stripped, type: 'contact', photo: photo, label: number['label'], tags: ['contact']}; contact_cards.push(contact_card); seen_uris.set(number_stripped, true); var contact_card = {id: uuid.v4(), displayName: name, remoteParty: number_stripped, type: 'contact', photo: photo, label: number['label'], tags: ['contact'] }; } } }); contact['emailAddresses'].forEach(function (email, index) { let email_stripped = email['email'].replace(/\s|\(|\)/g, ''); if (!seen_uris.has(email_stripped)) { //console.log(name, email['label'], email_stripped); //console.log(' ----> ', email['label'], email_stripped); var contact_card = {id: uuid.v4(), displayName: name, remoteParty: email_stripped, type: 'contact', photo: photo, label: email['label'], tags: ['contact'] }; contact_cards.push(contact_card); seen_uris.set(email_stripped, true); } }); } this.contacts = contact_cards; if (this.state.myPhoneNumber) { var myContact = this.findObjectByKey(contact_cards, 'remoteParty', this.state.myPhoneNumber); if (myContact) { this.setState({myDisplayName: myContact.displayName}); } } } }) } get _notificationCenter() { // getter to lazy-load the NotificationCenter ref if (!this.__notificationCenter) { this.__notificationCenter = this.refs.notificationCenter; } return this.__notificationCenter; } findObjectByKey(array, key, value) { for (var i = 0; i < array.length; i++) { if (array[i][key] === value) { return array[i]; } } return null; } _detectOrientation() { if(this.state.Width_Layout > this.state.Height_Layout && this.state.orientation !== 'landscape') { this.setState({orientation: 'landscape'}); } else { this.setState({orientation: 'portrait'}); } } changeRoute(route) { if (this.currentRoute === route) { return; } if (route === '/ready') { this.closeLocalMedia(); this.setState({ refreshHistory: !this.state.refreshHistory, outgoingMedia: null, outgoingCallUUID: null, currentCall: null, incomingCall: null, targetUri: '', reconnectingCall: false, - localMedia: null + localMedia: null, + muted: false }); } utils.timestampedLog('Change route:', this.currentRoute, '->', route); this.currentRoute = route; history.push(route); } async componentDidMount() { this._loaded = true; try { await RNCallKeep.hasPhoneAccount(); } 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 }) } this.changeRoute('/login'); // prime the ref //logger.debug('NotificationCenter ref: %o', this._notificationCenter); this._boundOnPushkitRegistered = this._onPushkitRegistered.bind(this); this._boundOnPushRegistered = this._onPushRegistered.bind(this); if (Platform.OS === 'android') { Linking.getInitialURL().then((url) => { if (url) { utils.timestampedLog('Initial Linking URL: ' + url); this.incomingCallFromUrl(url); } }).catch(err => { logger.error({ err }, 'Error getting initial URL'); }); firebase.messaging().getToken() .then(fcmToken => { if (fcmToken) { this._onPushRegistered(fcmToken); } }); Linking.addEventListener('url', this.updateLinkingURL); } else if (Platform.OS === 'ios') { 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') { 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; utils.timestampedLog('Handle Firebase', event, 'push notification for', message.data['session-id']); if (event === 'incoming_conference_request') { this.incomingConference(message.data['session-id'], message.data['to_uri'], message.data['from_uri']); } else if (event === 'incoming_session') { this.incomingCallFromPush(message.data['session-id'], message.data['from_uri']); } else if (event === 'cancel') { this.cancelIncomingCall(message.data['session-id']); } }); } this._detectOrientation(); getPhoneNumber().then(phoneNumber => { this.setState({myPhoneNumber: phoneNumber}); this.loadContacts(); }); } cancelIncomingCall(callUUID) { this._callKeepManager.endCall(callUUID, 6); } _proximityDetect(data) { return; if (data.isNear) { this.speakerphoneOff(); } else { this.speakerphoneOn(); } } 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.incomingCallFromUrl(event.url); } startCallWhenReady(targetUri, options) { if (!options.video) { this._callKeepManager.startCall(options.callUUID, targetUri, options.video); } if (options.conference) { this.startConference(targetUri, options); } else { this.startCall(targetUri, options); } } _sleep(ms) { return new Promise(resolve => setTimeout(resolve, ms)); } _onPushkitRegistered(token) { utils.timestampedLog('Set VoIP pushkit token', token); this.pushkittoken = token; } _onPushRegistered(token) { utils.timestampedLog('Set background push token', token); this.pushtoken = token; } _sendPushToken() { if (this.state.account && this.pushtoken) { let token = null; if (Platform.OS === 'ios') { token = `${this.pushkittoken}#${this.pushtoken}`; } else if (Platform.OS === 'android') { token = this.pushtoken; } utils.timestampedLog('Push token', token, 'sent to server'); this.state.account.setDeviceToken(token, Platform.OS, deviceId, true, bundleId); } } componentWillUnmount() { AppState.removeEventListener('change', this._handleAppStateChange); } _handleAppStateChange = nextAppState => { //TODO - stop if we havent been backgrounded because of becoming active from a push notification and then going background again // if (nextAppState.match(/background/)) { // logger.debug('app moving to background so we should stop the client sylk client if we dont have an active call'); // if (this._callKeepManager.count === 0) { // logger.debug('callmanager count is 0 so closing connection'); // this.state.connection.close(); // } // } if (nextAppState === 'active') { if (this._callKeepManager.count === 0 && this.state.connection) { this.state.connection.reconnect(); } } } startCallFromCallKeeper(data) { // like from native iOS history - utils.timestampedLog("CallKeep started call from outside the app to", data.handle); + //utils.timestampedLog("CallKeep started call from outside the app to", data.handle); // we dont have options in the tmp var, which means this likely came from the native dialer // for now, we only do audio calls from the native dialer. let callUUID = data.callUUID || uuid.v4(); let is_conf = data.handle.search('videoconference.') === -1 ? false: true; if (is_conf) { this.callKeepStartConference(data.handle, {audio: true, video: true, callUUID: callUUID}); } else { this.callKeepStartCall(data.handle, {audio: true, video: false, callUUID: callUUID}); } this._notificationCenter.removeNotification(); } connectionStateChanged(oldState, newState) { utils.timestampedLog('Web socket state changed:', oldState, '->' , newState); switch (newState) { case 'closed': this.setState({connection: null, loading: null}); //this._notificationCenter.postSystemNotification('Connection failed', {body: '', timeout: 3000}); break; case 'ready': this._notificationCenter.removeNotification(); //this._notificationCenter.postSystemNotification('Connection OK', {body: '', timeout: 1}); this.processRegistration(this.state.accountId, this.state.password, this.state.displayName); break; case 'disconnected': if (this.state.currentCall) { this.hangupCall(this.state.currentCall._callkeepUUID, 'connection_failed'); } if (this.state.incomingCall) { this.hangupCall(this.state.incomingCall._callkeepUUID, 'connection_failed'); } this.setState({ registrationState: 'failed', generatedVideoTrack: false, }); //this._notificationCenter.postSystemNotification('Connection lost', {body: '', timeout: 3000}); break; default: if (this.state.registrationKeepalive !== true) { this.setState({loading: 'Connecting...'}); } break; } } notificationCenter() { return this._notificationCenter; } showRegisterFailure(reason) { logger.debug('Registration error: ' + reason); this.setState({ loading : null, registrationState: 'failed', status : { msg : 'Sign In failed: ' + reason, level : 'danger' } }); } registrationStateChanged(oldState, newState, data) { utils.timestampedLog('Registration state changed:', oldState, '->', newState); if (newState === 'failed') { this._callKeepManager.setAvailable(false); let reason = data.reason; if (reason.match(/904|408/)) { // Sofia SIP: WAT reason = 'Wrong account or password'; } this.showRegisterFailure(reason); if (this.state.registrationKeepalive === true) { if (this.state.connection !== null) { utils.timestampedLog('Retry to register...'); //this.setState({loading: 'Register...'}); this._notificationCenter.postSystemNotification('Registering', {body: 'now', timeout: 10000}); this.state.account.register(); } else { // add a timer to retry register after awhile utils.timestampedLog('Retry to register after a delay...'); setTimeout(this.state.account.register(), 5000); } } } else if (newState === 'registered') { if (this.registrationFailureTimer) { clearTimeout(this.registrationFailureTimer); this.registrationFailureTimer = null; } this._callKeepManager.setAvailable(true); this.setState({loading: null, registrationKeepalive: true, registrationState: 'registered'}); //if (!this.state.currentCall) { if (this.currentRoute === '/login') { this.changeRoute('/ready'); } //this._notificationCenter.postSystemNotification('Ready to receive calls', {body: '', timeout: 1}); return; } else { this.setState({status: null, registrationState: newState }); this._callKeepManager.setAvailable(false); } } showCalls(prefix) { if (this.state.currentCall) { utils.timestampedLog('Current calls', prefix, 'currentCall:', this.state.currentCall ? (this.state.currentCall._callkeepUUID + ' ' + this.state.currentCall.direction): 'None'); } if (this.state.incomingCall) { utils.timestampedLog('Current calls', prefix, 'incomingCall:', this.state.incomingCall ? (this.state.incomingCall._callkeepUUID + ' ' + this.state.incomingCall.direction): 'None'); } if (this._callKeepManager.callUUIDS.length > 0) { utils.timestampedLog('Current calls', prefix, 'callkeep sessions:', this._callKeepManager.callUUIDS); } } resetGoToReadyTimer() { if (this.goToReadyTimer !== null) { clearTimeout(this.goToReadyTimer); this.goToReadyTimer = null; } } callStateChanged(oldState, newState, data) { // outgoing accepted: null -> progress -> accepted -> established -> terminated // incoming accepted: null -> incoming -> accepted -> established -> terminated // 2nd incoming call is automatically rejected by sylkrtc library //this.showCalls('Begin callStateChanged'); let call = this._callKeepManager._calls.get(data.id); if (!call) { utils.timestampedLog("callStateChanged error: call", data.id, 'not found in callkeep manager'); return; } let callUUID = call._callkeepUUID; utils.timestampedLog(call.direction, 'call', callUUID, 'state change:', oldState, '->', newState); if (newState === 'established' || newState === 'accepted') { // restore the correct UI state if it has transitioned illegally to /ready state if (call.hasOwnProperty('_participants')) { this.changeRoute('/conference'); } else { this.changeRoute('/call'); } } let newCurrentCall; let newincomingCall; let direction = call.direction; let goToReady = direction === 'incoming' ? true : false; if (this.state.incomingCall && this.state.currentCall) { if (this.state.incomingCall != this.state.currentCall) { utils.timestampedLog('We have two calls'); } if (newState === 'terminated') { if (this.state.incomingCall == this.state.currentCall) { newCurrentCall = null; newincomingCall = null; } else { if (oldState === 'incoming') { utils.timestampedLog('Call state changed:', 'We have two calls, new call must be cancelled'); // new call must be cancelled newincomingCall = null; newCurrentCall = this.state.currentCall; } else if (oldState === 'established') { utils.timestampedLog('Call state changed:', 'Old call must be closed'); // old call must be closed newCurrentCall = null; newincomingCall = null; } else { utils.timestampedLog('Call state changed:', 'Error: unclear call combination') } } } else if (newState === 'accepted') { if (this.state.incomingCall == this.state.currentCall) { newCurrentCall = this.state.incomingCall; newincomingCall = this.state.incomingCall; } else { utils.timestampedLog('Call state changed:', 'Error: we have two different calls and unhandled state transition'); } } else if (newState === 'established') { if (this.state.incomingCall == this.state.currentCall) { newCurrentCall = this.state.incomingCall; newincomingCall = this.state.incomingCall; } else { utils.timestampedLog('Call state changed:', 'Error: we have two different calls and unhandled state transition'); } } else { utils.timestampedLog('Call state changed:', 'We have two calls and unhandled state'); } } else if (this.state.incomingCall) { if (oldState === 'incoming' && newState === 'terminated') { utils.timestampedLog("Incoming call was cancelled"); this.setState({showIncomingModal: false}); newincomingCall = null; newCurrentCall = null; } else if (newState === 'accepted' || newState === 'established') { utils.timestampedLog("Incoming call is accepted"); newCurrentCall = this.state.incomingCall; newincomingCall = this.state.incomingCall; this.setState({showIncomingModal: false}); } else if (oldState === 'established' && newState === 'terminated') { utils.timestampedLog("Incoming call was terminated"); // old call was hangup to accept a new incoming calls newCurrentCall = null; newincomingCall = null; } else { utils.timestampedLog('Call state changed:', 'we have one inbound call and unhandled state'); } } else { newCurrentCall = newState === 'terminated' ? null : this.state.currentCall; newincomingCall = null; } switch (newState) { case 'progress': //utils.timestampedLog('Play ringback tone'); if (!this.state.isConference) { InCallManager.startRingback('_BUNDLE_'); } this.setState({ currentCall: newCurrentCall, incomingCall: newincomingCall }); this.resetGoToReadyTimer(); break; case 'established': this.setState({ currentCall: newCurrentCall, incomingCall: newincomingCall }); this.resetGoToReadyTimer(); if (direction === 'outgoing') { let hasVideo = false; if (!this.state.isConference) { const videoTracks = call.remoteMediaDirections.video; hasVideo = videoTracks && videoTracks.length > 0; this._callKeepManager.startCall(callUUID, call.remoteIdentity.uri, hasVideo); } } else { this._callKeepManager.setCurrentCallActive(callUUID); } break; case 'accepted': InCallManager.stopRingback(); if (this.state.isConference) { this.speakerphoneOn(); } else if (this.state.currentCall && this.state.currentCall.remoteMediaDirections) { const videoTracks = call.remoteMediaDirections.video; const hasVideo = videoTracks && videoTracks.length > 0; if (hasVideo) { utils.timestampedLog('Call state changed:', 'Video call started') this.speakerphoneOn(); } } else { this.speakerphoneOff(); } this.setState({ currentCall: newCurrentCall, incomingCall: newincomingCall }); this.resetGoToReadyTimer(); break; case 'terminated': let callSuccesfull = false; let reason = data.reason; let play_busy_tone = true; let CALLKEEP_REASON; //utils.timestampedLog('Call state changed:', 'call', callUUID, 'terminated reason:', reason); if (!reason || reason.match(/200/)) { if (oldState === 'progress' || oldState === 'incoming') { reason = 'Cancelled'; play_busy_tone = false; CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.UNANSWERED; } else { reason = 'Hangup'; callSuccesfull = true; CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.REMOTE_ENDED; } goToReady = true; } else if (reason.match(/403/)) { reason = 'This domain is not served here'; CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.FAILED; goToReady = true; } else if (reason.match(/404/)) { reason = 'User not found'; CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.FAILED; goToReady = true; } else if (reason.match(/408/)) { reason = 'Timeout'; CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.FAILED; goToReady = true; } else if (reason.match(/480/)) { reason = 'User not online'; CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.UNANSWERED; goToReady = true; } else if (reason.match(/486/) || reason.match(/60[036]/)) { reason = 'Busy'; CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.REMOTE_ENDED; goToReady = true; } else if (reason.match(/487/)) { reason = 'Cancelled'; play_busy_tone = false; CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.MISSED; goToReady = true; } else if (reason.match(/488/)) { reason = 'Unacceptable media'; CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.FAILED; goToReady = true; } else if (reason.match(/5\d\d/)) { reason = 'Server failure'; CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.FAILED; goToReady = true; } else if (reason.match(/904/)) { // Sofia SIP: WAT reason = 'Wrong account or password'; CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.FAILED; goToReady = true; } else { reason = 'Connection failed'; CALLKEEP_REASON = CK_CONSTANTS.END_CALL_REASONS.FAILED; } this._callKeepManager.endCall(callUUID, CALLKEEP_REASON); if (this.state.currentCall === null) { utils.timestampedLog('Call state changed:', 'Turn off speakerphone'); this.speakerphoneOff(); } if (play_busy_tone && oldState !== 'established') { this._notificationCenter.postSystemNotification('Call ended:', {body: reason, timeout: callSuccesfull ? 5 : 10}); } this.setFocusEvents(false); if (newCurrentCall) { // we had an old active call that must be revived this._callKeepManager.setCurrentCallActive(newCurrentCall._callkeepUUID); } if (!newCurrentCall && !newincomingCall) { if (play_busy_tone) { this.playBusyTone(); } else { //utils.timestampedLog('Stop InCall manager'); InCallManager.stop(); } if (goToReady) { this.goToReadyTimer = setTimeout(() => { this.changeRoute('/ready'); }, 4000); } setTimeout(() => { this.setState({refreshHistory: !this.state.refreshHistory}); }, 2000); } this.updateHistoryEntry(callUUID); break; default: break; } } handleCallByUri(displayName, targetUri) { const accountId = `${utils.generateUniqueId()}@${config.defaultGuestDomain}`; this.setState({ accountId : accountId, password : '', displayName : displayName, //mode : MODE_GUEST_CALL, targetUri : utils.normalizeUri(targetUri, config.defaultDomain), loading : 'Connecting...' }); if (this.state.connection === null) { let connection = sylkrtc.createConnection({server: config.wsServer}); connection.on('stateChanged', this.connectionStateChanged); this.setState({connection: connection}); } } handleConferenceByUri(displayName, targetUri) { const accountId = `${utils.generateUniqueId()}@${config.defaultGuestDomain}`; this.setState({ accountId : accountId, password : '', displayName : displayName, //mode : MODE_GUEST_CONFERENCE, targetUri : targetUri, loading : 'Connecting...' }); if (this.state.connection === null) { let connection = sylkrtc.createConnection({server: config.wsServer}); connection.on('stateChanged', this.connectionStateChanged); this.setState({connection: connection}); } } handleRegistration(accountId, password, remember) { this.setState({ accountId : accountId, password : password, mode : remember ? MODE_NORMAL : MODE_PRIVATE, loading : 'Connecting...' }); if (this.state.connection === null) { const userAgent = 'Sylk Mobile'; console.log('User Agent:', userAgent); if (this.state.phoneNumber) { console.log('Phone number:', this.state.phoneNumber); } let connection = sylkrtc.createConnection({server: config.wsServer, userAgent: {name: userAgent, version: version}}); connection.on('stateChanged', this.connectionStateChanged); this.setState({connection: connection}); } else { utils.timestampedLog('Websocket connection active, try to register'); this.processRegistration(accountId, password, ''); } } processRegistration(accountId, password, displayName) { if (this.state.account !== null) { logger.debug('We already have an account, removing it'); this.state.connection.removeAccount(this.state.account, (error) => { this.setState({registrationState: null, registrationKeepalive: false}); } ); } const options = { account: accountId, password: password, displayName: displayName }; this.registrationFailureTimer = setTimeout(this.showRegisterFailure, 6000, 'Wrong account or password'); const account = this.state.connection.addAccount(options, (error, account) => { if (!error) { account.on('outgoingCall', this.outgoingCall); account.on('conferenceCall', this.outgoingCall); switch (this.state.mode) { case MODE_PRIVATE: case MODE_NORMAL: account.on('registrationStateChanged', this.registrationStateChanged); account.on('incomingCall', this.incomingCallFromWebSocket); account.on('missedCall', this.missedCall); account.on('conferenceInvite', this.conferenceInviteFromWebSocket); this.setState({account: account}); this._sendPushToken(); account.register(); logger.debug(this.state.mode); if (this.state.mode !== MODE_PRIVATE) { storage.set('account', { accountId: this.state.accountId, password: this.state.password }); } else { // Wipe storage if private login //storage.remove('account'); // lets try this out // history.clear().then(() => { // this.setState({history: []}); // }); } break; case MODE_GUEST_CALL: this.setState({account: account, loading: null, registrationState: 'registered'}); logger.debug(`${accountId} (guest) signed in`); // Start the call immediately, this is call started with "Call by URI" this.startGuestCall(this.state.targetUri, {audio: true, video: true}); break; case MODE_GUEST_CONFERENCE: this.setState({account: account, loading: null, registrationState: 'registered'}); logger.debug(`${accountId} (conference guest) signed in`); // Start the call immediately, this is call started with "Conference by URI" this.startGuestConference(this.state.targetUri); break; default: logger.debug(`Unknown mode: ${this.state.mode}`); break; } } 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, next route', nextRoute); const constraints = Object.assign({}, mediaConstraints); if (constraints.video === true) { if ((nextRoute === '/conference' || this.state.mode === MODE_GUEST_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' || this.state.mode === MODE_GUEST_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('Got local media done, next route is', nextRoute); this.setState({status: null, loading: null, 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); /* logger.debug('Audio only media, but video was requested, creating generated video track'); const generatedVideoTrack = utils.generateVideoTrack(localStream); localStream.addTrack(generatedVideoTrack); utils.timestampedLog('Next route', nextRoute); this.setState({status: null, loading: null, localMedia: localStream, generatedVideoTrack: true}); */ if (nextRoute !== null) { this.changeRoute(nextRoute); } }) .catch((error) => { utils.timestampedLog('Access to local media failed:', error); clearTimeout(this.loadScreenTimer); this._notificationCenter.postSystemNotification("Can't access camera or microphone", {timeout: 10}); this.setState({ loading: null }); this.changeRoute('/ready'); }); }); } callKeepStartConference(targetUri, options={audio: true, video: true}) { let callUUID = options.callUUID || uuid.v4(); this.addHistoryEntry(targetUri, callUUID); this.setState({outgoingCallUUID: callUUID, outgoingMedia: options, reconnectingCall: false}); utils.timestampedLog('CallKeep will start conference', callUUID, 'to', targetUri); this._callKeepManager.backToForeground(); this.startCallWhenReady(targetUri, {audio: options.audio, video: options.video, conference: true, callUUID: callUUID}); } callKeepStartCall(targetUri, options) { let callUUID = options.callUUID || uuid.v4(); this.setState({outgoingCallUUID: callUUID, reconnectingCall: false}); utils.timestampedLog('CallKeep will start call', callUUID, 'to', targetUri); this._callKeepManager.backToForeground(); this.startCallWhenReady(targetUri, {audio: options.audio, video: options.video, callUUID: callUUID}); } startCall(targetUri, options) { utils.timestampedLog('startCall', targetUri); this.setState({targetUri: targetUri, isConference: false}); this.getLocalMedia(Object.assign({audio: true, video: true}, options), '/call'); } callKeepAcceptCall(callUUID) { // called from user interaction with Old alert panel // options used to be media to accept audio only but native panels do not have this feature utils.timestampedLog('CallKeep will answer call', callUUID); this._callKeepManager.acceptCall(callUUID); } callKeepRejectCall(callUUID) { // called from user interaction with Old alert panel utils.timestampedLog('CallKeep will reject call', callUUID); this._callKeepManager.rejectCall(callUUID); } acceptCall() { utils.timestampedLog('User accepted call'); //this.showCalls('acceptCall') this.setFocusEvents(false); if (this.state.currentCall) { this.hangupCall(this.state.currentCall._callkeepUUID, 'accept_new_call'); this.setState({currentCall: null}); } this.setState({localMedia: null}); 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); if (!this.state.currentCall) { this.changeRoute('/ready'); } if (this.state.incomingCall && this.state.incomingCall._callkeepUUID === callUUID) { this.state.incomingCall.terminate(); utils.timestampedLog('Sylkrtc reject call', callUUID); } this.forceUpdate(); } timeoutCall(callUUID, uri) { utils.timestampedLog('Timeout answering call', callUUID); this.addHistoryEntry(uri, callUUID, direction='received'); this.forceUpdate(); } closeLocalMedia() { if (this.state.localMedia != null) { sylkrtc.utils.closeMediaStream(this.state.localMedia); utils.timestampedLog('Close local media'); } } hangupCall(callUUID, reason) { utils.timestampedLog('Hangup call', callUUID, 'reason:', reason); //utils.timestampedLog('Stop ringback tone'); InCallManager.stopRingback(); let call = this._callKeepManager._calls.get(callUUID); let direction = null; let targetUri = null; if (call) { let direction = call.direction; targetUri = call.remoteIdentity.uri; call.terminate(); } if (this.busyToneInterval) { clearInterval(this.busyToneInterval); this.busyToneInterval = null; } if (reason !== 'connection_failed') { this.setState({reconnectingCall: false}); if (reason === 'user_cancelled' || reason === 'timeout' || reason === 'stop_preview' || reason === 'user_press_hangup') { this.changeRoute('/ready'); } else { if (reason !== 'escalate_to_conference') { setTimeout(() => { this.changeRoute('/ready'); }, 4000); } } } else { this.setState({reconnectingCall: true, outgoingCallUUID: uuid.v4()}); utils.timestampedLog('Call', callUUID, 'failed due to connection'); } } playBusyTone() { //utils.timestampedLog('Play busy tone'); InCallManager.stop({busytone: '_BUNDLE_'}); } callKeepSendDtmf(digits) { utils.timestampedLog('Send DTMF', digits); if (this.state.currentCall) { this._callKeepManager.sendDTMF(this.state.currentCall._callkeepUUID, digits); } } - callKeepToggleMute(mute) { - utils.timestampedLog('Toggle mute %s', mute); - if (this.state.currentCall) { - this._callKeepManager.setMutedCall(this.state.currentCall._callkeepUUID, mute); - } + toggleMute(callUUID, mute) { + utils.timestampedLog('Toggle mute for call', callUUID, ':', mute); + this._callKeepManager.setMutedCall(callUUID, mute); + this.setState({muted: mute}); } toggleSpeakerPhone() { if (this.state.speakerPhoneEnabled === true) { this.speakerphoneOff(); } else { this.speakerphoneOn(); } } speakerphoneOn() { utils.timestampedLog('Speakerphone On'); this.setState({speakerPhoneEnabled: true}); InCallManager.setForceSpeakerphoneOn(true); } speakerphoneOff() { utils.timestampedLog('Speakerphone Off'); this.setState({speakerPhoneEnabled: false}); InCallManager.setForceSpeakerphoneOn(false); } startGuestConference(targetUri) { this.setState({targetUri: targetUri}); this.getLocalMedia({audio: true, video: true}); } - toggleMute() { - this.muteIncoming = !this.muteIncoming; - } - outgoingCall(call) { // called by sylrtc.js when an outgoig call or conference starts const localStreams = call.getLocalStreams(); let mediaType = 'audio'; if (localStreams.length > 0) { const localStream = call.getLocalStreams()[0]; mediaType = localStream.getVideoTracks().length > 0 ? 'video' : 'audio'; } utils.timestampedLog('Outgoing', mediaType, 'call', call.id, 'started to', call.remoteIdentity.uri); this._callKeepManager.handleOutgoingCall(call); //utils.timestampedLog('Start InCall manager:', mediaType); InCallManager.start({media: mediaType}); call.on('stateChanged', this.callStateChanged); this.setState({currentCall: call}); //this._callKeepManager.updateDisplay(call._callkeepUUID, call.remoteIdentity.displayName, call.remoteIdentity.uri); } _onLocalNotificationReceivedBackground(notification) { let notificationContent = notification.getData(); utils.timestampedLog('Handle local iOS push notification: ', notificationContent); } _onNotificationReceivedBackground(notification) { let notificationContent = notification.getData(); // get the uuid from the notification // have we already got a waiting call in call manager? if we do, then its been "answered" and we're waiting for the invite // we may still never get the invite if theres network issues... so still need a timeout // no waiting call, so that means its still "ringing" (it may have been cancelled) so set a timer and if we havent recieved // an invite within 10 seconds then clear it down let event = notificationContent['event']; let callUUID = notificationContent['session-id']; utils.timestampedLog('Handle iOS', event, 'push notification for', callUUID); logger.debug(notificationContent); if (notificationContent['event'] === 'incoming_session') { utils.timestampedLog('Incoming call for push mobile notification for call', callUUID); this.incomingCallFromPush(callUUID, notificationContent['from_uri']); if (VoipPushNotification.wakeupByPush) { utils.timestampedLog('We wake up by a push notification'); VoipPushNotification.wakeupByPush = false; } VoipPushNotification.onVoipNotificationCompleted(callUUID); } else if (notificationContent['event'] === 'incoming_conference_request') { let callUUID = notificationContent['session-id']; utils.timestampedLog('Incoming conference for push mobile notification for call', callUUID); this.incomingConference(callUUID, notificationContent['to_uri'], notificationContent['from_uri']); VoipPushNotification.onVoipNotificationCompleted(callUUID); } /* if (notificationContent['event'] === 'incoming_session') { VoipPushNotification.presentLocalNotification({ alertBody:'Incoming ' + notificationContent['media-type'] + ' call from ' + notificationContent['from_display_name'] }); } */ if (notificationContent['event'] === 'cancel') { this.cancelIncomingCall(callUUID); VoipPushNotification.presentLocalNotification({ alertBody:'Call cancelled' }); } if (VoipPushNotification.wakeupByPush) { utils.timestampedLog('We wake up by push notification'); VoipPushNotification.wakeupByPush = false; } } async incomingConference(callUUID, to_uri, from_uri) { utils.timestampedLog('Handle incoming conference', callUUID, 'when ready'); var n = 0; let wait_interval = 15; while (n < wait_interval) { if (!this.state.connection || this.state.connection.state !== 'ready' || this.state.account === null) { utils.timestampedLog('Waiting for connection...'); this._notificationCenter.postSystemNotification('Waiting for connection...', {timeout: 1}); await this._sleep(1000); } else { utils.timestampedLog('Web socket is ready'); utils.timestampedLog('Using account', this.state.account.id); // answer here this._callKeepManager.handleConference(callUUID, to_uri, from_uri); this.setFocusEvents(true); return; } if (n === wait_interval - 1) { utils.timestampedLog('Terminating call', callUUID, 'that did not start yet'); this.cancelIncomingCall(callUUID) } n++; } } startConference(targetUri, options={audio: true, video: true}) { utils.timestampedLog('New outgoing conference to room', targetUri); this.setState({targetUri: targetUri, isConference: true}); this.getLocalMedia({audio: options.audio, video: options.video}, '/conference'); } escalateToConference(participants) { const uri = `${utils.generateSillyName()}@${config.defaultConferenceDomain}`; utils.timestampedLog('Escalate call to conference', uri, 'with participants', participants); if (this.state.currentCall) { this.hangupCall(this.state.currentCall._callkeepUUID, 'escalate_to_conference'); this.setState({currentCall: null}); } if (this.state.incomingCall) { this.hangupCall(this.state.incomingCall._callkeepUUID, 'escalate_to_conference'); this.setState({incomingCall: null}); } this.setState({localMedia: null}); this.participantsToInvite = participants; this.callKeepStartConference(uri); } conferenceInviteFromWebSocket(data) { // comes from web socket utils.timestampedLog('Conference invite from websocket', data.id, 'from', data.originator, 'for room', data.room); this._notificationCenter.postSystemNotification('Conference invite', {body: `from ${data.originator.displayName || data.originator.uri}`, timeout: 5, silent: false}); } incomingCallFromPush(callUUID, from) { utils.timestampedLog('Handle incoming push call', callUUID, 'from', from); 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._callKeepManager.rejectCall(callUUID); } else { this._callKeepManager.incomingCallFromPush(callUUID, from); } } incomingCallFromUrl(url) { try { var url_parts = url.split("/"); const direction = url_parts[2]; const event = url_parts[3]; const callUUID = url_parts[4]; const uri = url_parts[5]; const to = url_parts[6]; utils.timestampedLog('Parsed URL:', direction, event, 'from', uri, 'to', to); if (direction === 'outgoing' && event === 'conference' && uri && to) { this.incomingConference(callUUID, uri, to); } else if (direction === 'incoming' && event === 'call' && uri) { //this.setState({showIncomingModal: true}); this.incomingCallFromPush(callUUID, uri); } else if (direction === 'outgoing' && event === 'call' && uri) { // from native dialer this.callKeepStartCall(uri, {audio: true, video: false, callUUID: callUUID}); } else { utils.timestampedLog('Unclear URL structure'); } } catch (err) { utils.timestampedLog('Error parsing url', url, ":", err); } } incomingCallFromWebSocket(call, mediaTypes) { utils.timestampedLog('New incoming call from WebSocket', call.id); // this is called by the websocket invite // 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 (call.remoteIdentity.uri === this.state.account.id && this.state.currentCall && this.state.currentCall.remoteIdentity.uri) { utils.timestampedLog('Reject call to myself', call.id); this._callKeepManager.rejectCall(call.id); call.terminate(); return; } if (this.state.blockedUris && this.state.blockedUris.indexOf(call.remoteIdentity.uri) > -1) { utils.timestampedLog('Reject call from blocked URI', call.remoteIdentity.uri); this._callKeepManager.rejectCall(call.id); call.terminate(); let from = call.remoteIdentity.displayName || call.remoteIdentity.uri; this._notificationCenter.postSystemNotification('Call rejected', {body: `from ${from}`, timeout: 5000, silent: true}); return; } let mediaType = mediaTypes.video ? 'video' : 'audio'; call.mediaTypes = mediaTypes; utils.timestampedLog('New', mediaType, 'incoming call from', call.remoteIdentity['_displayName'], call.remoteIdentity['_uri']); call.on('stateChanged', this.callStateChanged); this.setState({incomingCall: call}); //utils.timestampedLog('Start InCall manager:', mediaType); InCallManager.start({media: mediaType}); this._callKeepManager.incomingCallFromWebSocket(call); this.setFocusEvents(true); } setFocusEvents(enabled) { // if (this.shouldUseHashRouting) { // const remote = window.require('electron').remote; // if (enabled) { // const currentWindow = remote.getCurrentWindow(); // currentWindow.on('focus', this.hasFocus); // currentWindow.on('blur', this.hasNoFocus); // this.setState({haveFocus: currentWindow.isFocused()}); // } else { // const currentWindow = remote.getCurrentWindow(); // currentWindow.removeListener('focus', this.hasFocus); // currentWindow.removeListener('blur', this.hasNoFocus); // } // } } // hasFocus() { // this.setState({haveFocus: true}); // } // hasNoFocus() { // this.setState({haveFocus: false}); // } missedCall(data) { utils.timestampedLog('Missed call from ' + data.originator); if (!this.state.currentCall) { //utils.timestampedLog('Update snackbar'); let from = data.originator.display_name || data.originator.uri; this._notificationCenter.postSystemNotification('Missed call', {body: `from ${from}`, timeout: 180, silent: false}); } this.forceUpdate(); } startPreview() { this.getLocalMedia({audio: true, video: true}, '/preview'); } updateHistoryEntry(callUUID) { let newHistory = this.state.localHistory; var historyItem = this.findObjectByKey(newHistory, 'sessionId', callUUID); if (historyItem) { let current_datetime = new Date(); let stopTime = current_datetime.getFullYear() + "-" + utils.appendLeadingZeroes(current_datetime.getMonth() + 1) + "-" + utils.appendLeadingZeroes(current_datetime.getDate()) + " " + utils.appendLeadingZeroes(current_datetime.getHours()) + ":" + utils.appendLeadingZeroes(current_datetime.getMinutes()) + ":" + utils.appendLeadingZeroes(current_datetime.getSeconds()); historyItem.stopTime = stopTime; var diff = current_datetime.getTime() - historyItem.startTimeObject.getTime(); historyItem.duration = parseInt(diff/1000); delete historyItem['startTimeObject']; if (this._historyConferenceParticipants.has(callUUID)) { historyItem.participants = this._historyConferenceParticipants.get(callUUID); } else { historyItem.participants = []; } //console.log('Save history', historyItem); this.setState({localHistory: newHistory}); storage.set('history', newHistory); } } setFavoriteUri(uri) { let favoriteUris = this.state.favoriteUris; let idx = favoriteUris.indexOf(uri); let ret; console.log('idx', idx); if (idx === -1) { favoriteUris.push(uri); ret = true; } else { let removed = favoriteUris.splice(idx, 1); ret = false; } storage.set('favoriteUris', favoriteUris); this.setState({favoriteUris: favoriteUris, refreshHistory: !this.state.refreshHistory}); return ret; } setBlockedUri(uri) { let blockedUris = this.state.blockedUris; console.log('Old blocked Uris:', blockedUris); let ret; let idx = blockedUris.indexOf(uri); console.log('idx', idx); if (idx === -1) { blockedUris.push(uri); ret = true; } else { let removed = blockedUris.splice(idx, 1); console.log('Removed', removed); ret = false; } console.log('New blocked Uris:', blockedUris); storage.set('blockedUris', blockedUris); this.setState({blockedUris: blockedUris, refreshHistory: !this.state.refreshHistory}); return ret; } saveParticipant(callUUID, room, uri) { console.log('Save participant', uri, 'for conference', room); if (this._historyConferenceParticipants.has(callUUID)) { let old_participants = this._historyConferenceParticipants.get(callUUID); if (old_participants.indexOf(uri) === -1) { old_participants.push(uri); } } else { let new_participants = [uri]; this._historyConferenceParticipants.set(callUUID, new_participants); } if (!this.myParticipants) { this.myParticipants = new Object(); } if (this.myParticipants.hasOwnProperty(room)) { let old_uris = this.myParticipants[room]; if (old_uris.indexOf(uri) === -1 && uri !== this.state.account.id && (uri + '@' + config.defaultDomain) !== this.state.account.id) { this.myParticipants[room].push(uri); } } else { let new_uris = []; if (uri !== this.state.account.id && (uri + '@' + config.defaultDomain) !== this.state.account.id) { new_uris.push(uri); } if (new_uris) { this.myParticipants[room] = new_uris; } } storage.set('myParticipants', this.myParticipants); } saveInvitedParties(callUUID, room, uris) { if (!this.myInvitedParties) { this.myInvitedParties = new Object(); } if (this.myInvitedParties.hasOwnProperty(room)) { let old_uris = this.myInvitedParties[room]; uris.forEach((uri) => { if (old_uris.indexOf(uri) === -1 && uri !== this.state.account.id && (uri + '@' + config.defaultDomain) !== this.state.account.id) { this.myInvitedParties[room].push(uri); } }); } else { let new_uris = []; uris.forEach((uri) => { if (uri !== this.state.account.id && (uri + '@' + config.defaultDomain) !== this.state.account.id) { new_uris.push(uri); } }); if (new_uris) { this.myInvitedParties[room] = new_uris; } } storage.set('myInvitedParties', this.myInvitedParties); } deleteHistoryEntry(uri) { let history = this.state.localHistory; for (var i = history.length - 1; i >= 0; --i) { if (history[i].remoteParty === uri) { history.splice(i,1); } } storage.set('history', history); this.setState({localHistory: history, refreshHistory: !this.state.refreshHistory}); } addHistoryEntry(uri, callUUID, direction='placed') { if (this.state.mode === MODE_NORMAL || this.state.mode === MODE_PRIVATE) { 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, media: ['audio', 'video'], displayName: 'Conference ' + uri.split('@')[0], sessionId: callUUID, startTime: startTime, stopTime: startTime, startTimeObject: current_datetime, duration: 0, tags: ['history', 'local'] }; const historyItem = Object.assign({}, item); console.log('Added history item', historyItem); let newHistory = this.state.localHistory; newHistory.push(historyItem); this.setState({localHistory: newHistory}); storage.set('history', newHistory); } } // checkRoute(nextPath, navigation, match) { // if (nextPath !== this.prevPath) { // logger.debug(`Transition from ${this.prevPath} to ${nextPath}`); // // // Press back in ready after a login, prevent initial navigation // // don't deny if there is no registrationState (connection fail) // if (this.prevPath === '/ready' && nextPath === '/login' && this.state.registrationState !== null) { // logger.debug('Transition denied redirecting to /logout'); // this.changeRoute('/logout'); // return false; // // Press back in ready after a call // } else if ((nextPath === '/call' || nextPath === '/conference') && this.state.localMedia === null && this.state.registrationState === 'registered') { // return false; // // Press back from within a call/conference, don't navigate terminate the call and // // let termination take care of navigating // } else if (nextPath === '/ready' && this.state.registrationState === 'registered' && this.state.currentCall !== null) { // this.state.currentCall.terminate(); // return false; // // Guest call ended, needed to logout and display msg and logout // } else if (nextPath === '/ready' && (this.state.mode === MODE_GUEST_CALL || this.state.mode === MODE_GUEST_CONFERENCE)) { // this.changeRoute('/logout'); // this.forceUpdate(); // } // } // this.prevPath = nextPath; // } render() { //utils.timestampedLog('Render main app'); let footerBox = ; let extraStyles = {}; if (this.state.localMedia || this.state.registrationState === 'registered') { footerBox = null; } return ( this.setState({ Width_Layout : event.nativeEvent.layout.width, Height_Layout : event.nativeEvent.layout.height }, ()=> this._detectOrientation())}> {/* */} {/* */} {/* */} ); } notFound(match) { const status = { title : '404', message : 'Oops, the page your looking for can\'t found', level : 'danger', width : 'large' } return ( ); } saveHistoryForLater(history) { //console.log('Cache history for later', history.length) this.cachedHistory = history; storage.set('cachedHistory', history); } ready() { return ( ); } preview() { return ( ); } call() { return ( ) } callByUri(urlParameters) { // check if the uri contains a domain if (urlParameters.targetUri.indexOf('@') === -1) { const status = { title : 'Invalid user', message : `Oops, the domain of the user is not set in '${urlParameters.targetUri}'`, level : 'danger', width : 'large' } return ( ); } return ( ); } conference() { let _previousParticipants = new Set(); if (this.myParticipants) { let room = this.state.targetUri.split('@')[0]; if (this.myParticipants.hasOwnProperty(room)) { let uris = this.myParticipants[room]; if (uris) { uris.forEach((uri) => { if (uri.search(config.defaultDomain) > -1) { let user = uri.split('@')[0]; _previousParticipants.add(user); } else { _previousParticipants.add(uri); } }); } } } if (this.myInvitedParties) { let room = this.state.targetUri.split('@')[0]; if (this.myInvitedParties.hasOwnProperty(room)) { let uris = this.myInvitedParties[room]; if (uris) { uris.forEach((uri) => { if (uri.search(config.defaultDomain) > -1) { let user = uri.split('@')[0]; _previousParticipants.add(user); } else { _previousParticipants.add(uri); } }); } } } let previousParticipants = Array.from(_previousParticipants); return ( ) } 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 ( ); } return ( ); } login() { let registerBox; let statusBox; if (this.state.status !== null) { statusBox = ( ); } if (this.state.registrationState !== 'registered') { registerBox = ( ); } return ( {registerBox} {statusBox} ); } logout() { this._callKeepManager.setAvailable(false); if (this.state.registrationState !== null && (this.state.mode === MODE_NORMAL || this.state.mode === MODE_PRIVATE)) { this.state.account.unregister(); } if (this.state.account !== null) { this.state.connection.removeAccount(this.state.account, (error) => { if (error) { logger.debug(error); } }); } storage.set('account', {accountId: this.state.accountId, password: ''}); this.serverHistory = []; this.setState({account: null, registrationState: null, registrationKeepalive: false, status: null, history: [], localHistory: [], cachedHistory: [] }); this.changeRoute('/login'); return null; } main() { return null; } } export default Sylk; diff --git a/app/components/AudioCallBox.js b/app/components/AudioCallBox.js index b987c6d..4b80d5a 100644 --- a/app/components/AudioCallBox.js +++ b/app/components/AudioCallBox.js @@ -1,269 +1,264 @@ import React, { Component } from 'react'; import { View, Platform } from 'react-native'; import { IconButton, Dialog, Text, ActivityIndicator, Colors } from 'react-native-paper'; import PropTypes from 'prop-types'; import autoBind from 'auto-bind'; import EscalateConferenceModal from './EscalateConferenceModal'; import CallOverlay from './CallOverlay'; import DTMFModal from './DTMFModal'; import UserIcon from './UserIcon'; import styles from '../assets/styles/blink/_AudioCallBox.scss'; import utils from '../utils'; class AudioCallBox extends Component { constructor(props) { super(props); autoBind(this); this.state = { active : false, - audioMuted : false, + audioMuted : this.props.muted, showDtmfModal : false, showEscalateConferenceModal : false, call : this.props.call, reconnectingCall : this.props.reconnectingCall }; this.remoteAudio = React.createRef(); this.userHangup = false; } componentDidMount() { // This component is used both for as 'local media' and as the in-call component. // Thus, if the call is not null it means we are beyond the 'local media' phase // so don't call the mediaPlaying prop. if (this.state.call != null) { switch (this.state.call.state) { case 'established': this.attachStream(this.state.call); break; case 'incoming': this.props.mediaPlaying(); // fall through default: this.state.call.on('stateChanged', this.callStateChanged); break; } } else { this.props.mediaPlaying(); } } componentWillUnmount() { if (this.state.call != null) { this.state.call.removeListener('stateChanged', this.callStateChanged); } } //getDerivedStateFromProps(nextProps, state) { UNSAFE_componentWillReceiveProps(nextProps) { if (nextProps.call && 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) { console.log('Audio box got prop reconnecting', nextProps.reconnectingCall); this.setState({reconnectingCall: nextProps.reconnectingCall}); } + + if (nextProps.hasOwnProperty('muted')) { + this.setState({audioMuted: nextProps.muted}); + } } componentWillUnmount() { if (this.state.call != null) { this.state.call.removeListener('stateChanged', this.callStateChanged); } clearTimeout(this.callTimer); } callStateChanged(oldState, newState, data) { if (newState === 'established') { this.attachStream(this.state.call); this.setState({reconnectingCall: false}); } } attachStream(call) { this.setState({stream: call.getRemoteStreams()[0]}); //we dont use it anywhere though as audio gets automatically piped } escalateToConference(participants) { this.props.escalateToConference(participants); } hangupCall(event) { event.preventDefault(); this.props.hangupCall('user_press_hangup'); this.userHangup = true; } cancelCall(event) { event.preventDefault(); this.props.hangupCall('user_cancelled'); } muteAudio(event) { event.preventDefault(); - const localStream = this.state.call.getLocalStreams()[0]; - const track = localStream.getAudioTracks()[0]; - - if(this.state.audioMuted) { - this.props.callKeepToggleMute(false); - track.enabled = true; - this.setState({audioMuted: false}); - } else { - track.enabled = false; - this.props.callKeepToggleMute(true); - this.setState({audioMuted: true}); - } - } + this.props.toggleMute(this.props.call.id, !this.state.audioMuted); + } showDtmfModal() { this.setState({showDtmfModal: true}); } hideDtmfModal() { this.setState({showDtmfModal: false}); } toggleEscalateConferenceModal() { this.setState({ showEscalateConferenceModal: !this.state.showEscalateConferenceModal }); } render() { let buttonContainerClass; let userIconContainerClass; let remoteIdentity = {uri: this.props.remoteUri, displayName: this.props.remoteDisplayName}; let displayName = (this.props.remoteDisplayName && this.props.remoteUri !== this.props.remoteDisplayName) ? this.props.remoteDisplayName: this.props.remoteUri; if (this.props.isTablet) { buttonContainerClass = this.props.orientation === 'landscape' ? styles.tabletLandscapeButtonContainer : styles.tabletPortraitButtonContainer; userIconContainerClass = styles.tabletUserIconContainer; } else { buttonContainerClass = this.props.orientation === 'landscape' ? styles.landscapeButtonContainer : styles.portraitButtonContainer; userIconContainerClass = styles.userIconContainer; } const buttonSize = this.props.isTablet ? 40 : 34; const buttonClass = (Platform.OS === 'ios') ? styles.iosButton : styles.androidButton; return ( {displayName} { (this.props.remoteDisplayName && this.props.remoteUri !== this.props.remoteDisplayName) ? {this.props.remoteUri} : null } {this.props.orientation !== 'landscape' && !this.userHangup && this.state.reconnectingCall ? : null } {this.state.call && this.state.call.state === 'established' ? : } ); } } AudioCallBox.propTypes = { remoteUri : PropTypes.string.isRequired, remoteDisplayName : PropTypes.string, call : PropTypes.object, connection : PropTypes.object, accountId : PropTypes.string, escalateToConference : PropTypes.func, hangupCall : PropTypes.func, mediaPlaying : PropTypes.func, callKeepSendDtmf : PropTypes.func, - callKeepToggleMute : PropTypes.func, + toggleMute : PropTypes.func, toggleSpeakerPhone : PropTypes.func, speakerPhoneEnabled : PropTypes.bool, orientation : PropTypes.string, isTablet : PropTypes.bool, - reconnectingCall : PropTypes.bool + reconnectingCall : PropTypes.bool, + muted : PropTypes.bool + }; export default AudioCallBox; diff --git a/app/components/Call.js b/app/components/Call.js index 99e1e0b..336780e 100644 --- a/app/components/Call.js +++ b/app/components/Call.js @@ -1,414 +1,417 @@ 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'; class Call extends Component { constructor(props) { super(props); autoBind(this); this.defaultWaitInterval = 60; // until we can connect or reconnect this.waitCounter = 0; this.waitInterval = this.defaultWaitInterval; let audioOnly = false; if (this.props.localMedia && this.props.localMedia.getVideoTracks().length === 0) { audioOnly = true; } let remoteUri = ''; let remoteDisplayName = ''; let callState = null; let direction = 'outgoing'; let callUUID; let callEnded = false; this.mediaIsPlaying = false; if (this.props.call !== null) { // If current call is available on mount we must have incoming this.props.call.on('stateChanged', this.callStateChanged); callState = this.props.call.state; remoteUri = this.props.call.remoteIdentity.uri; direction = this.props.call.direction; callUUID = this.props.call.id; remoteDisplayName = this.props.call.remoteIdentity.displayName; } else { remoteUri = this.props.targetUri; remoteDisplayName = this.props.targetUri; callUUID = this.props.callUUID; } if (this.props.connection) { this.props.connection.on('stateChanged', this.connectionStateChanged); } this.state = { audioOnly: audioOnly, remoteUri: remoteUri, remoteDisplayName: remoteDisplayName, connection: this.props.connection, accountId: this.props.account ? this.props.account.id : null, callState: callState, direction: direction, callUUID: callUUID, reconnectingCall: this.props.reconnectingCall } } mediaPlaying() { if (this.state.direction === 'incoming') { this.answerCall(); } else { this.mediaIsPlaying = true; } } componentDidMount() { if (this.state.direction === 'outgoing') { this.startCallWhenReady(); } } componentWillUnmount() { //console.log('Call: will unmount'); } lookupContact() { let remoteUri = ''; let remoteDisplayName = ''; if (this.props.call !== null) { remoteUri = this.props.call.remoteIdentity.uri; remoteDisplayName = this.props.call.remoteIdentity.displayName || this.props.call.remoteIdentity.uri; } else { remoteUri = this.props.targetUri; remoteDisplayName = this.props.targetUri; } if (remoteUri.indexOf('3333@') > -1) { remoteDisplayName = 'Video Test'; } else if (remoteUri.indexOf('4444@') > -1) { remoteDisplayName = 'Echo Test'; } 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; this.setState({remoteDisplayName: remoteDisplayName}); if (isPhoneNumber) { remoteUri = username; } } else { if (isPhoneNumber) { remoteUri = username; remoteDisplayName = username; } } } this.setState({remoteDisplayName: remoteDisplayName, remoteUri: remoteUri }); } //getDerivedStateFromProps(nextProps, state) { UNSAFE_componentWillReceiveProps(nextProps) { //console.log('Call: received props'); // Needed for switching to incoming call while in a call if (this.props.call != null && this.props.call != nextProps.currentCall) { if (nextProps.currentCall != null) { nextProps.currentCall.on('stateChanged', this.callStateChanged); } } if (nextProps.reconnectingCall !== this.state.reconnectingCall) { this.setState({reconnectingCall: nextProps.reconnectingCall}); } } callStateChanged(oldState, newState, data) { //console.log('Call: callStateChanged', oldState, '->', newState); let remoteHasNoVideoTracks; let remoteIsRecvOnly; let remoteIsInactive; let remoteStreams; if (newState === 'established') { this.setState({reconnectingCall: false}); const currentCall = this.props.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.props.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.props.localMedia && this.props.localMedia.getVideoTracks().length !== 0) { //console.log('Media type changed to video on accepted'); this.setState({audioOnly: false}); } } this.forceUpdate(); } connectionStateChanged(oldState, newState) { utils.timestampedLog('Call: connection state changed:', 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; this.startCallWhenReady(); } 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; } async startCallWhenReady() { if (!this.props.callUUID || !this.props.targetUri) { return; } utils.timestampedLog('Call: start call', this.props.callUUID, 'when ready to', this.props.targetUri); this.waitCounter = 0; this.lookupContact(); utils.timestampedLog('Call: waiting for establishing call', this.waitInterval, 'seconds'); let diff = 0; while (this.waitCounter < this.waitInterval) { if (this.userHangup) { this.hangupCall('user_cancelled'); return; } if (this.waitCounter >= this.waitInterval - 1) { utils.timestampedLog('Call: terminating conference', this.props.callUUID, 'that did not start yet'); this.hangupCall('timeout'); } if (!this.props.connection || this.props.connection.state !== 'ready' || this.props.registrationState !== 'registered' || !this.mediaIsPlaying ) { utils.timestampedLog('Call: waiting for connection', this.waitInterval - this.waitCounter, 'seconds'); await this._sleep(1000); } else { this.waitCounter = 0; this.call(); return; } this.waitCounter++; } } _sleep(ms) { return new Promise(resolve => setTimeout(resolve, ms)); } call() { utils.timestampedLog('Call: starting call', this.props.callUUID); if (this.props.localMedia === null) { console.log('Call: cannot create new call without local media'); return; } let options = {pcConfig: {iceServers: config.iceServers}, id: this.props.callUUID}; options.localStream = this.props.localMedia; let call = this.props.account.call(this.props.targetUri, options); call.on('stateChanged', this.callStateChanged); } answerCall() { if (this.props.call && this.props.call.state === 'incoming') { this.lookupContact(); let options = {pcConfig: {iceServers: config.iceServers}}; options.localStream = this.props.localMedia; this.props.call.answer(options); } } hangupCall(reason) { let callUUID = this.props.call ? this.props.call._callkeepUUID : this.props.callUUID; this.waitInterval = this.defaultWaitInterval; this.props.callUUID || this.props.call._callkeepUUID; if (this.props.call) { this.props.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.props.localMedia !== null) { if (this.state.audioOnly) { box = ( ); } else { if (this.props.call != null && (this.props.call.state === 'established' || this.props.call.state === 'terminated')) { box = ( ); } else { if (this.props.call && this.props.call.state === 'terminated') { //console.log('Skip render local media'); // do not render } else { //console.log('Render local media'); box = ( ); } } } } return box; } } Call.propTypes = { targetUri : PropTypes.string.isRequired, 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, - callKeepToggleMute : PropTypes.func, + toggleMute : PropTypes.func, speakerPhoneEnabled : PropTypes.bool, callUUID : PropTypes.string, contacts : PropTypes.array, intercomDtmfTone : PropTypes.string, orientation : PropTypes.string, isTablet : PropTypes.bool, - reconnectingCall : PropTypes.bool + reconnectingCall : PropTypes.bool, + muted : PropTypes.bool }; export default Call; diff --git a/app/components/Conference.js b/app/components/Conference.js index 6af93af..168927a 100644 --- a/app/components/Conference.js +++ b/app/components/Conference.js @@ -1,174 +1,178 @@ import React from 'react'; import { View } from 'react-native'; import PropTypes from 'prop-types'; import assert from 'assert'; import debug from 'react-native-debug'; import autoBind from 'auto-bind'; import ConferenceBox from './ConferenceBox'; import LocalMedia from './LocalMedia'; import config from '../config'; import utils from '../utils'; const DEBUG = debug('blinkrtc:Conference'); debug.enable('*'); class Conference extends React.Component { constructor(props) { super(props); autoBind(this); this.waitCounter = 0; this.waitInterval = 180; this.userHangup = false; } confStateChanged(oldState, newState, data) { DEBUG(`Conference state changed ${oldState} -> ${newState}`); if (newState === 'established') { this.forceUpdate(); } } hangup() { this.props.hangupCall(this.props.callUUID, 'user_press_hangup'); this.userHangup = true; } async startConferenceWhenReady() { if (!this.props.callUUID || !this.props.targetUri) { return; } utils.timestampedLog('Call: start conference', this.props.callUUID, 'when ready to', this.props.targetUri); this.waitCounter = 0; //utils.timestampedLog('Call: waiting for connecting to the conference', this.waitInterval, 'seconds'); let diff = 0; while (this.waitCounter < this.waitInterval) { if (this.userHangup) { this.props.hangupCall(this.props.callUUID, 'user_cancelled'); return; } if (this.waitCounter >= this.waitInterval - 1) { utils.timestampedLog('Call: terminating conference', this.props.callUUID, 'that did not start yet'); this.props.hangupCall(this.props.callUUID, 'timeout'); } this.waitCounter++; if (!this.props.connection || this.props.connection.state !== 'ready' || this.props.registrationState !== 'registered') { utils.timestampedLog('Call: waiting for connection', this.waitInterval - this.waitCounter, 'seconds'); await this._sleep(1000); } else { this.waitCounter = 0; this.start(); return; } } } _sleep(ms) { return new Promise(resolve => setTimeout(resolve, ms)); } start() { if (this.props.currentCall === null) { const options = { id: this.props.callUUID, pcConfig: {iceServers: config.iceServers}, localStream: this.props.localMedia, audio: this.props.proposedMedia.audio, video: this.props.proposedMedia.video, offerOptions: { offerToReceiveAudio: false, offerToReceiveVideo: false }, initialParticipants: this.props.participantsToInvite }; //console.log('Sylkrtc.js will start conference call', this.props.callUUID, 'to', this.props.targetUri.toLowerCase(), options); const confCall = this.props.account.joinConference(this.props.targetUri.toLowerCase(), options); confCall.on('stateChanged', this.confStateChanged); } else { console.log('Cannot start conference, there is already a call in progress'); } } mediaPlaying() { if (this.props.currentCall === null) { this.startConferenceWhenReady(); } } render() { let box = null; if (this.props.localMedia !== null) { if (this.props.currentCall != null && this.props.currentCall.state === 'established') { - //console.log('Render conference in call state', this.props.currentCall.state); box = ( + muted = {this.props.muted} + /> ); } else { box = ( ); } } return box; } } Conference.propTypes = { notificationCenter : PropTypes.func.isRequired, account : PropTypes.object.isRequired, connection : PropTypes.object, registrationState : PropTypes.string, hangupCall : PropTypes.func.isRequired, saveParticipant : PropTypes.func, saveInvitedParties : PropTypes.func, previousParticipants : PropTypes.array, currentCall : PropTypes.object, localMedia : PropTypes.object, targetUri : PropTypes.string, participantsToInvite : PropTypes.array, generatedVideoTrack : PropTypes.bool, + toggleMute : PropTypes.func, + toggleSpeakerPhone : PropTypes.func, callUUID : PropTypes.string, proposedMedia : PropTypes.object, isLandscape : PropTypes.bool, - isTablet : PropTypes.bool + isTablet : PropTypes.bool, + muted : PropTypes.bool }; export default Conference; diff --git a/app/components/ConferenceBox.js b/app/components/ConferenceBox.js index 5d4c77c..8e4229c 100644 --- a/app/components/ConferenceBox.js +++ b/app/components/ConferenceBox.js @@ -1,812 +1,809 @@ 'use strict'; import React, {Component, Fragment} from 'react'; import { View, Platform, TouchableWithoutFeedback, Dimensions } from 'react-native'; import PropTypes from 'prop-types'; import * as sylkrtc from 'react-native-sylkrtc'; import classNames from 'classnames'; import debug from 'react-native-debug'; import superagent from 'superagent'; import autoBind from 'auto-bind'; import { RTCView } from 'react-native-webrtc'; import { IconButton, Appbar, Portal, Modal, Surface, Paragraph } from 'react-native-paper'; import config from '../config'; import utils from '../utils'; //import AudioPlayer from './AudioPlayer'; import ConferenceDrawer from './ConferenceDrawer'; import ConferenceDrawerLog from './ConferenceDrawerLog'; // import ConferenceDrawerFiles from './ConferenceDrawerFiles'; import ConferenceDrawerParticipant from './ConferenceDrawerParticipant'; import ConferenceDrawerParticipantList from './ConferenceDrawerParticipantList'; import ConferenceDrawerSpeakerSelection from './ConferenceDrawerSpeakerSelection'; import ConferenceDrawerSpeakerSelectionWrapper from './ConferenceDrawerSpeakerSelectionWrapper'; import ConferenceHeader from './ConferenceHeader'; import ConferenceCarousel from './ConferenceCarousel'; import ConferenceParticipant from './ConferenceParticipant'; import ConferenceMatrixParticipant from './ConferenceMatrixParticipant'; import ConferenceParticipantSelf from './ConferenceParticipantSelf'; import InviteParticipantsModal from './InviteParticipantsModal'; import styles from '../assets/styles/blink/_ConferenceBox.scss'; const DEBUG = debug('blinkrtc:ConferenceBox'); debug.enable('*'); class ConferenceBox extends Component { constructor(props) { super(props); autoBind(this); this.state = { callOverlayVisible: true, - audioMuted: false, + audioMuted: this.props.muted, videoMuted: false, participants: props.call.participants.slice(), showInviteModal: false, showDrawer: false, showFiles: false, shareOverlayVisible: false, showSpeakerSelection: false, activeSpeakers: props.call.activeParticipants.slice(), selfDisplayedLarge: false, eventLog: [], sharedFiles: props.call.sharedFiles.slice(), largeVideoStream: null }; const friendlyName = this.props.remoteUri.split('@')[0]; //if (window.location.origin.startsWith('file://')) { this.callUrl = `${config.publicUrl}/conference/${friendlyName}`; //} else { // this.callUrl = `${window.location.origin}/conference/${friendlyName}`; //} const emailMessage = `You can join me in the conference using a Web browser at ${this.callUrl} ` + 'or by using the freely available Sylk WebRTC client app at http://sylkserver.com'; const subject = 'Join me, maybe?'; this.emailLink = `mailto:?subject=${encodeURI(subject)}&body=${encodeURI(emailMessage)}`; this.overlayTimer = null; this.logEvent = {}; this.haveVideo = false; this.uploads = []; this.selectSpeaker = 1; [ 'error', 'warning', 'info', 'debug' ].forEach((level) => { this.logEvent[level] = ( (action, messages, originator) => { const log = this.state.eventLog.slice(); log.unshift({originator, originator, level: level, action: action, messages: messages}); this.setState({eventLog: log}); } ); }); } componentDidMount() { for (let p of this.state.participants) { p.on('stateChanged', this.onParticipantStateChanged); p.attach(); } this.props.call.on('participantJoined', this.onParticipantJoined); this.props.call.on('participantLeft', this.onParticipantLeft); this.props.call.on('roomConfigured', this.onConfigureRoom); this.props.call.on('fileSharing', this.onFileSharing); this.armOverlayTimer(); // attach to ourselves first if there are no other participants if (this.state.participants.length === 0) { setTimeout(() => { const item = { stream: this.props.call.getLocalStreams()[0], identity: this.props.call.localIdentity }; this.selectVideo(item); }); } else { this.state.participants.forEach((p) => { if (p.identity._uri.search('guest.') === -1) { // used for history item this.props.saveParticipant(this.props.call.id, this.props.remoteUri.split('@')[0], p.identity._uri); } }); // this.changeResolution(); } if (this.props.call.getLocalStreams()[0].getVideoTracks().length !== 0) { this.haveVideo = true; } } componentWillUnmount() { clearTimeout(this.overlayTimer); this.uploads.forEach((upload) => { this.props.notificationCenter().removeNotification(upload[1]); upload[0].abort(); }) } + //getDerivedStateFromProps(nextProps, state) { + UNSAFE_componentWillReceiveProps(nextProps) { + if (nextProps.hasOwnProperty('muted')) { + this.setState({audioMuted: nextProps.muted}); + } + } + onParticipantJoined(p) { DEBUG(`Participant joined: ${p.identity}`); if (p.identity._uri.search('guest.') === -1) { // used for history item this.props.saveParticipant(this.props.call.id, this.props.remoteUri.split('@')[0], p.identity._uri); } // this.refs.audioPlayerParticipantJoined.play(); p.on('stateChanged', this.onParticipantStateChanged); p.attach(); this.setState({ participants: this.state.participants.concat([p]) }); // this.changeResolution(); } onParticipantLeft(p) { DEBUG(`Participant left: ${p.identity}`); // this.refs.audioPlayerParticipantLeft.play(); const participants = this.state.participants.slice(); const idx = participants.indexOf(p); if (idx !== -1) { participants.splice(idx, 1); this.setState({ participants: participants }); } p.detach(true); // this.changeResolution(); } onParticipantStateChanged(oldState, newState) { if (newState === 'established' || newState === null) { this.maybeSwitchLargeVideo(); } } onConfigureRoom(config) { const newState = {}; newState.activeSpeakers = config.activeParticipants; this.setState(newState); if (config.activeParticipants.length === 0) { this.logEvent.info('set speakers to', ['Nobody'], config.originator); } else { const speakers = config.activeParticipants.map((p) => {return p.identity.displayName || p.identity.uri}); this.logEvent.info('set speakers to', speakers, config.originator); } this.maybeSwitchLargeVideo(); } onFileSharing(files) { let stateFiles = this.state.sharedFiles; stateFiles = stateFiles.concat(files); this.setState({sharedFiles: stateFiles}); files.forEach((file)=>{ if (file.session !== this.props.call.id) { this.props.notificationCenter().postFileShared(file, this.showFiles); } }) } onVideoSelected(item) { const participants = this.state.participants.slice(); const idx = participants.indexOf(item); participants.splice(idx, 1); participants.unshift(item); if (item.videoPaused) { item.resumeVideo(); } this.setState({ participants: participants }); } changeResolution() { let stream = this.props.call.getLocalStreams()[0]; if (this.state.participants.length < 2) { this.props.call.scaleLocalTrack(stream, 1.5); } else if (this.state.participants.length < 5) { this.props.call.scaleLocalTrack(stream, 2); } else { this.props.call.scaleLocalTrack(stream, 1); } } selectVideo(item) { DEBUG('Switching video to: %o', item); if (item.stream) { this.setState({selfDisplayedLarge: true, largeVideoStream: item.stream}); } } maybeSwitchLargeVideo() { // Switch the large video to another source, maybe. if (this.state.participants.length === 0 && !this.state.selfDisplayedLarge) { // none of the participants are eligible, show ourselves const item = { stream: this.props.call.getLocalStreams()[0], identity: this.props.call.localIdentity }; this.selectVideo(item); } else if (this.state.selfDisplayedLarge) { this.setState({selfDisplayedLarge: false}); } } handleClipboardButton() { utils.copyToClipboard(this.callUrl); this.props.notificationCenter().postSystemNotification('Join me, maybe?', {body: 'Link copied to the clipboard'}); this.setState({shareOverlayVisible: false}); } handleEmailButton(event) { // if (navigator.userAgent.indexOf('Chrome') > 0) { // let emailWindow = window.open(this.emailLink, '_blank'); // setTimeout(() => { // emailWindow.close(); // }, 500); // } else { // window.open(this.emailLink, '_self'); // } this.setState({shareOverlayVisible: false}); } handleShareOverlayEntered() { this.setState({shareOverlayVisible: true}); } handleShareOverlayExited() { this.setState({shareOverlayVisible: false}); } handleActiveSpeakerSelected(participant, secondVideo=false) { // eslint-disable-line space-infix-ops let newActiveSpeakers = this.state.activeSpeakers.slice(); if (secondVideo) { if (participant.id !== 'none') { if (newActiveSpeakers.length >= 1) { newActiveSpeakers[1] = participant; } else { newActiveSpeakers[0] = participant; } } else { newActiveSpeakers.splice(1,1); } } else { if (participant.id !== 'none') { newActiveSpeakers[0] = participant; } else { newActiveSpeakers.shift(); } } this.props.call.configureRoom(newActiveSpeakers.map((element) => element.publisherId), (error) => { if (error) { // This causes a state update, hence the drawer lists update this.logEvent.error('set speakers failed', [], this.localIdentity); } }); } handleDrop(files) { DEBUG('Dropped file %o', files); this.uploadFiles(files); }; handleFiles(e) { DEBUG('Selected files %o', e.target.files); this.uploadFiles(e.target.files); event.target.value = ''; } toggleSpeakerSelection() { this.setState({showSpeakerSelection: !this.state.showSpeakerSelection}); } startSpeakerSelection(number) { this.selectSpeaker = number; this.toggleSpeakerSelection(); } uploadFiles(files) { for (var key in files) { // is the item a File? if (files.hasOwnProperty(key) && files[key] instanceof File) { let uploadRequest; let complete = false; const filename = files[key].name let progressNotification = this.props.notificationCenter().postFileUploadProgress( filename, (notification) => { if (!complete) { uploadRequest.abort(); this.uploads.splice(this.uploads.indexOf(uploadRequest), 1); } } ); uploadRequest = superagent .post(`${config.fileSharingUrl}/${this.props.remoteUri}/${this.props.call.id}/${filename}`) .send(files[key]) .on('progress', (e) => { this.props.notificationCenter().editFileUploadNotification(e.percent, progressNotification); }) .end((err, response) => { complete = true; this.props.notificationCenter().removeFileUploadNotification(progressNotification); if (err) { this.props.notificationCenter().postFileUploadFailed(filename); } this.uploads.splice(this.uploads.indexOf(uploadRequest), 1); }); this.uploads.push([uploadRequest, progressNotification]); } } } downloadFile(filename) { // const a = document.createElement('a'); // a.href = `${config.fileSharingUrl}/${this.props.remoteUri}/${this.props.call.id}/${filename}`; // a.target = '_blank'; // a.download = filename; // const clickEvent = document.createEvent('MouseEvent'); // clickEvent.initMouseEvent('click', true, true, window, 0, // clickEvent.screenX, clickEvent.screenY, clickEvent.clientX, clickEvent.clientY, // clickEvent.ctrlKey, clickEvent.altKey, clickEvent.shiftKey, clickEvent.metaKey, // 0, null); // a.dispatchEvent(clickEvent); } preventOverlay(event) { // Stop the overlay when we are the thumbnail bar event.stopPropagation(); } muteAudio(event) { event.preventDefault(); - const localStream = this.props.call.getLocalStreams()[0]; - if (localStream.getAudioTracks().length > 0) { - const track = localStream.getAudioTracks()[0]; - if(this.state.audioMuted) { - DEBUG('Unmute microphone'); - track.enabled = true; - this.setState({audioMuted: false}); - } else { - DEBUG('Mute microphone'); - track.enabled = false; - this.setState({audioMuted: true}); - } - } - } + this.props.toggleMute(this.props.call.id, !this.state.audioMuted); + } toggleCamera(event) { event.preventDefault(); const localStream = this.props.call.getLocalStreams()[0]; if (localStream.getVideoTracks().length > 0) { const track = localStream.getVideoTracks()[0]; track._switchCamera(); } } muteVideo(event) { event.preventDefault(); const localStream = this.props.call.getLocalStreams()[0]; if (localStream.getVideoTracks().length > 0) { const track = localStream.getVideoTracks()[0]; if (this.state.videoMuted) { DEBUG('Unmute camera'); track.enabled = true; this.setState({videoMuted: false}); } else { DEBUG('Mute camera'); track.enabled = false; this.setState({videoMuted: true}); } } } hangup(event) { event.preventDefault(); for (let participant of this.state.participants) { participant.detach(); } this.props.hangup(); } armOverlayTimer() { clearTimeout(this.overlayTimer); this.overlayTimer = setTimeout(() => { this.setState({callOverlayVisible: false}); }, 4000); } showOverlay() { // if (!this.state.shareOverlayVisible && !this.state.showDrawer && !this.state.showFiles) { // if (!this.state.callOverlayVisible) { this.setState({callOverlayVisible: !this.state.callOverlayVisible}); // } // this.armOverlayTimer(); // } } toggleInviteModal() { this.setState({showInviteModal: !this.state.showInviteModal}); } toggleDrawer() { this.setState({callOverlayVisible: true, showDrawer: !this.state.showDrawer, showFiles: false, showSpeakerSelection: false}); clearTimeout(this.overlayTimer); } toggleFiles() { this.setState({callOverlayVisible: true, showFiles: !this.state.showFiles, showDrawer: false}); clearTimeout(this.overlayTimer); } showFiles() { this.setState({callOverlayVisible: true, showFiles: true, showDrawer: false}); clearTimeout(this.overlayTimer); } inviteParticipants(uris) { console.log('Invite participants', uris); this.props.saveInvitedParties(this.props.call.id, this.props.remoteUri.split('@')[0], uris); this.props.call.inviteParticipants(uris); } render() { if (this.props.call === null) { return (); } let watermark; const largeVideoClasses = classNames({ 'animated' : true, 'fadeIn' : true, 'large' : true, 'mirror' : !this.props.call.sharingScreen && !this.props.generatedVideoTrack, 'fit' : this.props.call.sharingScreen }); let matrixClasses = classNames({ 'matrix' : true }); const containerClasses = classNames({ 'video-container': true, 'conference': true, 'drawer-visible': this.state.showDrawer || this.state.showFiles }); const remoteUri = this.props.remoteUri.split('@')[0]; // const shareOverlay = ( // // // // // Invite other online users of this service, share this link with others or email, so they can easily join this conference. // // // // // // // // // // // // ); const buttons = {}; // const commonButtonTopClasses = classNames({ // 'btn' : true, // 'btn-link' : true // }); // const fullScreenButtonIcons = classNames({ // 'fa' : true, // 'fa-2x' : true, // 'fa-expand' : !this.isFullScreen(), // 'fa-compress' : this.isFullScreen() // }); const topButtons = []; // if (!this.state.showFiles) { // if (this.state.sharedFiles.length !== 0) { // topButtons.push( // // // // ); // } // } if (!this.state.showDrawer) { topButtons.push(); } buttons.top = {right: topButtons}; const muteButtonIcons = this.state.audioMuted ? 'microphone-off' : 'microphone'; const muteVideoButtonIcons = this.state.videoMuted ? 'video-off' : 'video'; const buttonClass = (Platform.OS === 'ios') ? styles.iosButton : styles.androidButton; const bottomButtons = []; bottomButtons.push( ); if (this.haveVideo) { bottomButtons.push( ); } bottomButtons.push( ); if (this.haveVideo) { bottomButtons.push( ); } bottomButtons.push( ) // bottomButtons.push( // // // // ); bottomButtons.push( ); buttons.bottom = bottomButtons; const participants = []; if (this.state.participants.length > 0) { if (this.state.activeSpeakers.findIndex((element) => {return element.id === this.props.call.id}) === -1) { participants.push( ); } } const drawerParticipants = []; drawerParticipants.push( ); let videos = []; if (this.state.participants.length === 0) { videos.push( ); } else { const activeSpeakers = this.state.activeSpeakers; const activeSpeakersCount = activeSpeakers.length; if (activeSpeakersCount > 0) { activeSpeakers.forEach((p) => { videos.push( ); }); this.state.participants.forEach((p) => { if (this.state.activeSpeakers.indexOf(p) === -1) { participants.push( {}} pauseVideo={true} display={false} /> ); } drawerParticipants.push( ); }); } else { this.state.participants.forEach((p, idx) => { videos.push( = 4) || (idx >= 2 && this.props.isTablet === false)} isLandscape={this.props.isLandscape} isTablet={this.props.isTablet} useTwoRows={this.state.participants.length > 2} /> ); if (idx >= 4 || idx >= 2 && this.props.isTablet === false) { participants.push( ); } drawerParticipants.push( ); }); } } // let filesDrawerContent = ( // // ); return ( {videos} {participants} {drawerParticipants} ); } } ConferenceBox.propTypes = { notificationCenter : PropTypes.func.isRequired, call : PropTypes.object, connection : PropTypes.object, hangup : PropTypes.func, saveParticipant : PropTypes.func, saveInvitedParties : PropTypes.func, previousParticipants: PropTypes.array, remoteUri : PropTypes.string, generatedVideoTrack : PropTypes.bool, + toggleMute : PropTypes.func, toggleSpeakerPhone : PropTypes.func, speakerPhoneEnabled : PropTypes.bool, isLandscape : PropTypes.bool, - isTablet : PropTypes.bool + isTablet : PropTypes.bool, + muted : PropTypes.bool }; export default ConferenceBox; diff --git a/app/components/VideoBox.js b/app/components/VideoBox.js index 413d5e8..635b481 100644 --- a/app/components/VideoBox.js +++ b/app/components/VideoBox.js @@ -1,375 +1,369 @@ import React, { Component } from 'react'; import PropTypes from 'prop-types'; import classNames from 'classnames'; import dtmf from 'react-native-dtmf'; import debug from 'react-native-debug'; import autoBind from 'auto-bind'; import { IconButton, ActivityIndicator, Colors } from 'react-native-paper'; import { View, Dimensions, TouchableWithoutFeedback, Platform } from 'react-native'; import { RTCView } from 'react-native-webrtc'; import CallOverlay from './CallOverlay'; import EscalateConferenceModal from './EscalateConferenceModal'; import DTMFModal from './DTMFModal'; import config from '../config'; import styles from '../assets/styles/blink/_VideoBox.scss'; const DEBUG = debug('blinkrtc:Video'); debug.enable('*'); class VideoBox extends Component { constructor(props) { super(props); autoBind(this); this.state = { callOverlayVisible: true, - audioMuted: false, + audioMuted: this.props.muted, videoMuted: false, localVideoShow: false, remoteVideoShow: false, remoteSharesScreen: false, showEscalateConferenceModal: false, localStream: null, remoteStream: null, showDtmfModal: false, doorOpened: false }; this.overlayTimer = null; this.localVideo = React.createRef(); this.remoteVideo = React.createRef(); this.userHangup = false; } + //getDerivedStateFromProps(nextProps, state) { + UNSAFE_componentWillReceiveProps(nextProps) { + if (nextProps.hasOwnProperty('muted')) { + this.setState({audioMuted: nextProps.muted}); + } + } + callStateChanged(oldState, newState, data) { this.forceUpdate(); } openDoor() { const tone = this.props.intercomDtmfTone; DEBUG('DTMF tone sent to intercom: ' + tone); this.setState({doorOpened: true}); this.forceUpdate(); dtmf.stopTone(); //don't play a tone at the same time as another dtmf.playTone(dtmf['DTMF_' + tone], 1000); if (this.props.call !== null && this.props.call.state === 'established') { this.props.call.sendDtmf(tone); /*this.props.notificationCenter.postSystemNotification('Door opened', {timeout: 5});*/ } } componentDidMount() { this.setState({ localStream: this.props.call.getLocalStreams()[0], localVideoShow: true, remoteStream: this.props.call.getRemoteStreams()[0], remoteVideoShow: true }); if (this.props.call) { this.props.call.on('stateChanged', this.callStateChanged); } this.armOverlayTimer(); } componentWillUnmount() { if (this.props.call != null) { this.props.call.removeListener('stateChanged', this.callStateChanged); } } showDtmfModal() { this.setState({showDtmfModal: true}); } hideDtmfModal() { this.setState({showDtmfModal: false}); } handleFullscreen(event) { event.preventDefault(); // this.toggleFullscreen(); } handleRemoteVideoPlaying() { this.setState({remoteVideoShow: true}); } handleRemoteResize(event, target) { const resolutions = [ '1280x720', '960x540', '640x480', '640x360', '480x270','320x180']; const videoResolution = event.target.videoWidth + 'x' + event.target.videoHeight; if (resolutions.indexOf(videoResolution) === -1) { this.setState({remoteSharesScreen: true}); } else { this.setState({remoteSharesScreen: false}); } } muteAudio(event) { event.preventDefault(); - const localStream = this.state.localStream; - if (localStream.getAudioTracks().length > 0) { - const track = localStream.getAudioTracks()[0]; - if(this.state.audioMuted) { - DEBUG('Unmute microphone'); - track.enabled = true; - this.props.callKeepToggleMute(false); - this.setState({audioMuted: false}); - } else { - DEBUG('Mute microphone'); - track.enabled = false; - this.props.callKeepToggleMute(true); - this.setState({audioMuted: true}); - } - } + this.props.toggleMute(this.props.call.id, !this.state.audioMuted); } muteVideo(event) { event.preventDefault(); const localStream = this.state.localStream; if (localStream.getVideoTracks().length > 0) { const track = localStream.getVideoTracks()[0]; if(this.state.videoMuted) { DEBUG('Unmute camera'); track.enabled = true; this.setState({videoMuted: false}); } else { DEBUG('Mute camera'); track.enabled = false; this.setState({videoMuted: true}); } } } toggleCamera(event) { event.preventDefault(); const localStream = this.state.localStream; if (localStream.getVideoTracks().length > 0) { const track = localStream.getVideoTracks()[0]; track._switchCamera(); } } hangupCall(event) { event.preventDefault(); this.props.hangupCall('user_press_hangup'); this.userHangup = true; } cancelCall(event) { event.preventDefault(); this.props.hangupCall('user_cancelled'); } escalateToConference(participants) { this.props.escalateToConference(participants); } armOverlayTimer() { clearTimeout(this.overlayTimer); this.overlayTimer = setTimeout(() => { this.setState({callOverlayVisible: false}); }, 4000); } toggleCallOverlay() { this.setState({callOverlayVisible: !this.state.callOverlayVisible}); } toggleEscalateConferenceModal() { this.setState({ callOverlayVisible : false, showEscalateConferenceModal : !this.state.showEscalateConferenceModal }); } render() { if (this.props.call === null) { return null; } // 'mirror' : !this.props.call.sharingScreen && !this.props.generatedVideoTrack, // we do not want mirrored local video once the call has started, just in preview const localVideoClasses = classNames({ 'video-thumbnail' : true, 'hidden' : !this.state.localVideoShow, 'animated' : true, 'fadeIn' : this.state.localVideoShow || this.state.videoMuted, 'fadeOut' : this.state.videoMuted, 'fit' : this.props.call.sharingScreen }); const remoteVideoClasses = classNames({ 'poster' : !this.state.remoteVideoShow, 'animated' : true, 'fadeIn' : this.state.remoteVideoShow, 'large' : true, 'fit' : this.state.remoteSharesScreen }); let buttonContainerClass; let userIconContainerClass; let buttons; const muteButtonIcons = this.state.audioMuted ? 'microphone-off' : 'microphone'; const muteVideoButtonIcons = this.state.videoMuted ? 'video-off' : 'video'; const buttonClass = (Platform.OS === 'ios') ? styles.iosButton : styles.androidButton; const buttonSize = this.props.isTablet ? 40 : 34; if (this.props.isTablet) { buttonContainerClass = this.props.orientation === 'landscape' ? styles.tabletLandscapeButtonContainer : styles.tabletPortraitButtonContainer; userIconContainerClass = styles.tabletUserIconContainer; } else { buttonContainerClass = this.props.orientation === 'landscape' ? styles.landscapeButtonContainer : styles.portraitButtonContainer; userIconContainerClass = styles.userIconContainer; } if (this.state.callOverlayVisible) { let content = ( ); if (this.props.intercomDtmfTone) { content = ( ); } buttons = ({content}); } const remoteStreamUrl = this.state.remoteStream ? this.state.remoteStream.toURL() : null //console.log('Render remote video stream Url', remoteStreamUrl); return ( {this.state.remoteVideoShow && !this.props.reconnectingCall ? : null } { this.state.localVideoShow ? : null } {this.props.reconnectingCall ? : null } {buttons} ); } } VideoBox.propTypes = { call : PropTypes.object, connection : PropTypes.object, accountId : PropTypes.string, remoteUri : PropTypes.string, remoteDisplayName : PropTypes.string, localMedia : PropTypes.object, hangupCall : PropTypes.func, shareScreen : PropTypes.func, escalateToConference : PropTypes.func, generatedVideoTrack : PropTypes.bool, callKeepSendDtmf : PropTypes.func, - callKeepToggleMute : PropTypes.func, + toggleMute : PropTypes.func, toggleSpeakerPhone : PropTypes.func, speakerPhoneEnabled : PropTypes.bool, intercomDtmfTone : PropTypes.string, orientation : PropTypes.string, isTablet : PropTypes.bool, - reconnectingCall : PropTypes.bool + reconnectingCall : PropTypes.bool, + muted : PropTypes.bool }; export default VideoBox;