4.35 out of 5
233 reviews on Udemy

Mobile App Development with Android (2015)

You'll create a real world social networking application! All of Android's core concepts in a production level project!
3D BUZZ Programming and Digital Art training
2,933 students enrolled
English [Auto]
Work comfortably with Android Studio and the Android build tools
Understand the challenges and solutions to common problems that crop up in production quality Android development
Work with live APIs, including uploading images and handling authentication
Handle the Android application lifecycle correctly, and in a standard way
Leverage OO design patterns to simplify development
Have the experience and knowledge to to build production quality social networking applications


******** 30 Day, Money Back Guarantee!********

In this series, you'll be introduced to all of the core concepts involved with building Android applications. Furthermore: you'll apply those concepts to build a real world social networking application that allows users to send their friends pictures, taken with the camera on their phone, complete with funny messages that can be decoded to your actual text message!

  • Action Bars
  • Navigation Drawers
  • Event Buses
  • List Views
  • Service Layers
  • Camera and Web API's
  • Push Notifications
  • External Logins
  • A full background with production level code
  • Over 40 hours of training!

******** That's not all!!********

You'll also get access to your own personal sandbox for your web server, courtesy of us. As well as access to the *ENTIRE SOURCE CODE in a Git repository, labeled by lesson! You'll get to see not only the code, but the corrections that occur in production along the way!

If you've wanted to program for Android, This is the course to build the solid foundation and skills you need to take you anywhere you want to go in the Android world.

We've structured this course to provide a solid grounding in concept, followed by the application of that concept within an actual app so you can put what you learn to practice immediately in a real-world context!

*Use of sandbox and source code for personal, educational use only. Use of either service for commercial purposes is strictly forbidden.

Introduction to Android Development


This video covers the course, how to use the source code, and what we will be building!

Setting up your Development Environment

This video shows how to get a complete Android development environment setup and ready to go!

Android Quickstart

This is a birds-eye view of the core concepts of Android development. We create a simple application with two screens that can send data to each other. This is a quick end-to-end example of how to build and run Android applications during development and introduces core terminology that we will be using in this series.

SDK Overview

This short video talks about API levels, minimum and target Android versions and walks though the directory structure of the Android SDK. We also add two very important folders to our PATH environment variable so we have access to the Android tools globally on our system.

The Android Build System

This video covers the new Android build system - showing how to use it from the command line to build and deploy applications.

Android Project Directory Structure

In this video, we cover the project structure of an Android project, showing how the structure allows us to create unique resources on a per-configuration basis as well as discussing the Android Manifest.

Extending the Build process with Flavors

Here we show how to use the Android build system to create what are called product flavors: different versions of the same application and codebase.

Activities from Scratch and Linear Layouts

This video looks more in depth into activities, how Android Studio organizes our project, resources, layout XML files, and working with linear layouts.

Click Handles and Inner Classes

We talk about the different ways we can apply click handlers to our views. This video also serves as an introduction to Java inner classes - a fairly unique language feature in Java that is important to understand when working in this language.

Relative Views

This video introduces the very important and flexible relative view group.

Layout Includes

Continuing our discussions about views, we talk in this video about how to include layouts in one another.

Activity Lifecycle Part 1

We now take a step back from views and talk about how activities are managed by the Android operating system by inspecting all of the lifecycle callbacks that may be invoked during our application.

Activity Lifecycle Part 2

We continue our discussion of activity lifecycle by talking about how activities can communicate between each other in a robust manner.

Activity Lifecycle Part 3

We wrap up our discussion about activity lifecycles with two examples: a login form and a "root" activity - such as Facebook's Timeline, or an inbox. We discuss how we can modify the lifecycle of certain activities by setting certain flags in our intents and in our Android manifest.

Beginning our Application

[App 01] - The Application Class (and other odds and ends)

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

[App 02] - Using GIT with Android Studio

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.

[App 03] - A Soft Introduction to Fragments

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.

[App 04] - Communicating with Fragments

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.

[App 05] - Register Activity Stubs

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

Action Bars and Navigation Drawers

Action Bars - Introduction

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

Action Bars - AppCompat and Material Design

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.

Action Bars - Basic Buttons

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

Action Bars - Checkboxes, Radio Buttons, and Groups

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

