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(); }