Shape Shape point chapter-list Group Group Group Group Group Shape Copy 12 Group Group Shape Shape Copy 3 Shape Shape dropdown editor editor Combined Shape grid Shape Copy 4 Shape Copy 7 Shape language language Shape megaphone paperback Shape platform noun_419259-2 copy play-icon Group BS-Question-Rounded-Circle quotes noun_610406 stacked-books-1 stacked-books-2 Group Group Group Group Group Group Group Group Group Group Group Path
The Android Avalanche Bundle is only available until Friday, March 30!

Android Avalanche Bundle

  • Platform Android4.4+
  • Language Kotlin1.2
  • Editor AndroidStudio 3
Introductory Bundle ($99.99 + $19.99/mo) $129.97

Includes two full-length digital edition books, 8 full-length courses with over 600 minutes of video to take you from novice coder to experienced Android developer—plus your first month’s video subscription to our site is free.

Already a subscriber?

You can get both books in this package for just $79.99 (that’s a value of $109.98!) You’ll also enjoy the complete set of Android video courses as part of your current subscription.

Comparing bundles

Existing Subscriber Bundle $79.99 The Android Avalanche Existing Subscriber Bundle is a book-only package for existing subscribers, as our way of saying "thanks" for supporting our site!
Introductory Bundle $99.99 The Android Avalanche Introductory Bundle is our special introductory package for non-subscribers, and gives you a free first month to all of our iOS and Android video courses.
Android Apprentice
Kotlin Apprentice Monthly Subscription
Existing subscribers already have access
First month free, continues at $19.99/month

What's included

Android Apprentice


Getting Set Up With Android Studio

To begin creating that killer Android App, you’ll need some guidance on how to install the tools you’ll need as a young apprentice. Android development takes place inside Android Studio, a customized IDE based on IntelliJ that gives you a powerful set of tools to work with.



If bricks and mortar are the foundation of a sturdy building, then Layouts are the Android equivalent of a sturdy app. Layouts are incredibly flexible and let you define how your user interface is presented on the device to the user.



Android apps are built around a set of screens that have a specific purpose. Each screen you see in an app is known as an Activity. An Activity is built around a single task that you want your user to perform.



In the previous two chapters, you focused on developing TimeFighter into a fully-fledged app. In this chapter, you’ll focus on how to debug your app when it begins to exhibit bugs.


Prettifying the App

In this final chapter, you’ll learn how to adjust your app to adhere to the Material Design Guidelines, how to add some small touches to give your app that "polished" feeling, and how to add a simple animation to your app to give it some life.


Creating a New Project

In the previous section, you had a starter project to begin building your app. But in this section, you’re going to create your own project from scratch! You’ll go through the steps and choices given to you to ensure your project is set up right from the very start.



In Android development, the simplest way to implement lists in your app is to use a class named RecyclerView. You’ll how to get started with RecyclerView, how to set up a RecyclerView Adapter to populate your list with data, and how to set up a ViewHolder to handle the layout of each item in your list.



In this chapter, you’ll add functionality to ListMaker to create, save, and delete lists. You’ll learn what SharedPreferences are and how you can use them to save and retrieve user data.


Communicating Between Activities

As your app gets more complex, trying to cram more visual elements into a single screen becomes difficult, and can make your app confusing for users. In this chapter, you’ll learn how to create separate Activites, how to communicate between Activities using an Intent, and how to pass data between Activities.


Completing the Detail View

In this chapter, you’re going to build up the Activity you created in the previous chapter with familiar components such as a RecyclerView to display the list, and add a FloatingActionButton to add tasks to the list. You’ll also learn how to communicate back to the previous Activity using an Intent.


Using Fragments to Expand UI

When it comes to coding an appealing user interface that adapts across all Android devices with varying screen sizes, things can get tricky! Although you won’t be building an app for a fridge just yet (give it time), in this chapter you’ll learn what Fragments are and how they work with Activities and how to split up Activities into Fragments.


Material Design

Material Design is a design language that aims to standardize how a user interacts with an app. This ranges from everything to button clicks, to widget presentation and positioning, even to animation within the app. In this chapter, you’ll update ListMaker so it adopts some Material Design principles.


Creating a Map Based App

