< Back to Package Overview

Making a MeetMe conference call through HTTPUA

Using the Client SDK, you can easily integrate the ability to join an Equinox conference call without the use of any telephony infrastructure. This is referred to as an Over the Top Call. Over the Top calls can only be outgoing calls.

To make a MeetMe conference call through HTTPUA, you must complete the following activities:

• Retrieve iView conference token and Service Gateway URL through Unified Portal Service
• Create a CSCall object and initialize the details for the call
• Implement the call delegate to monitor for call progress events
• Implement the conference delegate
• Start the call
• End the call

Retrieve iView conference token and Service Gateway URL for MeetMe conference call.

// Create Unified Portal configuration object
CSUnifiedPortalConfiguration *unifiedPortalConfiguration = 
    [[CSUnifiedPortalConfiguration alloc] init];

// Specify Unified Portal URL (mandatory)
unifiedPortalConfiguration.serverURL = myMeetingInfo.unifiedPortalURL;

// Optionally, specify credential provider to sign in portal 
// and join the meeting as signed in user.
unifiedPortalConfiguration.credentialProvider = [CredentialProvider 
    credentialProviderWithUserName: myAppConfig.unifiedPortalUsername
                          password: myAppConfig.unifiedPortalPassword
                            domain: @""
                         ha1String: @""];

// Retrieve the token and other meeting details
CSUnifiedPortalService *unifiedPortalService = user.unifiedPortalService;
[unifiedPortalService 
    requestToJoinMeetingWithConfiguration: unifiedPortalConfiguration
                             conferenceId: myMeetingInfo.conferenceID
                                 userName: myAppConfig.displayName
                     presentationOnlyMode: NO
                           callbackNumber: @""
                               oneTimePin: @""
                        completionHandler:
        ^(CSUnifiedPortalMeetingInfo *meetingInfo, NSError *error)
        {
            if(error != nil)
            {
                // Display error
            }
            else
            {
                myMeetingInfo.meetingInfoFromPortal = meetingInfo;
            }
        }];

Create a call object

CSCallCreationInfo *callCreationInfo = [[CSCallCreationInfo alloc] init];
callCreationInfo.callType             = CSCallTypeHttpMeetme;
callCreationInfo.conferenceId         = myMeetingInfo.conferenceID;
callCreationInfo.conferencePasscode   = myMeetingInfo.conferencePasscode;
callCreationInfo.portalToken          = myMeetingInfo.meetingInfoFromPortal.portalToken;
callCreationInfo.uccpURL              = myMeetingInfo.meetingInfoFromPortal.uccpURL;
callCreationInfo.serviceGatewayURL    = myMeetingInfo.meetingInfoFromPortal.serviceGatewayURL;
callCreationInfo.portalURL            = myMeetingInfo.unifiedPortalURL;
callCreationInfo.meetmeUserName       = myAppConfig.displayName;
callCreationInfo.presentationOnlyMode = NO;


__weak CSCall *call;
call = [user.callService createCallWithInfo: callCreationInfo];
call.remoteAddress = myMeetingInfo.remoteAddress;

Implement the call delegate

To monitor call progress events, the <CSCallDelegate> protocol can be used. This protocol provides notification as the call state changes.

@interface AppCallHandler() 
...
@end

@implementation AppCallHandler

    - (void)callDidStart:(CSCall *)call {
        // Called to report that call has started (ie, call is in progress).
        // Add code here to update the UI as appropriate.
    }

    - (void)callDidBeginRemoteAlerting:(CSCall *)call 
                        withEarlyMedia:(BOOL)hasEarlyMedia {
        // Called to report that an outgoing call is ringing at the far end.
        // Add code here to update the UI as appropriate.
    }

    - (void)callDidEstablish:(CSCall *)call {
        // Called to report that an outgoing call has been established 
        // (ie, far end has answered and speechpath has been established).
        // Add code here to update the UI as appropriate.
    }

    - (void)callDidEnd:(CSCall *)call reason:(CSCallEndReason)reason {
        // Called to report that call has ended.
        // Add code here to update the UI as appropriate.
    }

    - (void)call:(CSCall *)call didFailWithError:(NSError *)error {
        // Called to report that call has failed and the failure reason
        // is described in the error parameter.
        // Add code here to update the UI as appropriate.
    }

    - (void)call:(CSCall *)call didChangeConferenceStatus:(BOOL)isConference {
        // Called to report a change in conference status of the call.
        // Add code here to update the UI as appropriate.
    }

    ...

@end

You can instantiate an application call handler (AppCallHandler) and add that as a delegate to the call.

AppCallHandler *callHandler = [[AppCallHandler alloc] init];
call.delegate = callHandler;

Implement the conference delegate

To monitor CSConference events, the <CSConferenceDelegate> protocol can be used. This protocol provides notification as the conference properties changes.

@interface AppConferenceHandler() 
...
@end

