Accepting or Declining a Signaling Session INVITE

Accepting or Declining a Signaling Session INVITE

This content is no longer actively maintained. It is provided as is, for anyone who may still be using these technologies, with no warranties or claims of accuracy with regard to the most recent product version or service release.

After an incoming signaling session is received, an application can accept the incoming session by either calling the Participate method synchronously or by using the BeginParticipate EndParticipate asynchronous programming pattern. The application can also choose to decline the invitation by calling the Terminate or TerminateWithRejection method.

The following code example illustrates the synchronous programming pattern for accepting an incoming signaling session INVITE request.

SignalingSession session = ...;

try
{
  session.Participate();
}

catch (RealTimeException exp)
{
  // Handle accept failures.
}

Before accepting a session, an application normally registers for the StateChanged event and sets the desired session properties, such as MediaNegotiation.

The following code example illustrates the asynchronous programming pattern for accepting an incoming signaling session INVITE request. Following the call to BeginParticipate, the invitee should catch InvalidOperationException, which can be thrown if the inviter cancels the session before BeginParticipate is called. This can occur even when the application determines that the SignalingState state is Incoming, during race conditions.

SignalingSession session = ...;

try 
{
  session.BeginParticipate(new AsyncCallback(this.Accept_Completed), 
                           session);
}

catch (InvalidOperationException exp)
{
  // Handle accept failures.
}

void Accept_Completed(IAsyncResult asyncResult)
{
  SignalingSession session = 
                 (SignalingSession) asyncResult.AsyncState;

  try
  {
    session.EndParticipate();
  }

  catch (FailureResponseException exp)
  {
    // Handle a failure response
    Console.WriteLine("Failure response for {0}: {1}",
                       session.RemoteParticipant.Uri,
                       exp.ToString());
  }

  catch (OperationTimeoutException exp)
  {
    // Operation timed out
    Console.WriteLine("Operation timed out for {0}: {1}",
                       session.RemoteParticipant.Uri,
                       exp.ToString());
  }

  catch (RealTimeException exp)
  {
    // Handle exception.
    Console.WriteLine("Invite Failure for {0}: {1}", 
                       session.RemoteParticipant.Uri,
                       exp.ToString());
  }
}

It is possible for the participate operation to fail. Possible reasons are that the inviter is no longer available or that the inviter has cancelled the session. An application can determine whether the accept operation completed successfully by using try ... catch ... blocks around Participate or BeginParticipate...EndParticipate.

The following code example illustrates the programming pattern for declining a signaling session INVITE request.

SignalingSession session = ...; // an incoming session just received

session.TerminateWithRejection(ResponseCode.NotAcceptableHere, null);

An application can provide some custom headers in the call.

Alternatively, the application can also call Terminate on an incoming session to decline the invitation. As with TerminateWithRejection, custom headers can be passed in the call.

Show:
© 2016 Microsoft