Have you ever been on a road trip and wanted to makes notes about places you’ve visited? Or needed to warn your future self about some heartburn-inducing greasy food from a roadside diner? If so, then you’re in luck! You’re about to build PlaceBook, an app that meets all of those needs by letting you bookmark and make notes using a map-based interface.


User Location and Permissions

In this chapter, you’ll tighten up the map experience by automatically centering the map on the user’s location at startup, and allowing the user to recenter the map to their current location at any time.


Google Places

Before you can achieve your ultimate goal of allowing users to bookmark places, you need to let them identify existing places on the map. In this chapter, you'll learn how to identify when a user taps on a place and use the Google Places API to retrieve detailed information about the place.


Saving Bookmarks with Room

Now that the user can tap on places to get an info window pop-up, it’s time to give them a way to bookmark and edit a place. You’ll learn about the Room Persistence Library and how it fits into the overall Android Component Architecture.


Detail Activity

In this chapter you'll add the ability to edit bookmarks. This will involve creating a new activity to display the bookmark details with editable fields.


Navigation and Photos

Currently, the only way to find an existing bookmark is to locate its pin on the map. In this chapter, you’ll add the ability to navigate directly to bookmarks, and you’ll replace the photo for a bookmark.


Finishing Touches

In this chapter you’ll add some finishing touches that improve both the look and usability of the PlaceBook app. Even though PlaceBook is perfectly functional as-is, it’s often the little touches that make an app go from good to great.



In this section, you’re going to use many of the skills you’ve already learned and dive into some more advanced areas of Android development. You’ll build a full-featured Podcast manager and player app named PodPlay. This app will allow searching and subscribing to podcasts from iTunes and provide a playback interface with speed controls.


Finding Podcasts

Creating a search interface can be as simple as adding a text view, responding to the user entering text, and populating a RecyclerView with the results. While this method works fine, the Android SDK provides a built-in search feature that helps future-proof your apps.


Podcast Details

Now that the user can find their favorite podcasts, you’re ready to add a podcast detail screen. In this chapter, you’ll design and build the podcast detail fragment, expand on the app architecture, and add a podcast detail fragment.


Podcast Episodes

Until this point, you’ve only dealt with the top-level podcast details. Now it’s time to dive deeper into the podcast episode details, and that involves loading and parsing the RSS feeds.


Podcast Subscriptions I

By giving users the ability to search for podcasts and displaying the podcast episodes, you made great progress in the development of the podcast app. In this section, you’ll add the ability to subscribe to favorite podcasts.


Podcast Subscriptions II

Now that the user can subscribe to podcasts, it’s helpful to notify them when new episodes are available. In this chapter, you’ll update the app to periodically check for new episodes in the background and post a notification if any are found.


Podcast Playback

So far, you’ve built a decent podcast management app — too bad there’s no way to listen to content. In this chapter, you’ll learn how to build a media player that plays audio and video podcasts, and integrates into the Android ecosystem.


Episode Player

In the last chapter, you succeeded in adding audio playback to the app, but you stopped short of adding any built-in playback features. In this final chapter of this section, you’ll finish up the PodPlay app by adding a full playback interface and support for videos.


Android Fragmentation and Libraries

In a perfect world, every Android device would run a single version of Android and app development would be easy. Sadly, the world isn’t perfect. As of May 2017, there were two billion active Android devices around the world, all running various versions and flavors of Android. This chapter explores the history of Android versions, and how developers can target as many versions of Android as possible.


Keeping Your App Up To Date

The more you commit to your app, the more value your users will see in the product. Keeping your app up-to-date is an incentive to growing that important group of users. Publishing an app is an achievement, but supporting an app over the years to come is an even greater achievement.


Preparing for Release

So you finally built that app you’ve been dreaming about. Now it’s time to share it with the world! But where do you start? Although this chapter will focus primarily on preparing the app for the Google Play store, most of the steps will apply regardless of the publishing platform.


Testing and Publishing

In this chapter, you’ll complete the app publishing process and discover additional ways to distribute your app. You’ll also go through the Alpha and Beta testing process to make sure your app is ready to share with the world.

Kotlin Apprentice


Coding Essentials and your IDE

Get a quick-start introduction to Kotlin and how to use Intellij IDEA to work with the projects through this book.


Expressions, Variables & Constants

