Export (0) Print
Expand All

How to: Manage a meeting lobby

[This is preliminary documentation and is subject to change.]

Describes how a meeting presenter manages a meeting lobby in a closed Microsoft Lync 2013 Preview meeting.

A Microsoft Lync 2013 Preview meeting lobby is a virtual waiting area that holds people who are waiting to join a ConferenceAccessType.Closed meeting that they have not been invited to. This topic shows how to get the people waiting in the meeting lobby and then either admit or deny access to the meeting. In addition, the topic shows how to create a conference URL that can be made available to people who may want to “dial in” to a meeting without an invitation from a meeting presenter.

Tip Tip

A meeting lobby is useful when you are the organizer of a meeting that does not include invited users. Instead, a meeting URL is published to a large group of people who can join the meeting by using the URL. The meeting can be configured to enable people in your organization to go directly into the meeting while other people must wait in the meeting lobby for admittance.

This topic shows how to complete the following related tasks:

  • Get the meeting access properties to determine whether a meeting is closed, open, or locked.

  • Create a meeting URL to be published to a group of potential meeting attendees.

  • Get meeting attendees as they enter the meeting lobby.

  • Individually or collectively admit or deny access to the occupants of the meeting lobby.

The meeting properties that are discussed in this topic can be set while the meeting is being scheduled in Outlook or after joining the meeting using the Lync 2013 Preview conversation window that is hosting the meeting. You cannot set these conference access properties by using the Microsoft Lync 2013 Preview API because the properties are read-only in the Microsoft.Lync.Model.Conversation.Conversation class.

Get the initial meeting property settings in the ConversationManagerConversationAdded() event that is raised when the local user either starts a new conversation or joins an online Lync 2013 Preview meeting that was scheduled in Outlook. The initial set of meeting access properties are populated with the configuration choices that a user made when the meeting was scheduled. If this is a new conversation that does not have meeting access properties set, the values in the Conversation.Properties will be null.

If the local user configures meeting access properties in the Lync 2013 Preview conversation window that is hosting the new meeting, these changes are available to your application in the Conversation.PropertyChanged event.

Example

The following example reads the conversation properties that are set at the time that the meeting is scheduled. Reading conversation properties involves the following tasks:

  • Iterates on the conversation property collection by conversation property type.

  • For each item, skip any property whose name starts with “Reserved”.

  • Get a property value from the collection based on the key

  • Get the meeting URL if the ConversationProperty.ConferencingUri is not null.

    Use that value and the ConversationProperty.Id value to create a publishable meeting URL. This will only be the case when the meeting was scheduled in advance. Otherwise, the meeting URL is available after the organizing user has invited a third user or connected the Microsoft.Lync.Model.Conversation.Sharing.ContentSharingModality in the conversation.

            foreach (ConversationProperty propertyType in _conversation.Properties.Keys)
            {
                if (propertyType.ToString().StartsWith("Reserved"))
                {
                    continue;
                }
                try
                {
                    object propValue;
                    if (_conversation.Properties.TryGetValue(propertyType, out propValue))
                    {
                        if (propertyType == ConversationProperty.ConferencingAccessType && ((ConferenceAccessType)propValue) == ConferenceAccessType.Closed)
                        {
                            Console.WriteLine("Conference is closed, you must admit people in the lobby when they arrive");
                        }
                        if (propertyType == ConversationProperty.ConferencingUri && propValue != null)
                        {
                            Console.WriteLine("conf:" + propValue.ToString() + "?" + _conversation.Properties[ConversationProperty.Id]);
                        }
                    }
                }
                catch (NotImplementedException nie) 
                {
                    Console.WriteLine(o.ToString() + " Property is not implemented: " + nie.Message);
                }
            }

When a conversation is escalated to a meeting after the conversation has started, the new meeting URL is available when the meeting escalation is complete.

Example

