[MUSIC]
(University of Maryland)
(Programming Mobile Applications for Android Handheld Systems)
One of the defining characteristics of modern hand held 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
programming practices that you'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 requests.
In particular, I'll talk about two popular data formatting languages.
One, the Javascript Object Notation Language, 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 formatted in one of these languages.
So early handheld devices gave us mobility.
You could move from one place to another, and still perform useful computation.
However,
their networking capabilities were primitive by today's standards.
Now moving forward, today's devices combine powerful processors
with fast network connections over WiFi and cellular networks.
Handheld applications will therefore often want to make use
of 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.apache 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.
And 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 LoadData.
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 earthquake 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 AsyncTask called HttpGetTask. Let's look at that class.
The HttpGetTask class first declares some variables,
they're used in creating an HTTP GET Request.
When the execute method is called, on the HttpGetTask,
the doInBackground method is called.
And that method begins by creating a new socket
that will be connected to the host computer, api.geonames.org,
on the standard http port, port 80. Next, the code gets
the socket's output stream, and then writes the HTTPGETCOMMAND.
And this string will be sent to the host computer, which interprets it
as an HTTPGetRequest, 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 readStream.
The readStream method ultimately reads the response data
from the socket's InputStream and then returns the response as a single string.
And this string is passed to the
onPostExecute method which executes on the main thread
and which displays the response in the text view.
If we return 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 really just want to show you the earthquake data.
So in the case, I should have parsed the response
and pulled out just the data that I wanted.
In addition, you might have noticed 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 trade-offs 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 HttpUrlConnection 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 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 is putting its efforts into improving this class going forward.
So let's look at the example application
implemented this time with the HttpURLConnection class.
...
Now I'll launch the NetworkingURL 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
Load Data button.
There you can see the requested data, appearing in a 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 AsyncTask 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 httpUrlConnection.
This object is then stored in a variable called HttpURLConnection.
The code continues by getting the HttpURLConnection's input stream,
and by passing it through the readStream method.
And as before, the readStream 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 onPostExecute method
which displays the response in a text view.
The third class is Android HTTP client. 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 networking Android HTTP client application opened 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
AndroidHttpClient object by calling the classes newInstance 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 HttpGet request.
In this case, the ResponseHandler is of type
basicResponseHandler, which will return the response's body.
Now we'll see a more complex ResponseHandler later in this lesson.
And finally, the request and the ResponseHandler
are passed into the execute method,
which sends the request, gets the response,
passing it through the ResponseHandler.
And the result of all this
is then passed on to onPostExecute,
which displays the response in a text field.
[BLANK_AUDIO]