Action Bars - Fragments - Part 1

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.

Action Bars - Fragments - Part 2

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

Action Bars - Custom Views

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

Action Bars - Custom Themes

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 - Part 1

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

Nav Drawers - Part 2

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

Top Level Navigation and Profile Activity

[App 06] - Integrating Toolbars

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

[App 07] - Nav Drawer Integration Stub

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

[App 08] - Nav Drawer Implementation

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

[App 09] - Nav Drawer Layouts

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

[App 10] - Nav Drawer Fix and Top Level Activities

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.

[App 11] - Top Level Activity Animations

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

[App 12] - Profile - Layout

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

[App 13] - Profile - Choosing Images

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.

[App 14] - Profile - Editing Fields

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

[App 15] - Profile - Change Password Dialog

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

Event Bus and Service Layer

Introduction to Otto

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

[App 16] - Service Layer - Adding Otto

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

[App 17] - Service Layer - Handling Events

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

[App 18] - Service Layer - In Memory Service Intro

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.

[App 19] - Service Layer - In Memory Service Base

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.

[App 20] - Login and Register API Calls

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.

[App 21] - Fake Login and Register API

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

[App 22] - Finishing our Login and Register Activities

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

[App 23] - Auto Login

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.

List Views

List Views - Basic Usage

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

List Views - Custom Layouts

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

List Views - Custom Adapters

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.

List Views - Selecting Items

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

List Views - Select Items Part 2

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

List Views - Contextual Action Bar

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

Contact Activities

[App 24] - Contacts Activity - API

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

[App 25] - Contacts Activity - Stubs

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

[App 26] - Action Scheduler

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

[App 27] - Contacts Activity

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

[App 28] - Activity Lifecycle Bus Bug

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

[App 29] - Pending Contact Requests

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

[App 30] - Contact List

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

Recycler View - Crash Course

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

[App 31] - Messages Recyclerview Adapter

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

[App 32] - Sent Messages Activity

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.

[App 33] - Contact Activity

In this video, we implement our contact activity.

[App 34] - Add Contact Activity

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

[App 35] - Serialization in Android - Parcelable

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

[App 36] - Select Contact Activity

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

Camera API and Send Message Activity

[App 37] - Camera Preview

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

[App 38] - New Message Activity

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

[App 39] - Send Message API

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

[App 40] - Send Message Layout

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

[App 41] - Finishing 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.

Inbox and Message Display Activities

[App 42] - Quick Tweaks

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

[App 43] - Service Layer Tweaks

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

[App 44] - Main Activity - Part 1 - Supporting Code

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

[App 45] - Main Activity - Part 2 - Implementation

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

[App 46] - Main Activity - Part 3 - Inbox Adapter

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

[App 47] - Main Activity - Part 4 - Wrapping Up

This video finishes off the Main Activity.

[App 48] - Message Activity

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

Hooking up the Live Web API

Retrofit Crash Course

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

[App 49] - Live Services Infrastructure

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

[App 50] - Live Service - Account

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!

[App 51] - Live Service - Contacts

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

[App 52] - Live Service - Messages

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

Push Notifications, External Logins and Conclusion

Google Play Services on Genymotion

To receive push notifications, you must have Google Play Services installed. While virtually all Android devices have them, or can get them easily, getting this to work on Genymotion takes some work.

[App 53] - Push Notifications Registration

The first thing we need to do is register with Google's Push Notification API.

[App 54] - Push Notifications Implementation

With our device registered, we can now being receiving push notifications!

You can view and review the lecture materials indefinitely, like an on-demand channel.
Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don't have an internet connection, some instructors also let their students download course lectures. That's up to the instructor though, so make sure you get on their good side!
4.4 out of 5
233 Ratings

Detailed Rating

Stars 5
Stars 4
Stars 3
Stars 2
Stars 1
30-Day Money-Back Guarantee


40 hours on-demand video
Full lifetime access
Access on mobile and TV
Certificate of Completion
Mobile App Development with Android (2015)
$59.98 $48


For Professionals

For Businesses

We support Sales, Marketing, Account Management and CX professionals. Learn new skills. Share your expertise. Connect with experts. Get inspired.


Partnership Opportunities

Layer 1
Register New Account
Compare items
  • Total (0)