All Lessons Combined

Android
Development
with Kotlin
Android Development with Kotlin v1.0 This work is licensed under the Apache 2 license. 1
About this course
Android Development with Kotlin This work is licensed under the Apache 2 license. 2
Prerequisites
● Experience in an object-oriented programming language

● Comfortable using an IDE
● Familiar with using GitHub
● Access to a computer and internet connection
● (Optional) Android device and USB cable
What you'll learn
● How to build a variety of Android

apps in Kotlin
● Kotlin language essentials
● Best practices for app development
● Resources to keep learning
The opportunity
● Mobile devices are becoming increasingly
commonplace
● Mobile apps connect users to information
and services that can improve their quality of
life
● Many industries have yet to be revolutionized
through mobile, and offer great opportunities
for new businesses and solutions
Android
● Open-source mobile platform

● 11 major platform releases so far
● 2.5 billion monthly active Android devices
● 2+ billion monthly active Google Play users
Available across different form factors
Build Android apps in Kotlin
Kotlin
A modern programming language

that helps developers be more
productive.
Benefits of Kotlin
● Expressive and concise

● Safer code
● Interoperable
● Structured Concurrency
Idiomatic Kotlin
● Kotlin is at its best when used idiomatically

● Avoid just translating Java into Kotlin
● As you learn more Kotlin, you'll find easier, more concise ways
to do things
● For a list of common Kotlin idioms, refer to the Kotlin Language
Guide on Idioms
Learning experience
Course structure
4 units with a total of 13 lessons across 13 weeks
Unit 1 (3 weeks) Unit 2 (3 weeks) Unit 3 (6 weeks) Unit 4 (1 week)
Get Started with Introduction to Android App App Design

Kotlin Android Architecture
Basics, Functions, First App, Layouts, App Architecture, Data App UI Design
Classes & Objects, Navigation Persistence, Display
Extensions Lists, Connect to
Internet, Background
Work
Lectures
We’ll cover important topics together as a class.
Learning pathways
After each class, complete

the corresponding learning
pathway with articles and
codelabs to practice what
you learned.
Accessing the pathways
Pathway
Codelab
Earn badges for your developer profile
What you need
To work through the Kotlin and Android examples in the Android
Development with Kotlin labs you'll need to install the following software
on your computer:
● Java Development Kit
● Java Runtime Engine (Windows only)
● IntelliJ IDEA
● Android Studio
Resources
Kotlin resources
● Learn Kotlin for a list of official reference materials

● Kotlin Language Documentation (downloadable PDF)
● Kotlin Koans for more snippets to practice with
● Coding Conventions for a coding style guide for the Kotlin language
● Learn Kotlin by Example for a set of small and simple annotated
examples
Android and other resources
● Official Android developer website
● Android Developers Blog
● Android Developers Medium blog
● Android Developers YouTube channel
● @AndroidDev on Twitter
● Android Developer Newsletter
● Stack Overflow
● Offline documentation through SDK Manager
Lesson 1:
Kotlin basics
About this lesson
Lesson 1: Kotlin basics
○ Get started
○ Operators
○ Data types
○ Variables
○ Conditionals
○ Lists and arrays
○ Null safety
○ Summary
Get started
Open IntelliJ IDEA
Create a new project
Name the project
Open REPL (Read-Eval-Print-Loop)
It may take a few

moments before the
Kotlin menu appears
under Tools.
Create a printHello() function
Press Control+Enter
(Command+Enter on
a Mac) to execute.
Operators
Operators
● Mathematical operators
● Increment and decrement operators
● Comparison operators
● Assignment operator
● Equality operators
Math operators with integers
Math operators with doubles
Math operators
⇒ ⇒
⇒ indicates output
⇒ ⇒ from your code.
Result includes the

type (kotlin.Int).
⇒
Numeric operator methods
Kotlin keeps numbers as primitives, but lets you call methods on numbers
as if they were objects.
Data types
Integer types
Type Bits Notes
Long 64 From -263 to 263-1
Int 32 From -231 to 231-1
Short 16 From -32768 to 32767
Byte 8 From -128 to 127
Floating-point and other numeric types
Type Bits Notes
Double 64 16 - 17 significant digits

Float 32 6 - 7 significant digits
Char 16 16-bit Unicode character
Boolean 8 True or false. Operations include:

