Demo Architecture and Implementation

// Determine the notification type from the triggering SIP request 
private CallNotificationTypes determineNotificationType(
            SipFeatureScriptExecutionPoint executionPoint,
            IncomingSipRequest request)
{
    switch (executionPoint) {
        // the initial trigger
        case SipAccess_SessionStart:
            return CallNotificationTypes.CALLDIRECTION;
        // one of the participants hangs up
        case SipMidSession_PartyRequest:
            return "BYE".equals(request.getMethod())
                        ? CallNotificationTypes.CALLDIRECTION : null;
        // a notification is not required
        default: return null;
    }
}

// Determine the notification type from the triggering SIP response 
private CallNotificationTypes determineNotificationType(
            SipFeatureScriptExecutionPoint executionPoint,
            IncomingSipResponse response)
{
    switch (executionPoint) {
        case SipAccess_PartyResponse:
            if (! "INVITE".equals(response.getRequest().getMethod()))
                return null;
            switch (response.getStatus()) {
                case SipResponse.SC_OK:
                    return CallNotificationTypes.CALLEVENT;
                // 486 - called party busy
                case SipResponse.SC_BUSY_HERE:
                // 404 - no route to destination
                case SipResponse.SC_NOT_FOUND:
                // 408 - no answer
                case SipResponse.SC_REQUEST_TIMEOUT:
                // 480 - no answer
                case SipResponse.SC_TEMPORARLY_UNAVAILABLE:
                    return CallNotificationTypes.CALLDIRECTION;
                // a notification is not required
                default: return null;
            }

        case SipMidSession_PartyResponse:
            if (SipResponse.SC_OK == response.getStatus()
                && "BYE".equals(response.getRequest().getMethod()))
                return CallNotificationTypes.CALLEVENT;
            // otherwise a notification is not required
            return null;

        // a notification is not required
        default: return null;
    }
}

// Determine the CallEvent from the triggering SIP request 
private CallEvents determineCallEvent(
                        SipFeatureScriptExecutionPoint executionPoint,
                        IncomingSipRequest request)
{
    switch (executionPoint) {
        // the initial trigger
        case SipAccess_SessionStart:
            return CallEvents.CALLEDNUMBER;
        // one of the participants hangs up
        case SipMidSession_PartyRequest:
            return "BYE".equals(request.getMethod())
                        ? CallEvents.DISCONNECTED : null;
        // a notification is not required
        default: return null;
    }
}

// Determine the CallEvent from the triggering SIP response 
private CallEvents determineCallEvent(
            SipFeatureScriptExecutionPoint executionPoint,
            IncomingSipResponse response)
{
    switch (executionPoint) {
        case SipAccess_PartyResponse:
            if (! "INVITE".equals(response.getRequest().getMethod()))
                return null;
            switch (response.getStatus()) {
                case SipResponse.SC_OK:
                    return CallEvents.ANSWER;
                // 486 - called party busy
                case SipResponse.SC_BUSY_HERE:
                    return CallEvents.BUSY;
                // 404 - no route to destination
                case SipResponse.SC_NOT_FOUND:
                    return CallEvents.NOTREACHABLE;
                // 408 - no answer
                case SipResponse.SC_REQUEST_TIMEOUT:
                // 480 - no answer
                case SipResponse.SC_TEMPORARLY_UNAVAILABLE:
                    return CallEvents.NOANSWER;
                // a notification is not required
                default: return null;
            }
        case SipMidSession_PartyResponse:
            if (SipResponse.SC_OK == response.getStatus()
                && "BYE".equals(response.getRequest().getMethod()))
                return CallEvents.DISCONNECTED;
            // otherwise a notification is not required
            return null;

        // a notification is not required
        default: return null;
    }
}