@implementation AppConferenceHandler

    - (void)conference:(CSConference *)conference 
    didChangeLectureModeStatus:(BOOL)active {
        // Called to report that Lecture Mode has enabled or disabled in this
        // conference call. Add code here to update the UI as appropriate.
    }

    - (void)conference:(CSConference *)conference 
    didChangeEntryExitToneStatus:(BOOL)active {
        // Called to report that entry/exit tones have been enabled or disabled 
        // in this conference call. 
        // Add code here to update the UI as appropriate.
    }

    - (void)conference:(CSConference *)conference 
    didChangeLockStatus:(BOOL)locked {
        // Called to report that the conference has been locked or unlocked.
        // Add code here to update the UI as appropriate.
    }

    - (void)conference:(CSConference *)conference 
    didRequirePasscode:(BOOL)permissionToEnterLockedConferenceRequired {
        // Called to report that the conference requires admission passcode.
        // Add code here to update the UI as appropriate.
    }

    - (void)conference:(CSConference *)conference 
    didChangeContinuationStatus:(BOOL)active {
        // Called to report that the conference continuation 
        // (after moderator leave) has been enabled or disabled.
        // Add code here to update the UI as appropriate.
    }

    - (void)conference:(CSConference *)conference 
    didChangeRecordingStatus:(CSConferenceRecordingStatus)status {
        // Called to report that conference recording has been started or 
        // stopped. Add code here to update the UI as appropriate.
    }

    - (void)conference:(CSConference *)conference
    didChangeExternalAdmissionStatus:(BOOL)required {
        // Called to report whether the conference requires admission request 
        // from user. Add code here to update the UI as appropriate.
    }

    - (void)conferenceDidRequirePermissionToEnter:(CSConference *)conference {
        // Called to report that the user has to request moderator for 
        // a permission to enter the conference.
        // Add code here to update the UI as appropriate.
    }

    - (void)conference:(CSConference *)conference 
    didChangeVideoStatus:(BOOL)allowed {
        // Called to report that the conference video has been enabled or 
        // disabled. Add code here to update the UI as appropriate.
    }

    - (void)conference:(CSConference *)conference 
    didChangeSubject:(NSString *)subject {
        // Called to report that the conference subject has changed.
        // Add code here to update the UI as appropriate.
    }

    - (void)conference:(CSConference *)conference
    didChangeBrandName:(NSString *)brandName {
        // Called to report that the conference brand name has changed.
        // Add code here to update the UI as appropriate.
    }

    - (void)conferenceHandRaised:(CSConference *)conference {
        // Called to report that the user's hand has been raised.
        // Add code here to update the UI as appropriate.
    }

    - (void)conferenceHandLowered:(CSConference *)conference {
        // Called to report that the user's hand has been lowered.
        // Add code here to update the UI as appropriate.
    }

    - (void)conferenceCapabilitiesDidChange:(CSConference *)conference {
        // Called to report that some of conference capabilities have changed.
        // Add code here to update the UI as appropriate.
    }

    - (void)conferenceWaitingToStart:(CSConference *)conference {
        // Called to report that the conference has not yet been started 
        // by moderator. Add code here to update the UI as appropriate.
    }

    - (void)conferenceDidStart:(CSConference *)conference {
        // Called to report that the conference has been started.
        // Add code here to update the UI as appropriate.
    }

    - (void)conference:(CSConference *)conference
    didChangeMeetingEndTime:(NSDate *)meetingEndTime {
        // Called to report that the conference scheduled end time has been 
        // changed. Add code here to update the UI as appropriate.
    }

    - (void)conferenceServiceDidBecomeAvailable:(CSConference *)conference {
        // Called to report that the conference has a healthy signaling path.
        // Add code here to update the UI as appropriate.
    }

    - (void)conference:(CSConference *)conference 
    serviceDidBecomeUnavailable:(NSError *)error {
        // Called to report that conferencing server connection has been lost.
        // Add code here to update the UI as appropriate.
    }

    - (void)conference:(CSConference *)conference 
    didChangeEncryptionStatus:(CSConferenceEncryptionStatus)status {
        // Called to report that overall media encryption status of the 
        // conference call has changed.
        // Add code here to update the UI as appropriate.
    }

    - (void)conference:(CSConference *)conference
    didChangeStreamingStatus:(CSConferenceStreamingStatus)status {
        // Called to report that the conference streaming status has changed.
        // Add code here to update the UI as appropriate.
    }

    ...

@end

You can instantiate an application conference handler (AppConferenceHandler) and add that as a delegate to the call even before the call has been started and become a conference call.

AppConferenceHandler *conferenceHandler = [[AppConferenceHandler alloc] init];
call.conference.delegate = conferenceHandler;

Start the call

Once a call delegate has been added, you can call the start method on the CSCall object. Call progress events will be provided through the <CSCallDelegate> protocol.

[call start];

End the call

To terminate the call, you can call the end method on the CSCall object.

[call end];

The callDidEnd:reason: callback event is sent to the call delegate when the call has been ended. You can use this event to update the UI of your application.