/// <summary> /// Event handler to receive auto-provisioned ApplicationEndpointSettings for /// a given application Id. Auto-provisioned ApplicationEndpointSettings contains /// the correct proxy server and proxy port, as well as other configurational /// information required to establish a connection between the endpoint and the /// server. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> static void ApplicationEndpointSettingsDiscovered(object sender, ApplicationEndpointSettingsDiscoveredEventArgs e) { Console.WriteLine("ApplicationEndpointOwnerDiscovered event was raised."); Console.WriteLine("provisioned application ID = \'{0}\' ", _appID); Console.WriteLine("Owner display name is: " + e.ApplicationEndpointSettings.OwnerDisplayName); Console.WriteLine("Owner URI is: " + e.ApplicationEndpointSettings.OwnerUri); Console.WriteLine("ProxyHost: " + e.ApplicationEndpointSettings.ProxyHost); Console.WriteLine("ProxyPort: " + e.ApplicationEndpointSettings.ProxyPort); try { ApplicationEndpointSettings settings = e.ApplicationEndpointSettings; _superEndpoint = new ApplicationEndpoint(_collabPlatform, settings); // Establish the endpoint. _superEndpoint.EndEstablish(_superEndpoint.BeginEstablish(null, null)); Console.WriteLine("ApplicationEndpoint state={0}", _superEndpoint.State.ToString()); _superP2PEndpoint = (SipPeerToPeerEndpoint)_superEndpoint.InnerEndpoint; } 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): Error handling code. Console.WriteLine("Invalid Operation Exception: " + iOpEx.ToString()); } }
// Registered event handler for the ApplicationEndpointOwnerDiscovered event on the // CollaborationPlatform for the provisioned application. private void Platform_ApplicationEndpointOwnerDiscovered(object sender, ApplicationEndpointSettingsDiscoveredEventArgs e) { Helper.Logger.Info("ApplicationEndpointOwnerDiscovered event was raised during startup of the " + "CollaborationPlatform."); ApplicationEndpointSettings settings = e.ApplicationEndpointSettings; settings.UseRegistration = false; m_applicationEndpoint = new ApplicationEndpoint(m_collabPlatform, settings); bool epBeginEstablishFailed = true; try { this.RegisterEndpointEventHandlers(m_applicationEndpoint); m_applicationEndpoint.BeginEstablish(this.EndpointEstablishCompleted, m_applicationEndpoint); epBeginEstablishFailed = false; } catch (InvalidOperationException ioe) { Helper.Logger.Error("Endpoint establishment operation threw an exception {0}", EventLogger.ToString(ioe)); } finally { if (epBeginEstablishFailed) { this.Cleanup(); } } }
// Registered event handler for the ApplicationEndpointOwnerDiscovered // event on the CollaborationPlatform for the provisioned application. private void Platform_ApplicationEndpointOwnerDiscovered(object sender, ApplicationEndpointSettingsDiscoveredEventArgs e) { Console.WriteLine("ApplicationEndpointOwnerDiscovered event was raised during startup of the " + "CollaborationPlatform for the provisioned application with ID \'{0}\'."); ApplicationEndpointSettings settings = e.ApplicationEndpointSettings; settings.SupportedMimePartContentTypes = new ContentType[] { new ContentType("text/plain") }; //Set the endpoint presence to appear as always online InitializePublishAlwaysOnlineSettings(settings); Console.WriteLine("Initializing the ApplicationEndpoint that corresponds to the provisioned " + "application with ID \'{0}\'.", _appID); // Initialize the endpoint using the settings retrieved above. _appEndpoint = new ApplicationEndpoint(_collabPlatform, settings); // Wire up the StateChanged event. _appEndpoint.StateChanged += this.Endpoint_StateChanged; try { // Establish the endpoint. _appEndpoint.BeginEstablish(EndEndpointEstablish, _appEndpoint); } 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()); } }
private void StartupEndpoint(AsyncTask task, object state) { task.DoOneStep( delegate() { m_endpoint = new ApplicationEndpoint(m_parent.Platform, m_settings); m_endpoint.RegisterForIncomingCall <AudioVideoCall>(this.ReceiveIncomingAvCall); m_endpoint.RegisterForIncomingCall <InstantMessagingCall>(this.ReceiveIncomingIMCall); m_endpoint.LocalOwnerPresence.SubscriberNotificationReceived += SubscriberNotificationReceived; m_endpoint.StateChanged += this.EndpointStateChanged; Logger.Log(Logger.LogLevel.Info, "Starting Application Endpoint."); m_endpoint.BeginEstablish( delegate(IAsyncResult ar) { task.DoOneStep( delegate() { m_endpoint.EndEstablish(ar); Logger.Log(Logger.LogLevel.Info, "Started Application Endpoint. Tel #:" + m_endpoint.OwnerPhoneUri ?? "null"); m_endpoint.LocalOwnerPresence.BeginSubscribe( delegate(IAsyncResult ar2) { task.DoFinalStep( delegate() { m_endpoint.LocalOwnerPresence.EndSubscribe(ar2); }); }, null); }); }, null); }); }
private void Platform_ApplicationEndpointOwnerDiscovered(object sender, ApplicationEndpointSettingsDiscoveredEventArgs e) { Console.WriteLine("Contact discovered: {0}", e.ApplicationEndpointSettings.OwnerUri); var settings = e.ApplicationEndpointSettings; settings.AutomaticPresencePublicationEnabled = true; settings.Presence.PresentityType = "automaton"; settings.Presence.Description = "Toujours disponible !"; _applicationEndpoint = new ApplicationEndpoint(_CollabPlatform, settings); Console.WriteLine("Establishing the endopint"); _applicationEndpoint.BeginEstablish(EndpointEstablishCompleted, null); }
private static ApplicationEndpoint CreateEndPoint(ServerPlatformSettings settings) { CollaborationPlatform collaborationPlatform = new CollaborationPlatform(settings); collaborationPlatform.EndStartup(collaborationPlatform.BeginStartup(null, null)); ApplicationEndpoint result; try { ApplicationEndpoint applicationEndpoint = new ApplicationEndpoint(collaborationPlatform, new ApplicationEndpointSettings(BaseUMconnectivityTester.SipPlatformConnectionManager.OwnerUri)); applicationEndpoint.EndEstablish(applicationEndpoint.BeginEstablish(null, null)); result = applicationEndpoint; } catch (Exception) { collaborationPlatform.EndShutdown(collaborationPlatform.BeginShutdown(null, null)); throw; } return(result); }
// Registered event handler for the ApplicationEndpointOwnerDiscovered event on the // CollaborationPlatform for the provisioned application. static void Platform_ApplicationEndpointOwnerDiscovered(object sender, ApplicationEndpointSettingsDiscoveredEventArgs e) { Console.WriteLine("ApplicationEndpointOwnerDiscovered event was raised during startup of the CollaborationPlatform."); Console.WriteLine("The ApplicationEndpointOwnerConfiguration that corresponds to the provisioned application are: "); Console.WriteLine("Owner display name is: " + e.ApplicationEndpointSettings.OwnerDisplayName); Console.WriteLine("Owner URI is: " + e.ApplicationEndpointSettings.OwnerUri); Console.WriteLine("Now retrieving the ApplicationEndpointSettings from the ApplicationEndpointSettingsDiscoveredEventArgs."); ApplicationEndpointSettings settings = e.ApplicationEndpointSettings; settings.AutomaticPresencePublicationEnabled = true; settings.SupportedMimePartContentTypes = new ContentType[] { new ContentType("text/plain") }; settings.Presence.Description = "AlwaysOnlineBot"; PreferredServiceCapabilities capabilities = settings.Presence.PreferredServiceCapabilities; capabilities.ApplicationSharingSupport = CapabilitySupport.Supported; capabilities.AudioSupport = CapabilitySupport.Supported; capabilities.InstantMessagingSupport = CapabilitySupport.Supported; capabilities.VideoSupport = CapabilitySupport.Supported; Console.WriteLine("Initializing the ApplicationEndpoint that corresponds to the provisioned application."); // Initalize the endpoint using the settings retrieved above. _appEndpoint = new ApplicationEndpoint(_collabPlatform, settings); // Wire up the StateChanged event. _appEndpoint.StateChanged += Endpoint_StateChanged; // Wire up the ApplicationEndpointOwnerPropertiesChanged event. _appEndpoint.OwnerPropertiesChanged += Endpoint_ApplicationEndpointOwnerPropertiesChanged; try { // Establish the endpoint. _appEndpoint.BeginEstablish(EndEndpointEstablish, _appEndpoint); } catch (InvalidOperationException iOpEx) { Console.WriteLine("Invalid Operation Exception: " + iOpEx.ToString()); } }
// Registered event handler for the ApplicationEndpointOwnerDiscovered event on the // CollaborationPlatform for the provisioned application. void Platform_ApplicationEndpointOwnerDiscovered(object sender, ApplicationEndpointSettingsDiscoveredEventArgs e) { Console.WriteLine("ApplicationEndpointOwnerDiscovered event was raised during startup of the " + "CollaborationPlatform."); Console.WriteLine("The ApplicationEndpointOwnerConfiguration that corresponds to the provisioned " + "application with ID \'{0}\' are: ", _appID); Console.WriteLine("Owner display name is: " + e.ApplicationEndpointSettings.OwnerDisplayName); Console.WriteLine("Owner URI is: " + e.ApplicationEndpointSettings.OwnerUri); Console.WriteLine("Now retrieving the ApplicationEndpointSettings from the " + "ApplicationEndpointSettingsDiscoveredEventArgs."); ApplicationEndpointSettings settings = e.ApplicationEndpointSettings; settings.SupportedMimePartContentTypes = new ContentType[] { new ContentType("text/plain") }; Console.WriteLine("Initializing the ApplicationEndpoint that corresponds to the provisioned " + "application with ID \'{0}\'.", _appID); // Initalize the endpoint using the settings retrieved above. _appEndpoint = new ApplicationEndpoint(_collabPlatform, settings); // Wire up the StateChanged event. _appEndpoint.StateChanged += this.Endpoint_StateChanged; // Wire up the ApplicationEndpointOwnerPropertiesChanged event. _appEndpoint.OwnerPropertiesChanged += this.Endpoint_ApplicationEndpointOwnerPropertiesChanged; try { // Establish the endpoint. _appEndpoint.BeginEstablish(EndEndpointEstablish, _appEndpoint); } 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): Error handling code. Console.WriteLine("Invalid Operation Exception: " + iOpEx.ToString()); } }
public static void Start() { try { var host = Plugin.LyncPlugin.Configuration.GetString("host"); var thumbprint = Plugin.LyncPlugin.Configuration.GetString("thumbprint"); var gruu = Plugin.LyncPlugin.Configuration.GetString("gruu"); var trustPort = Plugin.LyncPlugin.Configuration.GetInt("trustedPort"); var appPort = Plugin.LyncPlugin.Configuration.GetInt("appPort"); var sip = Plugin.LyncPlugin.Configuration.GetString("accountSip"); var platformSettings = new ServerPlatformSettings(UserAgent, host, trustPort, gruu, CertificateUtil.GetCertificate(StoreName.My, StoreLocation.LocalMachine, thumbprint)); Platform = new CollaborationPlatform(platformSettings); AppEndpoint = new ApplicationEndpoint(Platform, new ApplicationEndpointSettings(sip, host, appPort) { UseRegistration = true }); Log("Starting Lync platform."); Platform.EndStartup(Platform.BeginStartup(null, null)); Log("Lync platform started."); AppEndpoint.EndEstablish(AppEndpoint.BeginEstablish(null, null)); UserEndpoint = new UserEndpoint(Platform, new UserEndpointSettings(sip, host, appPort) { AutomaticPresencePublicationEnabled = true }); UserEndpoint.EndEstablish(UserEndpoint.BeginEstablish(null, null)); RemotePresence = new RemotePresenceView(UserEndpoint, new RemotePresenceViewSettings()); RemotePresence.PresenceNotificationReceived += PresenceNotificationReceived; } catch (Exception ex) { Error(ex.Message); } }
public ApplicationEndpoint CreateApplicationEndpoint(string contactFriendlyName) { string prompt = string.Empty; if (string.IsNullOrEmpty(contactFriendlyName)) { contactFriendlyName = "Default Contact"; } Console.WriteLine(); Console.WriteLine("Creating Application Endpoint {0}...", contactFriendlyName); Console.WriteLine(); // If application settings are provided via the app.config file, then use them // Else prompt user for details if (!ReadApplicationContactConfiguration()) { // Prompt user for server FQDN. If server FQDN was entered before, then let the user use the saved value. if (string.IsNullOrEmpty(_serverFqdn)) { prompt = "Please enter the FQDN of the Microsoft Lync Server for this topology => "; _serverFqdn = PromptUser(prompt, null); } if (string.IsNullOrEmpty(_applicationHostFQDN)) { prompt = "Please enter the FQDN of the Machine that the application service is configured to => "; _applicationHostFQDN = PromptUser(prompt, null); } if (0 >= _applicationPort) { // Prompt user for contact port prompt = "Please enter the port that the application service is configured to => "; _applicationPort = int.Parse(PromptUser(prompt, null), CultureInfo.InvariantCulture); } if (string.IsNullOrEmpty(_applicationGruu)) { // Prompt user for Contact GRUU prompt = "Please enter the GRUU assigned to the application service => "; _applicationGruu = PromptUser(prompt, null); } if (string.IsNullOrEmpty(_applicationContactURI)) { // Prompt user for contact URI prompt = "Please enter the Contact URI in the User@Host format => "; _applicationContactURI = PromptUser(prompt, null); if (!_applicationContactURI.Trim().StartsWith(_sipPrefix, StringComparison.OrdinalIgnoreCase)) { _applicationContactURI = _sipPrefix + _applicationContactURI.Trim(); } } if (string.IsNullOrEmpty(_certificateFriendlyName)) { // Prompt user for contact URI prompt = "Please enter the friendly name of the certificate to be used => "; _certificateFriendlyName = PromptUser(prompt, null); } } // Reuse platform instance so that all endpoints share the same platform. if (_serverCollabPlatform == null) { CreateAndStartServerPlatform(); } // Initalize and register the endpoint. // NOTE: the _applicationContactURI should always be of the form "sip:user@host" ApplicationEndpointSettings appEndpointSettings = new ApplicationEndpointSettings(_applicationContactURI, _serverFqdn, 5061); _applicationEndpoint = new ApplicationEndpoint(_serverCollabPlatform, appEndpointSettings); _endpointInitCompletedEvent.Reset(); Console.WriteLine("Establishing the endpoint..."); _applicationEndpoint.BeginEstablish(EndEndpointEstablish, _applicationEndpoint); // Sync; wait for the registration to complete. _endpointInitCompletedEvent.WaitOne(); Console.WriteLine("Application Endpoint established..."); return(_applicationEndpoint); }
private void EstablishApplicationEndpoint() { string contactUri = ConfigurationManager.AppSettings["contactUri"]; string proxyServerFqdn = ConfigurationManager.AppSettings["proxyServerFqdn"]; int tlsPort = 5061; // ApplicationEndpointSettings settings = new ApplicationEndpointSettings(contactUri); ApplicationEndpointSettings settings = new ApplicationEndpointSettings(contactUri, proxyServerFqdn, tlsPort); settings.UseRegistration = true; settings.AutomaticPresencePublicationEnabled = true; settings.Presence.PresentityType = "automaton"; settings.Presence.Description = "Always available !"; PreferredServiceCapabilities capabilities = settings.Presence.PreferredServiceCapabilities; capabilities.InstantMessagingSupport = CapabilitySupport.Supported; capabilities.AudioSupport = CapabilitySupport.Supported; capabilities.VideoSupport = CapabilitySupport.Supported; capabilities.ApplicationSharingSupport = CapabilitySupport.Supported; _appEndpoint = new ApplicationEndpoint(_collaborationPlatform, settings); _appEndpoint.StateChanged += new EventHandler<LocalEndpointStateChangedEventArgs>(_appEndpoint_StateChanged); // Register to be notified of incoming calls _appEndpoint.RegisterForIncomingCall<AudioVideoCall>(OnAudioVideoCallReceived); // Register to be notified of incoming instant messaging calls _appEndpoint.RegisterForIncomingCall<InstantMessagingCall>(OnInstantMessagingCallReceived); _logger.Log("Establishing application endpoint..."); _appEndpoint.BeginEstablish(OnApplicationEndpointEstablishCompleted, null); }
private void OnApplicationEndpointSettingsDiscovered(object sender, ApplicationEndpointSettingsDiscoveredEventArgs args) { // Keep track of how many endpoints we've found // so that we only take one. Interlocked.Increment(ref _endpointsDiscovered); if (_endpointsDiscovered > 1) { // We've already found an endpoint // and we don't need another one. Sorry! return; } _appEndpoint = new ApplicationEndpoint(_collaborationPlatform, args.ApplicationEndpointSettings); _appEndpoint.BeginEstablish(OnApplicationEndpointEstablishCompleted, null); }
/// <summary> /// Callback from <code>BeginStartup</code> method on platform. /// </summary> /// <param name="result"> /// Status of the platform startup operation. /// </param> private void PlatformStartupCompleted(IAsyncResult result) { // Extract the platform that was passed in as the state argument to // the BeginStartup() method. CollaborationPlatform platform = result.AsyncState as CollaborationPlatform; if (platform == null) { UCMASampleHelper.WriteErrorLine("CollaborationPlatform not passed into BeginStartup() method."); UCMASampleHelper.FinishSample(); return; } try { // Determine whether the startup operation completed // successfully. platform.EndStartup(result); UCMASampleHelper.WriteLine("Platform has been started."); } catch (TlsFailureException tlsFailureException) { // TlsFailureException will be thrown if the certificate used to // startup the platform is invalid or otherwise unusable. // TODO (Left to the reader): Error handling code to either // retry the platform startup operation with a different // certificate, log the error for debugging, or gracefully exit // the program. UCMASampleHelper.WriteException(tlsFailureException); UCMASampleHelper.FinishSample(); } catch (ConnectionFailureException connectionFailureException) { // ConnectionFailureException will be thrown when the platform // could not listen on any of the configured IP/port // combinations. // TODO (Left to the reader): Error handling code to notify user // the configured IP address cannot be used or some other // process is already using the port, log the error for // debugging, or gracefully exit the program. UCMASampleHelper.WriteException(connectionFailureException); UCMASampleHelper.FinishSample(); } catch (RealTimeException realTimeException) { // RealTimeException will be thrown when the platform startup // operation failed for some other reason. // TODO (Left to the reader): Error handling code to notify user // the configured IP address cannot be used or some other // process is already using the port, log the error for // debugging, or gracefully exit the program. UCMASampleHelper.WriteException(realTimeException); UCMASampleHelper.FinishSample(); } try { // Create the ApplicationEndpointSettings. _endpointSettings = new ApplicationEndpointSettings(_endpointOwnerURI, _registrarFQDN, _registrarPort); // Create the ApplicationEndpoint from the // ApplicationEndpointSettings and bind it to the platform. _endpoint = new ApplicationEndpoint(platform, _endpointSettings); // Bind an event handler to notify when the endpoint changes // state. _endpoint.StateChanged += new EventHandler <LocalEndpointStateChangedEventArgs>( _endpoint_StateChanged); // Establish the endpoint so that it can receive incoming calls // and conference invitations. EndEndpointEstablish() will be // called when the endpoint finishes establishment. _endpoint.BeginEstablish(EndpointEstablishmentCompleted, _endpoint); UCMASampleHelper.WriteLine("Endpoint has been established."); } catch (ArgumentNullException argumentNullException) { // ArgumentNullException will be thrown if the parameters used to // construct ApplicationEndpointSettings or ApplicationEndpoint // are null. // TODO (Left to the reader): Error handling code to either // retry creating the endpoint with non-null parameters, log the // error for debugging or gracefully exit the program. UCMASampleHelper.WriteException(argumentNullException); UCMASampleHelper.FinishSample(); } catch (ArgumentException argumentException) { // ArgumentException will be thrown if the parameters used to // construct ApplicationEndpointSettings or ApplicationEndpoint // are invalid. // TODO (Left to the reader): Error handling code to either // retry creating the endpoint with corrected parameters, log // the error for debugging or gracefully exit the program. UCMASampleHelper.WriteException(argumentException); UCMASampleHelper.FinishSample(); } catch (InvalidOperationException invalidOperationException) { // InvalidOperationException will be thrown if the platform is // already shutdown, an endpoint with the same SIP URI already // exists, or the endpoint has already been established or // terminated. // TODO (Left to the reader): Error handling code to log the // error for debugging. UCMASampleHelper.WriteException(invalidOperationException); UCMASampleHelper.FinishSample(); } }