private void Run()
{
// A helper class to take care of platform and endpoint setup and
// cleanup. This has been abstracted from this sample to focus on
// Call Control.
_helper = new UCMASampleHelper();
// Create a user endpoint, using the network credential object
// defined above.
UserEndpoint callerEndpoint = _helper.CreateEstablishedUserEndpoint(
"Caller" /*endpointFriendlyName*/);
// Create a second user endpoint, using the network credential object
// defined above.
UserEndpoint calleeEndpoint = _helper.CreateEstablishedUserEndpoint(
"Callee" /*endpointFriendlyName*/);
// Here, we are accepting an Instant Messaging call only. If the
// incoming call is not an Instant Messaging call (for example, an
// AudioVideo call or a custom Call, then it will not get raised to
// the application. UCMA 3.0 handles this silently by having the call
// types register for various modalities (as part of the extensibility
// framework). The appropriate action (here, accepting the call) will
// be handled in the handler assigned to the method call below.
calleeEndpoint.RegisterForIncomingCall <InstantMessagingCall>(On_InstantMessagingCall_Received);
// Setup the call and conversation objects for the initial call (IM)
// and place the call (synchronously).
_conversation = new Conversation(callerEndpoint);
InstantMessagingCall instantMessagingCall = new InstantMessagingCall(_conversation);
// Add registration for the AudioVideo modality, before placing the
// second call. This could have been done at any time before placing
// the audio video call. This handler could choose to accept, deflect
// or drop this portion of the call entirely.
calleeEndpoint.RegisterForIncomingCall <AudioVideoCall>(On_AudioVideoCall_Received);
// Place the call to the remote party, without specifying any custom
// options.
instantMessagingCall.BeginEstablish(calleeEndpoint.OwnerUri, new ToastMessage("Sample Toast Message"),
null, CallEstablishCompleted, instantMessagingCall);
// Force synchronization to ensure that the both AVCall and IMCall
// are now complete.
_sampleCompleted.WaitOne();
UCMASampleHelper.PauseBeforeContinuing("Press ENTER to shutdown and exit.");
//And shutdown (synchronously).
Console.WriteLine("Shutting down the sample...");
_helper.ShutdownPlatform();
}
//Launches an instant message. Text of the message depends on the parameter value.
public void UcmaIM(Int32 choice)
{
helper = new UCMASampleHelper();
userEndpoint = helper.CreateEstablishedUserEndpoint("SampleUser");
Console.WriteLine("endpoint owned by " + userEndpoint.OwnerUri + " is established/registered");
ConversationSettings conversationSettings = new ConversationSettings();
conversationSettings.Subject = conversationSubject;
Conversation conversation = new Conversation(userEndpoint, conversationSettings);
ImCall = new InstantMessagingCall(conversation);
ImCall.InstantMessagingFlowConfigurationRequested += new EventHandler <InstantMessagingFlowConfigurationRequestedEventArgs>(ImCall_InstantMessagingFlowConfigurationRequested);
Int32 helloChoice = 1;
Int32 goodbyeChoice = 2;
if (choice == helloChoice)
{
messageText = "hello";
}
else if (choice == goodbyeChoice)
{
messageText = "goodbye";
}
else
{
messageText = "press 1 or press 2";
}
string targetURI = ConfigurationManager.AppSettings["UserURI1"];
ImCall.BeginEstablish(targetURI, null, CallEstablishCompleted, null);
completedEvent.WaitOne();
}
private void Run()
{
// A helper class to take care of platform and endpoint setup and
// cleanup. This has been abstracted from this sample to focus on
// Call Control.
_helper = new UCMASampleHelper();
// Create a user endpoint, using the network credential object
// defined above.
_userEndpoint = _helper.CreateEstablishedUserEndpoint("DeclineCall Sample User" /*endpointFriendlyName*/);
// Here, we are Declining an Instant Messaging call only. If the
// incoming call is not an Instant Messaging call (for example, an
// AudioVideo call, or a custom (Foo) Call, then it will not get
// raised to the application. UCMA 3.0 handles this silently by
// having the call types register for various modalities (as part of
// the extensibility framework). The appropriate action (here,
// declining the call) will be handled in the handler assigned to the
// method call below.
_userEndpoint.RegisterForIncomingCall <InstantMessagingCall>(On_InstantMessagingCall_Received);
// Wait for the call to complete Decline, then shutdown the platform.
Console.WriteLine("Waiting for incoming call...");
_autoResetEvent.WaitOne();
UCMASampleHelper.PauseBeforeContinuing("Press ENTER to shutdown and exit.");
// Shut down the sample.
_helper.ShutdownPlatform();
}
public void Run()
{
// Initialize and register the endpoint, using the credentials of the user the application will be acting as.
_helper = new UCMASampleHelper();
_userEndpoint = _helper.CreateEstablishedUserEndpoint("B2BCall Sample User" /*endpointFriendlyName*/);
_userEndpoint.RegisterForIncomingCall <AudioVideoCall>(inboundAVCall_CallReceived);
// Conversation settings for the outbound call (to the agent).
ConversationSettings outConvSettings = new ConversationSettings();
outConvSettings.Priority = _conversationPriority;
outConvSettings.Subject = _outConversationSubject;
// Create the Conversation instance between UCMA and the agent.
_outboundConversation = new Conversation(_userEndpoint, outConvSettings);
// Create the outbound call between UCMA and the agent.
_outboundAVCall = new AudioVideoCall(_outboundConversation);
// Register for notification of the StateChanged event on the outbound call.
_outboundAVCall.StateChanged += new EventHandler <CallStateChangedEventArgs>(outboundAVCall_StateChanged);
// Prompt for called party - the agent.
_calledParty = UCMASampleHelper.PromptUser("Enter the URI of the called party, in sip:User@Host form or tel:+1XXXYYYZZZZ form => ", "RemoteUserURI1");
_outboundCallLeg = new BackToBackCallSettings(_outboundAVCall, _calledParty);
// Pause the main thread until both calls, the BackToBackCall, both conversations,
// and the platform are shut down.
_waitUntilOneUserHangsUp.WaitOne();
// Pause the console to allow for easier viewing of logs.
Console.WriteLine("Press any key to end the sample.");
Console.ReadKey();
}
public void Run()
{
// Create and establish the endpoint, using the credentials of the user the application will be acting as.
_helper = new UCMASampleHelper();
_userEndpoint = _helper.CreateEstablishedUserEndpoint("VoiceXML Sample User" /*endpointFriendlyName*/);
_userEndpoint.RegisterForIncomingCall <AudioVideoCall>(inboundAVCall_CallReceived);
// Pause the main thread until a call is received and then accepted.
_waitForCallReceived.WaitOne();
_waitForCallAccepted.WaitOne();
InitializeVoiceXmlBrowser();
_voiceXmlBrowser.SetAudioVideoCall(_audioVideoCall);
Uri startPageURI = new Uri(startPageURL);
Console.WriteLine("Browser state: " + _voiceXmlBrowser.State.ToString());
_voiceXmlBrowser.RunAsync(startPageURI, null);
_waitForSessionCompleted.WaitOne();
_collabPlatform = _conversation.Endpoint.Platform;
// Terminate the call.
_audioVideoCall.BeginTerminate(CallTerminateCB, _audioVideoCall);
_waitForPlatformShutdownCompleted.WaitOne();
// Pause the console to allow the user to view logs.
Console.WriteLine("Press any key to end the sample.");
Console.ReadKey();
}
public void Run()
{
// A helper class to take care of platform and endpoint setup and cleanup.
_helper = new UCMASampleHelper();
// Create a user endpoint using the network credential object.
_userEndpoint = _helper.CreateEstablishedUserEndpoint("Broadcast User");
// Register a delegate to be called when an incoming audio-video call arrives.
_userEndpoint.RegisterForIncomingCall <AudioVideoCall>(AudioVideoCall_Received);
// Wait for the incoming call to be accepted.
Console.WriteLine("Waiting for incoming call...");
_waitForCallToBeAccepted.WaitOne();
// Create a speech recognition connector and attach an AudioVideoFlow to it.
SpeechRecognitionConnector speechRecognitionConnector = new SpeechRecognitionConnector();
speechRecognitionConnector.AttachFlow(_audioVideoFlow);
// Start the speech recognition connector.
SpeechRecognitionStream stream = speechRecognitionConnector.Start();
// Create a speech recognition engine.
SpeechRecognitionEngine speechRecognitionEngine = new SpeechRecognitionEngine();
speechRecognitionEngine.SpeechRecognized += new EventHandler <SpeechRecognizedEventArgs>(SpeechRecognitionEngine_SpeechRecognized);
//Add a grammar.
string[] recoString = { "buy", "sell", "Fabrikam", "Contoso", "maximum", "minimum", "one", "ten", "twenty", "send" };
Choices choices = new Choices(recoString);
speechRecognitionEngine.LoadGrammar(new Grammar(new GrammarBuilder(choices)));
//Attach to audio stream to the SR engine.
SpeechAudioFormatInfo speechAudioFormatInfo = new SpeechAudioFormatInfo(8000, AudioBitsPerSample.Sixteen, Microsoft.Speech.AudioFormat.AudioChannel.Mono);
speechRecognitionEngine.SetInputToAudioStream(stream, speechAudioFormatInfo);
Console.WriteLine("\r\nGrammar loaded, say send to send IM.");
//Prepare the SR engine to perform multiple asynchronous recognitions.
speechRecognitionEngine.RecognizeAsync(RecognizeMode.Multiple);
//Pause the main thread until recognition completes.
_waitForConnectorToStop.WaitOne();
speechRecognitionConnector.Stop();
Console.WriteLine("connector stopped");
// Detach the flow from the speech recognition connector, to prevent the flow from being kept in memory.
speechRecognitionConnector.DetachFlow();
// Terminate the call, the conversation, and then unregister the
// endpoint from receiving an incoming call.
_audioVideoCall.BeginTerminate(CallTerminateCB, _audioVideoCall);
_waitForConversationToBeTerminated.WaitOne();
// Shut down the platform.
_helper.ShutdownPlatform();
}
public void Run()
{
//Initialize and register the endpoint, using the credentials of the user the application will be acting as.
_helper = new UCMASampleHelper();
_userEndpoint = _helper.CreateEstablishedUserEndpoint("AVCall Sample User" /*endpointFriendlyName*/);
//Set up the conversation and place the call.
ConversationSettings convSettings = new ConversationSettings();
convSettings.Priority = _conversationPriority;
convSettings.Subject = _conversationSubject;
//Conversation represents a collection of modalities in the context of a dialog with one or multiple callees.
Conversation conversation = new Conversation(_userEndpoint, convSettings);
_audioVideoCall = new AudioVideoCall(conversation);
//Call: StateChanged: Only hooked up for logging.
_audioVideoCall.StateChanged += new EventHandler <CallStateChangedEventArgs>(audioVideoCall_StateChanged);
//Subscribe for the flow configuration requested event; the flow will be used to send the media.
//Ultimately, as a part of the callback, the media will be sent/received.
_audioVideoCall.AudioVideoFlowConfigurationRequested += this.audioVideoCall_FlowConfigurationRequested;
// Prompt for called party
_calledParty = UCMASampleHelper.PromptUser("Enter the URI for the user logged onto Microsoft Lync, in the sip:User@Host format or tel:+1XXXYYYZZZZ format => ", "RemoteUserURI");
//Place the call to the remote party.
_audioVideoCall.BeginEstablish(_calledParty, null, EndCallEstablish, _audioVideoCall);
//Sync; wait for the call to complete.
Console.WriteLine("Calling the remote user...");
_waitForCallToEstablish.WaitOne();
// Terminate the call, and then the conversation.
// Terminating these additional objects individually is made redundant by shutting down the platform right after, but in the multiple call case,
// this is needed for object hygene. Terminating a Conversation terminates all it's associated calls, and terminating an endpoint will terminate
// all conversations on that endpoint.
_audioVideoCall.BeginTerminate(EndTerminateCall, _audioVideoCall);
Console.WriteLine("Waiting for the call to get terminated...");
_waitForCallToTerminate.WaitOne();
_audioVideoCall.Conversation.BeginTerminate(EndTerminateConversation, _audioVideoCall.Conversation);
Console.WriteLine("Waiting for the conversation to get terminated...");
_waitForConversationToTerminate.WaitOne();
//Now, cleanup by shutting down the platform.
Console.WriteLine("Shutting down the platform...");
_helper.ShutdownPlatform();
// Pause the console to allow for easier viewing of logs.
Console.WriteLine("Please hit any key to end the sample.");
Console.ReadKey();
}
private void Run()
{
// A helper class to take care of platform and endpoint setup and
// cleanup. This has been abstracted from this sample to focus on Call Control.
_helper = new UCMASampleHelper();
// Create the user endpoints from the network credential objects
// defined above.
_transfereeEndpoint = _helper.CreateEstablishedUserEndpoint("Transferee" /*endpointFriendlyName*/);
_transferorUserEndpoint = _helper.CreateEstablishedUserEndpoint(
"Transferor" /*endpointFriendlyName*/);
_transferTargetEndpoint = _helper.CreateEstablishedUserEndpoint(
"Transfer Target" /*endpointFriendlyName*/);
_transfereeURI = _transfereeEndpoint.OwnerUri;
_transferTargetURI = _transferTargetEndpoint.OwnerUri;
// Register for incoming audio calls on the initial and final endpoints.
_transferTargetEndpoint.RegisterForIncomingCall <AudioVideoCall>(On_AudioVideoCall_Received);
_transfereeEndpoint.RegisterForIncomingCall <AudioVideoCall>(On_AudioVideoCall_Received);
// Setup the call objects for both the call from transferring
// to initial and transferring to final
Conversation convInitialandTransferring = new Conversation(_transferorUserEndpoint);
_avCallTransferringtoInitial = new AudioVideoCall(convInitialandTransferring);
// Perform the first call, from the transferor user to the initial
// user, without specifying any custom options.
_avCallTransferringtoInitial.BeginEstablish(_transfereeURI, null, InitialCallEstablishCompleted,
_avCallTransferringtoInitial);
_sampleCompleted.WaitOne();
UCMASampleHelper.PauseBeforeContinuing("Press ENTER to shutdown and exit.");
// And shutdown.
_helper.ShutdownPlatform();
}
private void Run()
{
// A helper class to take care of platform and endpoint setup and
// cleanup. This has been abstracted from this sample to focus on
// Call Control.
_helper = new UCMASampleHelper();
// Create a user endpoint, using the network credential object
// defined above.
_transferorEndpoint = _helper.CreateEstablishedUserEndpoint("Transferor" /*endpointFriendlyName*/);
// Get the URI of the user to transfer the call to.
// Prepend URI with "sip:" if not present.
_transferTargetUri = UCMASampleHelper.PromptUser("Enter a URI of the user to transfer the call to: ", "TransferTargetUri");
if (!(_transferTargetUri.ToLower().StartsWith("sip:") || _transferTargetUri.ToLower().StartsWith("tel:")))
{
_transferTargetUri = "sip:" + _transferTargetUri;
}
// Here, we are accepting an AudioVideo call only. If the incoming
// call is not an AudioVideo call then it will not get raised to the
// application. UCMA 3.0 handles this silently by having the call
// types register for various modalities (as part of the extensibility
// framework). The appropriate action (here, accepting the call)
// will be handled in the handler assigned to the method call below.
_transferorEndpoint.RegisterForIncomingCall <AudioVideoCall>(On_AudioVideoCall_Received);
// Wait for the call to complete accept.
Console.WriteLine(String.Empty);
Console.WriteLine("Transferor waiting for incoming call...");
_waitForCallAccept.WaitOne();
Console.WriteLine("Initial call accepted by Transferor.");
// Then transfer the call to another user, as designated above.
_audioVideoCall.BeginTransfer(_transferTargetUri, EndTransferCall, _audioVideoCall);
Console.WriteLine("Waiting for transfer to complete...");
// Wait for the call to complete the transfer.
_waitForTransferComplete.WaitOne();
Console.WriteLine("Transfer completed.");
UCMASampleHelper.PauseBeforeContinuing("Press ENTER to shutdown and exit.");
// Now that the call has completed, shutdown the platform.
_helper.ShutdownPlatform();
}
private void Run()
{
// A helper class to take care of platform and endpoint setup and
// cleanup. This has been abstracted from this sample to focus on
// Call Control.
_helper = new UCMASampleHelper();
// Create a user endpoint using the network credential object
// defined above. Again, the credentials used must be for a user
// enabled for Microsoft Lync Server, and capable of logging
// in from the machine that is running this code.
_userEndpoint = _helper.CreateEstablishedUserEndpoint(
"BasicCall Sample User" /* endpointFriendlyName */);
// Here, we are accepting an Instant Messaging call only.
// If the incoming call is not an Instant Messaging call (for example,
// an AudioVideo call, or a custom Call, then it will not get
// raised to the application. UCMA 3.0 handles this silently by having
// the call types register for various modalities (as part of the
// extensibility framework). The appropriate action (here, accepting the
// call) will be handled in the handler assigned to the method call below.
_userEndpoint.RegisterForIncomingCall <InstantMessagingCall>(On_InstantMessagingCall_Received);
// Wait for the call to complete accept, then terminate the conversation.
Console.WriteLine("Waiting for incoming instant messaging call...");
_autoResetEvent.WaitOne();
UCMASampleHelper.PauseBeforeContinuing("Press ENTER to shutdown and exit.");
// Terminate the call, the conversation, and then unregister the
// endpoint from the receiving an incoming call. Terminating these
// additional objects individually is made redundant by shutting down
// the platform right after, but in the multiple call case, this is
// needed for object hygiene. Terminating a Conversation terminates
// all it's associated calls, and terminating an endpoint will
// terminate all conversations on that endpoint.
_instantMessagingCall.BeginTerminate(EndTerminateCall, _instantMessagingCall);
_autoResetEvent.WaitOne();
_instantMessagingCall.Conversation.BeginTerminate(EndTerminateConversation,
_instantMessagingCall.Conversation);
_autoResetEvent.WaitOne();
_userEndpoint.UnregisterForIncomingCall <InstantMessagingCall>(On_InstantMessagingCall_Received);
//Now, cleanup by shutting down the platform.
_helper.ShutdownPlatform();
}
private void Run()
{
// A helper class to take care of platform and endpoint setup and
// cleanup. This has been abstracted from this sample to focus on
// Call Control.
_helper = new UCMASampleHelper();
// Create a user endpoint, using the network credential object
// defined above.
_userEndpoint = _helper.CreateEstablishedUserEndpoint("Forwarding User" /*endpointFriendlyName*/);
// Enter the URI of the user to forward the call to.
_forwardUserURI = UCMASampleHelper.PromptUser(
"Enter the URI of the user to forward the incoming call to, in the User@Host format => ",
"ForwardingTargetURI");
if (!(_forwardUserURI.ToLower().StartsWith("sip:") || _forwardUserURI.ToLower().StartsWith("tel:")))
{
_forwardUserURI = "sip:" + _forwardUserURI;
}
// Here, we are dealing with an Audio Video call only. If the
// incoming call is not of the media type expected, then it will not
// get raised to the application. UCMA 3.0 handles this silently by
// having the call types register for various modalities (as part of
// the extensibility framework). The appropriate action (here,
// forwarding the call) will be handled in the handler assigned to the
// method call below.
_userEndpoint.RegisterForIncomingCall <AudioVideoCall>(On_AudioVideoCall_Received);
// Wait for the call to complete forward, then shutdown the platform.
Console.WriteLine("Waiting for incoming call...");
_autoResetEvent.WaitOne();
UCMASampleHelper.PauseBeforeContinuing("Press ENTER to shutdown and exit.");
// Shut down the sample.
_helper.ShutdownPlatform();
}
private void Run()
{
// A helper class to take care of platform and endpoint setup and cleanup.
_helper = new UCMASampleHelper();
// Create and establish a user endpoint using the user’s network credentials.
_userEndpoint = _helper.CreateEstablishedUserEndpoint(
"FindContact Sample User" /* endpointFriendlyName */);
// Register a delegate to be called when an incoming InstantMessagingCall arrives.
_userEndpoint.RegisterForIncomingCall <InstantMessagingCall>(InstantMessagingCall_Received);
Console.WriteLine("Waiting for an incoming instant messaging call...");
int ThreadID = Thread.CurrentThread.ManagedThreadId;
Console.WriteLine("Main thread: ID " + ThreadID);
// Pause main thread until an incoming call arrives and is accepted.
_waitUntilIncomingCallIsAccepted.WaitOne();
InstantMessagingFlow imFlow = _instantMessagingCall.Flow;
imFlow.BeginSendInstantMessage("Press 1 for Service Department.\n" +
"Press 2 for Sales Department.", CallSendInstantMessageCB, _instantMessagingCall);
imFlow.MessageReceived += new EventHandler <InstantMessageReceivedEventArgs>(IMFlow_MessageReceived);
_waitForAvailableTarget.WaitOne();
if (_remoteContactUri != null)
{
imFlow.BeginSendInstantMessage("Contact found: " + _remoteContactUri.ToString(), CallSendInstantMessageCB, _instantMessagingCall);
// Join the conversation to the IM MCU.
_conferenceSession = _incomingConversation.ConferenceSession;
ConferenceJoinOptions confJoinOptions = new ConferenceJoinOptions();
confJoinOptions.JoinMode = JoinMode.Default;
_conferenceSession.BeginJoin(confJoinOptions, ConferenceJoinCB, _conferenceSession);
ThreadID = Thread.CurrentThread.ManagedThreadId;
Console.WriteLine("Main thread: ID " + ThreadID);
_waitUntilConferenceInvitationIsDelivered.WaitOne();
}
else
{
Console.WriteLine("Could not find an available contact.");
imFlow.BeginSendInstantMessage("Could not find an available contact.\nPlease call again later.", CallSendInstantMessageCB, _instantMessagingCall);
}
// Unregister for notification of the MessageReceived event.
imFlow.MessageReceived -= new EventHandler <InstantMessageReceivedEventArgs>(IMFlow_MessageReceived);
// Cancel the subscription to the presence session by unsubscribing.
_userEndpoint.ContactGroupServices.BeginUnsubscribe(ContactGroupUnsubscribeCB, _userEndpoint.ContactGroupServices);
_remotePresenceView.BeginTerminate(ViewTerminateCB, _remotePresenceView);
UCMASampleHelper.PauseBeforeContinuing("Press ENTER to shut down and exit.");
// Terminate the call, the conversation, and then unregister the
// endpoint from receiving an incoming call. Terminating these
// additional objects individually is made redundant by shutting down
// the platform right after, but in the multiple call case, this is
// needed for object hygiene. Terminating a Conversation terminates
// all its associated calls, and terminating an endpoint
// terminates all conversations on that endpoint.
_instantMessagingCall.BeginTerminate(CallTerminateCB, _instantMessagingCall);
_waitUntilConversationIsTerminated.WaitOne();
_userEndpoint.UnregisterForIncomingCall <InstantMessagingCall>(InstantMessagingCall_Received);
// Clean up by shutting down the platform.
_helper.ShutdownPlatform();
}
/// <summary>
/// Retrieves the application configuration and begins running the
/// sample.
/// </summary>
private void Run()
{
// Prepare and instantiate the platform and an endpoint.
_helper = new UCMASampleHelper();
_userEndpoint = _helper.CreateEstablishedUserEndpoint(
"SubscribePresenceView Sample User" /*endpointFriendlyName*/);
// Get the Uri of the remote user to subscribe to.
_remoteUserUri = "sip:" +
UCMASampleHelper.PromptUser(
"Please enter the URI, in the format User@Host, of the user to subscribe to => ",
"RemoteUserURI");
Console.WriteLine("\nChanging PresenceSubscriptionCategory Filter to only include ContactCard " +
"and PresenceState");
// Set category filter. This is a global filter for all persistent
// subscriptions and can only be changed before any subscriptions
// are active.
// BUGBUG: error CS0618: 'Microsoft.Rtc.Collaboration.LocalEndpoint.RemotePresence' is obsolete: 'This property will be removed from future Versions. Please see RemotePresenceView and PresenceServices instead.'
// _userEndpoint.RemotePresence.PresenceSubscriptionCategories =
// new string[] { PresenceCategoryNames.ContactCard, PresenceCategoryNames.State };
// RemotePresencView objects can be used to group subscriptions.
// When a RemotePresenceView is created, it is created with the
// specified RemotePresenceViewSettings and associated with the
// specified LocalEndpoint. The views can then be accessed via the
// LocalEndpoint setting: RemotePresenceViews.
// RemotePresenceView.ApplicationContext can be used to pass or
// store information related to the view (seen below).
// Create a RemotePresenceView with a persistent subscription mode.
// This type of view can represent a contact list, for example.
// Note: The Default SubscriptionMode will start a subscription as
// Persistent and downgrade to Polling if an error occurs.
var persistentSettings = new RemotePresenceViewSettings();
persistentSettings.SubscriptionMode = RemotePresenceViewSubscriptionMode.Default;
_persistentView = new RemotePresenceView(_userEndpoint, persistentSettings);
_persistentView.ApplicationContext = "Persistent View";
// Wire up event handlers for the view
this.WireUpHandlersForView(_persistentView);
// Create a RemotePresenceView with a polling subscription mode
// This type of view can represent a list of people
// on the To: line of an e-mail, for example.
var pollingSettings = new RemotePresenceViewSettings();
pollingSettings.SubscriptionMode = RemotePresenceViewSubscriptionMode.Polling;
// The line below is not necessary; PollingInterval has a default
// (and minimum) value of 5 minutes.
pollingSettings.PollingInterval = TimeSpan.FromMinutes(5);
_pollingView = new RemotePresenceView(_userEndpoint, pollingSettings);
_pollingView.ApplicationContext = "Polling View";
// Wire up event handlers for the view
this.WireUpHandlersForView(_pollingView);
Console.WriteLine("\nChanging Polling View's category filter to only include Note.");
_pollingView.SetPresenceSubscriptionCategoriesForPolling(
new string[] { PresenceCategoryNames.Note });
try
{
// This constructor does very basic validation on the uri
_target = new RemotePresentitySubscriptionTarget(_remoteUserUri);
}
catch (ArgumentException argumentException)
{
// ArgumentException will be thrown if the parameter used to
// create the RemotePresentitySubscriptionTarget is an
// invalid sip Uri.
// TODO (Left to the reader): Error handling code to either
// retry creating the target with corrected parameters, log
// the error for debugging or gracefully exit the program.
Console.WriteLine(argumentException.ToString());
throw;
}
Console.WriteLine("\nInitiating subscriptions for both Views to user: "******"succeed", but the StateChanged notifications will indicate the
// subscription went to a Terminated state.
_persistentView.StartSubscribingToPresentities(new RemotePresentitySubscriptionTarget[] { _target });
_pollingView.StartSubscribingToPresentities(new RemotePresentitySubscriptionTarget[] { _target });
// There is no callback for the StartSubscribingToPresentities
// operation because subscriptions to multiple targets can
// complete at different times. Completion or failure of the
// subscription can be monitored through the
// SubscriptionStateChanged event handler,
// RemotePresenceView_NotificationReceived.
UCMASampleHelper.PauseBeforeContinuing("Press ENTER to unsubscribe.");
Console.WriteLine("\nBoth Views are terminating any subscriptions to user: "******"Press ENTER to shutdown and exit.");
// Shutdown Platform
_helper.ShutdownPlatform();
}
private void Run()
{
// A helper class to take care of platform and endpoint setup and
// cleanup. This has been abstracted from this sample to focus on
// Call Control.
_helper = new UCMASampleHelper();
// Create a user endpoint, using the network credential object
// defined above.
UserEndpoint callerEndpoint = _helper.CreateEstablishedUserEndpoint("Caller" /*endpointFriendlyName*/);
// Create a second user endpoint, using the network credential object
// defined above.
UserEndpoint calleeEndpoint = _helper.CreateEstablishedUserEndpoint("Callee" /*endpointFriendlyName*/);
// Here, we are accepting an InstantMessaging call only.
// If the incoming call is not an InstantMessaging call (for example,
// an AudioVideo call) then it will not get raised to the application.
// UCMA 3.0 handles this silently by having the call types register
// for various modalities (as part of the extensibility framework).
// The appropriate action (here, accepting the call) will be handled
// in the handler assigned to the method call below.
calleeEndpoint.RegisterForIncomingCall <InstantMessagingCall>
(On_InstantMessagingCall_Received_ByCallee);
// Setup the call and conversation objects for the initial call (IM)
// and place the call (synchronously).
Conversation callerConversation = new Conversation(callerEndpoint);
InstantMessagingCall callerInstantMessagingCall = new InstantMessagingCall(callerConversation);
callerInstantMessagingCall.BeginEstablish(calleeEndpoint.OwnerUri, null, EndCallerCallEstablish,
callerInstantMessagingCall);
// Force synchronization to ensure that the call is now complete.
_waitForCallAcceptByCallee.WaitOne();
_waitForCallerCallEstablish.WaitOne();
// Now that the call is established, we can begin the escalation.
// First, we bind the conference state changed event handler, largely
// for logging reasons.
callerConversation.ConferenceSession.StateChanged += new
EventHandler <StateChangedEventArgs <ConferenceSessionState> >(ConferenceSession_StateChanged);
Console.WriteLine("");
Console.WriteLine(" Beginning conference creation and escalation...");
Console.WriteLine("");
// Next, the initiator of the escalation creates an ad-hoc conference
// (using the current modalities present in the conversation) by calling
// ConferenceSession.BeginJoin on a conversation, without providing
// a conference URI. This prepares the calls for actual escalation by
// binding the appropriate conference multipoint Control Unit (MCU)
// sessions. When EndJoinConference is called, it will kick off the
// subsequent escalation. As part of the escalation, the remote party
// will receive an escalation request, via the event on the far end
// conversation, EscalateToConferenceRequested. Also, the existing
// calls will be shifted to the MCUs.
callerConversation.ConferenceSession.BeginJoin(default(ConferenceJoinOptions),
EndCallerJoinConference, callerConversation.ConferenceSession);
//Wait for both sides to fully escalate to the new conference.
_waitForCallerConferenceEscalation.WaitOne();
_waitForCalleeConferenceEscalation.WaitOne();
Console.WriteLine("");
Console.WriteLine(" Beginning conference command and control...");
Console.WriteLine("");
// Promote a participant to leader; Leaders can lock and unlock the
// conference, as well as possessing the ability to eject and control
// other participants, and mute participants (in an Audio conference).
// For purposes of the demonstration, choose an arbitrary conference
// participant here, the first.
ConversationParticipant target = null;
if (callerConversation.RemoteParticipants.Count >= 1)
{
target = callerConversation.RemoteParticipants[0];
}
else
{
// TODO (Left to the reader): Add error handling code.
}
Console.WriteLine("User " + target.UserAtHost + " is currently an " + target.Role + ".");
// Note: This is the naive synch implementation, and is not generally
// suitable for production code. It is only used here for brevity.
callerConversation.ConferenceSession.BeginModifyRole(target, ConferencingRole.Leader,
EndModifyRole, callerConversation.ConferenceSession);
_waitForRoleModification.WaitOne();
Console.WriteLine("User " + target.UserAtHost + " is now a " + target.Role + ".");
Console.WriteLine("The conference access level is currently " +
callerConversation.ConferenceSession.AccessLevel + ".");
// Locking the conference prevents new users from joining the
// conference, unless explicitly called into the conference through
// the dialout API.
callerConversation.ConferenceSession.BeginLockConference(EndLockConference,
callerConversation.ConferenceSession);
_waitForConferenceLock.WaitOne();
Console.WriteLine("The conference accesslevel is now " +
callerConversation.ConferenceSession.AccessLevel + ".");
// Now, eject the participant, and then shut down the platform.
Console.WriteLine("The conference currently has " +
callerConversation.ConferenceSession.GetRemoteParticipantEndpoints().Count + " attendees.");
// Ejection can only be performed by leaders of the conference.
callerConversation.ConferenceSession.BeginEject(target, EndEject, callerConversation.ConferenceSession);
_waitForParticipantEject.WaitOne();
Console.WriteLine("The conference now has " +
callerConversation.ConferenceSession.GetRemoteParticipantEndpoints().Count + " attendees.");
_helper.ShutdownPlatform();
Console.ReadLine();
}
/// <summary>
/// Retrieves the application configuration and runs the sample.
/// </summary>
private void Run()
{
// Prepare and instantiate the platform.
_helper = new UCMASampleHelper();
_userEndpoint = _helper.CreateEstablishedUserEndpoint(
"SubscribePresence Sample User" /*endpointFriendlyName*/);
// Get the URI of the remote user whose presence to subscribe to.
_remoteUserUri = "sip:" + UCMASampleHelper.PromptUser(
"Please enter the URI, in the format user@host, of the user whose Presence to subscribe to "
+ "=> ", "RemoteUserURI");
// RemotePresenceView is the class to be used to subscribe to
// another entity's presence.
_remotePresenceView = new RemotePresenceView(_userEndpoint);
// Wire up event handlers to receive the incoming notifications of
// the remote user being subscribed to.
_remotePresenceView.SubscriptionStateChanged += new EventHandler <
RemoteSubscriptionStateChangedEventArgs>(
RemotePresence_SubscriptionStateNotificationReceived);
_remotePresenceView.PresenceNotificationReceived += new EventHandler <
RemotePresentitiesNotificationEventArgs>(RemotePresence_PresenceNotificationReceived);
try
{
// Subscribe to target user.
_target = new RemotePresentitySubscriptionTarget(_remoteUserUri);
_remotePresenceView.StartSubscribingToPresentities(
new RemotePresentitySubscriptionTarget[] { _target });
// Subscribe to ContactGroupServices.
// This is done so that the user can add/delete groups and
// add/delete contacts, among other operations.
_userEndpoint.ContactGroupServices.NotificationReceived += new EventHandler
<Microsoft.Rtc.Collaboration.ContactsGroups.ContactGroupNotificationEventArgs>(
ContactGroupServices_NotificationReceived);
_userEndpoint.ContactGroupServices.SubscriptionStateChange += new EventHandler
<PresenceSubscriptionStateChangedEventArgs>(ContactGroupServices_SubscriptionStateChange);
_userEndpoint.ContactGroupServices.BeginSubscribe(EndSubscribeCompleted,
_userEndpoint.ContactGroupServices);
// Wait for subscription to ContactsGroups to be completed.
_waitForSubscribedToContactsGroupsCompleted.WaitOne();
Console.WriteLine("Subscription to ContactsGroups completed.");
// Create a new group.
_userEndpoint.ContactGroupServices.BeginAddGroup(_groupName,
null /* group data */,
EndAddGroupCompleted,
_userEndpoint.ContactGroupServices);
// Wait for group to be created.
_waitForGroupIdSet.WaitOne();
// Add the remote user to the newly created group.
ContactsGroups.ContactAddOptions addOptions
= new Microsoft.Rtc.Collaboration.ContactsGroups.ContactAddOptions();
addOptions.GroupIds.Add(_groupId);
_userEndpoint.ContactGroupServices.BeginAddContact(_remoteUserUri,
addOptions,
EndAddContactCompleted,
_userEndpoint.ContactGroupServices);
UCMASampleHelper.PauseBeforeContinuing("You are now subscribed to the presence of the remote "
+ "user. \nPlease toggle the user state of the remote user to get the appropriate "
+ "notifications. \nPress ENTER to delete the contact, delete the group, and unsubscribe"
+ "to the presence of the remote user.");
// Remove contact from group, and delete group.
_userEndpoint.ContactGroupServices.BeginDeleteContact(_remoteUserUri,
EndDeleteContactCompleted,
_userEndpoint.ContactGroupServices);
}
catch (ArgumentException ex)
{
Console.WriteLine("Could not subscribe to the presence of the remote user: "******"\n\n********************");
Console.WriteLine("Press ENTER to shutdown and exit.");
Console.WriteLine("********************\n\n");
Console.ReadLine();
// Shutdown Platform
_helper.ShutdownPlatform();
}
private void Run()
{
// Initialize and startup the platform.
Exception ex = null;
try
{
// Create the UserEndpoint
_helper = new UCMASampleHelper();
_userEndpoint = _helper.CreateEstablishedUserEndpoint(
"IMCall Sample User" /*endpointFriendlyName*/);
Console.Write("The User Endpoint owned by URI: ");
Console.Write(_userEndpoint.OwnerUri);
Console.WriteLine(" is now established and registered.");
// Setup the conversation and place the call.
ConversationSettings convSettings = new ConversationSettings();
convSettings.Priority = _conversationPriority;
convSettings.Subject = _conversationSubject;
// Conversation represents a collection of modes of communication
// (media types)in the context of a dialog with one or multiple
// callees.
Conversation conversation = new Conversation(_userEndpoint, convSettings);
_instantMessagingCall = new InstantMessagingCall(conversation);
// Call: StateChanged: Only hooked up for logging. Generally,
// this can be used to surface changes in Call state to the UI
_instantMessagingCall.StateChanged += this.InstantMessagingCall_StateChanged;
// Subscribe for the flow created event; the flow will be used to
// send the media (here, IM).
// Ultimately, as a part of the callback, the messages will be
// sent/received.
_instantMessagingCall.InstantMessagingFlowConfigurationRequested +=
this.InstantMessagingCall_FlowConfigurationRequested;
// Get the sip address of the far end user to communicate with.
String _calledParty = "sip:" +
UCMASampleHelper.PromptUser(
"Enter the URI of the user logged onto Microsoft Lync, in the User@Host format => ",
"RemoteUserURI");
// Place the call to the remote party, without specifying any
// custom options. Please note that the conversation subject
// overrides the toast message, so if you want to see the toast
// message, please set the conversation subject to null.
_instantMessagingCall.BeginEstablish(_calledParty, new ToastMessage("Hello Toast"), null,
CallEstablishCompleted, _instantMessagingCall);
}
catch (InvalidOperationException iOpEx)
{
// Invalid Operation Exception may be thrown if the data provided
// to the BeginXXX methods was invalid/malformed.
// TODO (Left to the reader): Write actual handling code here.
ex = iOpEx;
}
finally
{
if (ex != null)
{
// If the action threw an exception, terminate the sample,
// and print the exception to the console.
// TODO (Left to the reader): Write actual handling code here.
Console.WriteLine(ex.ToString());
Console.WriteLine("Shutting down platform due to error");
_helper.ShutdownPlatform();
}
}
// Wait for sample to complete
_sampleCompletedEvent.WaitOne();
}
private void Run()
{
// A helper class to take care of platform and endpoint setup and
// cleanup. This has been abstracted from this sample to focus on
// Call Control.
_helper = new UCMASampleHelper();
// Create a user endpoint, using the network credential object
// defined above.
_callerEndpoint = _helper.CreateEstablishedUserEndpoint(
"Conference Leader" /* friendly name for conference leader endpoint */);
// Create a second user endpoint, using the network credential object
// defined above.
_calleeEndpoint = _helper.CreateEstablishedUserEndpoint(
"Conference Attendee" /* friendly name for conference attendee endpoint */);
// Get the URI for the user logged onto Microsoft Lync
String _ocUserURI = "sip:" + UCMASampleHelper.PromptUser(
"Enter the URI for the user logged onto Microsoft Lync, in the User@Host format => ",
"RemoteUserURI" /* key to specify remote user's URI in app.config */);
// One of the endpoints schedules the conference in advance. At
// schedule time, all the conference settings are set.
// The base conference settings object, used to set the policies for the conference.
ConferenceScheduleInformation conferenceScheduleInformation = new ConferenceScheduleInformation();
// An open meeting (participants can join who are not on the list),
// but requiring authentication (no anonymous users allowed.)
conferenceScheduleInformation.AccessLevel = ConferenceAccessLevel.SameEnterprise;
// The below flag determines whether or not the passcode is optional
// for users joining the conference.
conferenceScheduleInformation.IsPasscodeOptional = true;
conferenceScheduleInformation.Passcode = "1357924680";
// The verbose description of the conference
conferenceScheduleInformation.Description = "Interesting Description";
// The below field indicates the date and time after which the conference can be deleted.
conferenceScheduleInformation.ExpiryTime = System.DateTime.Now.AddHours(5);
// These two lines assign a set of modalities (here, only
// InstantMessage) from the available MCUs to the conference. Custom
// modalities (and their corresponding MCUs) may be added at this
// time as part of the extensibility model.
ConferenceMcuInformation instantMessageMCU = new ConferenceMcuInformation(McuType.InstantMessaging);
conferenceScheduleInformation.Mcus.Add(instantMessageMCU);
// Now that the setup object is complete, schedule the conference
// using the conference services off of Endpoint. Note: the conference
// organizer is considered a leader of the conference by default.
_callerEndpoint.ConferenceServices.BeginScheduleConference(conferenceScheduleInformation,
EndScheduleConference, _callerEndpoint.ConferenceServices);
// Wait for the scheduling to complete.
_waitForConferenceScheduling.WaitOne();
// Now that the conference is scheduled, it's time to join it. As we
// already have a reference to the conference object populated from
// the EndScheduleConference call, we do not need to get the
// conference first. Initialize a conversation off of the endpoint,
// and join the conference from the uri provided above.
Conversation callerConversation = new Conversation(_callerEndpoint);
callerConversation.ConferenceSession.StateChanged += new
EventHandler <StateChangedEventArgs <ConferenceSessionState> >(ConferenceSession_StateChanged);
// Join and wait, again forcing synchronization.
callerConversation.ConferenceSession.BeginJoin(_conference.ConferenceUri, null /*joinOptions*/,
EndJoinConference, callerConversation.ConferenceSession);
_waitForConferenceJoin.WaitOne();
// Placing the calls on the conference-connected conversation
// connects to the respective MCUs. These calls may then be used to
// communicate with the conference/MCUs.
InstantMessagingCall instantMessagingCall = new InstantMessagingCall(callerConversation);
// Hooking up event handlers and then placing the call.
instantMessagingCall.InstantMessagingFlowConfigurationRequested +=
this.instantMessagingCall_InstantMessagingFlowConfigurationRequested;
instantMessagingCall.StateChanged += this._call_StateChanged;
instantMessagingCall.BeginEstablish(EndCallEstablish, instantMessagingCall);
//Synchronize to ensure that call has completed.
_waitForCallEstablish.WaitOne();
//send conf invite
ConferenceInvitationDeliverOptions deliverOptions = new ConferenceInvitationDeliverOptions();
deliverOptions.ToastMessage = new ToastMessage("Welcome to my conference");
ConferenceInvitation invitation = new ConferenceInvitation(callerConversation);
invitation.BeginDeliver(_ocUserURI, deliverOptions, EndDeliverInvitation, invitation);
// Synchronize to ensure that invitation is complete
_waitForConversationInviteRemoteParticipants.WaitOne();
//And from the other endpoint's perspective:
//Initialize a conversation off of the endpoint, and join the
//conference from the uri provided above.
Conversation calleeConversation = new Conversation(_calleeEndpoint);
calleeConversation.ConferenceSession.StateChanged += new
EventHandler <StateChangedEventArgs <ConferenceSessionState> >(ConferenceSession_StateChanged);
// Join and wait, again forcing synchronization.
calleeConversation.ConferenceSession.BeginJoin(_conference.ConferenceUri, null /*joinOptions*/,
EndJoinConference, calleeConversation.ConferenceSession);
_waitForConferenceJoin.WaitOne();
// Placing the calls on the conference-connected conversation
// connects to the respective MCUs. These calls may then be used to
//communicate with the conference/MCUs.
InstantMessagingCall instantMessagingCall2 = new InstantMessagingCall(calleeConversation);
//Hooking up event handlers and then placing the call.
instantMessagingCall2.InstantMessagingFlowConfigurationRequested +=
this.instantMessagingCall2_InstantMessagingFlowConfigurationRequested;
instantMessagingCall2.StateChanged += this._call_StateChanged;
instantMessagingCall2.BeginEstablish(EndCallEstablish, instantMessagingCall2);
//Synchronize to ensure that call has completed.
_waitForCallEstablish.WaitOne();
//Synchronize to ensure that all messages are sent and received
_waitForMessageReceived.WaitOne();
//Wait for shutdown initiated by user
_waitForShutdown.WaitOne();
UCMASampleHelper.PauseBeforeContinuing("Press ENTER to shutdown and exit.");
}
