This is a guest post from Mark Headd, introducing a PHP library for the Tropo WebAPI.

This post is a continuation of the series on building cloud communication applications with Tropo and the PHP WebAPI Library.

In this post, we’ll be looking at Tropo’s support for multi-channel applications and using the incredibly flexible and powerful Limonade library for PHP (think Sinatra for PHP).

Working with the Session Object

As I explained very briefly in the previous post on this subject, the Tropo WebAPI is an HTTP/JSON API for building multi-channel communication apps.

What this means essentially is that the Tropo platform does all of the hard stuff involved with executing a communication app – DTMF/speech recognition, rendering Text-To-Speech (TTS), maintaining and managing all of the connections to the different communication networks (PSTN, SMS, IM networks, Twitter). You tell Tropo how to govern the interaction between a caller and your application on a specific channel by sending it a set of instructions in JSON format.

In this series of posts, we’re using the PHP WebAPI Library for Tropo to generate the JSON that gets sent to, and consumed by Tropo. But this exchange of JSON isn’t one-way – Tropo also sends JSON packages to your application with important information about (among other things) the network a user selects to interact with your application on and any input they have provided in response to prompts.

At the beginning of a user session (when a user first connects to your application), Tropo will deliver a JSON Session object to your application. This object contains all sorts of useful information that your app can use when rendering out JSON instructions to send back to Tropo. Let’s examine what a real life Session object looks like.

The easiest way to do this is to simply go over to PostBin.org and make a new PostBin. PostBin is a service that lets you see HTTP posts that get sent to the special URL that is generated when you create a new PostBin.

After you have created a new PostBin, log into your Tropo account and create a new WebAPI application. Use the PostBin URL as the URL that powers your new Tropo WebAPI app. After your app is created, you will have a newly provisioned Skype number that you can use to call it.

When you call your application using the Skype number provisioned by Tropo, you won’t hear anything – remember, we haven’t yet generated any JSON to tell the Tropo platform what to say or do when a user connects. After you make your call (it will be over quickly), go back to your PostBin URL (you may need to refresh) and you will see an object in JSON format, like this:

{
  "session": {
    "accountId": "9178", 
    "callId": "33e6f280ec9e740ad57ec3464175e502", 
    "from": {
      "channel": "VOICE", 
      "id": "mheadd", 
      "name": "unknown", 
      "network": "PSTN"
    }, 
    "headers": {
      "CSeq": "2 INVITE", 
      "Call-ID": "0-13c4-4c162a69-77e521a6-72fc-1d004d38", 
      "Contact": "<sip:mheadd@10.90.63.103:5060>", 
      "Content-Length": "249", 
      "Content-Type": "application\/sdp", 
      "From": "<sip:mheadd@10.90.63.103:5060>;tag=0-13c4-4c162a69-77e521a6-5ba", 
      "To": "<sip:9991443038@10.90.61.101:5060>", 
      "Via": "SIP\/2.0\/UDP 67.28.127.103:5060;received=10.90.63.103", 
      "x-sbc-allow": "BYE", 
      "x-sbc-call-id": "MTJjZTIzNzBkMDI1MzJhMmJlNjQ1YWQ0NmNmODZkMmM.", 
      "x-sbc-contact": "<sip:0000123456@192.168.14.61:16000>", 
      "x-sbc-cseq": "1 INVITE", 
      "x-sbc-from": "\"mheadd\"<sip:0000123456@192.168.14.61>;tag=93658f52", 
      "x-sbc-max-forwards": "70", 
      "x-sbc-record-route": "<sip:80.252.85.73:5061;r2=on;lr;ftag=93658f52>", 
      "x-sbc-request-uri": "sip:990009369991443038@67.28.127.103:5060", 
      "x-sbc-to": "<sip:990009369991443038@67.28.127.103:5060>", 
      "x-sbc-user-agent": "sipgw-1.0", 
      "x-sid": "cc6499d5ec479c60633f7ad2b6a4df15", 
      "x-voxeo-sbc": "true", 
      "x-voxeo-sbc-name": "10.90.63.103", 
      "x-voxeo-sbc-session-id": "cc6499d5ec479c60633f7ad2b6a4df15", 
      "x-voxeo-to": "<sip:990009369991443038@67.28.127.103:5060>"
    }, 
    "id": "6e15c4ecadf33b72c9e0ba52f707b18c", 
    "initialText": null, 
    "timestamp": "2010-06-14T13:11:04.977Z", 
    "to": {
      "channel": "VOICE", 
      "id": "9991443038", 
      "name": "unknown", 
      "network": "PSTN"
    }, 
    "userType": "HUMAN"
  }
}

