public void CallState(LinphoneCall call, LinphoneCallState state, string message) { WriteLog("CallState: {0} | {1}", state, message); switch (state) { case LinphoneCallState.IncomingReceived: this.UIThreadInvoke(() => AcceptCall(call, message)); break; case LinphoneCallState.OutgoingRinging: this.UIThreadInvoke(() => WriteLog("Ringing")); break; case LinphoneCallState.Connected: this.UIThreadInvoke(() => WriteLog("Talking")); this.UIThreadInvoke(() => this.btnCall.Text = "Hangup"); break; case LinphoneCallState.CallEnd: this.UIThreadInvoke(() => WriteLog("Call ended")); this.UIThreadInvoke(() => this.btnCall.Text = "Call"); break; default: break; } }
/// <summary> /// Called when the call changes its state to paused or resumed. /// </summary> public void PauseStateChanged(LinphoneCall call, bool isCallPaused, bool isCallPausedByRemote) { if (this.PauseListener != null) { this.PauseListener.PauseStateChanged(call, isCallPaused, isCallPausedByRemote); } }
/// <summary> /// Called when the call is updated by the remote party. /// </summary> /// <param name="call">The call that has been updated</param> /// <param name="isVideoAdded">A boolean telling whether the remote party added video</param> public void CallUpdatedByRemote(LinphoneCall call, bool isVideoAdded) { if (this.CallUpdatedByRemoteListener != null) { this.CallUpdatedByRemoteListener.CallUpdatedByRemote(call, isVideoAdded); } }
/// <summary> /// Method called when the page is displayed. /// Searches for a matching contact using the current call address or number and display information if found. /// </summary> protected override void OnNavigatedTo(NavigationEventArgs nee) { base.OnNavigatedTo(nee); this.ViewModel.MuteListener = this; this.ViewModel.PauseListener = this; this.ViewModel.CallUpdatedByRemoteListener = this; LinphoneManager.Instance.CallStateChanged += CallStateChanged; AudioRoutingManager.GetDefault().AudioEndpointChanged += AudioEndpointChanged; if (NavigationContext.QueryString.ContainsKey("sip")) { String calledNumber = NavigationContext.QueryString["sip"]; LinphoneAddress address = LinphoneManager.Instance.LinphoneCore.InterpretURL(calledNumber); calledNumber = String.Format("{0}@{1}", address.UserName, address.Domain); // While we dunno if the number matches a contact one, we consider it won't and we display the phone number as username Contact.Text = calledNumber; if (calledNumber != null && calledNumber.Length > 0) { ContactManager cm = ContactManager.Instance; cm.ContactFound += cm_ContactFound; cm.FindContact(calledNumber); } } ApplicationSettingsManager settings = new ApplicationSettingsManager(); settings.Load(); // Callback CallStateChanged set too late when call is incoming, so trigger it manually if (LinphoneManager.Instance.LinphoneCore.CallsNb > 0) { LinphoneCall call = (LinphoneCall)LinphoneManager.Instance.LinphoneCore.Calls[0]; if (call.State == LinphoneCallState.StreamsRunning) { CallStateChanged(call, LinphoneCallState.StreamsRunning); if (settings.VideoActiveWhenGoingToBackground) { LinphoneManager.Instance.LinphoneCore.VideoPolicy.AutomaticallyAccept = settings.VideoAutoAcceptWhenGoingToBackground; LinphoneCallParams callParams = call.GetCurrentParamsCopy(); callParams.VideoEnabled = true; LinphoneManager.Instance.LinphoneCore.UpdateCall(call, callParams); } } else if (call.State == LinphoneCallState.UpdatedByRemote) { // The call was updated by the remote party while we were in background LinphoneManager.Instance.CallState(call, call.State, "call updated while in background"); } } settings.VideoActiveWhenGoingToBackground = false; settings.Save(); oneSecondTimer = new DispatcherTimer(); oneSecondTimer.Interval = TimeSpan.FromSeconds(1); oneSecondTimer.Tick += timerTick; oneSecondTimer.Start(); }
public void CallState(LinphoneCall call, LinphoneCallState state, string message) { WriteLog("CallState: {0} | {1}", state, message); if (state == LinphoneCallState.IncomingReceived) { this.Lc.AcceptCall(call); } }
public void CallState(LinphoneCall call, LinphoneCallState state, string message) { Console.WriteLine("CallState: {0} | {1}", state, message); if (state == LinphoneCallState.IncomingReceived) { this.Lc.AcceptCall(call); } }
/// <summary> /// Pauses the current call if any and if it's running. /// </summary> public void PauseCurrentCall() { if (LinphoneCore.CallsNb > 0) { LinphoneCall call = LinphoneCore.CurrentCall; LinphoneCore.PauseCall(call); } }
public LinphoneCall GetCurrentCall() { LinphoneCall call = LinphoneManager.Instance.LinphoneCore.CurrentCall; if (call == null) { if (LinphoneManager.Instance.LinphoneCore.CallsNb > 0) { call = (LinphoneCall)LinphoneManager.Instance.LinphoneCore.Calls[0]; } } return(call); }
/// <summary> /// Called when user rotates the device /// </summary> public void OrientationChanged(object sender, Microsoft.Phone.Controls.OrientationChangedEventArgs e) { PageOrientation = e.Orientation; Logger.Msg("[InCall] OrientationChanged"); if (IsVideoActive) { HideVideo(); ShowVideo(); LinphoneCall call = GetCurrentCall(); if (call != null) { call.SendVFURequest(); } } }
/// <summary> /// Called when a call is finished. /// Goes back to the last page if possible, else displays Dialer.xaml. /// </summary> public void CallEnded(LinphoneCall call) { Debug.WriteLine("[CallListener] Call ended, can go back ? " + this.Page.NavigationService.CanGoBack); if (this.Page.NavigationService.CanGoBack) { this.Page.NavigationService.GoBack(); } else { // Launch the Dialer and remove the incall view from the backstack this.Page.NavigationService.Navigate(new Uri("/Views/Dialer.xaml", UriKind.RelativeOrAbsolute)); this.Page.NavigationService.RemoveBackEntry(); } }
/// <summary> /// Called when the call changes its state to paused or resumed. /// </summary> public void PauseStateChanged(LinphoneCall call, bool isCallPaused, bool isCallPausedByRemote) { buttons.pause.IsChecked = isCallPaused || isCallPausedByRemote; buttons_landscape.pause.IsChecked = isCallPaused || isCallPausedByRemote; buttons.pauseImg.Source = new BitmapImage(new Uri(isCallPaused || isCallPausedByRemote ? pauseOn : pauseOff, UriKind.RelativeOrAbsolute)); buttons_landscape.pauseImg.Source = new BitmapImage(new Uri(isCallPaused || isCallPausedByRemote ? pauseOn : pauseOff, UriKind.RelativeOrAbsolute)); if (!isCallPaused && !isCallPausedByRemote) { if (call.GetCurrentParamsCopy().VideoEnabled&& !((InCallModel)ViewModel).IsVideoActive) { // Show video if it was not shown yet ((InCallModel)ViewModel).IsVideoActive = true; buttons.video.IsChecked = true; buttons_landscape.video.IsChecked = true; buttons.videoImg.Source = new BitmapImage(new Uri(videoOn, UriKind.RelativeOrAbsolute)); buttons_landscape.videoImg.Source = new BitmapImage(new Uri(videoOn, UriKind.RelativeOrAbsolute)); ButtonsFadeInVideoAnimation.Begin(); StartFadeTimer(); } else if (!call.GetCurrentParamsCopy().VideoEnabled&& ((InCallModel)ViewModel).IsVideoActive) { // Stop video if it is no longer active ((InCallModel)ViewModel).IsVideoActive = false; buttons.video.IsChecked = false; buttons_landscape.video.IsChecked = false; buttons.videoImg.Source = new BitmapImage(new Uri(videoOff, UriKind.RelativeOrAbsolute)); buttons_landscape.videoImg.Source = new BitmapImage(new Uri(videoOff, UriKind.RelativeOrAbsolute)); ButtonsFadeInAudioAnimation.Begin(); StopFadeTimer(); } if (((InCallModel)ViewModel).IsVideoActive) { ButtonsFadeOutAnimation.Begin(); } } else { ((InCallModel)ViewModel).IsVideoActive = false; ((InCallModel)ViewModel).ShowButtonsAndPanel(); ButtonsFadeInAudioAnimation.Begin(); StopFadeTimer(); } }
/// <summary> /// Stops the current call if any. /// </summary> public void EndCurrentCall() { LinphoneCall call = LinphoneCore.CurrentCall; if (call != null) { LinphoneCore.TerminateCall(call); } else { foreach (LinphoneCall lCall in LinphoneCore.Calls) { if (lCall.State == LinphoneCallState.Paused) { LinphoneCore.TerminateCall(lCall); } } } }
/// <summary> /// Enables disables video. /// </summary> /// <param name="enable">Wether to enable or disable video</param> /// <returns>true if the operation has been successful, false otherwise</returns> public bool EnableVideo(bool enable) { if (LinphoneCore.InCall) { LinphoneCall call = LinphoneCore.CurrentCall; LinphoneCallParams parameters = call.GetCurrentParamsCopy(); if (enable != parameters.VideoEnabled) { parameters.VideoEnabled = enable; if (enable) { // TODO: Handle bandwidth limitation } LinphoneCore.UpdateCall(call, parameters); return(true); } } return(false); }
public void TerminateCall(Call call) { if (call == null) { throw new ArgumentNullException("call"); } if (linphoneCore == IntPtr.Zero || !running) { if (ErrorEvent != null) { ErrorEvent(call, "Cannot make or receive calls when Linphone Core is not working."); } return; } LinphoneCall linphonecall = (LinphoneCall)call; linphone_core_terminate_call(linphoneCore, linphonecall.LinphoneCallPtr); }
public void SendDTMFs(Call call, string dtmfs) { if (call == null) { throw new ArgumentNullException("call"); } if (linphoneCore == IntPtr.Zero || !running) { if (ErrorEvent != null) { ErrorEvent(call, "Cannot make or receive calls when Linphone Core is not working."); } return; } LinphoneCall linphonecall = (LinphoneCall)call; linphone_call_send_dtmfs(linphonecall.LinphoneCallPtr, dtmfs); }
/// <summary> /// Toggles the camera used for video capture. /// </summary> public void ToggleCameras() { if (NumberOfCameras >= 2) { String currentDevice = LinphoneCore.VideoDevice; if (currentDevice == frontCamera) { LinphoneCore.VideoDevice = backCamera; } else if (currentDevice == backCamera) { LinphoneCore.VideoDevice = frontCamera; } if (LinphoneCore.InCall) { LinphoneCall call = LinphoneCore.CurrentCall; LinphoneCore.UpdateCall(call, null); } } }
public void ReceiveCall(Call call) { if (call == null) { throw new ArgumentNullException("call"); } if (linphoneCore == IntPtr.Zero || !running) { if (ErrorEvent != null) { ErrorEvent(call, "Cannot receive call when Linphone Core is not working."); } return; } LinphoneCall linphonecall = (LinphoneCall)call; linphone_call_params_set_record_file(callsDefaultParams, null); linphone_core_accept_call_with_params(linphoneCore, linphonecall.LinphoneCallPtr, callsDefaultParams); }
private void LookupForContact(LinphoneCall call) { try { LinphoneAddress remoteAddress = call.RemoteAddress; if (remoteAddress.DisplayName.Length == 0) { string sipAddress = String.Format("{0}@{1}", remoteAddress.UserName, remoteAddress.Domain); Logger.Msg("[LinphoneManager] Display name null, looking for remote address in contact: " + sipAddress + "\r\n"); ContactManager.ContactFound += OnContactFound; ContactManager.FindContact(sipAddress); } else { Logger.Msg("[LinphoneManager] Display name found: " + call.RemoteAddress.DisplayName + "\r\n"); } } catch { Logger.Warn("[LinphoneManager] Exception occured while looking for contact...\r\n"); } }
/// <summary> /// Method called when the page is leaved. /// </summary> protected override void OnNavigatedFrom(NavigationEventArgs nee) { if (((InCallModel)ViewModel).IsVideoActive) { LinphoneCall call = null; try { call = (LinphoneCall)LinphoneManager.Instance.LinphoneCore.Calls[0]; } catch (System.ArgumentOutOfRangeException) { } if (call != null) { ApplicationSettingsManager settings = new ApplicationSettingsManager(); settings.Load(); settings.VideoActiveWhenGoingToBackground = true; settings.VideoAutoAcceptWhenGoingToBackground = LinphoneManager.Instance.LinphoneCore.VideoPolicy.AutomaticallyAccept; settings.Save(); LinphoneManager.Instance.LinphoneCore.VideoPolicy.AutomaticallyAccept = false; LinphoneCallParams callParams = call.GetCurrentParamsCopy(); callParams.VideoEnabled = false; LinphoneManager.Instance.LinphoneCore.UpdateCall(call, callParams); } } oneSecondTimer.Stop(); if (fadeTimer != null) { fadeTimer.Dispose(); fadeTimer = null; } base.OnNavigatedFrom(nee); this.ViewModel.MuteListener = null; this.ViewModel.PauseListener = null; LinphoneManager.Instance.CallStateChanged -= CallStateChanged; AudioRoutingManager.GetDefault().AudioEndpointChanged -= AudioEndpointChanged; }
/// <summary> /// Called when the call is updated by the remote party. /// </summary> /// <param name="call">The call that has been updated</param> /// <param name="isVideoAdded">A boolean telling whether the remote party added video</param> public void CallUpdatedByRemote(LinphoneCall call, bool isVideoAdded) { if (isVideoAdded) { Guide.BeginShowMessageBox(AppResources.VideoActivationPopupCaption, AppResources.VideoActivationPopupContent, new List <String> { "Accept", "Dismiss" }, 0, MessageBoxIcon.Alert, asyncResult => { int?res = Guide.EndShowMessageBox(asyncResult); LinphoneCallParams parameters = call.GetCurrentParamsCopy(); if (res == 0) { parameters.VideoEnabled = true; } LinphoneManager.Instance.LinphoneCore.AcceptCallUpdate(call, parameters); }, null); } }
public void CallStatsUpdated(LinphoneCall call, LinphoneCallStats stats) { Console.WriteLine("CallStatsUpdated: U:{0} | D:{1}", stats.UploadBandwidth, stats.DownloadBandwidth); }
public void DTMFReceived(LinphoneCall call, char dtmf) { Console.WriteLine("DTMFReceived"); }
public void CallStatsUpdated(LinphoneCall call, LinphoneCallStats stats) { WriteLog("CallStatsUpdated: U:{0} | D:{1}", stats.UploadBandwidth, stats.DownloadBandwidth); }
public void CallState(LinphoneCall call, LinphoneCallState state, string message) { WriteLog("CallState: {0} | {1}", state, message); switch (state) { case LinphoneCallState.IncomingReceived: this.UIThreadInvoke(() => AcceptCall(call, message)); break; case LinphoneCallState.OutgoingRinging: this.UIThreadInvoke(() => WriteLog("Ringing")); break; case LinphoneCallState.Connected: this.UIThreadInvoke(() => WriteLog("Talking")); this.UIThreadInvoke(() => this.btnCall.Text = "Hangup"); break; case LinphoneCallState.CallEnd: this.UIThreadInvoke(() => WriteLog("Call ended")); this.UIThreadInvoke(() => this.btnCall.Text = "Call" ); break; default: break; } }
/// <summary> /// Called when the call changes its state to paused or resumed. /// </summary> public void PauseStateChanged(LinphoneCall call, bool isCallPaused, bool isCallPausedByRemote) { buttons.pause.IsChecked = isCallPaused || isCallPausedByRemote; buttons_landscape.pause.IsChecked = isCallPaused || isCallPausedByRemote; buttons.pauseImg.Source = new BitmapImage(new Uri(isCallPaused || isCallPausedByRemote ? pauseOn : pauseOff, UriKind.RelativeOrAbsolute)); buttons_landscape.pauseImg.Source = new BitmapImage(new Uri(isCallPaused || isCallPausedByRemote ? pauseOn : pauseOff, UriKind.RelativeOrAbsolute)); if (!isCallPaused && !isCallPausedByRemote) { if (call.GetCurrentParamsCopy().VideoEnabled && !((InCallModel)ViewModel).IsVideoActive) { // Show video if it was not shown yet ((InCallModel)ViewModel).IsVideoActive = true; buttons.video.IsChecked = true; buttons_landscape.video.IsChecked = true; buttons.videoImg.Source = new BitmapImage(new Uri(videoOn, UriKind.RelativeOrAbsolute)); buttons_landscape.videoImg.Source = new BitmapImage(new Uri(videoOn, UriKind.RelativeOrAbsolute)); ButtonsFadeInVideoAnimation.Begin(); StartFadeTimer(); } else if (!call.GetCurrentParamsCopy().VideoEnabled && ((InCallModel)ViewModel).IsVideoActive) { // Stop video if it is no longer active ((InCallModel)ViewModel).IsVideoActive = false; buttons.video.IsChecked = false; buttons_landscape.video.IsChecked = false; buttons.videoImg.Source = new BitmapImage(new Uri(videoOff, UriKind.RelativeOrAbsolute)); buttons_landscape.videoImg.Source = new BitmapImage(new Uri(videoOff, UriKind.RelativeOrAbsolute)); ButtonsFadeInAudioAnimation.Begin(); StopFadeTimer(); } if (((InCallModel)ViewModel).IsVideoActive) { ButtonsFadeOutAnimation.Begin(); } } else { ((InCallModel)ViewModel).IsVideoActive = false; ((InCallModel)ViewModel).ShowButtonsAndPanel(); ButtonsFadeInAudioAnimation.Begin(); StopFadeTimer(); } }
void OnCallStateChanged(IntPtr lc, IntPtr call, LinphoneCallState cstate, string message) { if (linphoneCore == IntPtr.Zero || !running) return; #if (TRACE) Console.WriteLine("OnCallStateChanged: {0}", cstate); #endif Call.CallState newstate = Call.CallState.None; Call.CallType newtype = Call.CallType.None; string from = ""; string to = ""; IntPtr addressStringPtr; // detecting direction, state and source-destination data by state switch (cstate) { case LinphoneCallState.LinphoneCallIncomingReceived: case LinphoneCallState.LinphoneCallIncomingEarlyMedia: newstate = Call.CallState.Loading; newtype = Call.CallType.Incoming; addressStringPtr = linphone_call_get_remote_address_as_string(call); if (addressStringPtr != IntPtr.Zero) from = Marshal.PtrToStringAnsi(addressStringPtr); to = identity; break; case LinphoneCallState.LinphoneCallConnected: case LinphoneCallState.LinphoneCallStreamsRunning: case LinphoneCallState.LinphoneCallPausedByRemote: case LinphoneCallState.LinphoneCallUpdatedByRemote: newstate = Call.CallState.Active; break; case LinphoneCallState.LinphoneCallOutgoingInit: case LinphoneCallState.LinphoneCallOutgoingProgress: case LinphoneCallState.LinphoneCallOutgoingRinging: case LinphoneCallState.LinphoneCallOutgoingEarlyMedia: newstate = Call.CallState.Loading; newtype = Call.CallType.Outcoming; addressStringPtr = linphone_call_get_remote_address_as_string(call); if (addressStringPtr != IntPtr.Zero) to = Marshal.PtrToStringAnsi(addressStringPtr); from = this.identity; break; case LinphoneCallState.LinphoneCallError: newstate = Call.CallState.Error; break; case LinphoneCallState.LinphoneCallReleased: case LinphoneCallState.LinphoneCallEnd: newstate = Call.CallState.Completed; if (linphone_call_params_get_record_file (callsDefaultParams) != IntPtr.Zero) linphone_call_stop_recording (call); break; default: break; } LinphoneCall existCall = FindCall (call); if (existCall == null) { existCall = new LinphoneCall (); existCall.SetCallState (newstate); existCall.SetCallType (newtype); existCall.SetFrom (from); existCall.SetTo (to); existCall.LinphoneCallPtr = call; calls.Add (existCall); if ((CallStateChangedEvent != null)) CallStateChangedEvent (existCall); } else { if (existCall.GetState () != newstate) { existCall.SetCallState (newstate); CallStateChangedEvent (existCall); } } }
/// <summary> /// Called when the call is updated by the remote party. /// </summary> /// <param name="call">The call that has been updated</param> /// <param name="isVideoAdded">A boolean telling whether the remote party added video</param> public void CallUpdatedByRemote(LinphoneCall call, bool isVideoAdded) { if (this.CallUpdatedByRemoteListener != null) this.CallUpdatedByRemoteListener.CallUpdatedByRemote(call, isVideoAdded); }
private void AcceptCall(LinphoneCall call, string message) { this.lc.AcceptCall(call); }
/// <summary> /// Called when the call changes its state to paused or resumed. /// </summary> public void PauseStateChanged(LinphoneCall call, bool isCallPaused, bool isCallPausedByRemote) { if (this.PauseListener != null) this.PauseListener.PauseStateChanged(call, isCallPaused, isCallPausedByRemote); }
/// <summary> /// /// </summary> /// <param name="call"></param> /// <param name="state"></param> public void CallStateChanged(LinphoneCall call, LinphoneCallState state) { Logger.Dbg("[InCall] Call state changed: " + state.ToString()); if (state == LinphoneCallState.StreamsRunning || state == LinphoneCallState.Connected) { buttons.pause.IsEnabled = true; buttons.microphone.IsEnabled = true; buttons_landscape.pause.IsEnabled = true; buttons_landscape.microphone.IsEnabled = true; buttons.pauseImg.Opacity = BUTTON_ENABLED_OPACITY; buttons.microImg.Opacity = BUTTON_ENABLED_OPACITY; buttons_landscape.pauseImg.Opacity = BUTTON_ENABLED_OPACITY; buttons_landscape.microImg.Opacity = BUTTON_ENABLED_OPACITY; bool isVideoAvailable = LinphoneManager.Instance.IsVideoAvailable; buttons.video.IsEnabled = isVideoAvailable; buttons_landscape.video.IsEnabled = isVideoAvailable; buttons.videoImg.Opacity = isVideoAvailable ? BUTTON_ENABLED_OPACITY : BUTTON_DISABLED_OPACITY; buttons_landscape.videoImg.Opacity = isVideoAvailable ? BUTTON_ENABLED_OPACITY : BUTTON_DISABLED_OPACITY; buttons.camera.IsEnabled = isVideoAvailable; buttons_landscape.camera.IsEnabled = isVideoAvailable; buttons.cameraImg.Opacity = isVideoAvailable ? BUTTON_ENABLED_OPACITY : BUTTON_DISABLED_OPACITY; buttons_landscape.cameraImg.Opacity = isVideoAvailable ? BUTTON_ENABLED_OPACITY : BUTTON_DISABLED_OPACITY; bool isVideoEnabled = call.GetCurrentParamsCopy().VideoEnabled; buttons.video.IsChecked = isVideoEnabled; buttons_landscape.video.IsChecked = isVideoEnabled; } else if (state == LinphoneCallState.PausedByRemote) { buttons.pause.IsEnabled = false; buttons.microphone.IsEnabled = false; buttons.video.IsEnabled = false; buttons.camera.IsEnabled = false; buttons.pauseImg.Opacity = BUTTON_DISABLED_OPACITY; buttons.microImg.Opacity = BUTTON_DISABLED_OPACITY; buttons.videoImg.Opacity = BUTTON_DISABLED_OPACITY; buttons.cameraImg.Opacity = BUTTON_DISABLED_OPACITY; buttons_landscape.pause.IsEnabled = false; buttons_landscape.microphone.IsEnabled = false; buttons_landscape.video.IsEnabled = false; buttons_landscape.camera.IsEnabled = false; buttons_landscape.pauseImg.Opacity = BUTTON_DISABLED_OPACITY; buttons_landscape.microImg.Opacity = BUTTON_DISABLED_OPACITY; buttons_landscape.videoImg.Opacity = BUTTON_DISABLED_OPACITY; buttons_landscape.cameraImg.Opacity = BUTTON_DISABLED_OPACITY; } else if (state == LinphoneCallState.Paused) { buttons.microphone.IsEnabled = false; buttons.video.IsEnabled = false; buttons.camera.IsEnabled = false; buttons.microImg.Opacity = BUTTON_DISABLED_OPACITY; buttons.videoImg.Opacity = BUTTON_DISABLED_OPACITY; buttons.cameraImg.Opacity = BUTTON_DISABLED_OPACITY; buttons_landscape.microphone.IsEnabled = false; buttons_landscape.video.IsEnabled = false; buttons_landscape.camera.IsEnabled = false; buttons_landscape.microImg.Opacity = BUTTON_DISABLED_OPACITY; buttons_landscape.videoImg.Opacity = BUTTON_DISABLED_OPACITY; buttons_landscape.cameraImg.Opacity = BUTTON_DISABLED_OPACITY; } else if (state == LinphoneCallState.Error || state == LinphoneCallState.CallEnd) { oneSecondTimer.Stop(); } AudioEndpointChanged(null, null); }
public void CallEncryptionChanged(LinphoneCall call, bool encrypted, string authenticationToken) { WriteLog("CallEncryptionChanged"); }
/// <summary> /// Callback for LinphoneCoreListener /// </summary> public void CallState(LinphoneCall call, LinphoneCallState state, string message) { if (BaseModel.UIDispatcher == null) { return; } if (state == LinphoneCallState.OutgoingProgress) { BaseModel.UIDispatcher.BeginInvoke(() => { Logger.Msg("[LinphoneManager] Outgoing progress\r\n"); LookupForContact(call); if (CallListener != null && LinphoneCore.CallsNb > 0) { string sipAddress = call.RemoteAddress.AsStringUriOnly(); CallListener.NewCallStarted(sipAddress); } }); } else if (state == LinphoneCallState.IncomingReceived) { BaseModel.UIDispatcher.BeginInvoke(() => { Logger.Msg("[LinphoneManager] Incoming received\r\n"); if (false) //TODO: Find a proper way to let the user choose between the two. { BaseModel.CurrentPage.NavigationService.Navigate(new Uri("/Views/IncomingCall.xaml?sip=" + Utils.ReplacePlusInUri(call.RemoteAddress.AsStringUriOnly()), UriKind.RelativeOrAbsolute)); //Remove the current page from the back stack to avoid duplicating him after BaseModel.CurrentPage.NavigationService.RemoveBackEntry(); } LookupForContact(call); }); } else if (state == LinphoneCallState.Connected) { BaseModel.UIDispatcher.BeginInvoke(() => { Logger.Msg("[LinphoneManager] Connected\r\n"); if (CallListener != null) { string sipAddress = call.RemoteAddress.AsStringUriOnly(); CallListener.NewCallStarted(sipAddress); } }); } else if (state == LinphoneCallState.CallEnd || state == LinphoneCallState.Error) { BaseModel.UIDispatcher.BeginInvoke(() => { Logger.Msg(String.Format("[LinphoneManager] Call ended: {0}\r\n", message)); if (CallListener != null) { CallListener.CallEnded(call); } string text; switch (call.Reason) { case Reason.LinphoneReasonNone: case Reason.LinphoneReasonNotAnswered: break; case Reason.LinphoneReasonDeclined: if (call.Direction == CallDirection.Outgoing) { text = ResourceManager.GetString("CallErrorDeclined", CultureInfo.CurrentCulture); ShowCallError(text.Replace("#address#", call.RemoteAddress.UserName)); } break; case Reason.LinphoneReasonNotFound: text = ResourceManager.GetString("CallErrorNotFound", CultureInfo.CurrentCulture); ShowCallError(text.Replace("#address#", call.RemoteAddress.UserName)); break; case Reason.LinphoneReasonBusy: text = ResourceManager.GetString("CallErrorBusy", CultureInfo.CurrentCulture); ShowCallError(text.Replace("#address#", call.RemoteAddress.UserName)); break; case Reason.LinphoneReasonNotAcceptable: ShowCallError(ResourceManager.GetString("CallErrorNotAcceptable", CultureInfo.CurrentCulture)); break; case Reason.LinphoneReasonIOError: ShowCallError(ResourceManager.GetString("CallErrorIOError", CultureInfo.CurrentCulture)); break; default: ShowCallError(ResourceManager.GetString("CallErrorUnknown", CultureInfo.CurrentCulture)); break; } }); } else if (state == LinphoneCallState.Paused || state == LinphoneCallState.PausedByRemote) { BaseModel.UIDispatcher.BeginInvoke(() => { Logger.Msg("[LinphoneManager] Call paused\r\n"); bool pausedByRemote = state == LinphoneCallState.PausedByRemote; if (CallListener != null) { CallListener.PauseStateChanged(call, !pausedByRemote, pausedByRemote); } }); } else if (state == LinphoneCallState.StreamsRunning) { BaseModel.UIDispatcher.BeginInvoke(() => { Logger.Msg("[LinphoneManager] Call running\r\n"); if (CallListener != null) { CallListener.PauseStateChanged(call, false, false); } }); } else if (state == LinphoneCallState.Released) { BaseModel.UIDispatcher.BeginInvoke(() => { Logger.Msg("[LinphoneManager] Call released\r\n"); }); } else if (state == LinphoneCallState.UpdatedByRemote) { BaseModel.UIDispatcher.BeginInvoke(() => { Boolean videoAdded = false; VideoPolicy policy = LinphoneManager.Instance.LinphoneCore.VideoPolicy; LinphoneCallParams remoteParams = call.RemoteParams; LinphoneCallParams localParams = call.GetCurrentParamsCopy(); if (remoteParams.VideoEnabled && !localParams.VideoEnabled && !LinphoneManager.Instance.LinphoneCore.InConference) { if (policy.AutomaticallyAccept) { localParams.VideoEnabled = true; LinphoneManager.Instance.LinphoneCore.AcceptCallUpdate(call, localParams); } else { videoAdded = true; } } else { LinphoneManager.Instance.LinphoneCore.AcceptCallUpdate(call, localParams); } if (CallListener != null) { CallListener.CallUpdatedByRemote(call, videoAdded); } }); } BaseModel.UIDispatcher.BeginInvoke(() => { if (CallStateChanged != null) { CallStateChanged(call, state); } }); }
/// <summary> /// Start a new call to a sip address. /// </summary> /// <param name="sipAddress">SIP address to call</param> public void NewOutgoingCall(String sipAddress) { LinphoneCall LCall = LinphoneCore.Invite(sipAddress); }
/// <summary> /// Callback for LinphoneCoreListener /// </summary> public void DTMFReceived(LinphoneCall call, Char dtmf) { }
/// <summary> /// Called when the call is updated by the remote party. /// </summary> /// <param name="call">The call that has been updated</param> /// <param name="isVideoAdded">A boolean telling whether the remote party added video</param> public void CallUpdatedByRemote(LinphoneCall call, bool isVideoAdded) { if (isVideoAdded) { Guide.BeginShowMessageBox(AppResources.VideoActivationPopupCaption, AppResources.VideoActivationPopupContent, new List<String> { "Accept", "Dismiss" }, 0, MessageBoxIcon.Alert, asyncResult => { int? res = Guide.EndShowMessageBox(asyncResult); LinphoneCallParams parameters = call.GetCurrentParamsCopy(); if (res == 0) { parameters.VideoEnabled = true; } LinphoneManager.Instance.LinphoneCore.AcceptCallUpdate(call, parameters); }, null); } }
/// <summary> /// Callback for LinphoneCoreListener /// </summary> public void CallStatsUpdated(LinphoneCall call, LinphoneCallStats stats) { }
// TODO: Add OnCallStateChanged and OnChatMessageStateChanged. void OnCallStateChanged(IntPtr lc, IntPtr call, LinphoneCallState cstate, string message) { if (linphoneCore == IntPtr.Zero || !running) { return; } #if (TRACE) Console.WriteLine("OnCallStateChanged: {0}", cstate); #endif Call.State newstate = Call.State.Idle; Call.CallType newtype = Call.CallType.None; string from = ""; string to = ""; string peer_name = nameFromAddress(linphone_call_get_remote_address(call)); IntPtr addressStringPtr; // detecting direction, state and source-destination data by state switch (cstate) { case LinphoneCallState.LinphoneCallIncomingReceived: newstate = Call.State.IncomingRinging; newtype = Call.CallType.Incoming; addressStringPtr = linphone_call_get_remote_address_as_string(call); if (addressStringPtr != IntPtr.Zero) { from = Marshal.PtrToStringAnsi(addressStringPtr); to = this.identity; } break; case LinphoneCallState.LinphoneCallIncomingEarlyMedia: newstate = Call.State.IncomingEarlyMedia; newtype = Call.CallType.Incoming; addressStringPtr = linphone_call_get_remote_address_as_string(call); if (addressStringPtr != IntPtr.Zero) { from = Marshal.PtrToStringAnsi(addressStringPtr); to = this.identity; } break; case LinphoneCallState.LinphoneCallConnected: newstate = Call.State.Connected; break; case LinphoneCallState.LinphoneCallStreamsRunning: newstate = Call.State.StreamsRunning; break; case LinphoneCallState.LinphoneCallPausedByRemote: newstate = Call.State.PausedByRemote; break; case LinphoneCallState.LinphoneCallUpdatedByRemote: newstate = Call.State.UpdatedByRemote; break; case LinphoneCallState.LinphoneCallOutgoingInit: newstate = Call.State.OutgoingStart; addressStringPtr = linphone_call_get_remote_address_as_string(call); if (addressStringPtr != IntPtr.Zero) { from = this.identity; to = Marshal.PtrToStringAnsi(addressStringPtr); } break; case LinphoneCallState.LinphoneCallOutgoingProgress: newstate = Call.State.InProgress; break; case LinphoneCallState.LinphoneCallOutgoingRinging: newstate = Call.State.OutgoingRinging; break; case LinphoneCallState.LinphoneCallOutgoingEarlyMedia: newstate = Call.State.OutgoingEarlyMedia; newtype = Call.CallType.Outcoming; addressStringPtr = linphone_call_get_remote_address_as_string(call); if (addressStringPtr != IntPtr.Zero) { from = this.identity; to = Marshal.PtrToStringAnsi(addressStringPtr); } break; case LinphoneCallState.LinphoneCallError: newstate = Call.State.Error; break; case LinphoneCallState.LinphoneCallReleased: newstate = Call.State.Released; break; case LinphoneCallState.LinphoneCallEnd: newstate = Call.State.Ended; //hangupCall(call); if (linphone_call_params_get_record_file(calls_default_params) != IntPtr.Zero) { linphone_call_stop_recording(call); } break; default: break; } //Change the calls state or create a new call if it doesn't exist yet LinphoneCall existCall = FindCall(call); if (existCall == null) { existCall = new LinphoneCall(); existCall.state = newstate; existCall.call_type = newtype; existCall.from = from; existCall.to = to; existCall.ptr = call; existCall.peer_name = peer_name; calls.Add(existCall); if ((CallStateChangedEvent != null)) { CallStateChangedEvent(existCall); } } else { if (existCall.state != newstate) { existCall.state = newstate; CallStateChangedEvent(existCall); } } }
/// <summary> /// Callback for LinphoneCoreListener /// </summary> public void CallState(LinphoneCall call, LinphoneCallState state, string message) { if (BaseModel.UIDispatcher == null) return; if (state == LinphoneCallState.OutgoingProgress) { BaseModel.UIDispatcher.BeginInvoke(() => { Logger.Msg("[LinphoneManager] Outgoing progress\r\n"); LookupForContact(call); if (CallListener != null && LinphoneCore.CallsNb > 0) { string sipAddress = call.RemoteAddress.AsStringUriOnly(); CallListener.NewCallStarted(sipAddress); } }); } else if (state == LinphoneCallState.IncomingReceived) { BaseModel.UIDispatcher.BeginInvoke(() => { Logger.Msg("[LinphoneManager] Incoming received\r\n"); if (false) //TODO: Find a proper way to let the user choose between the two. { BaseModel.CurrentPage.NavigationService.Navigate(new Uri("/Views/IncomingCall.xaml?sip=" + Utils.ReplacePlusInUri(call.RemoteAddress.AsStringUriOnly()), UriKind.RelativeOrAbsolute)); //Remove the current page from the back stack to avoid duplicating him after BaseModel.CurrentPage.NavigationService.RemoveBackEntry(); } LookupForContact(call); }); } else if (state == LinphoneCallState.Connected) { BaseModel.UIDispatcher.BeginInvoke(() => { Logger.Msg("[LinphoneManager] Connected\r\n"); if (CallListener != null) { string sipAddress = call.RemoteAddress.AsStringUriOnly(); CallListener.NewCallStarted(sipAddress); } }); } else if (state == LinphoneCallState.CallEnd || state == LinphoneCallState.Error) { BaseModel.UIDispatcher.BeginInvoke(() => { Logger.Msg(String.Format("[LinphoneManager] Call ended: {0}\r\n", message)); if (CallListener != null) CallListener.CallEnded(call); string text; switch (call.Reason) { case Reason.LinphoneReasonNone: case Reason.LinphoneReasonNotAnswered: break; case Reason.LinphoneReasonDeclined: if (call.Direction == CallDirection.Outgoing) { text = ResourceManager.GetString("CallErrorDeclined", CultureInfo.CurrentCulture); ShowCallError(text.Replace("#address#", call.RemoteAddress.UserName)); } break; case Reason.LinphoneReasonNotFound: text = ResourceManager.GetString("CallErrorNotFound", CultureInfo.CurrentCulture); ShowCallError(text.Replace("#address#", call.RemoteAddress.UserName)); break; case Reason.LinphoneReasonBusy: text = ResourceManager.GetString("CallErrorBusy", CultureInfo.CurrentCulture); ShowCallError(text.Replace("#address#", call.RemoteAddress.UserName)); break; case Reason.LinphoneReasonNotAcceptable: ShowCallError(ResourceManager.GetString("CallErrorNotAcceptable", CultureInfo.CurrentCulture)); break; case Reason.LinphoneReasonIOError: ShowCallError(ResourceManager.GetString("CallErrorIOError", CultureInfo.CurrentCulture)); break; default: ShowCallError(ResourceManager.GetString("CallErrorUnknown", CultureInfo.CurrentCulture)); break; } }); } else if (state == LinphoneCallState.Paused || state == LinphoneCallState.PausedByRemote) { BaseModel.UIDispatcher.BeginInvoke(() => { Logger.Msg("[LinphoneManager] Call paused\r\n"); bool pausedByRemote = state == LinphoneCallState.PausedByRemote; if (CallListener != null) CallListener.PauseStateChanged(call, !pausedByRemote, pausedByRemote); }); } else if (state == LinphoneCallState.StreamsRunning) { BaseModel.UIDispatcher.BeginInvoke(() => { Logger.Msg("[LinphoneManager] Call running\r\n"); if (CallListener != null) CallListener.PauseStateChanged(call, false, false); }); } else if (state == LinphoneCallState.Released) { BaseModel.UIDispatcher.BeginInvoke(() => { Logger.Msg("[LinphoneManager] Call released\r\n"); }); } else if (state == LinphoneCallState.UpdatedByRemote) { BaseModel.UIDispatcher.BeginInvoke(() => { Boolean videoAdded = false; VideoPolicy policy = LinphoneManager.Instance.LinphoneCore.VideoPolicy; LinphoneCallParams remoteParams = call.RemoteParams; LinphoneCallParams localParams = call.GetCurrentParamsCopy(); if (remoteParams.VideoEnabled && !localParams.VideoEnabled && !LinphoneManager.Instance.LinphoneCore.InConference) { if (policy.AutomaticallyAccept) { localParams.VideoEnabled = true; LinphoneManager.Instance.LinphoneCore.AcceptCallUpdate(call, localParams); } else { videoAdded = true; } } else { LinphoneManager.Instance.LinphoneCore.AcceptCallUpdate(call, localParams); } if (CallListener != null) CallListener.CallUpdatedByRemote(call, videoAdded); }); } BaseModel.UIDispatcher.BeginInvoke(() => { if (CallStateChanged != null) { CallStateChanged(call, state); } }); }
/// <summary> /// Callback for LinphoneCoreListener /// </summary> public void CallState(LinphoneCall call, LinphoneCallState state, string message) { }
/// <summary> /// Callback for LinphoneCoreListener /// </summary> public void CallEncryptionChanged(LinphoneCall call, bool encrypted, string authenticationToken) { }
public void CallEncryptionChanged(LinphoneCall call, bool encrypted, string authenticationToken) { Console.WriteLine("CallEncryptionChanged"); }
public void DTMFReceived(LinphoneCall call, char dtmf) { WriteLog("DTMFReceived"); }
void OnCallStateChanged(IntPtr lc, IntPtr call, LinphoneCallState cstate, string message) { if (linphoneCore == IntPtr.Zero || !running) { return; } #if (TRACE) Console.WriteLine("OnCallStateChanged: {0}", cstate); #endif Call.CallState newstate = Call.CallState.None; Call.CallType newtype = Call.CallType.None; string from = ""; string to = ""; IntPtr addressStringPtr; // detecting direction, state and source-destination data by state switch (cstate) { case LinphoneCallState.LinphoneCallIncomingReceived: case LinphoneCallState.LinphoneCallIncomingEarlyMedia: newstate = Call.CallState.Loading; newtype = Call.CallType.Incoming; addressStringPtr = linphone_call_get_remote_address_as_string(call); if (addressStringPtr != IntPtr.Zero) { from = Marshal.PtrToStringAnsi(addressStringPtr); } to = identity; break; case LinphoneCallState.LinphoneCallConnected: case LinphoneCallState.LinphoneCallStreamsRunning: case LinphoneCallState.LinphoneCallPausedByRemote: case LinphoneCallState.LinphoneCallUpdatedByRemote: newstate = Call.CallState.Active; break; case LinphoneCallState.LinphoneCallOutgoingInit: case LinphoneCallState.LinphoneCallOutgoingProgress: case LinphoneCallState.LinphoneCallOutgoingRinging: case LinphoneCallState.LinphoneCallOutgoingEarlyMedia: newstate = Call.CallState.Loading; newtype = Call.CallType.Outcoming; addressStringPtr = linphone_call_get_remote_address_as_string(call); if (addressStringPtr != IntPtr.Zero) { to = Marshal.PtrToStringAnsi(addressStringPtr); } from = this.identity; break; case LinphoneCallState.LinphoneCallError: newstate = Call.CallState.Error; break; case LinphoneCallState.LinphoneCallReleased: case LinphoneCallState.LinphoneCallEnd: newstate = Call.CallState.Completed; if (linphone_call_params_get_record_file(callsDefaultParams) != IntPtr.Zero) { linphone_call_stop_recording(call); } break; default: break; } LinphoneCall existCall = FindCall(call); if (existCall == null) { existCall = new LinphoneCall(); existCall.SetCallState(newstate); existCall.SetCallType(newtype); existCall.SetFrom(from); existCall.SetTo(to); existCall.LinphoneCallPtr = call; calls.Add(existCall); if ((CallStateChangedEvent != null)) { CallStateChangedEvent(existCall); } } else { if (existCall.GetState() != newstate) { existCall.SetCallState(newstate); CallStateChangedEvent(existCall); } } }