Mobile App Development with Android (2015)
4.8 (172 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
2,626 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Mobile App Development with Android (2015) to your Wishlist.

Add to Wishlist

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!
4.8 (172 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
2,626 students enrolled
Last updated 6/2015
English
Learn Fest Sale
Current price: $10 Original price: $50 Discount: 80% off
1 day left at this price!
30-Day Money-Back Guarantee
Includes:
  • 40.5 hours on-demand video
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • 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
View Curriculum
Requirements
  • Willingness to learn design patterns and proper usage of an OO language
  • Basic programming ability, especially in a similar, statically typed language, such as C# or C++
  • All software is explained and installed on video
Description

ZERO TO HERO ANDROID APPLICATION TRAINING

******** 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.

Who is the target audience?
  • Beginner to advanced programmers
  • Experience in Java is not required, especially if the student already knows a similar language such as C#
  • Experience in Android, or any other mobile platform, is not required - we cover everything required to get set up in a modern development environment!
Students Who Viewed This Course Also Viewed
Curriculum For This Course
Expand All 91 Lectures Collapse All 91 Lectures 40:25:48
+
Introduction to Android Development
14 Lectures 09:01:41

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

Preview 11:50

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

Preview 25:23

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.

Preview 56:55

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.

SDK Overview
21:30

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

The Android Build System
40:28

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.

Android Project Directory Structure
38:00

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.

Extending the Build process with Flavors
24:36

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

Activities from Scratch and Linear Layouts
44:09

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.

Click Handles and Inner Classes
41:30

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

Relative Views
36:58

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

Layout Includes
44:53

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 1
48:51

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

Activity Lifecycle Part 2
01:00:53

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.

Activity Lifecycle Part 3
45:45
+
Beginning our Application
5 Lectures 03:42:05

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

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

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 02] - Using GIT with Android Studio
31:55

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 03] - A Soft Introduction to Fragments
01:02:44

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 04] - Communicating with Fragments
30:29

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

[App 05] - Register Activity Stubs
44:12
+
Action Bars and Navigation Drawers
11 Lectures 04:16:33

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

Action Bars - Introduction
08:58

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 - AppCompat and Material Design
25:03

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

Action Bars - Basic Buttons
27:51

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

Action Bars - Checkboxes, Radio Buttons, and Groups
24:09

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 1
29:57

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

Action Bars - Fragments - Part 2
19:21

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

Action Bars - Custom Views
23:25

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

Action Bars - Custom Themes
16:30

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!

Toolbars
21:23

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

Nav Drawers - Part 1
28:43

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

Nav Drawers - Part 2
31:13
+
Top Level Navigation and Profile Activity
10 Lectures 03:42:30

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

[App 06] - Integrating Toolbars
16:50

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

[App 07] - Nav Drawer Integration Stub
25:18

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

[App 08] - Nav Drawer Implementation
22:55

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

[App 09] - Nav Drawer Layouts
22:31

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 10] - Nav Drawer Fix and Top Level Activities
22:29

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

[App 11] - Top Level Activity Animations
14:15

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

[App 12] - Profile - Layout
24:19

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 13] - Profile - Choosing Images
32:24

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 14] - Profile - Editing Fields
23:17

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

[App 15] - Profile - Change Password Dialog
18:12
+
Event Bus and Service Layer
9 Lectures 03:24:10

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

Preview 22:09

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

[App 16] - Service Layer - Adding Otto
26:26

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

[App 17] - Service Layer - Handling Events
26:29

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 18] - Service Layer - In Memory Service Intro
19:03

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 19] - Service Layer - In Memory Service Base
22:06

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 20] - Login and Register API Calls
25:39

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

[App 21] - Fake Login and Register API
13:00

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

[App 22] - Finishing our Login and Register Activities
28:52

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.

[App 23] - Auto Login
20:26
+
List Views
6 Lectures 02:41:57

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

Preview 21:25

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

Preview 24:07

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.

Preview 26:12

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

List Views - Selecting Items
19:16

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

List Views - Select Items Part 2
24:55

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

List Views - Contextual Action Bar
46:02
+
Contact Activities
14 Lectures 05:21:45

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

[App 24] - Contacts Activity - API
26:45

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

[App 25] - Contacts Activity - Stubs
10:13

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

[App 26] - Action Scheduler
20:44

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

[App 27] - Contacts Activity
27:32

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

[App 28] - Activity Lifecycle Bus Bug
08:05

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

[App 29] - Pending Contact Requests
26:09

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

[App 30] - Contact List
25:27

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

Recycler View - Crash Course
31:19

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

[App 31] - Messages Recyclerview Adapter
22:40

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 32] - Sent Messages Activity
23:44

In this video, we implement our contact activity.

[App 33] - Contact Activity
26:01

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

[App 34] - Add Contact Activity
35:55

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

[App 35] - Serialization in Android - Parcelable
24:42

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

[App 36] - Select Contact Activity
12:29
+
Camera API and Send Message Activity
5 Lectures 01:56:30

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

[App 37] - Camera Preview
34:34

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 38] - New Message Activity
31:15

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

[App 39] - Send Message API
10:17

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

[App 40] - Send Message Layout
23:19

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

[App 41] - Finishing our Send Message Activity
17:05
+
Inbox and Message Display Activities
7 Lectures 02:31:26

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

[App 42] - Quick Tweaks
15:01

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

[App 43] - Service Layer Tweaks
26:06

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

[App 44] - Main Activity - Part 1 - Supporting Code
19:18

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

[App 45] - Main Activity - Part 2 - Implementation
14:47

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

[App 46] - Main Activity - Part 3 - Inbox Adapter
26:23

This video finishes off the Main Activity.

[App 47] - Main Activity - Part 4 - Wrapping Up
13:10

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

[App 48] - Message Activity
36:41
+
Hooking up the Live Web API
5 Lectures 02:11:12

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

Preview 33:26

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

[App 49] - Live Services Infrastructure
34:13

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 50] - Live Service - Account
37:30

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

[App 51] - Live Service - Contacts
11:14

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

[App 52] - Live Service - Messages
14:49
1 More Section
About the Instructor
3D BUZZ Programming and Digital Art training
4.4 Average rating
3,331 Reviews
54,959 Students
17 Courses

3D Buzz is a company dedicated to providing the world with quality technical education over 3D animation, programming, game design, and much more. We have been producing training videos since 2001, always pushing the envelope in the development of informative lessons with an engaging and personable format. We try to make the viewer feel more like they're involved in a classroom discussion with an energetic teacher as opposed to being stuck in a dry, uninspired, run-of-the-mill training video.

But 3D Buzz is so much more than just training videos. We maintain one of the most helpful online communities on the internet. We do our very best to keep in close contact with our community, and to make sure that when you're here, you feel at home.