We kick off the development of the application by creating a handful of classes that we will be using throughout the series.

This video introduces using GIT with Android Studio. We also setup a BitBucket repository and connect it to our local one. Feel free to skip this video if you're already comfortable using GIT with Android Studio.

This video demonstrates a use of a powerful Android feature - Fragments. We create a reusable login form that enables us to have different layouts on phones and tablet devices.

This video continues the previous one by showing a common and very powerful technique that allows a fragment to communicate with the activity that it is attached to.

To get some legwork out of the way, we stub out our register and external login activities and layouts.

This video introduces the action bar, and what we can do with it by taking a look at some built in applications.

The first thing we have to do before working with the action bar is talk about the AppCompat library and how to make our applications look good in both Android 4 and Android 5.

The most basic thing an action bar can do is display buttons, and in this video we introduce how to use them.

Next up, we talk about adding checkboxes, radio buttons, and button groups in action bars.

This video shows a basic technique of working with fragments; setting up an example application that we will be using to show how fragments work with action bars.

Now we use the sample application created in the last video to show how fragments interact with action bars.

In this video, we show a technique that allows us to create custom layouts on our action bars.

Finally, we wrap up our discussion of action bars by showing how we can manipulate our styles and themes.

Toolbars are a newer and more flexible version of action bars. In this video, we take a look at all the cool things they allow us to do!

Nav drawers are a common way to navigate modern applications. This video introduces how to use them in our applications.

We wrap up our discussion of nav drawers by showing how they interact with toolbars.

Back in our app, we will bring toolbars into the application in a consistent way.

We start implementing our top level navigation by stubbing out a helper class that will make managing our navigation drawer very easy.

Now we implement our helper nav drawer class that we stubbed out in the last video.

Finally, we put together our navigation drawer layout and create the necessary includes that can be imported into the top level activities' layouts.

We now stub out our top level activities, and address a bug in the navigation drawer code. This video shows some interesting internals of the layout inflater.

In this video we override the default Android animations between our top level activities.

This video shows the creation of a basic profile screen layout that adjusts itself based on the width of the screen.

The first bit of functionality that we will put together in our profile activity is the ability to choose an avatar from an existing image, or from an image taken by the phone's camera.

This video is the first which features the Contextual Action Bar. We use the CAB to provide an editing interface for our profile fields.

Next up we introduce custom dialogs, using dialog fragments. We use this to implement the “Change Password” dialog box.

Otto is an awesome event bus library that allows us to decouple our application's components.

We start off by integrating Otto into our application and then creating a handful of event objects that we will be using.

This video integrates the events that we defined in the last video into our change password dialog.

Now we can start implementing our “fake” in memory service layer that allows us to simulate a real web API without a connection to the Internet.

To make writing “fake” services easier, we factor out some code into a base in memory service class. We also finish implementing the fake API calls in our account service.

The first thing we need to do to finish our login and register activities, is to create the API calls requires to make them work in the form of the request/response event classes.

With our login and register events created, we have to create a fake/testing implementation of the calls themselves.

Finally, we hook our register and login screens into our shiny new service layer.

With our auth token being saved, we now have to write code that will perform an auto-login if the auth token is still valid.

We start off our section of ListViews with a basic introduction of the simplest ways that we can use them.

Then we take a look on how we can customize the list view's list item layouts.

The most flexible way to use a list views is to write our own adapters. In this video, we set up a custom adapter and talk about some very important performance concerns.

Now we take a look on how to handle selections in our list views - both using checkboxes and radio buttons.

Next up we look at how to handle item selections with custom adapters and layouts.

For the last video on list views specifically, we take a look at how to hook up list views to a contextual action mode.

The first thing we need to do with our contacts activity is to create the contacts service, and the corresponding “fake” implementation.

Next, we stub out the required classes for our contacts activity and fragments.

We take a step back to implement an action scheduler class that can be used in our fragments, activities, and dialogs.

This video implements the scaffolding of the contacts activity - allowing us to tab through different fragments using a spinner control in the toolbar.

Here we quickly address an issue with the way that our bus registration works.

In this video, we implement the Pending Contact Requests fragment - and import the Picasso library to help with image loading.

Next up, we implement our Contacts fragment - which displays a list of our current contacts.

This video is a crash course into using the Recycler View - a more modern ListView that Google recently introduced.

In order to display messages, we have to first create our view holder and adapter implementation for messages.

Now we put together our Sent Messages activity that uses the adapter we created in the last video; as well as the required service calls.

In this video, we implement our contact activity.

This video shows a use of custom Toolbar views to present a search dialog for sending contact requests.

We now introduce the serialization method in Android known as parcelables in order to pass around complex objects within our activities.

Just to wrap up all of our contacts-related-activities, we implement a simple contact chooser activity.

The first thing we have to do is create a way to preview our camera and display it on the screen.

Next, we implement the UI for our New Message Activity, and implement some logic that transforms and compresses images taken from the phone camera.

Before creating our Send Message Activity, we have to put together our API call for sending messages.

Now we'll put together the layout and basic interaction logic for our Send Message Activity.

With the implementation out of most of the activity out of the way, now we intergrate it with the rest of the application.

This video is a compilation of quick tweaks that our application needs in preperation of finishing our activities.

To finish the preperation of our final activities, we now add some new parameters and fixes to our service layer.

This video builds up the supporting layouts, adapters and view holders we need for our Main Activity.

With that out of the way, we can implement the bulk of the Main Activity!

This video demonstrates a non-trivial use of the Recycler View, which allows for multiple list item view types.

This video finishes off the Main Activity.

With the main activity out of the way, we can build up our message display activity.

This video is a quick introduction to how we will be handling our API calls.

Before writing our live services, we have to make some tweaks to how we work with Retrofit, including how we will handle authentication.

This video shows how we can hook up our account service to our live API; finally allowing us to register and log into real accounts!

Next up, we implement our contacts live service - allowing us to send and respond to contact requests.

The last, and simplist, live service to implement is the one responsible for sending and searching messages