/// <summary>
/// Establishes a new call with the client end tied to the proxy. Since the proxy will not be sending any audio the idea is that once
/// the call is up it should be re-INVITED off somewhere else pronto to avoid the callee sitting their listening to dead air.
/// </summary>
/// <param name="dest1">The dial string of the first call to place.</param>
/// <param name="dest2">The dial string of the second call to place.</param>
/// <param name="delaySeconds">Delay in seconds before placing the first call. Gives the user a chance to hangup their phone if they are calling themselves back.</param>
/// <param name="ringTimeoutLeg1">The ring timeout for the first call leg, If 0 the max timeout will be used.</param>
/// <param name="ringTimeoutLeg1">The ring timeout for the second call leg, If 0 the max timeout will be used.</param>
/// <param name="customHeadersCallLeg1">A | delimited string that contains a list of custom SIP headers to add to the INVITE request sent for the first call leg.</param>
/// /// <param name="customHeadersCallLeg2">A | delimited string that contains a list of custom SIP headers to add to the INVITE request sent for the second call leg.</param>
/// <returns>The result of the call.</returns>
public void Callback(string dest1, string dest2, int delaySeconds, int ringTimeoutLeg1, int ringTimeoutLeg2, string customHeadersCallLeg1, string customHeadersCallLeg2)
{
var ts = new CancellationTokenSource();
CancellationToken ct = ts.Token;
try
{
if (delaySeconds > 0)
{
delaySeconds = (delaySeconds > MAXCALLBACK_DELAY_SECONDS) ? MAXCALLBACK_DELAY_SECONDS : delaySeconds;
Log("Callback app delaying by " + delaySeconds + "s.");
Thread.Sleep(delaySeconds * 1000);
}
Log("Callback app commencing first leg to " + dest1 + ".");
SIPEndPoint defaultUDPEP = m_sipTransport.GetDefaultSIPEndPoint(SIPProtocolsEnum.udp);
SIPRequest firstLegDummyInviteRequest = GetCallbackInviteRequest(defaultUDPEP.GetIPEndPoint(), null);
ForkCall firstLegCall = new ForkCall(m_sipTransport, Log_External, m_callManager.QueueNewCall, null, m_username, m_adminMemberId, m_outboundProxy, m_callManager, null);
m_firstLegDialogue = Dial(firstLegCall, dest1, ringTimeoutLeg1, 0, firstLegDummyInviteRequest, SIPCallDescriptor.ParseCustomHeaders(customHeadersCallLeg1));
if (m_firstLegDialogue == null)
{
Log("The first call leg to " + dest1 + " was unsuccessful.");
return;
}
// Persist the dialogue to the database so any hangup can be detected.
m_sipDialoguePersistor.Add(new SIPDialogueAsset(m_firstLegDialogue));
SDP firstLegSDP = SDP.ParseSDPDescription(m_firstLegDialogue.RemoteSDP);
string call1SDPIPAddress = firstLegSDP.Connection.ConnectionAddress;
int call1SDPPort = firstLegSDP.Media[0].Port;
Log("The first call leg to " + dest1 + " was successful, audio socket=" + call1SDPIPAddress + ":" + call1SDPPort + ".");
Log("Callback app commencing second leg to " + dest2 + ".");
SIPRequest secondLegDummyInviteRequest = GetCallbackInviteRequest(defaultUDPEP.GetIPEndPoint(), m_firstLegDialogue.RemoteSDP);
ForkCall secondLegCall = new ForkCall(m_sipTransport, Log_External, m_callManager.QueueNewCall, null, m_username, m_adminMemberId, m_outboundProxy, m_callManager, null);
Task.Factory.StartNew(() =>
{
while (true)
{
Thread.Sleep(CHECK_FIRST_LEG_FOR_HANGUP_PERIOD);
Console.WriteLine("Checking if first call leg is still up...");
if (ct.IsCancellationRequested)
{
Console.WriteLine("Checking first call leg task was cancelled.");
break;
}
else
{
// Check that the first call leg hasn't been hung up.
var dialog = m_sipDialoguePersistor.Get(m_firstLegDialogue.Id);
if (dialog == null)
{
Console.WriteLine("First call leg has been hungup.");
// The first call leg has been hungup while waiting for the second call.
Log("The first call leg was hungup while the second call leg was waiting for an answer.");
secondLegCall.CancelNotRequiredCallLegs(CallCancelCause.ClientCancelled);
break;
}
}
}
Console.WriteLine("Checking first call leg task finished...");
}, ct);
SIPDialogue secondLegDialogue = Dial(secondLegCall, dest2, ringTimeoutLeg2, 0, secondLegDummyInviteRequest, SIPCallDescriptor.ParseCustomHeaders(customHeadersCallLeg2));
ts.Cancel();
if (secondLegDialogue == null)
{
Log("The second call leg to " + dest2 + " was unsuccessful.");
m_firstLegDialogue.Hangup(m_sipTransport, m_outboundProxy);
return;
}
// Check that the first call leg hasn't been hung up.
var firstLegDialog = m_sipDialoguePersistor.Get(m_firstLegDialogue.Id);
if (firstLegDialog == null)
{
// The first call leg has been hungup while waiting for the second call.
Log("The first call leg was hungup while waiting for the second call leg.");
secondLegDialogue.Hangup(m_sipTransport, m_outboundProxy);
return;
}
SDP secondLegSDP = SDP.ParseSDPDescription(secondLegDialogue.RemoteSDP);
string call2SDPIPAddress = secondLegSDP.Connection.ConnectionAddress;
int call2SDPPort = secondLegSDP.Media[0].Port;
Log("The second call leg to " + dest2 + " was successful, audio socket=" + call2SDPIPAddress + ":" + call2SDPPort + ".");
// Persist the second leg dialogue and update the bridge ID on the first call leg.
Guid bridgeId = Guid.NewGuid();
secondLegDialogue.BridgeId = bridgeId;
m_sipDialoguePersistor.Add(new SIPDialogueAsset(secondLegDialogue));
m_sipDialoguePersistor.UpdateProperty(firstLegDialog.Id, "BridgeID", bridgeId.ToString());
//m_callManager.CreateDialogueBridge(m_firstLegDialogue, secondLegDialogue, m_username);
Log("Re-inviting Callback dialogues to each other.");
m_callManager.ReInvite(m_firstLegDialogue, secondLegDialogue);
//m_callManager.ReInvite(secondLegDialogue, m_firstLegDialogue.RemoteSDP);
SendRTPPacket(call2SDPIPAddress + ":" + call2SDPPort, call1SDPIPAddress + ":" + call1SDPPort);
SendRTPPacket(call1SDPIPAddress + ":" + call1SDPPort, call2SDPIPAddress + ":" + call2SDPPort);
}
catch (Exception excp)
{
logger.Error("Exception CallbackApp. " + excp);
Log("Exception in Callback. " + excp);
}
finally
{
if (!ts.IsCancellationRequested)
{
ts.Cancel();
}
}
}
