private void AddRequest(CallbackRequest request)
{
lock (this.SyncRoot)
{
m_pendingRequests.AddLast(request);
}
}
private void RemoveRequest(CallbackRequest request)
{
lock (this.SyncRoot)
{
m_pendingRequests.Remove(request);
}
// We need to clean up the request. Since this is simple task, we can do it without sequence.
AsyncTask cleanupAction = new AsyncTask(this.CleanupRequest, request);
cleanupAction.StartTask();
}
private void ShutdownUserEndpoint(AsyncTask task, object state)
{
CallbackRequest callbackRequest = (CallbackRequest)state;
AsyncTask proxyTask = new AsyncTask(m_appFrontEnd.RelaseUserEndpoint, callbackRequest.MyUserEndpoint);
proxyTask.TaskCompleted +=
delegate(object sender, AsyncTaskCompletedEventArgs e)
{
task.Complete(e.ActionResult.Exception);
};
proxyTask.StartTask();
}
private void InitiateCallback(CallbackRequest request)
{
lock (this.SyncRoot)
{
if (this.IsTerminatingTerminated)
{
return;
}
this.RemoveRequest(request);
}
//Exit the lock to avoid deadlocks.
m_appFrontEnd.InitiateCallback(request.Customer, request.TargetUri, request.TargetDispalyName);
}
private void StartupUserEndpoint(AsyncTask task, object state)
{
CallbackRequest callbackRequest = (CallbackRequest)state;
AsyncTask proxyTask = new AsyncTask(m_appFrontEnd.CreateOrGetUserEndpoint, callbackRequest.Customer.UserUri);
proxyTask.TaskCompleted +=
delegate(object sender, AsyncTaskCompletedEventArgs e)
{
UserEndpointCreationActionResult result = proxyTask.TaskResult as UserEndpointCreationActionResult;
if (result != null)
{
callbackRequest.MyUserEndpoint = result.MyUserEndpoint;
}
task.Complete(e.ActionResult.Exception);
};
proxyTask.StartTask();
}
/// <summary>
/// Clean up a request given as argument in the task.
/// </summary>
/// <param name="task">The task for this operation.</param>
private void CleanupRequest(AsyncTask task, object state)
{
task.DoOneStep(
delegate()
{
CallbackRequest callbackRequest = (CallbackRequest)state;
// We need to terminate view and then endppoint. Endpoint termiantion alone is enough. We will do both here for sample usage.
AsyncTaskSequenceSerial sequence = new AsyncTaskSequenceSerial(this);
sequence.Name = "CleanupCallbackRequest";
sequence.FailureCompletionReportHandlerDelegate = delegate(Exception exception) { task.Complete(null); };
sequence.SuccessCompletionReportHandlerDelegate = delegate(Exception exception) { task.Complete(exception); };
AsyncTask viewShutdownAction = new AsyncTask(this.ShutdownPresenceView, callbackRequest);
sequence.AddTask(viewShutdownAction);
AsyncTask endpointShutdownAction = new AsyncTask(this.ShutdownUserEndpoint, callbackRequest);
sequence.AddTask(endpointShutdownAction);
sequence.Start();
});
}
private void ShutdownPresenceView(AsyncTask task, object state)
{
task.DoOneStep(
delegate()
{
CallbackRequest callbackRequest = (CallbackRequest)state;
var presenceView = callbackRequest.PresenceView;
presenceView.PresenceNotificationReceived -= this.PresenceView_NotificationReceived;
presenceView.SubscriptionStateChanged -= this.PresenceView_SubscriptionStateChanged;
presenceView.BeginTerminate(
delegate(IAsyncResult ar)
{
task.DoFinalStep(
delegate()
{
presenceView.EndTerminate(ar);
});
},
null);
});
}
private void StartupPresenceView(AsyncTask task, object state)
{
task.DoFinalStep(
delegate()
{
CallbackRequest callbackRequest = (CallbackRequest)state;
var viewSettings = new RemotePresenceViewSettings();
viewSettings.SubscriptionMode = RemotePresenceViewSubscriptionMode.Persistent;
var presenceView = new RemotePresenceView(callbackRequest.CutomerEndpoint, viewSettings);
presenceView.ApplicationContext = callbackRequest;
var target = new RemotePresentitySubscriptionTarget(callbackRequest.TargetUri);
presenceView.PresenceNotificationReceived += this.PresenceView_NotificationReceived;
presenceView.SubscriptionStateChanged += this.PresenceView_SubscriptionStateChanged;
callbackRequest.PresenceView = presenceView;
presenceView.StartSubscribingToPresentities(
new RemotePresentitySubscriptionTarget[] { target });
});
}
public void AddCallback(
Customer requestingCustomer,
string callbackTargetUri,
string callbackTargetDisplayName)
{
var request = new CallbackRequest(
requestingCustomer,
callbackTargetUri,
callbackTargetDisplayName);
System.Threading.ManualResetEvent callbackSetupWaitHandle = new System.Threading.ManualResetEvent(false);
AsyncTaskSequenceSerial sequence = new AsyncTaskSequenceSerial(this);
sequence.Name = "AddCallback";
sequence.SuccessCompletionReportHandlerDelegate =
delegate(Exception exception) { callbackSetupWaitHandle.Set(); };
sequence.FailureCompletionReportHandlerDelegate =
delegate(Exception exception) { request.Exception = exception; callbackSetupWaitHandle.Set(); };
lock (this.SyncRoot)
{
if (this.IsTerminatingTerminated)
{
throw new InvalidOperationException("AddCallback called when CallbackManager is terminating/terminated.");
}
this.AddRequest(request);
AsyncTask startEndpointTask = new AsyncTask(this.StartupUserEndpoint, request);
sequence.AddTask(startEndpointTask);
AsyncTask startPresenceView = new AsyncTask(this.StartupPresenceView, request);
sequence.AddTask(startPresenceView);
}
sequence.Start();
callbackSetupWaitHandle.WaitOne();
if (request.Exception != null)
{
this.RemoveRequest(request);
throw request.Exception;
}
}
private void CleanupElapsed(object sender, ElapsedEventArgs e)
{
if (this.IsTerminatingTerminated)
{
return;
}
AsyncTaskSequenceParallel requestsToCleanup = new AsyncTaskSequenceParallel(this);
requestsToCleanup.Name = "CleanupStaleRequests";
lock (this.SyncRoot)
{
var cutoff = DateTime.Now.Subtract(m_maxLifeSpanOfRequest);
while (m_pendingRequests.First != null && m_pendingRequests.First.Value.CreationTime < cutoff)
{
CallbackRequest request = m_pendingRequests.First.Value;
m_pendingRequests.RemoveFirst();
AsyncTask cleanupAction = new AsyncTask(this.CleanupRequest, request);
cleanupAction.IsOptional = true;
requestsToCleanup.AddTask(cleanupAction);
}
}
requestsToCleanup.Start();
}