The following example creates a meeting URL to be published for interested users after a conversation has started and is escalated to a meeting. The URL is created in the Conversation.PropertyChanged event. The example watches the progress of the conference escalation and when the process is ConferenceEscalationProgress.Completed, the meeting URL can be created.

        /// <summary>
        /// Raised when a property of the conversation is changed
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void _conversation_PropertyChanged(object sender, ConversationPropertyChangedEventArgs e)
        {
            if (e.Value == null)
            {
                return;
            }

            //If this event is fired because the conversation escalation to a meeting has completed, then 
            //build the new meeting URL
            if (e.Property == ConversationProperty.ConferenceEscalationProgress && ((ConferenceEscalationProgress)e.Value) == ConferenceEscalationProgress.Completed)
            {
                Console.WriteLine("conf:" + _conversation.Properties[ConversationProperty.ConferencingUri].ToString() + "?" + _conversation.Properties[ConversationProperty.Id]);
            }

        }

When a person enters the meeting lobby, the Conversation.ParticipantAdded event is raised. Use your registered event callback method to get the ParticipantProperty.IsInLobby property on the new participant. If the value of the property is true, then the person is in the lobby and the local user must admit or deny access to the user.

Example

The following example enables a command button on the sample UI when a person enters the meeting lobby. The command button admits any person who is waiting in the meeting lobby.

        /// <summary>
        /// Handles the participant added event. Registers for events on the application sharing modality for the 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void _conversation_ParticipantAdded(object sender, ParticipantCollectionChangedEventArgs e)
        {

            if (e.Participant.Properties[ParticipantProperty.IsInLobby] != null)
            {
                this.Invoke(new EnableDisableButtonDelegate(EnableDisableButton),new object[] {AdmitFromLobby_Button, true});
            }

            e.Participant.PropertyChanged += Participant_PropertyChanged;
        }

The people waiting in the lobby are Microsoft.Lync.Model.Conversation.Participant objects in the collection of all conversation participants. To admit the people in the lobby, get the individual Participant objects that represent the lobby people, add these objects to a List<Microsoft.Lync.Model.Conversation.Participant>, and then add the participants as a group.

Tip Tip

You can also admit or deny participants individually by calling the Participant.BeginAdmit method or the Participant.BeginDeny method on a participant.

Example

The following example admits all people who are waiting in the meeting lobby.

        /// <summary>
        /// Admit every person who is waiting in the lobby.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void AdmitFromLobby_Button_Click(object sender, EventArgs e)
        {
            List<Participant> lobbyParticipants = new List<Participant>();

            //Iterate on all conversation participants and add those
            //people who are waiting in the lobby.
            foreach (Participant p in _conversation.Participants)
            {
                if (p.Properties[ParticipantProperty.IsInLobby] != null && p.Properties[ParticipantProperty.IsInLobby].ToString().ToLower() == "true")
                {
                    lobbyParticipants.Add(p);
                }
            }

            //Admit the list of people waiting in the lobby
            _conversation.BeginAdmitParticipants(lobbyParticipants, (ar) => 
               {
                  _conversation.EndAdmitParticipants(ar);
               }
               , null);
        }

Once the meeting organizer has published the meeting URL, a user can dial in to the meeting using the URL. To dial in to a meeting, call the ConversationManager.JoinConference method. A new Microsoft.Lync.Model.Conversation.Conversation object is returned and the ConversationManager.ConversationAdded event is raised.

Note Note

A Lync 2013 Preview meeting is a conversation between three or more participants. The meeting is represented at each user’s endpoint as a Microsoft.Lync.Model.Conversation.Conversation object. This conversation object behaves very much like a peer-to-peer conversation except that the meeting conversation has additional properties related to conferencing. The conversation events and modalities are handled with the same code you would handle a peer-to-peer conversation with.

Example

The following example dials in to a meeting by calling the method and passing the meeting URL published by the meeting organizer.

Conversation _conversation = _LyncClient.ConversationManager.JoinConference("conf:sip:charlieh@contoso.com;gruu;opaque=app:conf:focus:id:9WJV8P67?Ac0teDCKZ0fqCqcEQr2ezAuOkRrdjg==");

Community Additions

Show:
© 2014 Microsoft