This is it, your whirlwind introduction to the world of programming! You’ll begin with an overview of computers and programming, and then spend your time working with code comments, arithmetic operations, constants and variables.


Types & Operations

You’ll learn about handling different types, including strings which allow you to represent text. You’ll learn about converting between types and you’ll also be introduced to type inference which makes your life as a programmer a lot simpler.


Basic Control Flow

You’ll learn how to make decisions and repeat tasks in your programs by using syntax to control the flow. You’ll also learn about Booleans, which represent true and false values, and how you can use these to compare data.


Advanced Control Flow

Continuing the theme of code not running in a straight line, you’ll learn about another loop known as the `for` loop. You’ll also learn about when expressions which are particularly powerful in Kotlin.



Functions are the basic building blocks you use to structure your code in Kotlin. You’ll learn how to define functions to group your code into reusable units.



Many programming languages suffer from the "billion dollar mistake" of null values. You'll learn about how Kotlin protects you from the dreaded null pointer exception.


Arrays and Lists

Arrays and lists are the most common collection types you’ll run into in Kotlin. They both are typed like regular variables and constants, and store multiple values in a single data structure. See how to iterate through arrays and lists and how to modify their contents.


Maps and Sets

Maps are useful when you want to look up values by means of an identifier. For example, the table of contents of this book maps chapter names to their page numbers, making it easy to skip to the chapter you want to read. With an array, you can only fetch a value by its index, which has to be an integer, and all indexes have to be sequential. In a map, the keys can be of any type and are generally in no particular order. You'll also learn about Sets, which let you store unique values in a collection.



A previous chapter taught you about functions. But Kotlin has another construct you can use to break up code into reusable chunks: lambdas. These have many uses, and become particularly useful when dealing with collections such as a list or map.



In this chapter, you’ll get acquainted with classes, which are are named types. Classes are one of the cornerstones of object-oriented programming, a style of programming where the types have both data and behavior. In classes, data takes the form of properties and behavior is implemented using functions called methods.



Kotlin has a special keyword object that makes it easy to follow the Singleton pattern in your projects, and that is also used to create properties specific to a class and not its instances. You also use the keyword to create anonymouse classes.



In this chapter, you’ll learn more about Kotlin properties, along with some tricks to deal with properties, how to monitor changes in a property’s value and how to delay initialization of a property.



Methods are merely functions that reside in a class. In this chapter, you’ll take a closer look at methods and see how to add methods onto classes that were created by someone else.



Classes are used when you want to create types that contain both state and behavior. When you need a type that allows primarily the specification of behavior, you're better off using an interface. See how to create and use interfaces.


Advanced Classes

Having seen the basics of creating classes, in this chapter you'll see the more advanced aspects of object-oriented programing, including inheritance and limiting member visibility.


Enum classes

Enumerations are useful when you have a quantity that can take on a finite set of discrete values. See how to define and use enum classes and see some examples of working with enum classes and when expressions.



At some point you will need to ability to create abstractions that go beyond what's available in regular classes and functions. You'll learn how to use generics to super-power your classes and functions.


Kotlin/Java Interoperability

Kotlin was designed from the start to be 100% compatible with Java and the Java ecosystem. See how to work with Kotlin and Java together in a single project and how to call back and forth between the two.



No software is immune to error conditions. See how to use exceptions in Kotlin to provide some control over when and how errors are handled.


Functional Programming

Kotlin goes beyond just being an object-oriented programming language, and provides many of the constructs found in the domain of functional programming. See how to treat functions as first-class citizens by learning how to use functions as parameters and return values from other functions.


Conventions and Operator Overloading

You'll learn the concept of conventions and see how to use conventions to implement operator overloading and write more concise but still readable code.


Kotlin Coroutines

Kotlin coroutines allow you to simplify your asynchrounous code and make it much more readable. You'll learn the difference between threads and coroutines and see examples of coroutines in use.


Scripting with Kotlin

Kotlin is not just useful on Android or the JVM, but also can be used for scripting at the command line. See how to use Kotlin as a scripting language.

Meet the authors

Joe Howard Android Team Lead
Richard Lucas Android Team
Irina Galata Android Team
Ellen Shapiro Android Team
Darryl Bayliss Android Team
Tom Blankenship Android Team