This is the Session object for the call you just made. It’s what is sent to your application (via HTTP POST) each time a new session is started on Tropo. Working with this object using the PHP WebAPI Library is easy. You just create a new instance of the Session object in PHP and you can start accessing the properties of this object:

$session = new Session();
$from_info = $session->getFrom();
echo $from_info['channel'];
// Using the example Session object JSON from above would render VOICE.

Being able to access the channel and network a user is accessing your application from can be useful when you want to tailor prompts or actions to a specific channel – e.g., a phone call vs. an IM session.

Also make note of the initialText property – this will be important when building SMS and IM applications, where a user will begin an interaction with your application by sending information to it. This property will allow you to process the initial input for those channels without having to ask the user for it again (something users generally dislike).

Next, let’s take a look a the Result object that is sent from Tropo to your application when a user provides input in response to a prompt or direction. In order to do this, we need to take a sip of Limonade.

Mmmm… Limonade!

Limonade is a lightweight PHP framework that is very much like the Sinatra framework for Ruby. I won’t go into too much detail on it, as there is ample documentation available on the Limonade site , but here is quick introduction that will let us build enough of a structure to see the Tropo result object.

When you use Limonade, you set up routes for HTTP requests. A route is comprised of an HTTP method, a URL matching pattern and a PHP method. When an HTTP request is made to a URL that matches the pattern, and uses the method specified in the route, the designated PHP function gets invoked. For example:

dispatch_post('/', 'test');
  function test() {
    echo 'This is a test.';
}

The ‘dispatch_post()’ directive specifies that the HTTP method for this route with be POST (which is what is used by Tropo to send JSON to your application). The two parameters to this directive specify the URL pattern to match (in this case, the root directory on the domain were this script is located) and the PHP method to invoke, which is defined below this directive. In a nutshell, whenever an HTTP POST is made to the root domain where this script is located, the text This is a test will be rendered.

Let’s build out a simple shell that we’ll use to construct our Tropo application for the next few posts in this series:

// Include Tropo classes.
require('TropoClasses.php');

// Include Limonade framework (http://www.limonade-php.net/).
require('path/to/limonade/lib/limonade.php');

dispatch_post('/start', 'zip_start');
function zip_start() {
	// Tell the user to enter their zip code.
}

dispatch_post('/end', 'zip_end');
function zip_end() {
	// Do something with the entered zip code.
}

dispatch_post('/error', 'zip_error');
function zip_error() {
	// Tell the user an error has occurred.
}

// Run this sucker!
run();

Our Tropo application will collect a user’s zip code and then look up some information based on the input they provide. As you can see, we’ve included the PHP WebAPI Library and the Limonade Framework. We’ve also set up three Limonade routes start, end and error (all using the HTTP POST method) and stubbed out the PHP function that will render JSON for Tropo to consume.

To get a look at the Tropo Result object, lets add some logic to the zip_start() function:

