Exemplo n.º 1
0
        public async Task ShouldRaiseIncomingAudioVideoInviteToAllRegisteredEventHandlersInOrder()
        {
            var loggingContext = new LoggingContext(Guid.NewGuid());
            var data           = TestHelper.CreateApplicationEndpoint();
            Mock <IEventChannel> mockEventChannel    = data.EventChannel;
            ApplicationEndpoint  applicationEndpoint = data.ApplicationEndpoint;

            await applicationEndpoint.InitializeAsync(loggingContext).ConfigureAwait(false);

            await applicationEndpoint.InitializeApplicationAsync(loggingContext).ConfigureAwait(false);

            // Given
            var eventsReceived = 0;
            var lastEvent      = 0;

            applicationEndpoint.HandleIncomingAudioVideoCall += (sender, args) => { ++eventsReceived; lastEvent = 1; };
            applicationEndpoint.HandleIncomingAudioVideoCall += (sender, args) => { ++eventsReceived; lastEvent = 2; };

            // When
            TestHelper.RaiseEventsFromFile(mockEventChannel, "Event_IncomingAudioCall.json");

            // Then
            Assert.AreEqual(2, eventsReceived);
            Assert.AreEqual(2, lastEvent);
        }
        public async void TestSetup()
        {
            m_loggingContext = new LoggingContext(Guid.NewGuid());
            var data = TestHelper.CreateApplicationEndpoint();

            m_mockEventChannel = data.EventChannel;
            m_restfulClient    = data.RestfulClient;

            ApplicationEndpoint applicationEndpoint = data.ApplicationEndpoint;
            await applicationEndpoint.InitializeAsync(m_loggingContext).ConfigureAwait(false);

            await applicationEndpoint.InitializeApplicationAsync(m_loggingContext).ConfigureAwait(false);

            m_restfulClient.HandleRequestProcessed += (sender, args) =>
            {
                TestHelper.RaiseEventsOnHttpRequest(args, DataUrls.MessagingInvitations, HttpMethod.Post, "Event_MessagingInvitationStarted.json", m_mockEventChannel);
                TestHelper.RaiseEventsOnHttpRequest(args, DataUrls.MessagingInvitations, HttpMethod.Post, "Event_ConversationConnected.json", m_mockEventChannel);
                TestHelper.RaiseEventsOnHttpRequest(args, DataUrls.MessagingInvitations, HttpMethod.Post, "Event_ParticipantAdded.json", m_mockEventChannel);
            };

            IMessagingInvitation invitation = await applicationEndpoint.Application.Communication
                                              .StartMessagingAsync("Test subject", new SipUri("sip:[email protected]"), "https://example.com/callback", m_loggingContext)
                                              .ConfigureAwait(false);

            m_conversation = invitation.RelatedConversation;
        }
Exemplo n.º 3
0
        public async Task RunAsync()
        {
            var skypeId         = ConfigurationManager.AppSettings["Trouter_SkypeId"];
            var password        = ConfigurationManager.AppSettings["Trouter_Password"];
            var applicationName = ConfigurationManager.AppSettings["Trouter_ApplicationName"];
            var userAgent       = ConfigurationManager.AppSettings["Trouter_UserAgent"];
            var token           = SkypeTokenClient.ConstructSkypeToken(
                skypeId: skypeId,
                password: password,
                useTestEnvironment: false,
                scope: string.Empty,
                applicationName: applicationName).Result;

            m_logger = new ConsoleLogger();

            // Uncomment for debugging
            // m_logger.HttpRequestResponseNeedsToBeLogged = true;

            EventChannel = new TrouterBasedEventChannel(m_logger, token, userAgent);

            // Prepare platform
            var platformSettings = new ClientPlatformSettings(QuickSamplesConfig.AAD_ClientSecret, new Guid(QuickSamplesConfig.AAD_ClientId));
            var platform         = new ClientPlatform(platformSettings, m_logger);

            // Prepare endpoint
            var endpointSettings    = new ApplicationEndpointSettings(new SipUri(QuickSamplesConfig.ApplicationEndpointId));
            var applicationEndpoint = new ApplicationEndpoint(platform, endpointSettings, EventChannel);

            var loggingContext = new LoggingContext(Guid.NewGuid());
            await applicationEndpoint.InitializeAsync(loggingContext).ConfigureAwait(false);

            await applicationEndpoint.InitializeApplicationAsync(loggingContext).ConfigureAwait(false);

            // Meeting configuration
            var meetingConfiguration = new AdhocMeetingCreationInput(Guid.NewGuid().ToString("N") + " test meeting");

            // Schedule meeting
            var adhocMeeting = await applicationEndpoint.Application.CreateAdhocMeetingAsync(loggingContext, meetingConfiguration).ConfigureAwait(false);

            WriteToConsoleInColor("ad hoc meeting uri : " + adhocMeeting.OnlineMeetingUri);
            WriteToConsoleInColor("ad hoc meeting join url : " + adhocMeeting.JoinUrl);

            // Get all the events related to join meeting through Trouter's uri
            platformSettings.SetCustomizedCallbackurl(new Uri(EventChannel.CallbackUri));

            // Start joining the meeting
            var invitation = await adhocMeeting.JoinAdhocMeeting(loggingContext, null).ConfigureAwait(false);

            // Wait for the join to complete
            await invitation.WaitForInviteCompleteAsync().ConfigureAwait(false);

            invitation.RelatedConversation.HandleParticipantChange += Conversation_HandleParticipantChange;

            WriteToConsoleInColor("Showing roaster udpates for 5 minutes for meeting : " + adhocMeeting.JoinUrl);

            // Wait 5 minutes before exiting.
            // Since we have registered Conversation_HandleParticipantChange, we will continue to show participant changes in the
            // meeting for this duration.
            await Task.Delay(TimeSpan.FromMinutes(5)).ConfigureAwait(false);
        }
