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