This 4 week MOOC builds upon the core Android app components and concurrency frameworks covered in Course 2 by focusing on started and bound services, local inter-process communication (IPC), and content providers. Case study apps will be examined from multiple perspectives to learn how to program these app components using Android's material design paradigm. Students will work incrementally on a hands-on project involving a material design-based RSS reader app. Each week you will add additional capabilities to the project, based on material covered in the lecture videos. You'll spend roughly 4 hours per week watching video lectures, taking quizzes, and programming assignments with Java and Android.
Case Study: The HobbitContentProvider App (Part 2)
Loading...
From the course by Vanderbilt University
Android App Components - Services, Local IPC, and Content Providers
161 ratings
Explore Related Videos
At Coursera, you will find the best lectures in the world. Here are some of our personalized recommendations for you
From the lesson
Android Content Providers
Learning objectives are presented in the Module Introduction video lecture.
Meet the Instructors
Dr. Douglas C. SchmidtProfessor of Computer Science and Associate Chair of the Computer Science and Engineering Program
Electrical Engineering and Computer Science
[MUSIC]
Welcome to part two of our that drills deeper in to the HobbitContentProvider App
case study.
After completing this part of the lesson, you will understand
a portion the implementation of the HobbitContentProvider App In particular,
the user facing parts of the app.
Let's give an overview of the user facing parts of the app.
This user facing portion consists of the HobbitActivity
as well as the HobbitOps class, both of which are available
at the URL provided in my GitHub repository at the bottom of this slot.
We're now in the Android Studio project file for the Hobbit content provider app.
We'll start by looking at the files in the activities folder, starting with
HobbitActivity, which is a class that interacts with the user to coordinate
performing the various crud operations, such as insert, query, update, and delete,
on the Hobbit provider, using characters from Tolkiens classic novel, The Hobbit.
Have an activity,
extends LifecycleLoggingActivity, which we look at before, and it implements
the RaceFragment.OnClassClickCallback interface.
This side is part of the RaceFragment framework, which we mention earlier,
were not going to talk more about this framework now,
because were focus on contentproviders.
But I recommend to take a look because it’s got some interesting ways of
showing how to visualized the results of query of the contentprovider.
There are several fields that are provided in Hobbit activity including
nNecromancerUri, which is used to store the results of an insert
operation to be able to update that Uri easily later.
We also provide an nHobbitOps field which is an instance of a hopper class that
consolidates and simplifies operations on the hobbit provider.
There's a number of methods here starting with the onVreateHobb method.
This is used to initialize the activity when it comes into being,
not too much surprising here.
We start by calling up to our super class to deal with saved state,
we set the content view for the activity.
We set up the support toolbar and create an instance of the HobbitOps class,
which is our helper class that we talked about.
And then we go ahead and
we attempt to display anything that might currently be in the SQLite database.
If we've already done some operations, there'll be content that we want to
redisplay, for example if an orientation change has occurred.
The next several functions here implement the user interface button clicks,
starting with add all, where the user clicks the add all button.
We go ahead and do a bunch of insert operations,
we insert our main protagonist which is Bilbo, who's a Hobbit.
And Gandolf, who's a Maia, that's the fancy name for a wizard.
We do a bulk insert of all the dwarves, and then we insert Smaug the dragon.
And we do a bulk insert of various humans, including Bilbo's mother, Belladonna.
Then we come down here and we insert another antagonist,
which is a Necromancer, which starts out to be a Maia.
And you'll see here that we store this as a field so we can update it later.
After we've done all the inserts, we go ahead and display the results,
which will display the results that you saw when we ran the app.
Here's the modify all method implementation when the user clicks
the modify all button.
We go ahead and we update race by name.
We look at the update race by name method later, it's just a little rough in
the side, around the update method that provided by content resolver.
This changes the race of Beorn
from a human to a bear because he's a skin changer.
If the necromancer has been created, we'd go ahead and change the necromancer's
name to be Sauron because he's really Sauron, not the necromancer.
And then down here, we go ahead and delete Thorin, Kili, and
Fili, who are three dwarves, and get killed in the Battle of the Five Armies.
Down here, we go ahead and we delete Smaug, because he gets killed.
We delete Dragons by their race.
And then we also delete the remaining Humans, because the Master of Lake Town
is killed, and because Bilbo's mother, Belladona dies at some point of old age.
After that stunt, we go ahead and display the results.
Let us say that we also go ahead and
update the backdrop image to the original image.
That will change every time someone clicks on one of the laces,
it'll pull up an image that shows a picture of that race.
Down here we see the delete all Method this is connected to the deleteAll button.
When the user clicks this, we delete everything in the database,
which removes it from the SQLite persistent store.
We indicate how may characters were deleted,
and then we redisplay the results and update the original background image.
Here is the display cursor method as you can see here, this goes ahead and
looks up the race fragment by ID in the fragment manager.
And assuming that we find it, it goes ahead and sets the cursor that
came back from query to be the cursor that be displayed by the race fragment,
and that's what changes the user's interface.
And then finally, we have the update image method and
this is simply going to change the display image background, or backdrop.
As you see here, we're going to have fade the animation and the image in slowly so
we can see it kind of change, that's a nice visual effect.
Now that we've looked at the source code for HobbitActivity, we'll examine
the source code for HobbitOps, which is a helper class that consolidates and
simplifies operations on the Hobbit provider.
There's several fields to find in the HobbitOps class including a field
that keeps track of the reference to the HobbitActivity.
A field that keeps track of a cursor retaining the results to a query so
the display can be updated automatically after a run time configuration change
occurs.
We also keep track of a field for a content resolver that used to access
the underlining hobbit provider and then finally we have the field
called all races that keep track of all the races in the program.
Dwarves, hobbits, humans and so on.
Let's take a look at the various methods.
Here's the constructor.
It's used to get a reference to the content resolver for
this particular app as well as the hobbit activity to stash it away.
Here is the insert method.
As you can see this method is really a wrapper around the insert method that's
defined by a content resolver.
Which we'll take a look at in a second, and
what this does is it takes a character's name and a character's race.
Sticks those into the content values object and then goes ahead and
inserts that at the particular content URI that
represents the database that we're using here in SQLite.
Here's the insert method itself.
As you can see, this simply uses the content resolver insert method to
insert the content values at that URI.
Down here we see a bulk insert,
where we take an array of characters of a particular race.
And we go ahead and we create an array of content values.
And we insert each of the characters into the array in the appropriate place, and
then we call the bulk insert method.
Here is bulk insert.
As you can see bulk insert simply forwards to the content resolver to insert
the array of content values at that URI,
which indicates which table element we're talking about here.
Down here is the query method.
As you can see,
a query is simply just used to forward to the underlying content resolver.
Nothing too complicated here, we'll take a more detailed look at that a little later.
Here's the updateByUri method.
This is going to take a URI,
and it's going to update the current name and race with new values.
So we make a new content Values object, stick in the new name and the new race and
we call update.
We'll take a look at the update method here in a second.
Here's update race by name.
We're going to go ahead update the race of the character with a given name.
Does more was the same thing.
Here's the update method itself.
As you can see, it's simply forwards to the Content Resolver, passing in the URI,
and the Content values that was passed in by
one of the other two update methods that we just took a look at here.
Down here we're going to have a umber of deletion methods, these are all just
helper methods so you don't have to keep doing low level calls to content resolver.
We have delete by name, which is going to go ahead and
delete all the characters that are named in the string.
We have delete by race,
we're just going to delete everything based on their race.
We have a delete method which is going to go ahead and
do a delete, which will delete whatever selection parameters are passed in.
And selection args and then down here we have delete all which just goes ahead and
deletes everything that's in the table pointed to by this content URI.
And then, the final method here is Display All.
As you can see, what this does t calls query and the table and
it goes ahead and gets all the races.
It's going to query all the various elements in the table for
all the different races.
If we get back anything, then we go ahead and
display the results by calling back on display cursor on the activity.
Otherwise if there is nothing in the table,
because we've deleted things before, we never put anything in the first place,
we go ahead and display the cursor and indicate there is nothing to show.
We also pop ap toast indicating there is nothing to display.
So that's essentially what our user facing portion and
our helper class portion of this program looks like.
This is the end of part two of our case study on
the Hobbit Content Provider app.
Explore our Catalog
Join for free and get personalized recommendations, updates and offers.
Coursera provides universal access to the world’s best education,
partnering with top universities and organizations to offer courses online.
© 2019 Coursera Inc. All rights reserved.
