private void InstantMessagingFlow_MessageReceived(object sender, InstantMessageReceivedEventArgs e)
{
// On an incoming Instant Message, print the contents to the console.
Console.WriteLine(e.Sender.Uri + " said: " + e.TextBody);
// Shutdown if the far end tells us to.
if (e.TextBody.Equals("bye", StringComparison.OrdinalIgnoreCase))
{
// Shutting down the platform will terminate all attached objects.
// If this was a production application, it would tear down the
// Call/Conversation, rather than terminating the entire platform.
_instantMessagingFlow.BeginSendInstantMessage("Shutting Down...", SendMessageCompleted,
_instantMessagingFlow);
_helper.ShutdownPlatform();
_sampleCompletedEvent.Set();
}
else
{
// Echo the instant message back to the far end (the sender of
// the instant message).
// Change the composing state of the local end user while sending messages to the far end.
// A delay is introduced purposely to demonstrate the typing notification displayed by the
// far end client; otherwise the notification will not last long enough to notice.
_instantMessagingFlow.LocalComposingState = ComposingState.Composing;
Thread.Sleep(2000);
//Echo the message with an "Echo" prefix.
_instantMessagingFlow.BeginSendInstantMessage("Echo: " + e.TextBody, SendMessageCompleted,
_instantMessagingFlow);
}
}
private void OnRestart(object sender, EventArgs e)
{
if (!object.ReferenceEquals(null, _helper))
{
// Un-wire the presence notification event handler.
_localOwnerPresence.PresenceNotificationReceived -= LocalOwnerPresence_PresenceNotificationReceived;
// Shut down platform before exiting the sample.
_helper.ShutdownPlatform();
}
Application.Restart();
}
private void instantMessagingFlow2_MessageReceived(object sender, InstantMessageReceivedEventArgs e)
{
InstantMessagingFlow instantMessagingFlow = sender as InstantMessagingFlow;
//On an incoming Instant Message, print the contents to the console.
Console.WriteLine("In callee's message handler: " + e.Sender.DisplayName + " said: " + e.TextBody);
//Shutdown the platform
if (e.TextBody.Equals("bye", StringComparison.OrdinalIgnoreCase))
{
_helper.ShutdownPlatform();
_waitForShutdown.Set();
return;
}
Console.WriteLine("Message received will be echoed");
_messageToSend = "echo: " + e.TextBody;
//Send the message on the InstantMessagingFlow.
if (_IMFlow2 != null && _IMFlow2.State == MediaFlowState.Active)
{
_IMFlow2.BeginSendInstantMessage(_messageToSend, EndSendMessage, instantMessagingFlow);
}
else
{
Console.WriteLine("Could not echo message because flow was either null or inactive");
}
_waitForMessage2Received.Set();
}
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()
{
// 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();
}
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();
}
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();
}
/// <summary>
/// Retrieves the application configuration and begins running the
/// sample.
/// </summary>
private void Run()
{
try
{
// Prepare and instantiate the platform.
_helper = new UCMASampleHelper();
UserEndpointSettings userEndpointSettings = _helper.ReadUserSettings(
"PublishPresence Sample User" /*friendly name of the sample's user endpoint*/);
// Set auto subscription to LocalOwnerPresence.
userEndpointSettings.AutomaticPresencePublicationEnabled = true;
_userEndpoint = _helper.CreateUserEndpoint(userEndpointSettings);
// LocalOwnerPresence is the main class to manage the
// sample user's presence data.
_localOwnerPresence = _userEndpoint.LocalOwnerPresence;
// Wire up handlers to receive presence notifications to self.
_localOwnerPresence.PresenceNotificationReceived
+= LocalOwnerPresence_PresenceNotificationReceived;
// Establish the endpoint.
_helper.EstablishUserEndpoint(_userEndpoint);
// Publish presence categories with the new values that
// are outlined in the sample.
PublishPresenceCategories(true /* publish presence categories */);
Console.WriteLine("Note, AggregateState, and ContactCard published.");
// Wait for user to continue.
UCMASampleHelper.PauseBeforeContinuing(
"Press ENTER to continue and delete the published presence.");
// Delete presence categories, returning them to the original
// values before the sample was run.
PublishPresenceCategories(false /* delete presence categories */);
// Wait for user to continue.
UCMASampleHelper.PauseBeforeContinuing("Press ENTER to shutdown and exit.");
// Un-wire the presence notification event handler.
_localOwnerPresence.PresenceNotificationReceived
-= LocalOwnerPresence_PresenceNotificationReceived;
}
finally
{
// Shut down platform before exiting the sample.
_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();
}
// Shut down the BackToBackCall, both Conversations, and the platform.
void FinishShutdown()
{
_b2bCall.BeginTerminate(B2BTerminateCB, _b2bCall);
_waitForB2BCallToTerminate.WaitOne();
_outboundAVCall.Conversation.BeginTerminate(TerminateConversationCB, _outboundAVCall.Conversation);
_inboundAVCall.Conversation.BeginTerminate(TerminateConversationCB, _inboundAVCall.Conversation);
Console.WriteLine("Waiting for the conversation to be terminated...");
_waitForConversationToTerminate.WaitOne();
// Now, clean up by shutting down the platform.
Console.WriteLine("Shutting down the platform...");
_helper.ShutdownPlatform();
_waitUntilOneUserHangsUp.Set();
}
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 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.
_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. 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();
}
private void Run()
{
// Prepare and instantiate the platform.
_helper = new UCMASampleHelper();
UserEndpointSettings userEndpointSettings = _helper.ReadUserSettings(
"PresenceContainerMembership Sample subscribee" /*endpointFriendlyName*/);
// Set auto subscription to LocalOwnerPresence
userEndpointSettings.AutomaticPresencePublicationEnabled = true;
_subscribee = _helper.CreateUserEndpoint(userEndpointSettings);
// Establish the endpoint
_helper.EstablishUserEndpoint(_subscribee);
_subscriberUri = UCMASampleHelper.PromptUser("Please Enter the subscriber's Uri in the form "
+ "sip:User@Hostuser. Please ensure that the uri is in the same domain as "
+ _subscriberUriKey,
_subscriberUriKey);
if (!_subscriberUri.StartsWith(_sipPrefix, StringComparison.OrdinalIgnoreCase))
{
_subscriberUri = _sipPrefix + _subscriberUri;
}
Console.WriteLine("{0} will block {1}, then unblock him. Please login to Microsoft Lync as {1}.",
_subscribee.OwnerUri,
_subscriberUri);
UCMASampleHelper.PauseBeforeContinuing("Press ENTER to continue.");
// First publish MachineStateOnline using default grammar. UCMA SDK
// will publish to the correct containers.
_subscribee.LocalOwnerPresence.BeginPublishPresence(
new PresenceCategory[] { PresenceState.EndpointOnline, PresenceState.UserAvailable },
HandleEndPublishPresence,
null);
Console.WriteLine("{0} has published 'Available'. ", _subscribee.OwnerUri);
Console.WriteLine("Using Microsoft Lync, please subscribe to {0} when logged in as {1}. ",
_subscribee.OwnerUri,
_subscriberUri);
Console.WriteLine("You should see that {0} is online and Available. ", _subscribee.OwnerUri);
UCMASampleHelper.PauseBeforeContinuing("Press ENTER to continue.");
ContainerUpdateOperation operation = new ContainerUpdateOperation(_blockedContainer);
operation.AddUri(_subscriberUri);
_subscribee.LocalOwnerPresence.BeginUpdateContainerMembership(
new ContainerUpdateOperation[] { operation },
HandleEndUpdateContainerMembership, null);
Console.WriteLine("{0} has added {1} to container {2} - the blocked container.",
_subscribee.OwnerUri,
_subscriberUri,
_blockedContainer);
Console.WriteLine("Microsoft Lync should display 'Offline' for user {0} now. ",
_subscribee.OwnerUri);
UCMASampleHelper.PauseBeforeContinuing("Press ENTER to continue.");
operation = new ContainerUpdateOperation(_blockedContainer);
operation.DeleteUri(_subscriberUri);
_subscribee.LocalOwnerPresence.BeginUpdateContainerMembership(
new ContainerUpdateOperation[] { operation },
HandleEndUpdateContainerMembership, null);
Console.WriteLine("{0} has removed {1} from the blocked container. Microsoft Lync should display "
+ "'online' for user {0} now. ",
_subscribee.OwnerUri,
_subscriberUri);
Console.WriteLine(" Sample complete. ");
UCMASampleHelper.PauseBeforeContinuing("Press ENTER to shutdown and exit.");
// Shutdown 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();
}
/// <summary>
/// Retrieves the application configuration and begins running the
/// sample.
/// </summary>
public void Run()
{
try
{
_helper = new UCMASampleHelper();
_appEndpoint = _helper.CreateApplicationEndpoint("TrustedConferenceParticipant");
if (_appEndpoint.State == LocalEndpointState.Established)
{
Console.WriteLine("The Application Endpoint owned by URI {0}, is now established and "
+ "registered.", _appEndpoint.OwnerUri);
}
else
{
Console.WriteLine("The Application endpoint is not currently in the Established state, "
+ "exiting...");
return;
}
// Impersonate a user and create an ad-hoc conference.
ImpersonateAndCreateConference();
// Have the application endpoint join the ad-hoc conference as a
// trusted participant.
JoinConferenceAsTrustedParticipant();
// Start monitoring the AVMCU session for attendance changes.
StartAVMCUSessionAttendanceMonitoring();
int invitationCounter = 1;
while (true)
{
// Retrieve the uri of the user to be invited from the
// config file.
string prompt = "Please enter the uri of the user who should be sent an invitation to the"
+ "conference (Enter to Skip) => ";
string invitationTargetUri = UCMASampleHelper.PromptUser(prompt, "InvitationTargetURI"
+ invitationCounter);
if (!string.IsNullOrEmpty(invitationTargetUri))
{
InviteUserToConference(invitationTargetUri);
invitationCounter++;
if (_invitedParticipantAccepted)
{
// Wait for the invited participant to have the
// Trusted User establish an Av call and update the
// audio routes to communicate with them. This is
// purely so the logging for each invited user
// occurs in sequence for this sample.
Console.WriteLine("Waiting for the AudioRoute update on the Av Call for the new "
+ "participant to complete.");
_audioRouteUpdateForNewParticipantCallCompleted.WaitOne();
}
}
else
{
Console.WriteLine("No invitation uri provided, skipping conference invitation.");
break;
}
}
Console.WriteLine(RetrieveConversationParticipantsProperties(
_impersonatingAvCall.Conversation));
Console.Write("\n\n********************\n");
Console.WriteLine("Press enter to exit.");
Console.WriteLine("********************\n\n");
Console.ReadLine();
}
finally
{
//Terminate the platform which would in turn terminate any
// endpoints.
Console.WriteLine("Shutting down the platform.");
_helper.ShutdownPlatform();
}
}
/// <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()
{
// 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();
}
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();
}
