Example #1
0
        /// <summary>
        /// Unsubscribe from a specific uri.
        /// </summary>
        /// <param name="sipUri">Sip uri to unsubscribe from. Cannot be null or empty.</param>
        private void Unsubscribe(string sipUri)
        {
            Debug.Assert(!String.IsNullOrEmpty(sipUri), "Sip uri is null or empty");
            SipUriParser uriParser;

            if (SipUriParser.TryParse(sipUri, out uriParser))
            {
                m_remotePresenceView.StartUnsubscribingToPresentities(new List <string> {
                    sipUri
                });
            }
        }
Example #2
0
        /// <summary>
        /// Subscribe to a specific uri.
        /// </summary>
        /// <param name="sipUri">Sip uri to subscribe to. Cannot be null or empty.</param>
        private void Subscribe(string sipUri)
        {
            Debug.Assert(!String.IsNullOrEmpty(sipUri), "Sip uri is null or empty");
            SipUriParser uriParser;

            if (SipUriParser.TryParse(sipUri, out uriParser))
            {
                var subscriptionTargets = new List <RemotePresentitySubscriptionTarget>();
                subscriptionTargets.Add(new RemotePresentitySubscriptionTarget(uriParser.ToString()));
                // Immediately fires NotificationReceived with current presence of targets
                m_remotePresenceView.StartSubscribingToPresentities(subscriptionTargets);
            }
        }
Example #3
0
        internal AcdPlatformAnonymousSubscriberUriChangedEventArgs(string anonymousSubscriberUri)
        {
            SipUriParser parser;

            if (SipUriParser.TryParse(anonymousSubscriberUri, out parser))
            {
                _anonymousSubscriberUri = anonymousSubscriberUri;
            }
            else
            {
                throw new ArgumentException("AcdPlatformAnonymousSubscriberUriChangedEventArgs requires a valid Uri");
            }
        }
        internal bool DisallowParticipant(string participantUri)
        {
            SipUriParser parser;
            bool         result = false;

            if (SipUriParser.TryParse(participantUri, out parser))
            {
                lock (_syncRoot)
                {
                    result = _listOfAuthorizedParticipants.Remove(participantUri);
                }
            }

            return(result);
        }
        internal bool AuthorizeParticipant(string participantUri)
        {
            SipUriParser parser;

            if (SipUriParser.TryParse(participantUri, out parser))
            {
                lock (_syncRoot)
                {
                    _listOfAuthorizedParticipants.Add(participantUri);
                }

                List <ConversationParticipant> listOfLobbyParticipants = new List <ConversationParticipant>(_conversation.GetLobbyParticipants());

                listOfLobbyParticipants.ForEach(cp => {
                    if (SipUriCompare.Equals(cp.Uri, participantUri))
                    {
                        try
                        {
                            _conversation.ConferenceSession.LobbyManager.BeginAdmitLobbyParticipants(new List <ConversationParticipant>()
                            {
                                cp
                            },
                                                                                                     ar =>
                            {
                                LobbyManager lobbyMgr = ar.AsyncState as LobbyManager;
                                try
                                {
                                    lobbyMgr.EndAdmitLobbyParticipants(ar);
                                }
                                catch (RealTimeException rtex)
                                {
                                    _logger.Log("AcdConferenceServices failed to end admit a participant in the lobby", rtex);
                                }
                            },
                                                                                                     _conversation.ConferenceSession.LobbyManager);
                        }
                        catch (InvalidOperationException ivoex)
                        {
                            _logger.Log("AcdConferenceServicesAnchor failed to begin admit a participant in the lobby", ivoex);
                        }
                    }
                });
                return(true);
            }

            return(false);
        }
        internal bool ElevateToPresenter(string participantUri)
        {
            SipUriParser parser;

            if (SipUriParser.TryParse(participantUri, out parser))
            {
                lock (_syncRoot)
                {
                    _listOfPresenters.Add(participantUri);
                }

                List <ConversationParticipant> listOfParticipants = new List <ConversationParticipant>(_conversation.RemoteParticipants);

                listOfParticipants.ForEach(cp =>
                {
                    if (SipUriCompare.Equals(cp.Uri, participantUri))
                    {
                        if (cp.Role != ConferencingRole.Leader)
                        {
                            _conversation.ConferenceSession.BeginModifyRole(cp,
                                                                            ConferencingRole.Leader,
                                                                            mr =>
                            {
                                try
                                {
                                    _conversation.ConferenceSession.EndModifyRole(mr);
                                }
                                catch (RealTimeException rtex)
                                {
                                    this._logger.Log("ModifyRole failed", rtex);
                                }
                            },
                                                                            null);
                        }
                    }
                });

                return(true);
            }

            return(false);
        }
Example #7
0
        private void UpdatePresenceRelationshipWithAnonymousSubsriber(string newAnonymousSubscriberUri, string oldAnonymousSubscriberUri)
        {
            SipUriParser parser;

            Debug.Assert(SipUriParser.TryParse(newAnonymousSubscriberUri, out parser));

            ContainerUpdateOperation AddACE = new ContainerUpdateOperation(ContainerIDForWebUsers);

            AddACE.AddUri(newAnonymousSubscriberUri);

            if (!String.IsNullOrEmpty(oldAnonymousSubscriberUri))
            {
                Debug.Assert(SipUriParser.TryParse(oldAnonymousSubscriberUri, out parser));
                AddACE.DeleteUri(oldAnonymousSubscriberUri);
            }

            List <ContainerUpdateOperation> listOfOperations = new List <ContainerUpdateOperation>();

            listOfOperations.Add(AddACE);

            try
            {
                _endpoint.LocalOwnerPresence.BeginUpdateContainerMembership(listOfOperations,
                                                                            add =>
                {
                    try
                    {
                        _endpoint.LocalOwnerPresence.EndUpdateContainerMembership(add);
                    }
                    catch (RealTimeException rtex)
                    {
                        _logger.Log("AcdPortal was unable to end update the container membership for Anonymous Subscriber", rtex);
                    }
                },
                                                                            null);
            }
            catch (InvalidOperationException ivoex)
            {
                _logger.Log("AcdPortal was unable to begin update the container membership for Anonymous Subscriber", ivoex);
            }
        }