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!
******** 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.
This video covers the course, how to use the source code, and what we will be building!
This video shows how to get a complete Android development environment setup and ready to go!
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.
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.
This video covers the new Android build system - showing how to use it from the command line to build and deploy applications.
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.
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.
This video looks more in depth into activities, how Android Studio organizes our project, resources, layout XML files, and working with linear layouts.
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.
This video introduces the very important and flexible relative view group.
Continuing our discussions about views, we talk in this video about how to include layouts in one another.
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.
We continue our discussion of activity lifecycle by talking about how activities can communicate between each other in a robust manner.
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.
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
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.