Exemplo n.º 4
0
        public async Task ShouldRaiseIncomingIMInviteOnceIfSameEventHandlerRegisteredMultipleTimes()
        {
            var loggingContext = new LoggingContext(Guid.NewGuid());
            var data           = TestHelper.CreateApplicationEndpoint();
            Mock <IEventChannel> mockEventChannel    = data.EventChannel;
            ApplicationEndpoint  applicationEndpoint = data.ApplicationEndpoint;

            await applicationEndpoint.InitializeAsync(loggingContext).ConfigureAwait(false);

            await applicationEndpoint.InitializeApplicationAsync(loggingContext).ConfigureAwait(false);


            // Given
            var eventsReceived = 0;
            EventHandler <IncomingInviteEventArgs <IMessagingInvitation> > handler = (sender, args) => { Interlocked.Increment(ref eventsReceived); };

            applicationEndpoint.HandleIncomingInstantMessagingCall += handler;
            applicationEndpoint.HandleIncomingInstantMessagingCall += handler;

            // When
            TestHelper.RaiseEventsFromFile(mockEventChannel, "Event_IncomingIMCall.json");

            // Then
            Assert.AreEqual(1, eventsReceived);
        }
Exemplo n.º 5
0
        public async void TestSetup()
        {
            m_loggingContext = new LoggingContext(Guid.NewGuid());
            var data = TestHelper.CreateApplicationEndpoint();

            m_mockEventChannel = data.EventChannel;
            m_restfulClient    = data.RestfulClient;

            ApplicationEndpoint applicationEndpoint = data.ApplicationEndpoint;
            await applicationEndpoint.InitializeAsync(m_loggingContext).ConfigureAwait(false);

            await applicationEndpoint.InitializeApplicationAsync(m_loggingContext).ConfigureAwait(false);

            IConversation conversation = null;

            applicationEndpoint.HandleIncomingAudioVideoCall += (sender, args) => conversation = args.NewInvite.RelatedConversation;

            TestHelper.RaiseEventsFromFile(m_mockEventChannel, "Event_IncomingAudioCall.json");
            TestHelper.RaiseEventsFromFile(m_mockEventChannel, "Event_ConversationConnected_WithAudio.json");
            TestHelper.RaiseEventsFromFile(m_mockEventChannel, "Event_AudioVideoConnected.json");

            m_restfulClient.HandleRequestProcessed     +=
                (sender, args) => m_transferOperationId = TestHelper.RaiseEventsOnHttpRequest(args, DataUrls.Transfer, HttpMethod.Post, "Event_TransferStarted.json", m_mockEventChannel);

            m_transfer = await conversation.AudioVideoCall.TransferAsync(new SipUri("sip:[email protected]"), null, m_loggingContext).ConfigureAwait(false);
        }
Exemplo n.º 6
0
        public async Task ShoulNotRaiseIncomingAudioVideoInvitationToUnregisteredHandler()
        {
            // Given
            var loggingContext = new LoggingContext(Guid.NewGuid());
            var data           = TestHelper.CreateApplicationEndpoint();
            Mock <IEventChannel> mockEventChannel    = data.EventChannel;
            ApplicationEndpoint  applicationEndpoint = data.ApplicationEndpoint;
            var callReceived = false;

            await applicationEndpoint.InitializeAsync(loggingContext).ConfigureAwait(false);

            await applicationEndpoint.InitializeApplicationAsync(loggingContext).ConfigureAwait(false);

            EventHandler <IncomingInviteEventArgs <IAudioVideoInvitation> > handler = (sender, args) => { callReceived = true; };

            applicationEndpoint.HandleIncomingAudioVideoCall += handler;

            TestHelper.RaiseEventsFromFile(mockEventChannel, "Event_IncomingAudioCall.json");
            Assert.IsTrue(callReceived, "AudioVideo call not raised by SDK.");
            callReceived = false;

            // When
            applicationEndpoint.HandleIncomingAudioVideoCall -= handler;

            // Then
            Assert.IsFalse(callReceived, "AudioVideo call raised by SDK to an unregistered event handler.");
        }
Exemplo n.º 7
0
        public async void TestSetup()
        {
            m_loggingContext = new LoggingContext(Guid.NewGuid());
            var data = TestHelper.CreateApplicationEndpoint();

            m_mockEventChannel = data.EventChannel;
            m_restfulClient    = data.RestfulClient;

            m_applicationEndpoint = data.ApplicationEndpoint;
            await m_applicationEndpoint.InitializeAsync(m_loggingContext).ConfigureAwait(false);

            await m_applicationEndpoint.InitializeApplicationAsync(m_loggingContext).ConfigureAwait(false);

            ICommunication communication = m_applicationEndpoint.Application.Communication;

            m_restfulClient.HandleRequestProcessed += (sender, args) =>
            {
                TestHelper.RaiseEventsOnHttpRequest(args, DataUrls.MessagingInvitations, HttpMethod.Post, "Event_MessagingInvitationStarted.json", m_mockEventChannel);
                TestHelper.RaiseEventsOnHttpRequest(args, DataUrls.EstablishMessagingCall, HttpMethod.Post, "Event_MessagingInvitationStarted.json", m_mockEventChannel);
            };

            // Start a messaging invitation
            m_messagingInvitation = await communication.StartMessagingWithIdentityAsync(
                "Test subject",
                "sip:[email protected]",
                "https://example.com/callback",
                "Local user",
                "sip:[email protected]",
                m_loggingContext);
        }
