[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 HTTP<u>GET</u>COMMAND.

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]