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