- lazy disjunction, - lazy conjunction,
- negation
Operand types
Results of operations keep the types of the operands
⇒ ⇒
⇒ ⇒
Type casting
Assign an Int to a Byte
⇒
Convert Int to Byte with casting
Underscores for long numbers
Use underscores to make long numeric constants more readable.
Strings
Strings are any sequence of characters enclosed by double quotes.
String literals can contain escape characters
Or any arbitrary text delimited by a triple quote (""")
String concatenation
String templates
A template expression starts with a dollar sign ($) and can be a simple value:
Or an expression inside curly braces:
String template expressions
Variables
Variables
● Powerful type inference

● Let the compiler infer the type
● You can explicitly declare the type if needed
● Mutable and immutable variables
● Immutability not enforced, but recommended
Kotlin is a statically-typed language. The type is resolved at compile time and

never changes.
Specifying the variable type
Colon Notation
Important: Once a type has been assigned by you or the compiler, you can't
change the type or you get an error.
Mutable and immutable variables
● Mutable (Changeable)
● Immutable (Unchangeable)
Although not strictly enforced, using immutable variables is recommended in

most cases.
var and val
Conditionals
Control flow
Kotlin features several ways to implement conditional logic:

● If/Else statements
● When statements
● For loops
● While loops
if/else statements
if statement with multiple cases
Ranges
● Data type containing a span of comparable values (e.g.,

integers from 1 to 100 inclusive)
● Ranges are bounded
● Objects within a range can be mutable or immutable
Ranges in if/else statements
Note: There are no spaces around the "range to" operator (1..100)
when statement
As well as a when statement, you can also define a when expression that
provides a return value.
for loops
You don’t need to define an iterator variable and increment it for each pass.
for loops: elements and indexes
for loops: step sizes and ranges
⇒
for (i in 3..6 step 2) print(i)
⇒
for (i in 'd'..'g') print (i)

⇒
while loops
var bicycles = 0
while (bicycles < 50) {
bicycles++
}
println("$bicycles bicycles in the bicycle rack\n")
⇒
do {
bicycles--
} while (bicycles > 50)
println("$bicycles bicycles in the bicycle rack\n")
⇒
repeat loops
Lists and arrays
Lists
● Lists are ordered collections of elements

● List elements can be accessed programmatically through their
indices
● Elements can occur more than once in a list
An example of a list is a sentence: it's a group of words, their order is important,

and they can repeat.
Immutable list using listOf()
Declare a list using and print it out.
⇒ [trumpet, piano, violin]
Mutable list using mutableListOf()
Lists can be changed using mutableListOf()
With a list defined with val, you can't change which list the variable refers to, but
you can still change the contents of the list.
Arrays
● Arrays store multiple items
● Array elements can be accessed programmatically through

their indices
● Array elements are mutable

● Array size is fixed
Array using arrayOf()
An array of strings can be created using arrayOf()
With an array defined with val, you can't change which array the variable refers
to, but you can still change the contents of the array.
Arrays with mixed or single types
An array can contain different types.
An array can also contain just one type (integers in this case).
Combining arrays
Use the + operator.
Null safety
Null safety
● In Kotlin, variables cannot be null by default

● You can explicitly assign a variable to null using the safe call
operator
● Allow null-pointer exceptions using the !! operator
● You can test for null using the elvis (?:) operator
Variables cannot be null
In Kotlin, null variables are not allowed by default.
Declare an Int and assign null to it.
Safe call operator
The safe call operator (?), after the type indicates that a variable can be null.
Declare an Int? as nullable
In general, do not set a variable to null as it may have unwanted consequences.
Testing for null
Check whether the numberOfBooks variable is not null. Then decrement that
variable.
Now look at the Kotlin way of writing it, using the safe call operator.
The !! operator
If you’re certain a variable won’t be null, use !! to force the variable into a
non-null type. Then you can call methods/properties on it.
throws NullPointerException if s is null
Warning: Because !! will throw an exception, it should only be used when it

would be exceptional to hold a null value.
Elvis operator
Chain null tests with the ?: operator.
The ?: operator is sometimes called the "Elvis operator," because it's like a smiley
on its side with a pompadour hairstyle, like Elvis Presley styled his hair.
Summary
Summary
In Lesson 1, you learned how to:
● Create an IntelliJ IDEA project, opening REPL, and execute a function
● Use operators and numeric operator methods
● Use data types, type casting, strings, and string templates
● Use variables and type inference, and mutable and immutable
variables
● Use conditionals, control flow, and looping structures
● Use lists and arrays
● Use Kotlin's null safety features
Pathway
Practice what you’ve learned by

completing the pathway:
Lesson 1: Kotlin basics
Lesson 2:
Functions
About this lesson
Lesson 2: Functions
○ Programs in Kotlin
○ (Almost) Everything has a value
○ Functions in Kotlin
○ Compact functions
○ Lambdas and higher-order functions
○ List filters
○ Summary
Programs in Kotlin
Setting up
Before you can write code and run programs, you need to:
● Create a file in your project

● Create a main() function
● Pass arguments to main()(Optional)
● Use any passed arguments in function calls (Optional)
● Run your program
Create a new Kotlin file
In IntelliJ IDEA's Project pane, under Hello World, right-click the src folder.
● Select New > Kotlin File/Class.
● Select File, name the file Hello, and press Enter.
Create a Kotlin file
You should now see a file in the src folder called Hello.kt.
Create a main() function
main() is the entry point for execution for a Kotlin program.
In the Hello.kt file:
The args in the main() function are optional.
Run your Kotlin program
To run your program, click the Run icon ( ) to the left of the main() function.
IntelliJ IDEA runs the program, and displays the results in the console.
Pass arguments to main()
Select Run > Edit Configurations to open the Run/Debug Configurations window.
Use arguments in
Use args[0] to access the first input argument passed to main().
(Almost) Everything has a value
(Almost) Everything is an expression
In Kotlin, almost everything is an expression and has a value. Even an if

expression has a value.
Expression values
Sometimes, that value is kotlin.Unit.
Functions in Kotlin
About functions
● A block of code that performs a specific task
● Breaks a large program into smaller modular chunks
● Declared using the fun keyword
● Can take arguments with either named or default values
15
Android Development with Kotlin This work is licensed under the Apache 2 license.
Parts of a function
Earlier, you created a simple function that printed "Hello World".
Unit returning functions
If a function does not return any useful value, its return type is Unit.
Unit is a type with only one value: Unit.
Unit returning functions
The Unit return type declaration is optional.
is equivalent to:
Function arguments
Functions may have:
● Default parameters
● Required parameters
● Named arguments
Default parameters
Default values provide a fallback if no parameter value is passed.
Use "=" after the type

to define default values
⇒
⇒
⇒
Required parameters
If no default is specified for a parameter, the corresponding argument is required.
Required parameters
Default versus required parameters
Functions can have a mix of default and required parameters.
Has default value
Pass in required arguments.
Named arguments
To improve readability, use named arguments for required arguments.
It's considered good style to put default arguments after positional arguments,
that way callers only have to specify the required arguments.
Compact functions
Single-expression functions
Compact functions, or single-expression functions, make your code more concise

and readable.
Complete version
Compact version
Lambdas and higher-order
functions
Kotlin functions are first-class
● Kotlin functions can be stored in variables and data structures
● They can be passed as arguments to, and returned from, other

higher-order functions
● You can use higher-order functions to create new "built-in"

functions
Lambda functions
A lambda is an expression that makes a function that has no name.
Parameter and type

Function arrow
⇒ Code to execute
Syntax for function types
Kotlin's syntax for function types is closely related to its syntax for lambdas.
Declare a variable that holds a function.
Variable name Data type of variable Function

(function type)
Higher-order functions
Higher-order functions take functions as parameters, or return a function.
The body of the code calls the function that was passed as the second argument,
and passes the first argument along to it.
Higher-order functions
To call this function, pass it a string and a function.
Using a function type separates its implementation from its usage.
Passing a function reference
Use the :: operator to pass a named function as an argument to another function.
Passing a named function,

not a lambda
The :: operator lets Kotlin know that you are passing the function reference as an
argument, and not trying to call the function.
Last parameter call syntax
Kotlin prefers that any parameter that takes a function is the last parameter.
You can pass a lambda as a function parameter without putting it inside the
parentheses.
Using higher-order functions
Many Kotlin built-in functions are defined using last parameter call syntax.
List filters
List filters
Get part of a list based on some condition
red red-orange dark red orange bright orange saffron
Apply filter() on list

Condition: element contains “red”
red red-orange dark red
Iterating through lists
If a function literal has only one parameter, you can omit its declaration and the
"->". The parameter is implicitly declared under the name it.
Filter iterates through a collection, where it is the value of the element during the
iteration. This is equivalent to:
OR
List filters
The filter condition in curly braces {} tests each item as the filter loops through.
If the expression returns true, the item is included.
Eager and lazy filters
Evaluation of expressions in lists:
● Eager: occurs regardless of whether the result is ever used
● Lazy: occurs only if necessary at runtime
Lazy evaluation of lists is useful if you don't need the entire result, or if the list is
exceptionally large and multiple copies wouldn't wouldn't fit into RAM.
Eager filters
Filters are eager by default. A new list is created each time you use a filter.
Lazy filters
Sequences are data structures that use lazy evaluation, and can be used with
filters to make them lazy.
Sequences -> lists
Sequences can be turned back into lists using toList().
Other list transformations
● map() performs the same transform on every item and returns the list.
● flatten() returns a single list of all the elements of nested collections.
Summary
Summary
● Create a file and a main() function in your project, and run a program
● Pass arguments to the main() function
● Use the returned value of an expression
● Use default arguments to replace multiple versions of a function
● Use compact functions, to make code more readable
● Use lambdas and higher-order functions
● Use eager and lazy list filters
Pathway

Lesson 2: Functions
Lesson 3:
Classes and
objects
About this lesson
Lesson 3: Classes and objects
○ Classes
○ Inheritance
○ Extension functions
○ Special classes
○ Organizing your code
○ Summary
Classes
Class
Object
● Classes are blueprints for objects
instances
● Classes define methods that operate
on their object instances
Class
Class versus object instance
House Class Object Instances
Data
● House color (String)
● Number of windows (Int)
● Is for sale (Boolean)
Behavior
● updateColor()
● putOnSale() FOR SALE
Define and use a class
Class Definition Create New Object Instance
Constructors
When a constructor is defined in the class header, it can contain:
● No parameters
class A
● Parameters
○ Not marked with var or val → copy exists only within scope of the
constructor
class B(x: Int)
○ Marked var or val → copy exists in all instances of the class
class C(val y: Int)
Constructor examples
Default parameters
Class instances can have default values.
● Use default values to reduce the number of constructors needed
● Default parameters can be mixed with required parameters
● More concise (don’t need to have multiple constructor versions)
Primary constructor
Declare the primary constructor within the class header.
This is technically equivalent to:
Initializer block
● Any required initialization code is run in a special init block

● Multiple init blocks are allowed
● init blocks become the body of the primary constructor
Initializer block example
Use the init keyword:
Multiple constructors
● Use the constructor keyword to define secondary constructors

● Secondary constructors must call:
○ The primary constructor using this keyword
OR
○ Another secondary constructor that calls the primary constructor

● Secondary constructor body is not required
Multiple constructors example
Properties
● Define properties in a class using val or var

● Access these properties using
dot . notation with property name
● Set these properties using
dot . notation with property name (only if declared a var)
Person class with name property
Access with <property name>

Set with <property name>
Custom getters and setters
If you don’t want the default get/set behavior:
● Override get() for a property

● Override set() for a property (if defined as a var)
Format:
Custom getter
Custom setter
Member functions
● Classes can also contain functions

● Declare functions as shown in Functions in Lesson 2
○ fun keyword
○ Can have default or required parameters
○ Specify return type (if not Unit)
Inheritance
Inheritance
● Kotlin has single-parent class inheritance

● Each class has exactly one parent class, called a superclass
● Each subclass inherits all members of its superclass including
ones that the superclass itself has inherited
If you don't want to be limited by only inheriting a single class, you can define an
interface since you can implement as many of those as you want.
Interfaces
● Provide a contract all implementing classes must adhere to
● Can contain method signatures and property names
● Can derive from other interfaces
Format:
Interface example
Extending classes
To extend a class:
● Create a new class that uses an existing class as its core
(subclass)
● Add functionality to a class without creating a new one
(extension functions)
Creating a new class
● Kotlin classes by default are not subclassable
● Use open keyword to allow subclassing
● Properties and functions are redefined with the override

keyword
Classes are final by default
Declare a class
Try to subclass
Use keyword
Use open to declare a class so that it can be subclassed.
Declare a class
Subclass from C
Overriding
● Must use open for properties and methods that can be overridden
(otherwise you get compiler error)
● Must use override when overriding properties and methods
● Something marked override can be overridden in subclasses

(unless marked final)
Abstract classes
● Class is marked as abstract
● Cannot be instantiated, must be subclassed
● Similar to an interface with the added the ability to store state
● Properties and functions marked with abstract must be
overridden
● Can include non-abstract properties and functions
Example abstract classes
abstract class Food {
abstract val kcal : Int
abstract val name : String
fun consume() = println("I'm eating ${name}")
}
class Pizza() : Food() {
override val kcal = 600
override val name = "Pizza"
}
fun main() {
Pizza().consume() // "I'm eating Pizza"
}
When to use each
● Defining a broad spectrum of behavior or types? Consider an interface.
● Will the behavior be specific to that type? Consider a class.
● Need to inherit from multiple classes? Consider refactoring code to see

if some behavior can be isolated into an interface.
● Want to leave some properties / methods abstract to be defined by

subclasses? Consider an abstract class.
● You can extend only one class, but implement one or more interfaces.
Extension functions
Extension functions
Add functions to an existing class that you cannot modify directly.
● Appears as if the implementer added it
● Not actually modifying the existing class
● Cannot access private instance variables
Format:
Why use extension functions?
● Add functionality to classes that are not
● Add functionality to classes you don’t own
● Separate out core API from helper methods for classes you
own
Define extension functions in an easily discoverable place such as in the same file
as the class, or a well-named function.
Extension function example
Add isOdd() to Int class:
Call isOdd() on an Int:
Extension functions are very powerful in Kotlin!
Special classes
Data class
● Special class that exists just to store a set of data
● Mark the class with the data keyword
● Generates getters for each property (and setters for vars too)
● Generates toString(), equals(), hashCode(), copy()

methods, and destructuring operators
Format:
Data class example
Define the data class:
Use the data class:
Data classes make your code much more concise!
Pair and Triple
● Pair and Triple are predefined data classes that store

2 or 3 pieces of data respectively
● Access variables with .first, .second, .third respectively
● Usually named data classes are a better option

(more meaningful names for your use case)
Pair and Triple examples
Pair
Pair's special to variant lets you omit parentheses and periods (infix function).
It allows for more readable code
Also used in collections like Map and HashMap
Enum class
User-defined data type for a set of named values
● Use this to require instances be one of several constant values

● The constant value is, by default, not visible to you
● Use enum before the class keyword
Format: …
Referenced via
Enum class example
Define an enum with red, green, and blue colors.
Object/singleton
● Sometimes you only want one instance of a class to ever exist
● Use the object keyword instead of the class keyword
● Accessed with NameOfObject.<function or variable>
Object/singleton example
Companion objects
● Lets all instances of a class share a single instance of a set of

variables or functions
● Use companion keyword
● Referenced via ClassName.PropertyOrFunction
Companion object example
Organizing your code
Single file, multiple entities
● Kotlin DOES NOT enforce a single entity (class/interface)

per file convention
● You can and should group related structures in the same file
● Be mindful of file length and clutter
Packages
● Provide means for organization
● Identifiers are generally lower case words separated by periods
● Declared in the first non-comment line of code in a file

following the package keyword
package org.example.game
Example class hierarchy
org.example.vehicle
Vehicle
org.example.vehicle.moped org.example.vehicle.car
Moped Car
Moped50cc Sedan
Moped100cc Hatchback
Visibility modifiers
Use visibility modifiers to limit what information you expose.
● public means visible outside the class. Everything is public by default,

including variables and methods of the class.
● private means it will only be visible in that class (or source file if you are
working with functions).
● protected is the same as private, but it will also be visible to any
subclasses.
Summary
Summary
In Lesson 3, you learned about:
● Classes, constructors, and getters and setters
● Inheritance, interfaces, and how to extend classes
● Extension functions
● Special classes: data classes, enums, object/singletons, companion
objects
● Packages
● Visibility modifiers
Pathway

Lesson 3: Classes and objects
Lesson 4:
Build your first
Android app
About this lesson
Lesson 4: Build your first Android app
● Your first app
● Anatomy of an Android app
● Layouts and resources in Android
● Activities
● Make an app interactive
● Gradle: Building an Android app
● Accessibility
● Summary
Android Studio
Official IDE for building Android apps
Your first app
Open Android Studio
Create new project
Enter your project details
Android releases and API levels
Choose API levels for your app
● Minimum SDK: Device needs at least this API level to install

● Target SDK: API version and highest Android version tested
● Compile SDK: Android OS library version compiled with
minSdkVersion <= targetSdkVersion <= compileSdkVersion
The API level identifies the framework API version of the Android SDK.
Tour of Android Studio
Run your app
● Android device (phone, tablet)

● Emulator on your computer
Android Virtual Device (AVD) Manager
Anatomy of an Android App
project
Anatomy of a basic app project
● Activity
● Resources (layout files, images, audio files, themes, and colors)
● Gradle files
Android app project structure
├──
│ ├──
│ └──
│ ├──
│ ├──
│ │ ├──
│ │ ├──
│ │ └──
│ └──
├──
└──
Browse files in Android Studio
Layouts and resources in
Android
Views
● Views are the user interface building blocks in Android

○ Bounded by a rectangular area on the screen
○ Responsible for drawing and event handling
○ Examples: TextView, ImageView, Button
● Can be grouped to form more complex user interfaces
Layout Editor
XML Layouts
You can also edit your layout in XML.

● Android uses XML to specify the layout of user interfaces
(including View attributes)
● Each View in XML corresponds to a class in Kotlin that controls

how that View functions
XML for a TextView
Hello World!
Size of a View
● wrap_content
android:layout_width="wrap_content"
● match_parent
android:layout_width="match_parent"
● Fixed value (use dp units)
android:layout_width="48dp"
ViewGroups
A ViewGroup is a container that determines how views are displayed.
FrameLayout LinearLayout ConstraintLayout
TextView
TextView TextView
TextView TextView
Button
Button
The ViewGroup is the parent and the views inside it are its children.
FrameLayout example
A FrameLayout generally holds a single child View.
TextView
LinearLayout example
● Aligns child views in a row or column
● Set android:orientation to horizontal or vertical
TextView
TextView
Button
View hierarchy
LinearLayout
ImageView
ImageView TextView LinearLayout TextView
Button Button
Button Button
App resources
Static content or additional files that your code uses
● Layout files
● Images
● Audio files
● User interface strings
● App icon
Common resource directories
Add resources to your app by including them in the appropriate resource directory
under the parent res folder.
├──
└──
├──
├──
├──
└──
Resource IDs
● Each resource has a resource ID to access it.
● When naming resources, the convention is to use all lowercase with
underscores (for example, activity_main.xml).
● Android autogenerates a class file named R.java with references to all
resources in the app.
● Individual items are referenced with:
R.<resource_type>.<resource_name>
Examples: R.drawable.ic_launcher (res/drawable/ic_launcher.xml)
R.layout.activity_main (res/layout/activity_main.xml)
Resource IDs for views
Individual views can also have resource IDs.
Add the android:id attribute to the View in XML. Use @+id/name syntax.
Within your app, you can now refer to this specific TextView using:
R.id.helloTextView
Activities
What’s an Activity?
● An Activity is a means for the user to
accomplish one main goal.
● An Android app is composed of one or more
activities.
MainActivity.kt
How an Activity runs
Activity launched
App is running
Activity shut down
Implement the onCreate() callback
Called when the system creates your Activity
Layout inflation
Activity
ViewGroup
Layout files
LayoutInflater View1
layout1 layout2 layout3 ViewGroup
View2 View3
Make an app interactive
Define app behavior in Activity
Modify the Activity so the app responds to user input, such as a button tap.
Modify a View dynamically
Within MainActivity.kt:
Get a reference to the View in the view hierarchy:

val resultTextView: TextView = findViewById(R.id.textView)
Change properties or call methods on the View instance:

resultTextView.text = "Goodbye!"
Set up listeners for specific events
User interacts with a View
An event is fired
Did developer register a callback?
No Yes
Ignore the event Execute the callback
View.OnClickListener
SAM (single abstract method)
Converts a function into an implementation of an interface
Format: InterfaceName { lambda body }
is equivalent to
View.OnClickListener as a SAM
A more concise way to declare a click listener
Late initialization
Lateinit example in Activity
Gradle: Building an
Android app
What is Gradle?
● Builds automation system
● Manages the build cycle via a series of tasks (for example,
compiles Kotlin sources, runs tests, installs app to device)
● Determines the proper order of tasks to run
● Manages dependencies between projects and third-party
libraries
Gradle build file
● Declare plugins
● Define Android properties
● Handle dependencies
● Connect to repositories
Plugins
Provide libraries and infrastructure needed by your app
Android configuration
Dependencies
Repositories
Common Gradle tasks
● Clean
● Tasks
● InstallDebug
Accessibility
Accessibility
● Refers to improving the design and functionality of your

app to make it easier for more people, including those
with disabilities, to use
● Making your app more accessible leads to an overall
better user experience and benefits all your users
Make apps more accessible
● Increase text visibility with foreground and background color
contrast ratio:
○ At least 4.5:1 for small text against the background
○ At least 3.0:1 for large text against the background
● Use large, simple controls
○ Touch target size should be at least 48dp x 48dp
● Describe each UI element
○ Set content description on images and controls
Accessibility Scanner
Tool that scans your screen and suggests

improvements to make your app more
accessible, based on:
● Content labels
● Touch target sizes
● Clickable views
● Text and image contrast
Accessibility Scanner example
Add content labels
● Set contentDescription attribute → read aloud by screen
reader
● Text in TextView already provided to accessibility services,

no additional label needed
No content label needed
● For graphical elements that are purely for decorative

purposes, you can set
android:importantForAccessibility="no"
● Removing unnecessary announcements is better for the user
TalkBack
● Google screen reader included on Android devices

● Provides spoken feedback so you don’t have to look at the
screen to use your device
● Lets you navigate the device using gestures
● Includes braille keyboard for Unified English Braille
TalkBack example
Reads text
aloud as user
navigates the
screen
Switch access
● Allows for controlling the device using one or more switches

instead of the touchscreen
● Scans your app UI and highlights each item until you make a
selection
● Use with external switch, external keyboard, or buttons on the
Android device (e.g., volume buttons)
Android Accessibility Suite
Collection of accessibility apps that help you use
your Android device eyes-free, or with a switch
device. It includes:
● Talkback screen reader

● Switch Access
● Accessibility Menu
● Select to Speak
Accessibility Resources
● Build more accessible apps

● Principles for improving app accessibility
● Basic Android Accessibility codelab
● Material Design best practices on accessibility
Summary
Summary
● Use Views and ViewGroups to build the user interface of your app
● Access resources in your app from
R.<resource_type>.<resource_name>
● Define app behavior in the Activity (for example, register
OnClickListener)
● Use Gradle as the build system to build your app
● Follow best practices to make your apps more accessible
Learn more
● Layouts
● LinearLayout
● Input events overview
● View
● ViewGroup
Pathway

Lesson 4: Build your first Android app
Lesson 5:
Layouts
About this lesson
Lesson 5: Layouts
● Layouts in Android
● ConstraintLayout
● Additional topics for ConstraintLayout
● Data binding
● Displaying lists with RecyclerView
● Summary
Layouts in Android
Android devices
● Android devices come in many
different form factors.
● More and more pixels per inch
are being packed into device
screens.
● Developers need the ability to
specify layout dimensions that
are consistent across devices.
Density-independent pixels (dp)
Use dp when specifying sizes in your layout, such as the width or height of views.
● Density-independent pixels (dp)

take screen density into account.
● Android views are measured in Hello 80dp
density-independent pixels.
● dp = (width in pixels * 160)
160dp
screen density
Screen-density buckets
Density qualifier Description DPI estimate
ldpi (mostly unused) Low density ~120dpi
mdpi (baseline density) Medium density ~160dpi
hdpi High density ~240dpi
xhdpi Extra-high density ~320dpi
xxhdpi Extra-extra-high density ~480dpi
xxxhdpi Extra-extra-extra-high density ~640dpi
Android View rendering cycle
Measure
Layout
Draw
Drawing region
What we see:
How it's drawn:
View margins and padding
View with margin View with margin and padding
View View
View
ConstraintLayout
Deeply nested layouts are costly
● Deeply nested ViewGroups require more computation

● Views may be measured multiple times
● Can cause UI slowdown and lack of responsiveness
Use ConstraintLayout to avoid some of these issues!
What is ConstraintLayout?
● Recommended default layout for Android

● Solves costly issue of too many nested layouts, while
allowing complex behavior
● Position and size views within it using a set of constraints
What is a constraint?
A restriction or limitation on the

properties of a View that the layout
attempts to respect
Relative positioning constraints
Can set up a constraint relative to the parent container
Format: layout_constraint<SourceConstraint>_to<TargetConstraint>Of
Top
Hello!
Baseline
Bottom
Left Hello! Right
Start End
Simple ConstraintLayout example
Layout Editor in Android Studio
You can click and drag to add constraints to a View.
Constraint Widget in Layout Editor
Fixed
Wrap content
Match constraints
Wrap content for width and height
Wrap content for width, fixed height
Center a view horizontally
Use match_constraint
Can’t use match_parent on a child view, use match_constraint instead
Chains
● Let you position views in relation to each other

● Can be linked horizontally or vertically
● Provide much of LinearLayout functionality
Create a Chain in Layout Editor
1. Select the objects you want to be in

the chain.
2. Right-click and select Chains.
3. Create a horizontal or vertical chain.
Chain styles
Adjust space between views with these different chain styles.
Spread Chain
Spread Inside Chain
Weighted Chain
Packed Chain
Additional topics for
ConstraintLayout
Guidelines
● Let you position multiple views relative to a single guide

● Can be vertical or horizontal
● Allow for greater collaboration with design/UX teams
● Aren't drawn on the device
Guidelines in Android Studio
Example Guideline
Creating Guidelines
●
●
●
Groups
● Control the visibility of a set of widgets

● Group visibility can be toggled in code
Example group
Groups app code
Data binding
Current approach: findViewById()
Traverses the View hierarchy each time
MainActivity.kt activity_main.xml
…
…
…
…
Use data binding instead
Bind UI components in your layouts to data sources in your app.
MainActivity.kt activity_main.xml
initialize binding
…
Val binding:ActivityMainBinding
binding.name.text = …
binding.age.text = …
binding.loc.text = …
Modify build.gradle file
Add layout tag
Layout inflation with data binding
Replace this
with this
Data binding layout variables
In MainActivity.kt:
Data binding layout expressions
Displaying lists with
RecyclerView
RecyclerView
● Widget for displaying lists of data

● "Recycles" (reuses) item views to make scrolling more
performant
● Can specify a list item layout for each item in the dataset
● Supports animations and transitions
RecyclerView.Adapter
● Supplies data and layouts that the RecyclerView displays

● A custom Adapter extends from RecyclerView.Adapter and
overrides these three functions:
● getItemCount
● onCreateViewHolder
● onBindViewHolder
View recycling in RecyclerView
Boston, Massachusetts If item is scrolled
offscreen, it isn’t
Chicago, Illinois
destroyed. Item is put in
Mountain View, California a pool to be recycled.
Miami, Florida
Seattle, Washington
Reno, Nevada
onBindViewHolder binds
Nashville, Tennessee the view with the new
values, and then the view
Little Rock, Arkansas gets reinserted in the list.
Add RecyclerView to your layout
Create a list item layout
res/layout/item_view.xml
Create a list adapter
Set the adapter on the RecyclerView
In MainActivity.kt:
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val rv: RecyclerView = findViewById(R.id.rv)

rv.layoutManager = LinearLayoutManager(this)
rv.adapter = MyAdapter(IntRange(0, 100).toList())

}
Summary
Summary
● Specify lengths in dp for your layout
● Work with screen densities for different Android devices
● Render Views to the screen of your app
● Layout views within a ConstraintLayout using constraints
● Simplify getting View references from layout with data binding
● Display a list of text items using a RecyclerView and custom adapter
Learn more
● Pixel density on Android

● Spacing
● Device metrics
● Type scale
● Build a Responsive UI with ConstraintLayout
● Data Binding Library
● Create dynamic lists with RecyclerView
Pathway

Lesson 5: Layouts
Lesson 6:
App navigation
About this lesson
Lesson 6: App navigation
● Multiple activities and intents
● App bar, navigation drawer, and menus
● Fragments
● Navigation in an app
● More custom navigation behavior
● Navigation UI
● Summary
Multiple activities and
intents
Multiple screens in an app
Sometimes app functionality may be separated into multiple screens.
Examples:
● View details of a single item (for example, product in a shopping app)
● Create a new item (for example, new email)
● Show settings for an app
● Access services in other apps (for example, photo gallery or browse
documents)
Intent
Requests an action from another app component, such as another Activity
● An Intent usually has two primary pieces of information:

○ Action to be performed (for example, ACTION_VIEW,
ACTION_EDIT, ACTION_MAIN)
○ Data to operate on (for example, a person’s record in the contacts
database)
● Commonly used to specify a request to transition to another Activity
Explicit intent
● Fulfills a request using a specific component

● Navigates internally to an Activity in your app
● Navigates to a specific third-party app or another app you've
written
Explicit intent examples
Navigate between activities in your app:
Navigate to a specific external app:
Implicit intent
● Provides generic action the app can perform

● Resolved using mapping of the data type and action to known
components
● Allows any app that matches the criteria to handle the request
Implicit intent example
App bar, navigation drawer,
and menus
App bar
Navigation drawer
Menu
Define menu items in XML menu resource (located in res/menu folder)
More menu options
Options menu example
Inflate options menu
Handle menu options selected
Fragments
Fragments for tablet layouts
Fragment
● Represents a behavior or portion of the UI in an activity

("microactivity")
● Must be hosted in an activity
● Lifecycle tied to host activity's lifecycle
● Can be added or removed at runtime
Note about fragments
Use the AndroidX version of the Fragment class.

(androidx.fragment.app.Fragment).
Don't use the platform version of the Fragment class

(android.app.Fragment), which was deprecated.
Navigation within an app
Navigation component
● Collection of libraries and tooling, including an integrated editor, for
creating navigation paths through an app
● Assumes one Activity per graph with many Fragment
destinations
● Consists of three major parts:
○ Navigation graph
○ Navigation Host (NavHost)
○ Navigation Controller (NavController)
Add dependencies
In build.gradle, under dependencies:
Navigation host (NavHost)
Navigation graph
New resource type located in res/navigation
directory
● XML file containing all of your navigation
destinations and actions
● Lists all the (Fragment/Activity) destinations that
can be navigated to
● Lists the associated actions to traverse between
them
● Optionally lists animations for entering or exiting
Navigation Editor in Android Studio
Creating a Fragment
● Extend Fragment class
● Override onCreateView()
● Inflate a layout for the Fragment that you have defined in XML
Specifying Fragment destinations
● Fragment destinations are denoted by the action tag in the

navigation graph.
● Actions can be defined in XML directly or in the Navigation Editor by
dragging from source to destination.
● Autogenerated action IDs take the form of
action_<sourceFragment>_to_<destinationFragment>.
Example fragment destination
Navigation Controller (NavController)
NavController manages UI navigation in a navigation host.

● Specifying a destination path only names the action, but it
doesn’t execute it.
● To follow a path, use NavController.
Example NavController
More custom navigation
behavior
Passing data between destinations
Using Safe Args:
● Ensures arguments have a valid type
● Lets you provide default values
● Generates a <SourceDestination>Directions class with methods for
every action in that destination
● Generates a class to set arguments for every named action
● Generates a <TargetDestination>Args class providing access to the
destination's arguments
Setting up Safe Args
In the project build.gradle file:
In the app's or module's build.gradle file:
Sending data to a Fragment
1. Create arguments the destination fragment will expect.

2. Create action to link from source to destination.
3. Set the arguments in the action method on
<Source>FragmentDirections.
4. Navigate according to that action using the Navigation Controller.
5. Retrieve the arguments in the destination fragment.
Destination arguments
Supported argument types
Type Type Syntax Supports Default Supports Null
app:argType=<type> Values Values
Integer "integer" Yes No
Float "float" Yes No
Long "long" Yes No
Boolean "boolean" Yes ("true" or "false") No
String "string" Yes Yes
Array above type + "[]" Yes (only "@null") Yes
(for example, "string[]" "long[]")
Enum Fully qualified name of the enum Yes No
Resource reference "reference" Yes No
Supported argument types: Custom classes
Type Type Syntax Supports Default Supports Null

app:argType=<type> Values Values
Serializable Fully qualified class name Yes (only "@null") Yes
Parcelable Fully qualified class name Yes (only "@null") Yes
Create action from source to destination
In nav_graph.xml:
Navigating with actions
In InputFragment.kt:
Retrieving Fragment arguments
Navigation UI
Menus revisited
DrawerLayout for navigation drawer
Finish setting up navigation drawer
Connect DrawerLayout to navigation graph:
Set up NavigationView for use with a NavController:
Understanding the back stack
State 1 State 2 State 3
Activity 3
Activity 2 Activity 2 Activity 2
Back stack Back stack Back stack
Fragments and the back stack
State 1 State 2 State 3
Fragment 2
Fragment 1 Fragment 1 Fragment 1
Back stack Back stack Back stack
Summary
Summary
● Use explicit and implicit intents to navigate between Activities
● Structure apps using fragments instead of putting all UI code in the
Activity
● Handle navigation with NavGraph, NavHost, and NavController
● Use Safe Args to pass data between fragment destinations
● Use NavigationUI to hook up top app bar, navigation drawer, and bottom
navigation
● Android keeps a back stack of all the destinations you’ve visited, with
each new destination being pushed onto the stack.
Learn more
● Principles of navigation
● Navigation component
● Pass data between destinations
● NavigationUI
Pathway

Lesson 6: App navigation
Lesson 7:
Activity and
fragment lifecycles
About this lesson
Lesson 7: Activity and fragment lifecycles
● Activity lifecycle
● Logging
● Fragment lifecycle
● Lifecycle-aware components
● Tasks and back stack
● Summary
Activity lifecycle
Why it matters
● Preserve user data and state if:

○ User temporarily leaves app and then returns
○ User is interrupted (for example, a phone call)
○ User rotates device
● Avoid memory leaks and app crashes.
Simplified activity lifecycle
Activity launched
App is running
Activity shut down
Activity lifecycle
Activity launched
Activity running
Activity shut down
Activity states
CREATED
STARTED
RESUMED
Activity is running
PAUSED
STOPPED
DESTROYED
onCreate()
● Activity is created and other initialization work occurs

● You must implement this callback
● Inflate activity UI and perform other app startup logic
onStart()
● Activity becomes visible to the user

● Called after activity:
○ onCreate()
or
○ onRestart() if activity was previously stopped
onResume()
● Activity gains input focus:

○ User can interact with the activity
● Activity stays in resumed state until system triggers activity to
be paused
onPause()
● Activity has lost focus (not in foreground)

● Activity is still visible, but user is not actively interacting with it
● Counterpart to onResume()
onStop()
● Activity is no longer visible to the user

● Release resources that aren’t needed anymore
● Save any persistent state that the user is in the process of
editing so they don’t lose their work
onDestroy()
● Activity is about to be destroyed, which can be caused by:

○ Activity has finished or been dismissed by the user
○ Configuration change
● Perform any final cleanup of resources.
● Don’t rely on this method to save user data (do that earlier)
Summary of activity states
State Callbacks Description
Created onCreate() Activity is being initialized.
Started onStart() Activity is visible to the user.
Resumed onResume() Activity has input focus.
Paused onPause() Activity does not have input focus.
Stopped onStop() Activity is no longer visible.
Destroyed onDestroy() Activity is destroyed.
Save state
User expects UI state to stay the same after a config change or if the app
is terminated when in the background.
● Activity is destroyed and restarted, or app is terminated and activity is
started.
● Store user data needed to reconstruct app and activity Lifecycle
changes:
○ Use Bundle provided by onSaveInstanceState().
○ onCreate() receives the Bundle as an argument when activity
is created again.
Logging
Logging in Android
● Monitor the flow of events or state of your app.
● Use the built-in Log class or third-party library.
● Example Log method call: Log.d(TAG, "Message")
Write logs
Priority level Log method

Verbose Log.v(String, String)
Debug Log.d(String, String)
Info Log.i(String, String)
Warning Log.w(String, String)
Error Log.e(String, String)
Fragment lifecycle
Fragment states
CREATED
STARTED
RESUMED
Fragment is running
PAUSED
STOPPED
DESTROYED
Fragment lifecycle diagram
Fragment is
()
added
Fragment is Fragment is
active destroyed
onAttach()
● Called when a fragment is attached to a context

● Immediately precedes onCreate()
onCreateView()
● Called to create the view hierarchy associated with the

fragment
● Inflate the fragment layout here and return the root view
onViewCreated()
● Called when view hierarchy has already been created

● Perform any remaining initialization here (for example, restore
state from Bundle)
onDestroyView() and onDetach()
● onDestroyView() is called when view hierarchy of fragment

is removed.
● onDetach() is called when fragment is no longer attached to
the host.
Summary of fragment states
State Callbacks Description
Initialized onAttach() Fragment is attached to host.
Created onCreate(), onCreateView(), Fragment is created and layout is being

onViewCreated() initialized.
Started onStart() Fragment is started and visible.
Resumed onResume() Fragment has input focus.
Paused onPause() Fragment no longer has input focus.
Stopped onStop() Fragment is not visible.
Destroyed onDestroyView(), onDestroy(), Fragment is removed from host.

onDetach()
Save fragment state across config changes
Preserve UI state in fragments by storing state in Bundle:

● onSaveInstanceState(outState: Bundle)
Retrieve that data by receiving the Bundle in these fragment

callbacks:
● onCreate()
● onCreateView()
● onViewCreated()
Lifecycle-aware
components
Lifecycle-aware components
Adjust their behavior based on activity or fragment lifecycle

● Use the androidx.lifecycle library
● Lifecycle tracks the lifecycle state of an activity or fragment
○ Holds current lifecycle state
○ Dispatches lifecycle events (when there are state changes)
LifecycleOwner
● Interface that says this class has a lifecycle

● Implementers must implement getLifecycle() method
Examples: Fragment and AppCompatActivity are
implementations of LifecycleOwner
LifecycleObserver
Implement LifecycleObserver interface:
Add the observer to the lifecycle:
Tasks and back stack
Back stack of activities
EmailActivity
Back stack
Add to the back stack
ComposeActivity
EmailActivity
Back stack
Add to the back stack again
AttachFileActivity
ComposeActivity
EmailActivity
Back stack
Tap Back button
AttachFileActivity
popped off the stack
ComposeActivity
EmailActivity
Back stack
Tap Back button again
ComposeActivity
popped off the stack
EmailActivity
Back stack
First destination in the back stack
First
fragment
FirstFragment
Back stack
Add a destination to the back stack
Second
fragment
SecondFragment
FirstFragment
Back stack
Tap Back button
SecondFragment
First
fragment popped off the stack
FirstFragment
Back stack
Another back stack example
ResultFragment
Question3Fragment
Result Question2Fragment
fragment
Question1Fragment
WelcomeFragment
Back stack
Modify Back button behavior
ResultFragment
pop additional destinations Question3Fragment

off the back stack
Welcome Question2Fragment
fragment
Question1Fragment
WelcomeFragment
Back stack
Summary
Summary
● Understand how an activity instance transitions through different lifecycle
states as the user interacts with or leaves your app
● Reserve UI state across configuration changes using a Bundle
● Fragment lifecycle callback methods similar to activity, but with additions
● Use lifecycle-aware components help organize your app code
● Use default or custom back stack behavior
● Use logging to help debug and track the state of the app
Learn more
● Understand the Activity Lifecycle

● Activity class
● Fragments guide and lifecycle
● Fragment class
Pathway

Lesson 7: Activity and Fragment
Lifecycles
Lesson 8:
App architecture
(UI layer)
About this lesson
Lesson 8: App architecture (UI layer)
● Android app architecture
● ViewModel
● Data binding
● LiveData
● Transform LiveData
● Summary
Android app architecture
Avoid short-term hacks
● External factors, such as tight deadlines, can lead to poor

decisions about app design and structure.
● Decisions have consequences for future work (app can be
harder to maintain long-term).
● Need to balance on-time delivery and future maintenance
burden.
Examples of short-term hacks
● Tailoring your app to a specific device

● Blindly copying and pasting code into your files
● Placing all business logic in activity file
● Hardcoding user-facing strings in your code
Why you need good app architecture
● Clearly defines where specific business logic belongs

● Makes it easier for developers to collaborate
● Makes your code easier to test
● Lets you benefit from already-solved problems
● Saves time and reduces technical debt as you extend your app
Android Jetpack
● Android libraries that incorporate best practices and provide

backward compatibility in your apps
● Jetpack comprises the androidx.* package libraries
Separation of concerns
res/layout
UI Controller
(Activity/Fragment) ViewModel
LiveData
Data Layer
Architecture components
● Architecture design patterns, like MVVM and MVI, describe a

loose template for what the structure of your app should be.
● Jetpack architecture components help you design robust,
testable, and maintainable apps.
ViewModel
Gradle: lifecycle extensions
In app/build.gradle file:
ViewModel
● Prepares data for the UI

● Must not reference activity, fragment, or views in view hierarchy
● Scoped to a lifecycle (which activity and fragment have)
● Enables data to survive configuration changes
● Survives as long as the scope is alive
Lifetime of a ViewModel
Kabaddi Kounter
ViewModel class
abstract class ViewModel
Implement a ViewModel
Load and use a ViewModel
Using a ViewModel
Within MainActivity onCreate():
Data binding
ViewModels and data binding
● App architecture without data binding
UI Controller
Views
ViewModel (activity/fragment with
(defined in XML layout)
click listeners)
● ViewModels can work in concert with data binding
Views
ViewModel (defined in XML layout)
Data binding in XML revisited
Specify ViewModels in the data tag of a binding.
Attaching a ViewModel to a data binding
Using a ViewModel from a data binding
In activity_main.xml:
ViewModels and data binding
LiveData
Observer design pattern
● Subject maintains list of observers to notify when state changes.

● Observers receive state changes from subject and execute
appropriate code.
● Observers can be added or removed at any time.
Observer design pattern diagram
Observable
notify observe() notify observe()
Observer Observer
LiveData
● A lifecycle-aware data holder that can be observed
● Wrapper that can be used with any data including lists
(for example, LiveData<Int> holds an Int)
● Often used by ViewModels to hold individual data fields
● Observers (activity or fragment) can be added or removed
○ observe(owner: LifecycleOwner, observer: Observer)
removeObserver(observer: Observer)
LiveData versus MutableLiveData
LiveData<T> MutableLiveData<T>
● getValue() ● getValue()
● postValue(value: T)
● setValue(value: T)
T is the type of data that’s stored in LiveData or MutableLiveData.
Use LiveData in ViewModel
Add an observer on LiveData
Set up click listener to increment ViewModel score:
Create observer to update team A score on screen:
Add the observer onto scoreA LiveData in ViewModel:
Two-way data binding
● We already have two-way binding with ViewModel and

LiveData.
● Binding to LiveData in XML eliminates need for an observer in
code.
Example layout XML
Example Activity
Example ViewModel
Transform LiveData
Manipulating LiveData with transformations
LiveData can be transformed into a new LiveData object.

● map()
● switchMap()
Example LiveData with transformations
Summary
Summary
● Follow good app architecture design, and the separation-of-concerns
principle to make apps more maintainable and reduce technical debt
● Create a ViewModel to hold data separately from a UI controller
● Use ViewModel with data binding to make a responsive UI with less
code
● Use observers to automatically get updates from LiveData
Learn More
● Guide to app architecture

● Android Jetpack
● ViewModel Overview
● Android architecture sample app
● ViewModelProvider
● Lifecycle Aware Data Loading with Architecture Components
● ViewModels and LiveData: Patterns + AntiPatterns
Pathway

Lesson 8: App architecture (UI layer)
Lesson 9:
App architecture
(persistence)
About this lesson
Lesson 9: App architecture (persistence)
● Storing data
● Room persistence library
● Asynchronous programming
● Coroutines
● Testing databases
● Summary
Storing data
Ways to store data in an Android app
● App-specific storage
● Shared storage (files to be shared with other apps)
● Preferences
● Databases
What is a database?
Collection of structured data that can be easily accessed,
searched, and organized, consisting of:
● Tables Example Database
person car
● Rows
_id _id
● Columns name make
age model
email year
5
Structured Query Language (SQL)
Use SQL to access and modify a relational database.
● Create new tables

● Query for data
● Insert new data
● Update data
● Delete data
SQLite in Android
Store data
Your app
SQLite database
Example SQLite commands
Create INSERT INTO colors VALUES ("red", "#FF0000");
Read SELECT * from colors;
Update UPDATE colors SET hex="#DD0000" WHERE name="red";
Delete DELETE FROM colors WHERE name = "red";
Interacting directly with a database
● No compile-time verification of raw SQL queries
● Need lots of boilerplate code to convert between

SQL queries data objects
Room persistence library
Add Gradle dependencies
Room
Rest of the app code
Color("#FF0000", "red")
Room
Colors Data access object Color("#4CAF50", "green")

database
Color("#1155CC", "blue")
ColorValue app
Room
● Entity Color
● DAO ColorDao
● Database ColorDatabase
Color class
Annotations
● Provide extra information to the compiler

@Entity marks entity class, @Dao for DAO, @Database for database
● Can take parameters
@Entity(tableName = "colors")
● Can autogenerate code for you
Entity
Class that maps to a SQLite database table

● @Entity
● @PrimaryKey
● @ColumnInfo
Example entity
colors
Data access object (DAO)
Work with DAO classes instead of accessing database directly:

● Define database interactions in the DAO.
● Declare DAO as an interface or abstract class.
● Room creates DAO implementation at compile time.
● Room verifies all of your DAO queries at compile-time.
Example DAO
Query
Insert
Update
Delete
Create a Room database
● Annotate class with @Database and include list of entities:

@Database(entities = [Color::class], version = 1)
● Declare abstract class that extends RoomDatabase:

abstract class ColorDatabase : RoomDatabase() {
○ Declare abstract method with no args that returns the DAO:

abstract fun colorDao(): ColorDao
Example Room database
Create database instance
Get and use a DAO
Get the DAO from the database:

val colorDao = ColorDatabase.getInstance(application).colorDao()
Create new Color and use DAO to insert it into database:

val newColor = Color(hex = "#6200EE", name = "purple")
colorDao.insert(newColor)
Asynchronous
programming
Long-running tasks
● Download information
● Sync with a server
● Write to a file
● Heavy computation
● Read from, or write to, a database
Need for async programming
● Limited time to do tasks and remain responsive

● Balanced with the need to execute long-running tasks
● Control over how and where tasks are executed
Async programming on Android
● Threading
● Callbacks
● Plus many other options
What is the recommended way?
Coroutines
Coroutines
● Keep your app responsive while managing long-running tasks.

● Simplify asynchronous code in your Android app.
● Write code in sequential way
● Handle exceptions with try/catch block
Benefits of coroutines
● Lightweight
● Fewer memory leaks
● Built-in cancellation support
● Jetpack integration
Suspend functions
● Add suspend modifier

● Must be called by other suspend functions or coroutines
Suspend and resume
● suspend
Pauses execution of current coroutine and saves local variables
● resume
Automatically loads saved state and continues execution from
the point the code was suspended
Example
Add suspend modifier to DAO methods
Control where coroutines run
Dispatcher Description of work Examples of work
Dispatchers.Main UI and nonblocking Updating LiveData, calling

(short) tasks suspend functions
Dispatchers.IO Network and disk tasks Database, file IO
Dispatchers.Default CPU intensive Parsing JSON
withContext
CoroutineScope
Coroutines must run in a CoroutineScope:
● Keeps track of all coroutines started in it (even suspended ones)
● Provides a way to cancel coroutines in a scope
● Provides a bridge between regular functions and coroutines
Examples: GlobalScope
ViewModel has viewModelScope
Lifecycle has lifecycleScope
Start new coroutines
● launch - no result needed
● async - can return a result
ViewModelScope
Example viewModelScope
Testing databases
Testing Android code
● @RunWith(AndroidJUnit4::class)
● @Before
● @After
● @Test
Create test class
Create and close database for each test
In DatabaseTest.kt:
Test insert and retrieve from a database
In DatabaseTest.kt:
Summary
Summary
● Set up and configure a database using the Room library
● Use coroutines for asynchronous programming
● Use coroutines with Room
● Test a database
Learn more
● 7 Pro-tips for Room
● Room Persistence Library
● SQLite Home Page
● Save data using SQLite
● Coroutines Guide
● Dispatchers - kotlinx-coroutines-core
● Coroutines on Android (part I): Getting the background
● Coroutines on Android (part II): Getting started
● Easy Coroutines in Android: viewModelScope
● Kotlin Coroutines 101
Pathway

Lesson 9: App architecture
(persistence)
Lesson 10:
Advanced
RecyclerView
use cases
About this lesson
Lesson 10: Advanced RecyclerView use cases
● RecyclerView recap
● Advanced binding
● Multiple item view types
● Headers
● Grid layout
● Summary
RecyclerView recap
RecyclerView overview
● Widget for displaying lists of data

● "Recycles" (reuses) item views to make scrolling more
performant
● Can specify a list item layout for each item in the dataset
● Supports animations and transitions
View recycling in RecyclerView
Boston, Massachusetts If item is scrolled
offscreen, it isn’t
Chicago, Illinois
destroyed. Item is put in
Mountain View, California a pool to be recycled.
Miami, Florida
Seattle, Washington
Reno, Nevada
onBindViewHolder binds
Nashville, Tennessee the view with the new
values, and then the view
Little Rock, Arkansas gets reinserted in the list.
RecyclerViewDemo app
1
2
3
4
5
6
7
8
9
10
11
12
13
Adapter for RecyclerViewDemo
Functions for RecyclerViewDemo
Set the adapter onto the RecyclerView
In MainActivity.kt:
Make items in the list clickable
In NumberListAdapter.kt:
ListAdapter
● RecyclerView.Adapter
○ Disposes UI data on every update
○ Can be costly and wasteful
● ListAdapter
○ Computes the difference between what is currently shown
and what needs to be shown
○ Changes are calculated on a background thread
Sort using RecyclerView.Adapter
Starting state Ending state
1 1 1
5 2 2
2 3 3
6 4 4
3 5 5
8 deletions 8 insertions 16 actions:
7 6 6
8 deletions
4 7 8 insertions 7
8 8 8
Sort using ListAdapter
Starting state 1 Ending state
5
1 1
2
5 6 2
2 3 3
6 7 4
3 4 5
3 insertions 6 actions:
3 deletions 5 3 insertions
7 6
6 3 deletions
4 7
7
8 8 8
ListAdapter example
DiffUtil.ItemCallback
Determines the transformations needed to translate one list into another

●
●
DiffUtil.ItemCallback example
Advanced binding
ViewHolders and data binding
Using the ViewHolder in a ListAdapter
Binding adapters
Let you map a function to an attribute in your XML
● Override existing framework behavior:

android:text = "foo" → TextView.setText("foo") is called
● Create your own custom attributes:

app:base2Number = "5" → TextView.setBase2Number("5") is called
Custom attribute
Add another TextView in the list item layout that uses a custom attribute:
Example list item
5 101
Add a binding adapter
Declare binding adapter:
Updated RecyclerViewDemo app
Multiple item view types
Add a new item view type
1. Create a new list item layout XML file.
2. Modify underlying adapter to hold the new type.
3. Override getItemViewType in adapter.
4. Create a new ViewHolder class.
5. Add conditional code in onCreateViewHolder and
onBindViewHolder to handle the new type.
Declare new color item layout
New view type
● Adapter should know about two item view types:

○ Item that displays a number
○ Item that displays a color
enum class ITEM_VIEW_TYPE { NUMBER, COLOR }
● Modify getItemViewType() to return the appropriate type (as Int):

override fun getItemViewType(position: Int): Int
Override getItemViewType
Define new ViewHolder
Update onCreateViewHolder()
Update onBindViewHolder()
Headers
Headers Example
Entrees ● 2 item view types:
Burger $5.00 ○ header item
Salad $3.00 Drinks
Sandwich $4.00
○ food menu item
Drinks
Coffee $2.00
Coffee $2.00
Soda $1.00
Grid layout
List versus grid
Specifying a LayoutManager
In MainActivity onCreate(), once you have a reference to the RecyclerView

● Display a list with LinearLayoutManager:
recyclerView.layoutManager = LinearLayoutManager(this)
● Display a grid with GridLayoutManager:

recyclerView.layoutManager = GridLayoutManager(this, 2)
● Use a different layout manager (or create your own)
GridLayoutManager
● Arranges items in a grid as a table of rows and columns.

● Orientation can be vertically or horizontally scrollable.
● By default, each item occupies 1 span.
● You can vary the number of spans an item takes up (span size).
Set span size for an item
Create SpanSizeLookup instance and override getSpanSize(position):
Summary
Summary
● Use ListAdapter to make RecyclerView more efficient at
updating lists
● Create a binding adapter with custom logic to set View values from an
XML attribute
● Handle multiple ViewHolders in the same RecyclerView to show
multiple item types
● Use GridLayoutManager to display items as a grid
● Specify span size for an item in a grid with SpanSizeLookup
Learn More
● Create a List with RecyclerView
● RecyclerView
● ListAdapter
● Binding adapters
● GridLayoutManager
● DiffUtil and ItemCallback
Pathway

Lesson 10: Advanced RecyclerView
use cases
Lesson 11:
Connect to the
internet
About this lesson
Lesson 11: Connect to the internet
● Android permissions
● Connect to, and use, network resources
● Connect to a web service
● Display images
● Summary
Android permissions
Permissions
● Protect the privacy of an Android user

● Declared with the <uses-permission> tag in the
AndroidManifest.xml
Permissions granted to your app
● Permissions can be granted during installation or runtime,

depending on protection level.
● Each permission has a protection level: normal, signature, or
dangerous.
● For permissions granted during runtime, prompt users to
explicitly grant or deny access to your app.
Permission protection levels
Protection Level Granted when? Must prompt Examples

before use?
Normal Install time No
Signature Install time No N/A
Dangerous Runtime Yes
Add permissions to the manifest
In AndroidManifest.xml:
Internet access permissions
Request dangerous permissions
● Prompt the user to grant the permission when they try to

access functionality that requires a dangerous permission.
● Explain to the user why the permission is needed.
● Fall back gracefully if the user denies the permission (app
should still function).
Prompt for dangerous permission
App permissions best practices
● Only use the permissions necessary for your app to work.

● Pay attention to permissions required by libraries.
● Be transparent.
● Make system accesses explicit.
Connect to, and use,
network resources
Retrofit
● Networking library that turns your HTTP API into a Kotlin and
Java interface
● Enables processing of requests and responses into objects for
use by your apps
○ Provides base support for parsing common response types,
such as XML and JSON
○ Can be extended to support other response types
Why use Retrofit?
● Builds on industry standard libraries, like OkHttp, that provide:

○ HTTP/2 support
○ Connection pooling
○ Response caching and enhanced security
● Frees the developer from the scaffolding setup needed to run a
request
Connect to a web service
HTTP methods
● GET
● POST
● PUT
● DELETE
Example web service API
URL DESCRIPTION METHOD
Get a list of all posts
Get a list of posts by

user
Search posts using a
filter
Create a new post
Define a Retrofit service
Create a Retrofit object for network access
End-to-end diagram
Retrofit Service
HTTP Request
App UI Server
ViewModel HTTP Response Web API
Converter
(JSON)
Moshi
Converter.Factory
Helps convert from a response type into class objects

● JSON (Gson or Moshi)
● XML (Jackson, SimpleXML, JAXB)
● Protocol buffers
● Scalars (primitives, boxed, and Strings)
Moshi
● JSON library for parsing JSON into objects and back
● Add Moshi library dependencies to your app’s Gradle file.
● Configure your Moshi builder to use with Retrofit.
List of JSON
Moshi
Post objects response
Moshi JSON encoding
JSON code
Set up Retrofit and Moshi
Use Retrofit with coroutines
Launch a new coroutine in the view model:
Display images
Glide
● Third-party image-loading library in Android

● Focused on performance for smoother scrolling
● Supports images, video stills, and animated GIFs
Add Gradle dependency
Load an image
Customize a request with RequestOptions
● Apply a crop to an image

● Apply transitions
● Set options for placeholder image or error image
● Set caching policies
RequestOptions example
Summary
Summary
● Declare permissions your app needs in AndroidManifest.xml
● Use the three protection levels for permissions: normal, signature, and
dangerous (prompt the user at runtime for dangerous permissions)
● Use the Retrofit library to make web service API calls from your app
● Use the Moshi library to parse JSON response into class objects
● Load and display images from the internet using the Glide library
Learn More
● App permissions best practices

● Retrofit
● Moshi
● Glide
Pathway

Lesson 11:
Connect to the
internet
About this lesson
● Android permissions
● Connect to, and use, network resources
● Connect to a web service
● Display images
● Summary
Android permissions
Permissions
● Protect the privacy of an Android user

● Declared with the <uses-permission> tag in the
AndroidManifest.xml
Permissions granted to your app
● Permissions can be granted during installation or runtime,

depending on protection level.
● Each permission has a protection level: normal, signature, or
dangerous.
● For permissions granted during runtime, prompt users to
explicitly grant or deny access to your app.
Permission protection levels
Protection Level Granted when? Must prompt Examples

before use?
Normal Install time No
Signature Install time No N/A
Dangerous Runtime Yes
Add permissions to the manifest
Internet access permissions
Request dangerous permissions
● Prompt the user to grant the permission when they try to

access functionality that requires a dangerous permission.
● Explain to the user why the permission is needed.
● Fall back gracefully if the user denies the permission (app
should still function).
Prompt for dangerous permission
App permissions best practices
● Only use the permissions necessary for your app to work.

● Pay attention to permissions required by libraries.
● Be transparent.
● Make system accesses explicit.
Connect to, and use,
network resources
Retrofit
● Networking library that turns your HTTP API into a Kotlin and
Java interface
● Enables processing of requests and responses into objects for
use by your apps
○ Provides base support for parsing common response types,
such as XML and JSON
○ Can be extended to support other response types
Why use Retrofit?
● Builds on industry standard libraries, like OkHttp, that provide:

○ HTTP/2 support
○ Connection pooling
○ Response caching and enhanced security
● Frees the developer from the scaffolding setup needed to run a
request
Connect to a web service
HTTP methods
● GET
● POST
● PUT
● DELETE
Example web service API
URL DESCRIPTION METHOD
Get a list of all posts
Get a list of posts by

user
Search posts using a
filter
Create a new post
Define a Retrofit service
Create a Retrofit object for network access
End-to-end diagram
Retrofit Service
HTTP Request
App UI Server
ViewModel HTTP Response Web API
Converter
(JSON)
Moshi
Converter.Factory
Helps convert from a response type into class objects

● JSON (Gson or Moshi)
● XML (Jackson, SimpleXML, JAXB)
● Protocol buffers
● Scalars (primitives, boxed, and Strings)
Moshi
● JSON library for parsing JSON into objects and back
● Add Moshi library dependencies to your app’s Gradle file.
● Configure your Moshi builder to use with Retrofit.
List of JSON
Moshi
Post objects response
Moshi JSON encoding
JSON code
Set up Retrofit and Moshi
Use Retrofit with coroutines
Launch a new coroutine in the view model:
Display images
Glide
● Third-party image-loading library in Android

● Focused on performance for smoother scrolling
● Supports images, video stills, and animated GIFs
Add Gradle dependency
Load an image
Customize a request with RequestOptions
● Apply a crop to an image

● Apply transitions
● Set options for placeholder image or error image
● Set caching policies
RequestOptions example
Summary
Summary
● Declare permissions your app needs in AndroidManifest.xml
● Use the three protection levels for permissions: normal, signature, and
dangerous (prompt the user at runtime for dangerous permissions)
● Use the Retrofit library to make web service API calls from your app
● Use the Moshi library to parse JSON response into class objects
● Load and display images from the internet using the Glide library
Learn More
● App permissions best practices

● Retrofit
● Moshi
● Glide
Pathway

Lesson 12:
Repository pattern
and WorkManager
About this lesson
Lesson 12: Repository pattern and WorkManager
● Repository pattern
● WorkManager
● Work input and output
● WorkRequest constraints
● Summary
Repository pattern
Existing app architecture
UI Controller
ViewModel
Room
Relative data speeds
Operation Relative speed
Reading from LiveData FAST
Reading from Room database SLOW
Reading from network SLOWEST
Cache network responses
● Account for long network request times and still be responsive

to the user
● Use Room locally when retrieval from the network may be costly
or difficult
● Can cache based on the least recently used (LRU) value,
frequently accessed (FRU) values, or other algorithm
Repository pattern
● Can abstract away multiple data sources from the caller

● Supports fast retrieval using local database while sending
network request for data refresh (which can take longer)
● Can test data sources separately from other aspects of your app
App architecture with repository pattern
UI Controller
ViewModel
Repository
Remote data source Room Mock backend
Implement a repository class
● Provide a common interface to access data:

○ Expose functions to query and modify the underlying data
● Depending on your data sources, the repository can:
○ Hold a reference to the DAO, if your data is in a database
○ Make network requests if you connect to a web service
WorkManager
WorkManager
● Android Jetpack architecture component

● Recommended solution to execute background work
(immediate or deferred)
● Opportunistic and guaranteed execution
● Execution can be based on certain conditions
When to use WorkManager
Task
Yes Requires active No

user
Requires active
Immediate user
Yes No
Exact Deferred
Declare WorkManager dependencies
Important classes to know
● Worker - does the work on a background thread, override

doWork() method
● WorkRequest - request to do some work
● Constraint - conditions on when the work can run
● WorkManager - schedules the WorkRequest to be run
Define the work
Extend CoroutineWorker instead of Worker
WorkRequests
● Can be scheduled to run once or repeatedly

○ OneTimeWorkRequest
○ PeriodicWorkRequest
● Persisted across device reboots
● Can be chained to run sequentially or in parallel
● Can have constraints under which they will run
Schedule a OneTimeWorkRequest
Create WorkRequest:
Add the work to the WorkManager queue:
Schedule a PeriodicWorkRequest
● Set a repeat interval
● Set a flex interval (optional)
Flex period Flex period Flex period

can run work can run work can run work
...
Interval 1 Interval 2 Interval N
Specify an interval using TimeUnit (e.g., TimeUnit.HOURS, TimeUnit.DAYS)
Flex interval
Work could And then again
happen here soon after
Example 1
Day 1 Day 2
1 hr 1 hr
Example 2
11 PM 12 AM 11 PM 12 AM
Day 1 Day 2
PeriodicWorkRequest example
Enqueue periodic work
Work input and output
Define Worker with input and output
Result output from doWork()
Result status Result status with output
Send input data to Worker
WorkRequest constraints
Constraints
●
●
●
●
●
Constraints example
Summary
Summary
● Use a repository to abstract the data layer from the rest of the app
● Schedule background tasks efficiently and optimize them using
WorkManager
● Create custom Worker classes to specify the work to be done
● Create and enqueue one-time or periodic work requests
Learn more
● Fetch data
● Schedule tasks with WorkManager
● Define work requests
● Connect ViewModel and the repository
● Use WorkManager for immediate background execution
Pathway

Lesson 12: Repository pattern and
WorkManager
Lesson 13:
App UI design
About this lesson
Lesson 13: App UI design
● Android styling
● Typography
● Material Design
● Material Components
● Localization
● Example apps
● Summary
Android styling
Android styling system
● Used to specify the visual design of your app

● Helps you maintain a consistent look across your app
● Hierarchical (you can inherit from parent styles and override
specific attributes)
Precedence of each method of styling
View
attributes Overrides this
Style
Overrides this
Theme
Themes
● Collection of named resources, useful broadly across the app

● Named resources are known as theme attributes
● Examples:
○ Use a theme to define primary & secondary colors in the app
○ Use a theme to set the default font for all text within an activity
Declare a theme
In res/values/themes.xml:
Apply a theme
In layout file:
…
Refer to theme attribute in a layout
In layout file:
Use ?attr/themeAttributeName syntax.

Examples: ?attr/colorPrimary
?attr/colorPrimaryVariant
Styles
● A style is a collection of view attributes, specific to a

type of view
● Use a style to create a collection of reusable styling
information, such as font size or colors
● Good for declaring small sets of common designs used
throughout your app
Declare a style
In res/values/styles.xml:
Apply a style
On a view in a layout file:
Refer to theme attribute in a style
In res/values/styles.xml:
View attributes
● Use view attributes to set attributes explicitly for each view

● You can use every property that can be set via styles or themes
● Use for custom or one-off designs such as margins, paddings,
or constraints
Resources directory
└── res
├── drawable
├── drawable-*
├── layout
├── menu
├── mipmap-*
├── navigation
├── values
│ ├── colors.xml
│ ├── dimens.xml
│ ├── strings.xml
│ ├── styles.xml
│ └── themes.xml
└── values-*
Provide alternative resources
└── res
├── values
│ ├── colors.xml
│ ├── strings.xml
│ ├── styles.xml
│ └── themes.xml
└── values-b+es
│ ├── strings.xml Use when device locale is set to Spanish
└── values-night
└── themes.xml Use when night mode is turned on
Color resources
A way to name and standardize colors throughout your app
In res/values/colors.xml:
Specified as hexadecimal colors in form of #AARRGGBB
Dimension resources
A way to name and standardize dimension values in your layouts
● Declare your dimension values in res/values/dimens.xml:
● Refer to them as @dimen/<name> in layouts or R.dimen.<name> in code:

…
Typography
Scale-independent pixels (sp)
● The textual equivalent to

density-independent pixels (dp)
● Specify text sizes in sp
(takes into account user preferences)
● Users can adjust Font and Display sizes
in the Settings app (after Display)
Type scale
● A set of styles designed to work

together in a cohesive manner
for your app and content
● Contains reusable categories of
text with intended purpose for
each (for example, headline,
subtitle, caption)
TextAppearance
A TextAppearance style often alters one or more of these attributes:
● typeface (android:fontFamily)
● weight (android:textStyle)
● text size (android:textSize)
● capitalization (android:textAllCaps)
● letter spacing (android:letterSpacing)
Examples using TextAppearance
Customize your own TextAppearance
Use a custom TextAppearance in a theme
Material Design
Intro to Material
Adaptable system of
guidelines, components, and
tools that support best
practices for UI design
Material Design homepage
Material Components
Interactive building blocks

for creating a user interface
Material color tool
Baseline Material color theme
Material Components for Android Library
Material Themes
●
●
●
●
●
●
●
●
Material theme example
Light mode Dark mode
Dark theme
A low-light UI that displays mostly dark surfaces
● Replaces light-tinted surfaces and dark text
with dark-tinted surfaces and light text
● Makes it easier for anyone to use a device in
lower-light environments
● Improves visibility for users with low vision
and those sensitive to bright light
● Can significantly reduce power usage
(depending on the device)
Support dark theme
In values/themes.xml:
In values-night/themes.xml:
Material Components
Material Components
Component library provided for Android and design guidelines
● Text fields ● App bars (top and bottom)

● Buttons ● Floating Action Button (FAB)
● Menus ● Navigation Drawer
● Cards ● Bottom navigation
● Chips ● Snackbar
...and more!
Text field
● Composed of TextInputLayout with child view
TextInputEditText
● Shows a floating label or a text hint before the user enters text
● Two types:
Filled text field Outlined text field
Text field example
Bottom navigation
● Allows movement between top level

destinations in your app
● Alternate design pattern to a
navigation drawer
● Limited to 5 locations max
Bottom navigation example
Bottom navigation listener
Snackbar
● Display short messages within the app

● Messages have a duration (SHORT,
LONG, or INDEFINITE)
● May contain an optional action
● Works best in a CoordinatorLayout
● Shown at bottom of enclosing container
Snackbar examples
Show a simple message:
Add an action to a Snackbar:
Floating Action Button (FAB)
● Perform the most-common action for a screen (for example, creating a new
email)
● Come in multiple sizes (regular, mini, and extended)
CoordinatorLayout
● Acts as top-level container in an app

● Manages interaction of its child views, such as gestures
● Recommended for use with views like a Snackbar or FAB
FAB example
Cards
● A card holds content and actions

for a single item.
● Cards are often arranged in a list,
grid, or dashboard.
● Use MaterialCardView.
MaterialCardView example
Localization
Localize your app
● Separate the localized aspects of your app (for example, text, audio
files, currency, and numbers) as much as possible from the core Kotlin
functionality of the app.
Example: Extract the user facing strings into strings.xml.
● When a user runs your app, the Android system selects which
resources to load based on the device's locale.
● If locale-specific resources are not found, Android falls back to default
resources you defined.
Support different languages and cultures
● Decide which locales to support.
● Create locale-specific directories in res directory:
<resource type>-b+<language code>
[+<country code>]
Examples: layout-b+en+US
values-b+es
● Provide locale-specific resources (such as strings
and drawables) in those directories.
Support languages that use RTL scripts
● Users can choose a language that uses right-to-left (RTL) scripts.

● Add android:supportsRtl="true" to app tag in manifest.
● Convert left and right to start and end, respectively, in your layout
files (change android:paddingLeft to android:paddingStart).
● Localize strings and format text in messages.
● Optionally, use -ldrtl resource qualifier to provide alternate resources.
Example apps
Check out other apps
Sunflower Google I/O

app app
Summary
Summary
● Customize the visual look of your app using styles and themes
● Choose from predefined type scales for the text in your app (or create
your own text appearance)
● Select theme colors for your app using Material color tool
● Use Material Components library to speed up UI development
● Localize your app to support different languages and cultures
Learn more
● Material Design
● Material Components
● Tools for picking colors
● Dark theme
● Localize your app
● Blog posts: Themes vs Styles, Common Theme Attributes, Prefer Theme
Attributes, Themes Overlay
● Sample code: Sunflower app, Google I/O app, Android GitHub repo
Pathway

Lesson 13: App UI Design

All Lessons Combined

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

All Lessons Combined

Uploaded by

Copyright:

Available Formats

Android

● Experience in an object-oriented programming language

● How to build a variety of Android

● Open-source mobile platform

A modern programming language

● Expressive and concise

● Kotlin is at its best when used idiomatically

Unit 1 (3 weeks) Unit 2 (3 weeks) Unit 3 (6 weeks) Unit 4 (1 week)

Get Started with Introduction to Android App App Design

After each class, complete

● Learn Kotlin for a list of oﬃcial reference materials

● Android Developers Blog

● Android Developers Medium blog

● Android Developers YouTube channel

● Android Developer Newsletter

● Oﬄine documentation through SDK Manager

It may take a few

Result includes the

Long 64 From -263 to 263-1

Int 32 From -231 to 231-1

Short 16 From -32768 to 32767

Byte 8 From -128 to 127

Double 64 16 - 17 signiﬁcant digits

Boolean 8 True or false. Operations include:

Use underscores to make long numeric constants more readable.

Strings are any sequence of characters enclosed by double quotes.

String literals can contain escape characters

Or any arbitrary text delimited by a triple quote (""")

