Informizely customer feedback surveys
By using the Aculab site, you agree with our use of cookies.

UAS API - Uas Connection Test Sample Application

  • Filename:

    samples/uas_connection_test.py

    Description:

    This is an inbound application that rings the call for 2 seconds, answers the call, then reads out some text.

    The application grabs the host name and, if application_parameters is not an empty string, it will get that too (application_parameters is configured on the Inbound Services page). The call is then rung and answered using the channel.ring() and channel.answer() functions. A welcome message is played which contains machine's host name and the text from application_parameters.

    Code:

    """
        This is an inbound application that rings the call for 2 seconds, 
        answers the call, then reads out the following text::
    
        "Welcome to your U.A.S application."
        "The voice you are hearing has been commanded by your machine."
        "The hostname of the machine is <hostname>."
        "The application parameter supplied to the application is <application_parameters>. Goodbye."
    
    """
    
    __uas_identify__ = "application"
    __uas_version__ = "1.0b3"
    
    import sys, os, socket
    from prosody.uas import Hangup, Error
    
    def main(channel, application_instance_id, file_man, my_log, application_parameters):
        log_pref = "connection_test"
        call_to = channel.Details.call_to
        my_log.info("{0} started with call_to [{1}]".format(log_pref, call_to))
    
        #grab the machine hostname
        hostname = socket.gethostname()
    
        # Our default text for the application_parameters are "Nothing", which is replaced if there's any text to play
        test_args = "Nothing"
        if application_parameters != "":
            test_args = application_parameters
    
        # The main program
        try:
            # ring for two seconds
            channel.ring(2)
            # answer the call
            channel.answer()
            # say some text. The text is converted to speech using an inbuilt Text-To-Speech (TTS) converter
            channel.FilePlayer.say("Welcome to your U.A.S application. \
                                    The voice you are hearing has been commanded by your machine. \
                                    The hostname of the machine is {0}. \
                                    The application parameters supplied to the application are {1}. Goodbye.".format(hostname, test_args))
            # Hang up the call!
            channel.hang_up()
            
        except Hangup as exc:
            my_log.info("{0} completed with Hangup".format(log_pref))
    
        except Error as exc:
            my_log.error("{0} completed with Error exception! {1}".format(log_pref, exc))
            return -101
    
        except Exception as exc:
            my_log.exception("{0} completed with exception! {1}".format(log_pref, exc))
            return -102
    
        my_log.info("{0} completed".format(log_pref))
        return 0
    
  • Filename:

    Samples\UASApplications\UASConnectionTest\src\main\java\com\aculab\uas\app\UASConnectionTest.java

    Description:

    When this application starts, we log the caller and then grab the hostname of the machine from InetAddress.getLocalHost. We then access the applicationParameters argument, that is specified in the calling inbound service on the Cloud and sent to our application when it is run on our UAS. If there's anything in the parameter list we store it in parametersToSay. Otherwise we set parametersToSay to be "Empty".

    The application simulates the phone ringing with channel.ring(2), answers the call with channel.answer() and then uses Text-To-Speech (TTS) to convert some text to voice data. The text to say includes the hostname, gathered from the above code, just to confirm to the user that the UAS is running on their local machine. Additionally, the parametersToSay are played. Finally, the channel is disconnected with channel.hangUp.

    Code:

    package com.aculab.uas.app;
    
    // A simple inbound application that rings the call for 2 seconds, 
    // answers the call, then reads out some text including the machine name on 
    // which the UAS is running and the application parameters sent to the 
    // application, before hanging up.
    //
    // Requires:
    // [applicationParameters = the text to say]
    import java.net.InetAddress;
    import com.aculab.amsapi.*;
    import com.aculab.uasapi.*;
    
    // The application class.
    // This must extend either UASInboundApplication or UASOutboundApplication and
    // override the run method.
    // It must be packaged in a jar file of the same name together with a manifest file.
    public class UASConnectionTest extends UASInboundApplication  
    {
        // This is the entry point for the application
        @Override	
        public int run(UASCallChannel channel, String applicationParameters)
            throws Exception
        {
            this.getTrace().traceInfo("Start - appParms [%s]", applicationParameters);
    
            String callTo = channel.getCallDetails().getCallTo();
            this.getTrace().traceInfo("CallTo [%s]", callTo);
    
            // Grab the machine hostname
            String hostname = InetAddress.getLocalHost().getHostName();
    
            // Set what to say if applicationParameters is empty 
            String parametersToSay = "Empty";
            if (applicationParameters.length() > 0)
            {
                parametersToSay = applicationParameters;
            }
    
            try
            {
                // Ring for two seconds
                channel.ring(2);
    
                // Answer the call
                channel.answer();
        
                if (channel.getState() == CallState.Answered)
                {
                    // Say some text. 
                    // The text is converted to speech using the inbuilt Text-To-Speech (TTS) converter
                    channel.getFilePlayer().say("Welcome to your U A S application. " + 
                                                "The voice you are hearing has been commanded by your machine. " +
                                                "The hostname of the machine is %s.", 
                                                hostname);
                    channel.getFilePlayer().say("The application parameter supplied to the application is %s.",
                                                parametersToSay);
                    channel.getFilePlayer().say("Goodbye.");
                }
            }
            catch (Exception e)
            {
                this.getTrace().traceError("Exception thrown %s", e.getMessage());
            }
            finally
            {
                // Hang up the call
                channel.hangUp();
            }
    
            this.getTrace().traceInfo("Completed with return code %d", 0);
            return 0;
        }
    }
  • Filename:

    Samples\C#\UASConnectionTest\UASConnectionTest.cs

    Description:

    When this application starts, we log the caller and then grab the hostname of the machine from System.Environment.MachineName. We then access the applicationParameters argument, that is specified in the calling inbound service on the Cloud and sent to our application when it is run on our UAS. If there's anything in the parameter list we store it in parametersToSay. Otherwise we set parametersToSay to be "Empty".

    The application simulates the phone ringing with channel.Ring(2), answers the call with channel.Answer() and then uses Text-To-Speech (TTS) to convert some text to voice data. The text to say includes the hostname, gathered from the above code, just to confirm to the user that the UAS is running on their local machine. Additionally, the parametersToSay are played. Finally, the channel is disconnected with channel.HangUp.

    Code:

    using System;
    using System.Threading;
    using AMSClassLibrary;
    using UASAppAPI;
    
    // A simple inbound application that rings the call for 2 seconds, 
    // answers the call, then reads out some text including the machine name on 
    // which the UAS is running and the application parameters sent to the 
    // application, before hanging up.
    //
    // Requires:
    // [applicationParameters = the text to say]
    namespace UASConnectionTest
    {
        public class UASConnectionTest : UASInboundApplication
        {
            public override int Run(UASCallChannel channel,
                                    string applicationParameters)
            {
                string callTo = channel.CallDetails.CallTo;
                this.Trace.TraceInfo("Call started with callTo [{0}]", callTo);
    
                // Grab the machine hostname
                string hostname = System.Environment.MachineName;
    
                // Set what to say if applicationParameters is empty 
                string parametersToSay = "Empty";
                if (applicationParameters.Length > 0)
                {
                    parametersToSay = applicationParameters;
                }
    
                try
                {
                    // Ring for two seconds
                    channel.Ring(2);
    
                    // Answer the call
                    channel.Answer();
            
                    // Say some text. 
                    // The text is converted to speech using the inbuilt Text-To-Speech (TTS) converter
                    channel.FilePlayer.Say("Welcome to your U A S application. " + 
                                           "The voice you are hearing has been commanded by your machine. " +
                                           "The hostname of the machine is {0}.", 
                                           hostname);
                    channel.FilePlayer.Say("The application parameter supplied to the application is {0}.",
                                           parametersToSay);
                    channel.FilePlayer.Say("Goodbye.");
                }
                catch (Exception e)
                {
                    this.Trace.TraceError("Exception thrown {0}", e.Message);
                }
                finally
                {
                    // Hang up the call
                    channel.HangUp();
                }
    
                this.Trace.TraceInfo("Completed");
                return 0;
            }
        }
    }
  • Filename:

    Samples\VB\UASConnectionTest\UASConnectionTest.vb

    Description:

    When this application starts, we log the caller and then grab the hostname of the machine from System.Environment.MachineName. We then access the applicationParameters argument, that is specified in the calling inbound service on the Cloud and sent to our application when it is run on our UAS. If there's anything in the parameter list we store it in parametersToSay. Otherwise we set parametersToSay to be "Empty".

    The application simulates the phone ringing with channel.Ring(2), answers the call with channel.Answer() and then uses Text-To-Speech (TTS) to convert some text to voice data. The text to say includes the hostname, gathered from the above code, just to confirm to the user that the UAS is running on their local machine. Additionally, the parametersToSay are played. Finally, the channel is disconnected with channel.HangUp.

    Code:

    Imports AMSClassLibrary
    Imports UASAppAPI
    
    ' A simple inbound application that rings the call for 2 seconds, 
    ' answers the call, then reads out some text including the machine name on 
    ' which the UAS is running and the application parameters sent to the 
    ' application, before hanging up.
    '
    ' Requires:
    ' [applicationParameters = the text to say]
    Namespace UASConnectionTest
    
        Public Class UASConnectionTest
            Inherits UASInboundApplication
    
            Overrides Function Run(ByVal channel As UASCallChannel, _
                                   ByVal applicationParameters As String) _
                                   As Integer
    
                Dim callTo = channel.CallDetails.CallTo
                Me.Trace.TraceInfo("Call started with callTo [{0}]", callTo)
    
                ' Grab the machine hostname
                Dim hostname = System.Environment.MachineName
    
                ' Set what to say if applicationParameters is empty 
                Dim parametersToSay = "Empty"
                If applicationParameters.Length > 0 Then
                    parametersToSay = applicationParameters
                End If
    
                Try
                    ' Ring for two seconds
                    channel.Ring(2)
    
                    ' Answer the call
                    channel.Answer()
    
                    ' Say some text. 
                    ' The text is converted to speech using the inbuilt Text-To-Speech (TTS) converter
                    channel.FilePlayer.Say("Welcome to your U A S application. " + _
                                           "The voice you are hearing has been commanded by your machine. " + _
                                           "The hostname of the machine is {0}.", _
                                           hostname)
                    channel.FilePlayer.Say("The application parameter supplied to the application is {0}.", _
                                           parametersToSay)
                    channel.FilePlayer.Say("Goodbye.")
                Catch e As Exception
                    Me.Trace.TraceError("Exception thrown {0}", e.Message)
                Finally
                    ' Hang up the call
                    channel.HangUp()
                End Try
    
                Me.Trace.TraceInfo("Completed")
                Return 0
    
            End Function
    
        End Class
    
    End Namespace
  • Filename:

    Samples\F#\UASConnectionTest\UASConnectionTest.fs

    Description:

    When this application starts, we log the caller and then grab the hostname of the machine from System.Environment.MachineName. We then access the applicationParameters argument, that is specified in the calling inbound service on the Cloud and sent to our application when it is run on our UAS. If there's anything in the parameter list we store it in parametersToSay. Otherwise we set parametersToSay to be "Empty".

    The application simulates the phone ringing with channel.Ring(2), answers the call with channel.Answer() and then uses Text-To-Speech (TTS) to convert some text to voice data. The text to say includes the hostname, gathered from the above code, just to confirm to the user that the UAS is running on their local machine. Additionally, the parametersToSay parameter is played. Finally, the channel is disconnected with channel.HangUp and we return 0 to indicate success.

    Code:

    // A simple inbound application that rings the call for 2 seconds, 
    // answers the call, then reads out some text including the machine name on 
    // which the UAS is running and the application parameters sent to the 
    // application, before hanging up.
    //
    // Requires:
    // [applicationParameters = the text to say]
    namespace UASConnectionTest
    
        open AMSClassLibrary
        open UASAppAPI
        open System.Threading
    
        // The application class.
        // This must have the same name as the assembly and must inherit from either 
        // UASInboundApplication or UASOutboundApplication.
        // It must override the Run method.
        type UASConnectionTest() = 
            inherit UASInboundApplication()
    
            // This is the entry point for the application
            override obj.Run(channel:UASCallChannel, applicationParameters:string) : int = 
    
                let callTo = channel.CallDetails.CallTo
                obj.Trace.TraceInfo("Call started with callTo [{0}]", callTo)
    
                // Grab the machine hostname
                let hostname = System.Environment.MachineName
    
                // Set what to say if applicationParameters is empty 
                let parametersToSay = if (applicationParameters.Length > 0) then applicationParameters else "Empty"
    
                try
                    try
                        // Ring for two seconds
                        channel.Ring(2) |> ignore
    
                        // Answer the call
                        channel.Answer() |> ignore
            
                        // Say some text. 
                        // The text is converted to speech using the inbuilt Text-To-Speech (TTS) converter
                        channel.FilePlayer.Say("Welcome to your U A S application. " + 
                                               "The voice you are hearing has been commanded by your machine. " +
                                               "The hostname of the machine is {0}.", 
                                               hostname) |> ignore
                        channel.FilePlayer.Say("The application parameter supplied to the application is {0}.",
                                               parametersToSay) |> ignore
                        channel.FilePlayer.Say("Goodbye.") |> ignore
                    with
                        | _ as e ->
                            obj.Trace.TraceError("Exception thrown {0}", e.Message)
                finally
                    // Hang up the call
                    channel.HangUp() |> ignore
    
                obj.Trace.TraceInfo("Completed")
                0
                
  • Filename:

    Samples\C++\UASConnectionTest\UASConnectionTest.cpp

    Description:

    When this application starts, we log the caller and then grab the hostname of the machine from System::Environment::MachineName. We then access the applicationParameters argument, that is specified in the calling inbound service on the Cloud and sent to our application when it is run on our UAS. If there's anything in the parameter list we store it in parametersToSay. Otherwise we set parametersToSay to be "Empty".

    The application simulates the phone ringing with channel->Ring(2), answers the call with channel->Answer() and then uses Text-To-Speech (TTS) to convert some text to voice data. The text to say includes the hostname, gathered from the above code, just to confirm to the user that the UAS is running on their local machine. Additionally, the parametersToSay are played. Finally, the channel is disconnected with channel->HangUp.

    Code:

    // This is the main DLL file.
    
    #include "stdafx.h"
    #include "UASConnectionTest.h"
    
    // A simple inbound application that rings the call for 2 seconds, 
    // answers the call, then reads out some text including the machine name on 
    // which the UAS is running and the application parameters sent to the 
    // application, before hanging up.
    //
    // Requires:
    // [applicationParameters = the text to say]
    namespace UASConnectionTest 
    {
    	// Possible return codes
    	enum ReturnCode
    	{
    		// Success Codes:
    		Success = 0
    		// ... any positive integer
    
    		// Fail Codes:
    		// -1 to -99 reserved
    	};
    
    	// This is the entry point for the application
    	int UASConnectionTest::Run(UASCallChannel^ channel, String^ applicationParameters)
    	{
    		String^ callTo = channel->CallDetails->CallTo;
    		this->Trace->TraceInfo("Call started with callTo [{0}]", callTo);
    
    		// Grab the machine hostname
    		String^ hostname = System::Environment::MachineName;
    
    		// Set what to say if applicationParameters is empty 
    		String^ parametersToSay = "Empty";
    		if (applicationParameters->Length > 0)
    		{
    			parametersToSay = applicationParameters;
    		}
    
    		try
    		{
    			// Ring for two seconds
    			channel->Ring(2);
    
    			// Answer the call
    			array<String^>^ emptyCodecs = gcnew array<String^>(0);
    			channel->Answer(emptyCodecs);
    
    			// Say some text. 
    			// The text is converted to speech using the inbuilt Text-To-Speech (TTS) converter
    			channel->FilePlayer->Say("Welcome to your U A S application. " + 
    									 "The voice you are hearing has been commanded by your machine. " +
    									 "The hostname of the machine is {0}.", 
    									 hostname);
    			channel->FilePlayer->Say("The application parameter supplied to the application is {0}.",
    									 parametersToSay);
    			channel->FilePlayer->Say("Goodbye.");
    		}
    		catch (Exception^ e)
    		{
    			this->Trace->TraceError("Exception thrown {0}", e->Message);
    		}
    		finally
    		{
    			// Hang up the call
    			channel->HangUp();
    		}
    
    		this->Trace->TraceInfo("Completed");
    
    		return Success;
    	};
    }