private void InstantMessagingFlow_MessageReceived(object sender, InstantMessageReceivedEventArgs e) { //xueming InstantMessagingFlow _instantMessagingFlow = sender as InstantMessagingFlow; // On an incoming Instant Message, print the contents to the console. Console.WriteLine(e.Sender.Uri + " said: " + e.TextBody); // Shutdown if the far end tells us to. if (e.TextBody.Equals("bye", StringComparison.OrdinalIgnoreCase)) { // Shutting down the platform will terminate all attached objects. // If this was a production application, it would tear down the // Call/Conversation, rather than terminating the entire platform. _instantMessagingFlow.BeginSendInstantMessage("Shutting Down...", SendMessageCompleted, _instantMessagingFlow); _helper.ShutdownPlatform(); _OCSCompletedEvent.Set(); } else { // Echo the instant message back to the far end (the sender of // the instant message). // Change the composing state of the local end user while sending messages to the far end. // A delay is introduced purposely to demonstrate the typing notification displayed by the // far end client; otherwise the notification will not last long enough to notice. _instantMessagingFlow.LocalComposingState = ComposingState.Composing; Thread.Sleep(2000); //Echo the message with an "Echo" prefix. _instantMessagingFlow.BeginSendInstantMessage("Echo: " + e.TextBody, SendMessageCompleted, _instantMessagingFlow); } }
private void InstantMessagingFlow_StateChanged(object sender, MediaFlowStateChangedEventArgs e) { Console.WriteLine("Flow state changed from " + e.PreviousState + " to " + e.State); // When flow is active, media operations (here, sending an IM) // may begin. if (e.State == MediaFlowState.Active) { // Send the message on the InstantMessagingFlow. _instantMessagingFlow.BeginSendInstantMessage(_messageToSend, SendMessageCompleted, _instantMessagingFlow); } }
//Handler for the InstantMessagingFlow.StateChanged event. void ImFlow_StateChanged(object sender, MediaFlowStateChangedEventArgs e) { if (e.State == MediaFlowState.Active) { ImFlow.BeginSendInstantMessage(messageText, SendMessageCompleted, ImFlow); } }
/// <summary> /// Overridden process method. /// </summary> public override void Process() { bool exceptionEncountered = true; Exception exceptionCaught = null; try { m_imFlow.BeginSendInstantMessage(m_textBody, this.InstantMessagingSendMessageCompleted, null /*state*/); exceptionEncountered = false; } catch (InvalidOperationException ioe) { Helper.Logger.Info("Exception = {0}", EventLogger.ToString(ioe)); exceptionCaught = ioe; } finally { if (exceptionEncountered) { OperationFault operationFault = null; if (exceptionCaught != null) { operationFault = FaultHelper.CreateClientOperationFault(exceptionCaught.Message, exceptionCaught.InnerException); } else { operationFault = FaultHelper.CreateServerOperationFault(FailureStrings.GenericFailures.UnexpectedException, null /*innerException*/); } this.CompleteSendMessageOperationWithException(new FaultException <OperationFault>(operationFault)); } } }
private void instantMessagingFlow2_MessageReceived(object sender, InstantMessageReceivedEventArgs e) { InstantMessagingFlow instantMessagingFlow = sender as InstantMessagingFlow; //On an incoming Instant Message, print the contents to the console. Console.WriteLine("In callee's message handler: " + e.Sender.DisplayName + " said: " + e.TextBody); //Shutdown the platform if (e.TextBody.Equals("bye", StringComparison.OrdinalIgnoreCase)) { _helper.ShutdownPlatform(); _waitForShutdown.Set(); return; } Console.WriteLine("Message received will be echoed"); _messageToSend = "echo: " + e.TextBody; //Send the message on the InstantMessagingFlow. if (_IMFlow2 != null && _IMFlow2.State == MediaFlowState.Active) { _IMFlow2.BeginSendInstantMessage(_messageToSend, EndSendMessage, instantMessagingFlow); } else { Console.WriteLine("Could not echo message because flow was either null or inactive"); } _waitForMessage2Received.Set(); }
/// <summary> /// Send status message to customer on the IM channel. /// </summary> public void SendStatusMessageToCustomer(ContentType contentType, byte[] body) { try { InstantMessagingFlow imFlow = this.imCall.Flow; imFlow.BeginSendInstantMessage(contentType, body, (asyncResult) => { try { imFlow.EndSendInstantMessage(asyncResult); } catch (RealTimeException rte) { Console.WriteLine("Exception while sending message {0}", rte); this.logger.Log("Exception while sending message {0}", rte); } }, null); } catch (InvalidOperationException ioe) { Console.WriteLine("Exception while sending message {0}", ioe); this.logger.Log("Exception while sending message {0}", ioe); } }
private void instantMessagingFlow_StateChanged(object sender, MediaFlowStateChangedEventArgs e) { InstantMessagingFlow instantMessagingFlow = sender as InstantMessagingFlow; Console.WriteLine("Flow state changed from " + e.PreviousState + " to " + e.State); //When flow is active, media operations (here, sending an IM) may begin. if (e.State == MediaFlowState.Active) { _IMFlow = instantMessagingFlow; Console.WriteLine("Please type the message to send..."); string msg = Console.ReadLine(); //Send the message on the InstantMessagingFlow. instantMessagingFlow.BeginSendInstantMessage(msg, EndSendMessage, instantMessagingFlow); } }
/// <summary> /// Im flow message received event handler. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void ImFlowMessageReceived(object sender, InstantMessageReceivedEventArgs e) { if (Boolean.Parse(System.Configuration.ConfigurationManager.AppSettings["UseUserEndPoint"])) { if (this.isUserEndpointFirstMessage) { this.isUserEndpointFirstMessage = false; return; } } InstantMessagingFlow imFlow = sender as InstantMessagingFlow; string userResponse = e.TextBody.Trim(); Console.WriteLine("Received _ :" + userResponse + " from " + e.Sender.Uri); MimePartContentDescription package = this.menu.HandleUserInput(userResponse); if (package != null) { try { imFlow.BeginSendInstantMessage(package.ContentType, package.GetBody(), (asyncResult) => { try { imFlow.EndSendInstantMessage(asyncResult); } catch (RealTimeException rte) { Console.WriteLine("Exception while sending message {0}", rte); this.logger.Log("Exception while sending message {0}", rte); } }, null); } catch (InvalidOperationException ioe) { Console.WriteLine("Exception while sending message {0}", ioe); this.logger.Log("Exception while sending message {0}", ioe); } } }
private void InstantMessagingFlow_StateChanged(object sender, MediaFlowStateChangedEventArgs e) { Console.WriteLine("Flow state changed from " + e.PreviousState + " to " + e.State); // When flow is active, media operations (here, sending an IM) // may begin. //xueming InstantMessagingFlow instantMessagingFlow = sender as InstantMessagingFlow; if (e.State == MediaFlowState.Active) { // Send the message on the InstantMessagingFlow. // _instantMessagingFlow.BeginSendInstantMessage(_messageToSend, SendMessageCompleted, // _instantMessagingFlow); string str = _messageToSend.ToString(); byte[] bytes = Encoding.UTF8.GetBytes(str); instantMessagingFlow.BeginSendInstantMessage(new ContentType("text/html"), bytes, SendMessageCompleted, instantMessagingFlow); } }
private void SendIMResponse(InstantMessagingFlow imFlow, string message) { try { imFlow.BeginSendInstantMessage( message, delegate(IAsyncResult ar) { try { imFlow.EndSendInstantMessage(ar); } catch (RealTimeException) { } }, null); } catch (InvalidOperationException) { } }
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 SendMessage(InstantMessagingFlow flow, string message) { try { flow.BeginSendInstantMessage(message, ar => { try { flow.EndSendInstantMessage(ar); } catch (RealTimeException ex) { Console.WriteLine(ex); } }, null); } catch (InvalidOperationException ex) { Console.WriteLine(ex); } }