// Send a call event notification
private void sendNotification(
        String from, String fromDisplayName, String to,
        CallNotificationTypes notificationType, CallEvents callEvent)
{
    final SendCallNotificationConfig configuration =
            configurationReader.getConfiguration(
                    getSessionState().getSentinelSelectionKey());

    final ApiConfiguration apiConfiguration =
            ApiConfiguration.standardConfiguration();
    apiConfiguration.set(ApiOptions.destinationUrl,
                         configuration.getDestinationUrl());
    final MswCallNotificationRaTypeApiClient client =
            cnProvider.getApiClient(apiConfiguration);

    // Create a new CallEventNotification object 
    final CallEventNotification notification = new CallEventNotification();
    try {
        notification.notificationType(notificationType)
            .eventDescription(new EventDescription().callEvent(callEvent))
            .calledParticipant(new URI(to))
            .callingParticipant(new URI(from))
            .callingParticipantName(fromDisplayName);
    }
    catch (URISyntaxException e) {
        getTracer().severe(
            "Failed to extract participants from: {}, to: {}", from, to, e);
    }

    // Create a REST request to send 
    final NotificationApi nApi = client.getNotificationApi();
    final RestRequestBuilder notificationRequest =
            notificationType == CallNotificationTypes.CALLEVENT
            ? nApi.createCallEventNotificationRequest(notification)
            : nApi.createCallDirectionNotificationRequest(notification);

    try {
        // Send the REST request 
        final OutgoingRestActivity outgoingRestActivity =
            notificationApi.sendRequest(notificationRequest);
        final ActivityContextInterface newAci =
            cnACIFactory.getActivityContextInterface(outgoingRestActivity);
        final SentinelActivityContextInterface outgoingAci =
            getCaller().asSentinelActivityContextInterface(newAci);
        stats.incrementSendCallNotification(1);

        // Set the target feature to 'RestSendCallNotification' 
        outgoingAci.setTargetFeature(NAME);
        // Attach to the new activity, wait for the response 
        outgoingAci.attach(getFacilities().getSbbLocalObject());
        getTracer().finest("Notification sent. Waiting for response");
        getCaller().featureWaiting(outgoingAci);
    }
    catch (IOException e) {
        getCaller().featureFailedToExecute(
                new FeatureError(FeatureError.Cause.unclassified,
                    "Failed to send notification", e));
    }
}

private boolean processDirectionNotificationSuccessResponse(
            SipFeatureScriptExecutionPoint executionPoint,
            CallDirectionNotification_200_SuccessResponse trigger,
            Object activity)
{
    // Determine the action to perform 
    final Action actionToTake = trigger.getContent();
    if (null == actionToTake || null == actionToTake.getActionToPerform()) {
        stats.incrementCallDirectionResponseWithNoActionToTake(1);
        return true;
    }

    // Apply the requested Action 
    switch(actionToTake.getActionToPerform()) {
        case ROUTE:
            // Get the new destination 
            final URI newDestination  = actionToTake.getRoutingAddress();
            if (null == newDestination) {
                stats.incrementCallDirectionNoRoutingAddress(1);
                return true;
            }
            final org.jainslee.resources.sip.URI sipDestination =
                getSipUri(newDestination);
            if (null == sipDestination) {
                stats.incrementCallDirectionNonSipRoutingAddress(1);
                return true;
            }
            stats.incrementCallDirectionRoute(1);
            // route the call to the new destination 
            routeToNewDestination(executionPoint, sipDestination);
            return true;

        case CONTINUE:
            // Allow the call to continue without interruption 
            stats.incrementCallDirectionContinue(1);
            return true;

        case ENDCALL:
            // End the call 
            stats.incrementCallDirectionEndCall(1);

            // Check to see if an annoucement should be played 
            final String announcementIdStr = actionToTake.getAnnouncementId();
            if (null == announcementIdStr) {
                getTracer().fine("Action is to ENDCALL");
                // defer to the leg manager to end the session
                final LegManager lm = getCaller().getLegManager();
                lm.endSession(SipResponse.SC_FORBIDDEN);
            }
            else {
                // Schedule an announcement 
                try {
                    // announcement ID should be a Long.
                    final long announcementId = Long.parseLong(announcementIdStr);
                    getTracer().fine("Action is to ENDCALL after playing announcement: {}",
                                        announcementIdStr);
                    // tell sentinel-sip about the announcement to be played
                    final List<SipAnnouncementInformation> announcementQueue =
                                getSessionState().getEarlyMediaAnnouncementInfoQueue();
                    announcementQueue.add(SipAnnouncementInformation.getBuilder()
                                .setAnnouncementId(announcementId).build());
                    getSessionState().setEarlyMediaAnnouncementInfoQueue(announcementQueue);
                    // tell sentinel-sip to end the session after the announcement
                    getSessionState().setEndSessionAfterAnnouncement(SipResponse.SC_FORBIDDEN);
                    // used in rest-demo feature execution scripts
                    getSessionState().setPlayAnnouncementThenEndSession(true);
                }
                catch (NumberFormatException nfe) {
                    getTracer().fine("Announcement id: {} is not a valid. Ending the call.", announcementIdStr);
                    // defer to the leg manager to end the session
                    final LegManager lm = getCaller().getLegManager();
                    lm.endSession(SipResponse.SC_FORBIDDEN);
                }
            }
            // generate a DISCONNECTED notification 
            sendNotification(
                    lm.getCallingPartyLeg(),
                    CallNotificationTypes.CALLEVENT,
                    CallEvents.DISCONNECTED);
            return false; // sent a notification, feature has not finished
    }
    return true;
}