https:/.../index.mp4

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