-
[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.