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();
}
/// <summary>
/// Retrieves the application configuration and begins running the
/// sample.
/// </summary>
void Run()
{
_appID = null;
try
{
// Attempt to retrieve the application ID of the provisioned
// application from the config file.
_appID = System.Configuration.ConfigurationManager.AppSettings["ApplicationID"];
if (string.IsNullOrEmpty(_appID))
{
// The application ID wasn't retrieved from the config file
// so prompt for the application ID for the application that
// has been provisioned.
string prompt = "Please enter the unique ID of the application that is provisioned in "
+ "the topology => ";
_appID = UCMASampleHelper.PromptUser(prompt, null);
}
if (!string.IsNullOrEmpty(_appID))
{
Console.WriteLine("Creating CollaborationPlatform for the provisioned application with "
+ "ID \'{0}\' using ProvisionedApplicationPlatformSettings.", _appID);
ProvisionedApplicationPlatformSettings settings
= new ProvisionedApplicationPlatformSettings("UCMASampleApp", _appID);
_collabPlatform = new CollaborationPlatform(settings);
// Wire up a handler for the
// ApplicationEndpointOwnerDiscovered event.
_collabPlatform.RegisterForApplicationEndpointSettings(
this.Platform_ApplicationEndpointOwnerDiscovered);
// Initialize and startup the platform.
_collabPlatform.BeginStartup(EndPlatformStartup, _collabPlatform);
}
else
{
Console.WriteLine("No application ID was specified by the user.");
}
UCMASampleHelper.PauseBeforeContinuing("Press ENTER to shutdown and exit.");
}
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 for the
// occurrence.
Console.WriteLine("Invalid Operation Exception: " + iOpEx.ToString());
}
finally
{
// Terminate the platform which would in turn terminate any
// endpoints.
Console.WriteLine("Shutting down the platform.");
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();
}
/// <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();
}
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.
_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()
{
// 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();
}
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.");
}
/// <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();
}
/// <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();
}