Exemplo n.º 8
0
        public async Task RunAsync(Uri callbackUri)
        {
            m_logger = new SampleAppLogger();

            // Uncomment for debugging
            // m_logger.HttpRequestResponseNeedsToBeLogged = true;

            // Prepare platform
            var platformSettings = new ClientPlatformSettings(QuickSamplesConfig.AAD_ClientSecret, new Guid(QuickSamplesConfig.AAD_ClientId));
            var platform         = new ClientPlatform(platformSettings, m_logger);

            // You can hook up your own implementation of IEventChannel here
            IEventChannel eventChannel = WebEventChannel.WebEventChannel.Instance;

            // Prepare endpoint
            var endpointSettings    = new ApplicationEndpointSettings(new SipUri(QuickSamplesConfig.ApplicationEndpointId));
            var applicationEndpoint = new ApplicationEndpoint(platform, endpointSettings, eventChannel);

            var loggingContext = new LoggingContext(Guid.NewGuid());
            await applicationEndpoint.InitializeAsync(loggingContext).ConfigureAwait(false);

            await applicationEndpoint.InitializeApplicationAsync(loggingContext).ConfigureAwait(false);

            // Meeting configuration
            var meetingConfiguration = new AdhocMeetingCreationInput(Guid.NewGuid().ToString("N") + " test meeting");

            // Schedule meeting
            var adhocMeeting = await applicationEndpoint.Application.CreateAdhocMeetingAsync(meetingConfiguration, loggingContext).ConfigureAwait(false);

            WriteToConsoleInColor("ad hoc meeting uri : " + adhocMeeting.OnlineMeetingUri);
            WriteToConsoleInColor("ad hoc meeting join url : " + adhocMeeting.JoinUrl);

            // Get all the events related to join meeting through our custom callback uri
            platformSettings.SetCustomizedCallbackurl(callbackUri);

            // Start joining the meeting
            ICommunication communication = applicationEndpoint.Application.Communication;

            if (!communication.CanJoinAdhocMeeting(adhocMeeting))
            {
                throw new Exception("Cannot join adhoc meeting");
            }

            var invitation = await communication.JoinAdhocMeetingAsync(adhocMeeting, null, loggingContext).ConfigureAwait(false);

            // Wait for the join to complete
            await invitation.WaitForInviteCompleteAsync().ConfigureAwait(false);

            invitation.RelatedConversation.HandleParticipantChange += Conversation_HandleParticipantChange;
            WriteToConsoleInColor("Showing roaster udpates for 5 minutes for meeting : " + adhocMeeting.JoinUrl);

            // Wait 5 minutes before exiting.
            // Since we have registered Conversation_HandleParticipantChange, we will continue to show participant changes in the
            // meeting for this duration.
            await Task.Delay(TimeSpan.FromMinutes(5)).ConfigureAwait(false);

            await WebEventChannel.WebEventChannel.Instance.TryStopAsync().ConfigureAwait(false);
        }
        /// <summary>
        /// The initialize application endpoint function
        /// </summary>
        public async Task InitializeApplicationEndpointAsync(
            string applicationEndpointUri,
            string callbackUriFormat,
            string resourcesUriFormat,
            string audienceUri,
            string aadClientId,
            string aadClientSecret,
            string appTokenCertThumbprint,
            string instanceId,
            bool isSandBoxEnvionment        = false,
            bool logFullHttpRequestResponse = true)
        {
            this.InstanceId        = instanceId;
            this.ResourceUriFormat = resourcesUriFormat;
            this.CallbackUriFormat = callbackUriFormat;

            var logger = IOCHelper.Resolve <IPlatformServiceLogger>();

            logger.HttpRequestResponseNeedsToBeLogged = logFullHttpRequestResponse;

            ClientPlatformSettings platformSettings = null;

            if (!string.IsNullOrEmpty(appTokenCertThumbprint))
            {
                platformSettings = new ClientPlatformSettings(
                    Guid.Parse(aadClientId),
                    appTokenCertThumbprint,
                    isSandBoxEnvionment
                    );
            }
            else if (!string.IsNullOrEmpty(aadClientSecret))
            {
                platformSettings = new ClientPlatformSettings(
                    aadClientSecret,
                    Guid.Parse(aadClientId),
                    isSandBoxEnvionment
                    );
            }
            else
            {
                throw new InvalidOperationException("Should provide at least one prarameter in aadClientSecret and appTokenCertThumbprint");
            }

            var platform = new ClientPlatform(platformSettings, logger);

            var endpointSettings = new ApplicationEndpointSettings(new SipUri(applicationEndpointUri));

            ApplicationEndpoint = new ApplicationEndpoint(platform, endpointSettings, null);

            var loggingContext = new LoggingContext(Guid.NewGuid());
            await ApplicationEndpoint.InitializeAsync(loggingContext).ConfigureAwait(false);

            await ApplicationEndpoint.InitializeApplicationAsync(loggingContext).ConfigureAwait(false);
        }
Exemplo n.º 10
0
        public async Task RunAsync(Uri callbackUri)
        {
            var targetUserId = ConfigurationManager.AppSettings["Skype_TargetUserId"];

            m_logger = new SampleAppLogger();

            // Uncomment for debugging
            // m_logger.HttpRequestResponseNeedsToBeLogged = true;

            // You can hook up your own implementation of IEventChannel here
            IEventChannel eventChannel = WebEventChannel.WebEventChannel.Instance;

            // Prepare platform
            var platformSettings = new ClientPlatformSettings(QuickSamplesConfig.AAD_ClientSecret,
                                                              new Guid(QuickSamplesConfig.AAD_ClientId));
            var platform = new ClientPlatform(platformSettings, m_logger);

            // Prepare endpoint
            var endpointSettings    = new ApplicationEndpointSettings(new SipUri(QuickSamplesConfig.ApplicationEndpointId));
            var applicationEndpoint = new ApplicationEndpoint(platform, endpointSettings, eventChannel);

            var loggingContext = new LoggingContext(Guid.NewGuid());
            await applicationEndpoint.InitializeAsync(loggingContext).ConfigureAwait(false);

            await applicationEndpoint.InitializeApplicationAsync(loggingContext).ConfigureAwait(false);

            // Get all the events related to join meeting through our custom callback uri
            platformSettings.SetCustomizedCallbackurl(callbackUri);

            WriteToConsoleInColor("Start to send messaging invitation");
            var invitation = await applicationEndpoint.Application.Communication.StartMessagingAsync(
                "Subject",
                new SipUri(targetUserId),
                null,
                loggingContext).ConfigureAwait(false);

            // Wait for user to accept the invitation
            var conversation = await invitation.WaitForInviteCompleteAsync().ConfigureAwait(false);

            conversation.HandleParticipantChange += Conversation_HandleParticipantChange;
            conversation.MessagingCall.IncomingMessageReceived += Handle_IncomingMessage;

            // Send the initial message
            await conversation.MessagingCall.SendMessageAsync("Hello World!", loggingContext).ConfigureAwait(false);

            WriteToConsoleInColor("Staying in the conversation for 5 minutes");

            // Wait 5 minutes before exiting
            // Since we registered callbacks, we will continue to show message logs
            await Task.Delay(TimeSpan.FromMinutes(5)).ConfigureAwait(false);

            await WebEventChannel.WebEventChannel.Instance.TryStopAsync().ConfigureAwait(false);
        }