dispatch_post('/start', 'zip_start');
function zip_start() {

	// Step 1. Create a new instance of the Session object, and get the channel information.
	$session = new Session();
	$from_info = $session->getFrom();
	$network = $from_info['channel'];

       // Step 2. Create a new instance of the Tropo object.
	$tropo = new Tropo();

	// Step 3. Welcome prompt.
	$tropo->say("Welcome to the Tropo PHP zip code example for $network");

	// Step 4. Set up options for zip code input.
	$options = array("attempts" => 3, "bargein" => true, "choices" => "[5 DIGITS]", "name" => "zip", "timeout" => 5);

	// Step 5. Ask the caller for input, pass in options.
	$tropo->ask("Please enter your 5 digit zip code.", $options);

	// Step 6. Tell Tropo what to do when the user has entered input. Enter your PostBin URL in the "next" array element.
	$tropo->on(array("event" => "continue", "next" => "http://www.PostBin.org/xxxxxxx", "say" => "Please hold."));

	// Step 7. Render the JSON for the Tropo WebAPI to consume.
	return $tropo->RenderJson();

}

As you can see, inside this function we create a new instance of the Session object and get the channel the user is accessing our application from. We also create a new instance of the Tropo object (this is what we’ll use to send JSON instructions back to the Tropo platform).

The next several steps are fairly self explanatory, but take special note of Step 6. Here we are telling the Tropo platform that when a ‘continue’ event is raised (when a user finishes entering input) tell them to ‘Please hold’ and then POST the results of their input to a PostBin URL. (Note – replace the value above with the PostBin URL you used at the beginning of this tutorial.)

Working with the Result Object

Save your script and change the URL for your WebAPI application in the Tropo Applications manager to point to it. You can now test your script using the the Skype number for your app as we did before . When you access your script, you’ll get the instructions to enter a zip code, after which Tropo will POST the results to the PostBin URL you inserted into the script in Step 6 above.

Now, when you look at your PostBin URL, you’ll see something like this:

{
  "result": {
    "actions": {
      "attempts": 1, 
      "confidence": 100, 
      "disposition": "SUCCESS", 
      "interpretation": "12345", 
      "name": "zip", 
      "utterance": "1 2 3 4 5", 
      "value": "12345", 
      "xml": "<?xml version=\"1.0\"?>\r\n<result grammar=\"0@9ea5756d.vxmlgrammar\">\r\n    <interpretation grammar=\"0@9ea5756d.vxmlgrammar\" confidence=\"100\">\r\n        \r\n      <input mode=\"dtmf\">dtmf-1 dtmf-2 dtmf-3 dtmf-4 dtmf-5<\/input>\r\n    <\/interpretation>\r\n<\/result>\r\n"
    }, 
    "callId": "6d620e133c2f7f265b4b34f94438fd95", 
    "complete": true, 
    "error": null, 
    "sequence": 1, 
    "sessionDuration": 10, 
    "sessionId": "bc73448b723c8c5dc4498d1a322851ec", 
    "state": "ANSWERED"
  }
}

As you can see, the Result object that gets sent from Tropo to your app has a wealth of information on what the user entered, how it was interpreted by Tropo and even the confidence level of the recognition (if speech recognition is used).

You can access the Result object using the PHP WebAPI Library just like you can the Session object:

$result = new Result();<br />

$zip = $result->getValue();<br />
echo $zip
// Using the example Result object JSON from above would render 12345<br />

You would use the Result object in the zip_end() function we stubbed out above. You use the value of the zip code entered to look up information relevant for that zip code (like a weather forecast) and present it to the caller. In the next post in this series, we’ll complete our simple zip code example by adding a weather forecast lookup and present it to the user. We’ll also tweak our script to optimize it for different channels that a user might employ to access it, to ensure the experience is optimized for phone, IM and SMS.

Stay tuned…

About the author: Mark J. Headd is an experienced voice, mobile and web application developer who has been certified as a VoiceXML Application Developer by the VoiceXML Forum. He currently works as a Senior Application developer for Tele-Works, Inc., which develops IVR solutions and software for local government across the country. This post originally appeared on Mark’s blog.