Or an expression inside curly braces:

● Powerful type inference

Kotlin is a statically-typed language. The type is resolved at compile time and

Although not strictly enforced, using immutable variables is recommended in

Kotlin features several ways to implement conditional logic:

● Data type containing a span of comparable values (e.g.,

for (i in 'd'..'g') print (i)

● Lists are ordered collections of elements

An example of a list is a sentence: it's a group of words, their order is important,

Declare a list using and print it out.

⇒ [trumpet, piano, violin]

Lists can be changed using mutableListOf()

● Arrays store multiple items

● Array elements can be accessed programmatically through

● Array elements are mutable

An array of strings can be created using arrayOf()

An array can contain different types.

Use the + operator.

● In Kotlin, variables cannot be null by default

In Kotlin, null variables are not allowed by default.

Declare an Int and assign null to it.

Declare an Int? as nullable

In general, do not set a variable to null as it may have unwanted consequences.

throws NullPointerException if s is null

Warning: Because !! will throw an exception, it should only be used when it

Chain null tests with the ?: operator.

Practice what you’ve learned by

● Create a ﬁle in your project

In the Hello.kt ﬁle:

The args in the main() function are optional.

Use args[0] to access the ﬁrst input argument passed to main().

In Kotlin, almost everything is an expression and has a value. Even an if

Sometimes, that value is kotlin.Unit.

● A block of code that performs a speciﬁc task