Exemplo n.º 11
0
        public async Task InitializeAsyncWorksWithNullLoggingContext()
        {
            // Given
            var data = TestHelper.CreateApplicationEndpoint();
            ApplicationEndpoint applicationEndpoint = data.ApplicationEndpoint;

            // When
            await applicationEndpoint.InitializeAsync(null).ConfigureAwait(false);

            // Then
            // No exception
        }
Exemplo n.º 12
0
        /// <summary>
        /// The initialize application endpoint function
        /// </summary>
        public async Task InitializeApplicationEndpointAsync(
            string discoverUri,
            string applicationEndpointUri,
            string callbackUriFormat,
            string resourcesUriFormat,
            string aadClientId,
            string aadClientSecret,
            string aadAuthorityUri,
            string aadCertThumbprint,
            string instanceId,
            bool logFullHttpRequestResponse)
        {
            this.InstanceId        = instanceId;
            this.ResourceUriFormat = resourcesUriFormat;
            this.CallbackUriFormat = callbackUriFormat;

            var logger = IOCHelper.Resolve <IPlatformServiceLogger>();

            logger.HttpRequestResponseNeedsToBeLogged = logFullHttpRequestResponse;

            ClientPlatformSettings platformSettings;

            if (aadClientSecret.Length > 0)
            {
                // AAD auth to app using client secret
                platformSettings = new ClientPlatformSettings(
                    new System.Uri(discoverUri),
                    Guid.Parse(aadClientId),
                    null,
                    aadClientSecret
                    );
            }
            else
            {
                // AAD auth to app using cert
                platformSettings = new ClientPlatformSettings(
                    new System.Uri(discoverUri),
                    Guid.Parse(aadClientId),
                    aadCertThumbprint
                    );
            }

            var platform         = new ClientPlatform(platformSettings, logger);
            var endpointSettings = new ApplicationEndpointSettings(new SipUri(applicationEndpointUri));

            ApplicationEndpoint = new ApplicationEndpoint(platform, endpointSettings, null);

            var loggingContext = new LoggingContext(Guid.NewGuid());
            await ApplicationEndpoint.InitializeAsync(loggingContext).ConfigureAwait(false);

            await ApplicationEndpoint.InitializeApplicationAsync(loggingContext).ConfigureAwait(false);
        }
Exemplo n.º 13
0
      public async Task Run()
      {
          ConsoleLogger logger = new ConsoleLogger();

          logger.HttpRequestResponseNeedsToBeLogged = true;  //Set to true if you want to log all http request and responses

          //Prepare platform

          //For all public developers
          ClientPlatformSettings platformSettings = new ClientPlatformSettings(
              QuickSamplesConfig.AAD_ClientSecret,
              Guid.Parse(QuickSamplesConfig.AAD_ClientId),
              false
              );

          var platform = new ClientPlatform(platformSettings, logger);

          //Prepare endpoint
          var eventChannel     = new FakeEventChannel();
          var endpointSettings = new ApplicationEndpointSettings(new SipUri(QuickSamplesConfig.ApplicationEndpointId));
          ApplicationEndpoint applicationEndpoint = new ApplicationEndpoint(platform, endpointSettings, eventChannel);

          var loggingContext = new LoggingContext(Guid.NewGuid());
          await applicationEndpoint.InitializeAsync(loggingContext).ConfigureAwait(false);

          await applicationEndpoint.InitializeApplicationAsync(loggingContext).ConfigureAwait(false);


          //Schedule meeting
          var adhocMeeting = await applicationEndpoint.Application.GetAdhocMeetingResourceAsync(loggingContext,
                                                                                                new AdhocMeetingInput
            {
                AccessLevel = AccessLevel.Everyone,
                Subject     = Guid.NewGuid().ToString("N") + "testMeeting"
            });

          logger.Information("ad hoc meeting uri : " + adhocMeeting.OnlineMeetingUri);
          logger.Information("ad hoc meeting join url : " + adhocMeeting.JoinUrl);

          //Get anon join token
          AnonymousApplicationTokenResource anonToken = await applicationEndpoint.Application.GetAnonApplicationTokenAsync(loggingContext, new AnonymousApplicationTokenInput
            {
                ApplicationSessionId = Guid.NewGuid().ToString(),                                                                      //Should be unique everytime
                AllowedOrigins       = "https://contoso.com;https://litware.com;http://www.microsoftstore.com/store/msusa/en_US/home", //Fill your own web site, For allow cross domain using
                MeetingUrl           = adhocMeeting.JoinUrl
            }
                                                                                                                           );


          logger.Information("Get anon token : " + anonToken.AuthToken);
          logger.Information("Get discover url for web SDK : " + anonToken.AnonymousApplicationsDiscover.Href);
      }
Exemplo n.º 14
0
        public async void TestSetup()
        {
            m_loggingContext = new LoggingContext(Guid.NewGuid());
            var data = TestHelper.CreateApplicationEndpoint();

            m_mockEventChannel = data.EventChannel;
            m_restfulClient    = data.RestfulClient;

            m_applicationEndpoint = data.ApplicationEndpoint;
            await m_applicationEndpoint.InitializeAsync(m_loggingContext).ConfigureAwait(false);

            await m_applicationEndpoint.InitializeApplicationAsync(m_loggingContext).ConfigureAwait(false);
        }
Exemplo n.º 15
0
        public async Task ShouldStopEventChannelOnUnitialization()
        {
            var data = TestHelper.CreateApplicationEndpoint();
            Mock <IEventChannel> mockEventChannel    = data.EventChannel;
            ApplicationEndpoint  applicationEndpoint = data.ApplicationEndpoint;
            await applicationEndpoint.InitializeAsync(new LoggingContext(Guid.NewGuid())).ConfigureAwait(false);

            // When
            applicationEndpoint.Uninitialize();

            // Then
            mockEventChannel.Verify(foo => foo.TryStopAsync(), Times.Once);
        }
