[MUSIC]
One of the defining characteristics, of modern handheld systems, is that they
can keep us connected and networked, without tethering us to a single location.
In this lesson we'll explore the software and
programing practices that we'll need to connect your applications to the network.
So I'll start this lesson by discussing networking in general.
That discussion will focus on connecting your applications to the internet
using the hypertext transfer protocol or
HTTP, Specifically by using HTTP get requests.
After that I'll present several classes that Android provides to support this
kind of networking, And lastly I'll discuss how your applications can
process the data they receive in response to these HTTP get request.
In particular I'll talk about two popular data formatting languages.
One, the JavaScript Object Notation Langauge or
JSON, And two, the extensible markup language or XML.
And I'll talk about how you parse or make sense of
these HTTP responses when they're formated in one of these languages.
So early hand-held devices, gave us mobility.
You could move from one place to another and still perform useful computation.
However, their networking capabilities were primitive by todays standards.
Now moving forward todays devices combine power processors with
fast network connections over WiFi and cellular networks.
Handheld applications will therefore often want to make use,
are these networking capabilities to access and provide data and services.
Now to help you do this, Android includes a variety of networking support classes
including the socket and URL classes in the Java.net packages.
The HttpRequest and HttpResponse classes in the org.appache packages, and
the URI AndroidHttpClient and AudioStream classes in the android.net packages.
In this lesson we're going to look at several of these classes.
Using each of them to implement the same example application.
This application interacts with an internet service to get information about
earthquakes that have occurred in a particular geographic Region.
And as you'll see, that data is returned in various formats.
Now, initially we'll just display the downloaded text as is.
Later on in the lesson, I'll show you how to process that
data to extract just the information that you want.
Oh, and and one other thing.
As you'll see in a second, because this data includes geographic information,
it's really begging to be displayed on a map, rather than as text.
Now, we won't do that in this lesson, but keep this in
mind because we'll come back to this when we get to the lesson on maps and location.
So in order to make this application work, the code needs to create an http request,
send it to a server computer, retrieve the results, and then display those results.
Android provides several classes for helping with this.
Three we'll talk about now are the socket class.
The HTTPURLConnection class and the AndroidHTTPClient.
I'll launch the networking socket application.
As you can see,
this application initially displays a single button labeled Load Data.
When I press that button, the application will issue an HTTP GET request
to an external server, and that server will respond with some complex text,
containing the requested earth quake data.
Okay, so now I'll press the Load Data button,
and there you can see the requested data.
Let's look at the source code to see what it took to get that data.
Now, here I've opened the application in the IDE.
Now, I'll open the main activity for
this application, and here I'm showing the listener for the load data button.
When this button is pressed, the application will create and
then execute an async task called HTTP get task.
Let's look at that class.
The HTTP get task class first declares some variables that
are used in creating an HTTP get request.
When the execute method is called on the HTTP get task.
The do in background method is called.
That method begins by creating a new socket that will be connected to the host
computer API.geoname.org on the standard http port, port 80.
Next, the code gets the sockets output stream, and
then writes the http get command, and this string will be sent to the host computer.
Which interprets it as a HTTP GET request, and
then responds by sending back the appropriate, response data, and
then this code continues by getting the socket's input stream and
by passing it to a method called read stream.
The read stream method ultimately reads the response data from the socket's input
stream, and then returns the response as a single string.
And this string is then passed to the on post execute method which
executes on the main thread, and which displays the response in the text view.
We turn back to the application.
You'll notice that the response text includes not only the earthquake data but
also the HTTP response headers.
Now normally I wouldn't want to display that text here.
I'd really just want to show you the earthquake data.
So in this case I should have parsed the response, and
pulled out just the data that I wanted.
In addition, you might have noticed that I didn't write any of
the error handling code that you'd really need to make this application robust.
And these points capture pretty well the tradeoffs of using sockets.
They're very low level.
You can write whatever you want on the socket, but
in return, you have to handle all the many details of making the http requests,
all the error handling, and all the processing of the http responses.
The next implementation we'll look at uses the http URL connection class.
This class provides a higher level interface that handles more of
the networking details than the socket class does, but, as we'll see in a moment,
it also has a less flexible API than our last option, the H,
the Android HTTP client class.
Now having said that, I'll also point out that the Android team is not
actively working on the Android HTTP Client anymore, and
it's putting its efforts into improving this class going forward.
So, let's look at the example application implemented this time
with the HTTP URL connection class.
Now I'll launch the networking URL application.
As before, this application initially displays a single button
labeled load data, and as before, when I press on that button,
the application will issue an HTTP get request.
To an external server.
And that server will respond with some complex text
containing the requested earthquake data.
Okay.
So now I'll press the Low Data button.
There you can see the requested data appearing in the text view.
Notice however that this time the HTTP response headers have been stripped out.
Let's look at the source code and see how this works.
Now here I've got the application opened in the IDE.
Now I'll open the main activity for
this application, and here I'm showing the listener for the load data button.
As before, when this button is pressed the application will create and
then execute an asynch task called httpGetTask.
Let's look at that class.
When the execute method is called on HttpGetTask,
the doInBackground method is invoked.
That method begins by creating a new URL object and
passing a URL string for the desired service as a parameter.
The code then calls the open connection method on the url object.
Which returns an http url connection.
This object is then stored in a variable called http url connection.
The code continues by getting the http url connection's
input stream, and bypassing it to the read stream method.
And as before, the read stream method reads the response data from
the socket's input stream, and then returns the response as a single string.
This time, however, the http URL connection strips off the http
response headers, and handles the error checking for you.
Now this string is then passed to the onPost execute method.
Which displays the response in the text view.
The third class is AndroidHTTPClient.
This class is an implementation of the Apache Project's DefaultHttpClient.
And it allows a great deal of customization.
In particular, the class breaks an HTTP transaction into
a request object, and into a response object.
So you can create subclasses that customize the handling of requests and
their responses.
Now by this point you know what the application looks like so
let's jump straight into the code and look at the implementation.
Now here I've got the NetworkingAndroidHttpClient application.
Open in the IDE.
Now, I'll open the main activity for this application, and let's go right to
the http get task class, that class begins by creating a new Android
http client object, by calling the classes new instance method.
Now, when the doInBackground method is called, the code creates an HttpGet
object, passing in the URL string for that request.
Next, it creates a ResponseHandler object.
This object is responsible for handling the response.
To the http get request, in this case the response handler is of type,
Basic Response Handler, which will return the responses body.
Now we'll see a more complex response handler later in this lesson.
And finally the request and the response handler are passed into the execute method
which sends the request, gets the response, passing it through the response
handler, and the result of all this is then passed on to on post execute.
Which displays the response in a text view.