Exemplo n.º 16
0
        public async Task InitializeApplicationAsyncWorksWithNullLoggingContext()
        {
            // Given
            var loggingContext = new LoggingContext(Guid.NewGuid());
            var data           = TestHelper.CreateApplicationEndpoint();
            ApplicationEndpoint applicationEndpoint = data.ApplicationEndpoint;
            await applicationEndpoint.InitializeAsync(loggingContext).ConfigureAwait(false);

            // When
            await applicationEndpoint.InitializeApplicationAsync(null).ConfigureAwait(false);

            // Then
            Assert.IsNotNull(applicationEndpoint.Application);
            Assert.IsTrue(data.RestfulClient.RequestsProcessed("GET " + DataUrls.Application));
        }
        static void Main(string[] args)
        {
            Dictionary <string, string> skypeAuthSettings = new Dictionary <string, string>()
            {
                { "AAD_ClientId", "" },
                { "AAD_ClientSecret", "" },
                { "ApplicationEndpointId", "" },
                { "DiscoverUri", "https://api.skypeforbusiness.com/platformservice/discover?Region=northamerica" }
            };

            var logger = new StringLogger();

            try
            {
                ClientPlatformSettings platformSettings =
                    new ClientPlatformSettings(new Uri(skypeAuthSettings["DiscoverUri"]), new Guid(skypeAuthSettings["AAD_ClientId"]), null, skypeAuthSettings["AAD_ClientSecret"], false);


                var platform = new ClientPlatform(platformSettings, logger);

                //Prepare endpoint
                var endpointSettings = new ApplicationEndpointSettings(new SipUri(skypeAuthSettings["ApplicationEndpointId"]));
                ApplicationEndpoint applicationEndpoint = new ApplicationEndpoint(platform, endpointSettings, null);

                var loggingContext = new LoggingContext(Guid.NewGuid());
                applicationEndpoint.InitializeAsync().GetAwaiter().GetResult();
                applicationEndpoint.InitializeApplicationAsync().GetAwaiter().GetResult();


                //Schedule meeting
                var input        = new AdhocMeetingCreationInput(Guid.NewGuid().ToString("N") + "testMeeting");
                var adhocMeeting = applicationEndpoint.Application.CreateAdhocMeetingAsync(input, loggingContext).Result;

                Console.WriteLine("ad hoc meeting uri : " + adhocMeeting.OnlineMeetingUri);
                Console.WriteLine("ad hoc meeting join url : " + adhocMeeting.JoinUrl);

                //Get anon join token
                IAnonymousApplicationToken anonToken = applicationEndpoint.Application.GetAnonApplicationTokenForMeetingAsync(adhocMeeting.JoinUrl, "https://contoso.com;https://litware.com;http://www.microsoftstore.com/store/msusa/en_US/home<https://urldefense.proofpoint.com/v2/url?u=https-3A__contoso.com-3Bhttps-3A_litware.com-3Bhttp-3A_www.microsoftstore.com_store_msusa_en-5FUS_home&d=DwMGaQ&c=Bi8ZWNNcZUBhi-AHLorvrkVH0ArnzxTAZ7C8kNcJoZo&r=uycUjr279qo0kuj5jNiyFqi9adZMUkMtmsdo99NlvRQ&m=7jet88f1Tbswi73IIaQYzhITPDlxR_mzF2flXNxdbwQ&s=ozm8LVnKFoAyQtSX8KWnm56u950cmjrR5fvfEpP1SfM&e=>", Guid.NewGuid().ToString(), loggingContext).Result;

                Console.WriteLine("Get anon token : " + anonToken.AuthToken);
                Console.WriteLine("Get discover url for web SDK : " + anonToken.AnonymousApplicationsDiscoverUri);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            Console.Read();
        }
Exemplo n.º 18
0
        public async Task InitializeApplicationAsyncShouldPopulateApplicationProperty()
        {
            var loggingContext = new LoggingContext(Guid.NewGuid());
            var data           = TestHelper.CreateApplicationEndpoint();
            ApplicationEndpoint applicationEndpoint = data.ApplicationEndpoint;
            await applicationEndpoint.InitializeAsync(loggingContext).ConfigureAwait(false);

            // Given
            Assert.IsNull(applicationEndpoint.Application);

            // When
            await applicationEndpoint.InitializeApplicationAsync(loggingContext).ConfigureAwait(false);

            // Then
            Assert.IsNotNull(applicationEndpoint.Application);
        }
Exemplo n.º 19
0
        public async Task InitializingApplicationEndpointStartsEventChannel()
        {
            // Given
            var data = TestHelper.CreateApplicationEndpoint();
            Mock <IEventChannel> mockEventChannel    = data.EventChannel;
            ApplicationEndpoint  applicationEndpoint = data.ApplicationEndpoint;
            var loggingContext = new LoggingContext(Guid.NewGuid());

            mockEventChannel.Verify(foo => foo.TryStartAsync(), Times.Never);

            // When
            await applicationEndpoint.InitializeAsync(loggingContext).ConfigureAwait(false);

            // Then
            mockEventChannel.Verify(foo => foo.TryStartAsync(), Times.Once);
        }
Exemplo n.º 20
0
        public async void TestSetup()
        {
            m_loggingContext = new LoggingContext(Guid.NewGuid());
            var data = TestHelper.CreateApplicationEndpoint();

            m_mockEventChannel = data.EventChannel;
            m_restfulClient    = data.RestfulClient;

            ApplicationEndpoint applicationEndpoint = data.ApplicationEndpoint;
            await applicationEndpoint.InitializeAsync(m_loggingContext).ConfigureAwait(false);

            await applicationEndpoint.InitializeApplicationAsync(m_loggingContext).ConfigureAwait(false);

            ICommunication communication = applicationEndpoint.Application.Communication;

            m_restfulClient.HandleRequestProcessed += (sender, args) =>
            {
                TestHelper.RaiseEventsOnHttpRequest(args, DataUrls.MessagingInvitations, HttpMethod.Post, "Event_MessagingInvitationStarted.json", m_mockEventChannel);
                TestHelper.RaiseEventsOnHttpRequest(args, DataUrls.EstablishMessagingCall, HttpMethod.Post, "Event_MessagingInvitationStarted.json", m_mockEventChannel);

                // Message completed event has to be delivered after the response, so start a new thread to wait some time before delivering the event
                if (m_deliverMessageCompletedEvent)
                {
                    Task.Run(async() =>
                    {
                        await Task.Delay(TimeSpan.FromMilliseconds(10)).ConfigureAwait(false);
                        TestHelper.RaiseEventsOnHttpRequest(args, DataUrls.SendMessage, HttpMethod.Post, "Event_MessageCompleted.json", m_mockEventChannel);
                    });
                }
            };

            // Establish a messaging call
            IMessagingInvitation invitation = await communication.StartMessagingWithIdentityAsync(
                "Test subject",
                "sip:[email protected]",
                "https://example.com/callback",
                "Local user",
                "sip:[email protected]",
                m_loggingContext).ConfigureAwait(false);

            TestHelper.RaiseEventsFromFile(m_mockEventChannel, "Event_ConversationConnected.json"); // It has link to the messaging call
            TestHelper.RaiseEventsFromFile(m_mockEventChannel, "Event_ParticipantAdded.json");
            TestHelper.RaiseEventsFromFile(m_mockEventChannel, "Event_MessagingConnected.json");    // It has the messaging call

            m_messagingCall = invitation.RelatedConversation.MessagingCall;
        }
        private void InitializeEndpoint()
        {
            _platformSettings = new ClientPlatformSettings(null, _aadClientId, null, _aadClientSecret, true);
            var platform = new ClientPlatform(_platformSettings, Logger);

            _eventChannel = new FakeEventChannel();
            var endpointSettings = new ApplicationEndpointSettings(_applicationEndpointId);

            _applicationEndpoint = new ApplicationEndpoint(platform, endpointSettings, _eventChannel);

            _applicationEndpoint.InitializeAsync(null).GetAwaiter().GetResult();
            _applicationEndpoint.InitializeApplicationAsync(null).GetAwaiter().GetResult();

            if (_applicationEndpoint.Application != null)
            {
                _isInitialized = true;
            }
        }
Exemplo n.º 22
0
      public async Task Run()
      {
          var logger = new SampleAppLogger();

          logger.HttpRequestResponseNeedsToBeLogged = true;  //Set to true if you want to log all http request and responses

          //Prepare platform
          ClientPlatformSettings platformSettings = new ClientPlatformSettings(QuickSamplesConfig.AAD_ClientSecret, Guid.Parse(QuickSamplesConfig.AAD_ClientId));

          var platform = new ClientPlatform(platformSettings, logger);

          //Prepare endpoint
          var eventChannel     = new FakeEventChannel();
          var endpointSettings = new ApplicationEndpointSettings(new SipUri(QuickSamplesConfig.ApplicationEndpointId));
          ApplicationEndpoint applicationEndpoint = new ApplicationEndpoint(platform, endpointSettings, eventChannel);

          var loggingContext = new LoggingContext(Guid.NewGuid());
          await applicationEndpoint.InitializeAsync(loggingContext).ConfigureAwait(false);

          await applicationEndpoint.InitializeApplicationAsync(loggingContext).ConfigureAwait(false);


          //Schedule meeting
          var input        = new AdhocMeetingCreationInput(Guid.NewGuid().ToString("N") + "testMeeting");
          var adhocMeeting = await applicationEndpoint.Application.CreateAdhocMeetingAsync(loggingContext, input).ConfigureAwait(false);

          logger.Information("ad hoc meeting uri : " + adhocMeeting.OnlineMeetingUri);
          logger.Information("ad hoc meeting join url : " + adhocMeeting.JoinUrl);

          //Get anon join token
          IAnonymousApplicationToken anonToken = await applicationEndpoint.Application.GetAnonApplicationTokenForMeetingAsync(
              loggingContext,
              adhocMeeting.JoinUrl,
              "https://contoso.com;https://litware.com;http://www.microsoftstore.com/store/msusa/en_US/home", //Fill your own web site, For allow cross domain using
              Guid.NewGuid().ToString()                                                                       //Should be unique everytime
              ).ConfigureAwait(false);

          logger.Information("Get anon token : " + anonToken.AuthToken);
          logger.Information("Get discover url for web SDK : " + anonToken.AnonymousApplicationsDiscoverUri.ToString());

          Console.ForegroundColor = ConsoleColor.Green;
          logger.Information("RemoteAdvisor sample completed successfully!");
          Console.ResetColor();
      }
Exemplo n.º 23
0
        public async Task ShouldHandleIncomingEventWithMalformedBaseUri()
        {
            // Given
            var loggingContext = new LoggingContext(Guid.NewGuid());
            var data           = TestHelper.CreateApplicationEndpoint();
            Mock <IEventChannel> mockEventChannel    = data.EventChannel;
            ApplicationEndpoint  applicationEndpoint = data.ApplicationEndpoint;

            await applicationEndpoint.InitializeAsync(loggingContext).ConfigureAwait(false);

            await applicationEndpoint.InitializeApplicationAsync(loggingContext).ConfigureAwait(false);

            TestHelper.RaiseEventsFromFile(mockEventChannel, "Event_IncomingIMCall_MalformedBaseUri.json");

            // When
            TestHelper.RaiseEventsFromFile(mockEventChannel, "Event_IncomingIMCall.json");

            // Then
            // No exception is thrown
        }
Exemplo n.º 24
0
        public async Task ShouldNotThrowOnIncomingAudioVideoInviteIfNoEventHandlerRegistered()
        {
            var loggingContext = new LoggingContext(Guid.NewGuid());
            var data           = TestHelper.CreateApplicationEndpoint();
            Mock <IEventChannel> mockEventChannel    = data.EventChannel;
            ApplicationEndpoint  applicationEndpoint = data.ApplicationEndpoint;

            await applicationEndpoint.InitializeAsync(loggingContext).ConfigureAwait(false);

            await applicationEndpoint.InitializeApplicationAsync(loggingContext).ConfigureAwait(false);

            // Given
            // No event handler registered for applicationEndpoint.HandleIncomingAudioVideoCall

            // When
            TestHelper.RaiseEventsFromFile(mockEventChannel, "Event_IncomingAudioCall.json");

            // Then
            // No exception is thrown
        }
Exemplo n.º 25
0
        public async Task ShouldRaiseIncomingAudioVideoInvite()
        {
            // Given
            var loggingContext = new LoggingContext(Guid.NewGuid());
            var data           = TestHelper.CreateApplicationEndpoint();
            Mock <IEventChannel> mockEventChannel    = data.EventChannel;
            ApplicationEndpoint  applicationEndpoint = data.ApplicationEndpoint;
            var callReceived = false;

            await applicationEndpoint.InitializeAsync(loggingContext).ConfigureAwait(false);

            await applicationEndpoint.InitializeApplicationAsync(loggingContext).ConfigureAwait(false);

            applicationEndpoint.HandleIncomingAudioVideoCall += (sender, args) => { callReceived = true; };

            // When
            TestHelper.RaiseEventsFromFile(mockEventChannel, "Event_IncomingAudioCall.json");

            // Then
            Assert.IsTrue(callReceived, "AudioVideo call not raised by SDK to the application.");
        }
        public async void TestSetup()
        {
            m_loggingContext = new LoggingContext(Guid.NewGuid());
            var data = TestHelper.CreateApplicationEndpoint();

            m_mockEventChannel = data.EventChannel;
            m_restfulClient    = data.RestfulClient;

            ApplicationEndpoint applicationEndpoint = data.ApplicationEndpoint;
            await applicationEndpoint.InitializeAsync(m_loggingContext).ConfigureAwait(false);

            await applicationEndpoint.InitializeApplicationAsync(m_loggingContext).ConfigureAwait(false);

            IAudioVideoInvitation invitation = null;

            applicationEndpoint.HandleIncomingAudioVideoCall += (sender, args) => invitation = args.NewInvite;

            TestHelper.RaiseEventsFromFile(m_mockEventChannel, "Event_IncomingAudioCall.json");
            TestHelper.RaiseEventsFromFile(m_mockEventChannel, "Event_AudioVideoConnected.json");

            m_audioVideoCall = invitation.RelatedConversation.AudioVideoCall;
        }
Exemplo n.º 27
0
        private async Task InitializeApplicationEndpointAsync()
        {
            //Read application auth settings
            var applicationEndpointUri = ConfigurationManager.AppSettings["ApplicationEndpointId"];
            var aadClientId            = ConfigurationManager.AppSettings["AAD_ClientId"];
            var aadClientSecret        = ConfigurationManager.AppSettings["AAD_ClientSecret"];

            //Get singleton logger
            var logger = UnityHelper.Resolve <IPlatformServiceLogger>();

            logger.HttpRequestResponseNeedsToBeLogged = true;

            //Get singleton event channel
            var eventChannel = UnityHelper.Resolve <SimpleEventChannel>();

            //Initialize platform
            var platformSettings = new ClientPlatformSettings
                                   (
                aadClientSecret,
                Guid.Parse(aadClientId)
                                   );

            var platform = new ClientPlatform(platformSettings, logger);


            //Initialize application and application endpoint
            var endpointSettings    = new ApplicationEndpointSettings(new SipUri(applicationEndpointUri));
            var ApplicationEndpoint = new ApplicationEndpoint(platform, endpointSettings, eventChannel);
            var loggingContext      = new LoggingContext(Guid.NewGuid());

            await ApplicationEndpoint.InitializeAsync(loggingContext).ConfigureAwait(false);

            await ApplicationEndpoint.InitializeApplicationAsync(loggingContext).ConfigureAwait(false);

            //Hook up listener for incoming call
            ApplicationEndpoint.HandleIncomingAudioVideoCall += HandleIncomingAVCall;
        }
Exemplo n.º 28
0
        public async Task RunAsync()
        {
            var skypeId         = ConfigurationManager.AppSettings["Trouter_SkypeId"];
            var password        = ConfigurationManager.AppSettings["Trouter_Password"];
            var applicationName = ConfigurationManager.AppSettings["Trouter_ApplicationName"];
            var userAgent       = ConfigurationManager.AppSettings["Trouter_UserAgent"];
            var token           = SkypeTokenClient.ConstructSkypeToken(
                skypeId: skypeId,
                password: password,
                useTestEnvironment: false,
                scope: string.Empty,
                applicationName: applicationName).Result;

            m_logger = new SampleAppLogger();

            // Uncomment for debugging
            // m_logger.HttpRequestResponseNeedsToBeLogged = true;

            EventChannel = new TrouterBasedEventChannel(m_logger, token, userAgent);

            // Prepare platform
            var platformSettings = new ClientPlatformSettings(QuickSamplesConfig.AAD_ClientSecret, new Guid(QuickSamplesConfig.AAD_ClientId));
            var platform         = new ClientPlatform(platformSettings, m_logger);

            // Prepare endpoint
            var endpointSettings    = new ApplicationEndpointSettings(new SipUri(QuickSamplesConfig.ApplicationEndpointId));
            var applicationEndpoint = new ApplicationEndpoint(platform, endpointSettings, EventChannel);

            var loggingContext = new LoggingContext(Guid.NewGuid());
            await applicationEndpoint.InitializeAsync(loggingContext).ConfigureAwait(false);

            await applicationEndpoint.InitializeApplicationAsync(loggingContext).ConfigureAwait(false);

            // Meeting configuration
            var meetingConfiguration = new AdhocMeetingCreationInput(Guid.NewGuid().ToString("N") + " test meeting");

            // Schedule meeting
            var adhocMeeting = await applicationEndpoint.Application.CreateAdhocMeetingAsync(loggingContext, meetingConfiguration).ConfigureAwait(false);

            WriteToConsoleInColor("ad hoc meeting uri : " + adhocMeeting.OnlineMeetingUri);
            WriteToConsoleInColor("ad hoc meeting join url : " + adhocMeeting.JoinUrl);

            // Get all the events related to join meeting through Trouter's uri
            platformSettings.SetCustomizedCallbackurl(new Uri(EventChannel.CallbackUri));

            // Start joining the meeting
            var invitation = await adhocMeeting.JoinAdhocMeeting(loggingContext, null).ConfigureAwait(false);

            // Wait for the join to complete
            await invitation.WaitForInviteCompleteAsync().ConfigureAwait(false);

            WriteToConsoleInColor("Please use this url to join the meeting : " + adhocMeeting.JoinUrl);

            WriteToConsoleInColor("Giving 30 seconds for the user to join the meeting...");
            await Task.Delay(TimeSpan.FromSeconds(30)).ConfigureAwait(false);

            var conversation = invitation.RelatedConversation;

            var imCall = invitation.RelatedConversation.MessagingCall;

            if (imCall == null)
            {
                WriteToConsoleInColor("No messaging call link found in conversation of the conference.");
                return;
            }

            var messagingInvitation = await imCall.EstablishAsync(loggingContext).ConfigureAwait(false);

            messagingInvitation.HandleResourceCompleted += OnMessagingResourceCompletedReceived;

            await messagingInvitation.WaitForInviteCompleteAsync().ConfigureAwait(false);

            if (imCall.State != CallState.Connected)
            {
                WriteToConsoleInColor("Messaging call is not connected.");
                return;
            }

            var modalities = invitation.RelatedConversation.ActiveModalities;

            WriteToConsoleInColor("Active modalities : ");
            bool hasMessagingModality = false;

            foreach (var modality in modalities)
            {
                WriteToConsoleInColor(" " + modality.ToString());
                if (modality == ConversationModalityType.Messaging)
                {
                    hasMessagingModality = true;
                }
            }

            await imCall.SendMessageAsync("Hello World.", loggingContext).ConfigureAwait(false);

            if (!hasMessagingModality)
            {
                WriteToConsoleInColor("Failed to connect messaging call.", ConsoleColor.Red);
                return;
            }
            WriteToConsoleInColor("Adding messaging to meeting completed successfully.");
        }
Exemplo n.º 29
0
        public async Task RunAsync(Uri callbackUri)
        {
            m_logger = new SampleAppLogger();

            // Uncomment for debugging
            // m_logger.HttpRequestResponseNeedsToBeLogged = true;

            // You can hook up your own implementation of IEventChannel here
            IEventChannel eventChannel = WebEventChannel.WebEventChannel.Instance;

            // Prepare platform
            var platformSettings = new ClientPlatformSettings(QuickSamplesConfig.AAD_ClientSecret, new Guid(QuickSamplesConfig.AAD_ClientId));
            var platform         = new ClientPlatform(platformSettings, m_logger);

            // Prepare endpoint
            var endpointSettings    = new ApplicationEndpointSettings(new SipUri(QuickSamplesConfig.ApplicationEndpointId));
            var applicationEndpoint = new ApplicationEndpoint(platform, endpointSettings, eventChannel);

            var loggingContext = new LoggingContext(Guid.NewGuid());
            await applicationEndpoint.InitializeAsync(loggingContext).ConfigureAwait(false);

            await applicationEndpoint.InitializeApplicationAsync(loggingContext).ConfigureAwait(false);

            // Meeting configuration
            var meetingConfiguration = new AdhocMeetingCreationInput(Guid.NewGuid().ToString("N") + " test meeting");

            // Schedule meeting
            var adhocMeeting = await applicationEndpoint.Application.CreateAdhocMeetingAsync(meetingConfiguration, loggingContext).ConfigureAwait(false);

            WriteToConsoleInColor("ad hoc meeting uri : " + adhocMeeting.OnlineMeetingUri);
            WriteToConsoleInColor("ad hoc meeting join url : " + adhocMeeting.JoinUrl);

            // Get all the events related to join meeting through our custom callback uri
            platformSettings.SetCustomizedCallbackurl(callbackUri);

            // Start joining the meeting
            ICommunication communication = applicationEndpoint.Application.Communication;

            if (!communication.CanJoinAdhocMeeting(adhocMeeting))
            {
                throw new Exception("Cannot join adhoc meeting");
            }

            var invitation = await communication.JoinAdhocMeetingAsync(adhocMeeting, null, loggingContext).ConfigureAwait(false);

            // Wait for the join to complete
            await invitation.WaitForInviteCompleteAsync().ConfigureAwait(false);

            WriteToConsoleInColor("Please use this url to join the meeting : " + adhocMeeting.JoinUrl);

            WriteToConsoleInColor("Giving 30 seconds for the user to join the meeting...");
            await Task.Delay(TimeSpan.FromSeconds(30)).ConfigureAwait(false);

            var conversation = invitation.RelatedConversation;

            var imCall = invitation.RelatedConversation.MessagingCall;

            if (imCall == null)
            {
                WriteToConsoleInColor("No messaging call link found in conversation of the conference.");
                return;
            }

            var messagingInvitation = await imCall.EstablishAsync(loggingContext).ConfigureAwait(false);

            messagingInvitation.HandleResourceCompleted += OnMessagingInvitationCompleted;

            await messagingInvitation.WaitForInviteCompleteAsync().ConfigureAwait(false);

            if (imCall.State != CallState.Connected)
            {
                WriteToConsoleInColor("Messaging call is not connected.");
                return;
            }

            var modalities = invitation.RelatedConversation.ActiveModalities;

            WriteToConsoleInColor("Active modalities : ");
            bool hasMessagingModality = false;

            foreach (var modality in modalities)
            {
                WriteToConsoleInColor(" " + modality.ToString());
                if (modality == ConversationModalityType.Messaging)
                {
                    hasMessagingModality = true;
                }
            }

            if (!hasMessagingModality)
            {
                WriteToConsoleInColor("Failed to connect messaging call.", ConsoleColor.Red);
                return;
            }
            WriteToConsoleInColor("Adding messaging to meeting completed successfully.");

            WriteToConsoleInColor("Sending Hellow World!");
            await imCall.SendMessageAsync("Hello World!", loggingContext).ConfigureAwait(false);

            WriteToConsoleInColor("Sent Hello World!");

            await WebEventChannel.WebEventChannel.Instance.TryStopAsync().ConfigureAwait(false);
        }