Version Check

What Is Kotlin

Course Introduction

Benefit 1 - Conciseness

Why Native Android Development

Benefit 2 - Improved Null Safety

Tradeoffs and Considerations

Benefit 3 - Functional Programming

Course Overview

Course Overview

Developing Android Applications Kotlin Big Picture

Building Great UIs with Material Design

Adding Functionality with Google APIs

Better and Faster Code with Android Jetpack

Demo - Android Studio Features

Introduction

Downloading Android Studio

Creating a Kotlin Project

Modifying the Activity Layout

Adding Kotlin Code to the Activity

Running the App Within an Emulator

Summary

Understanding the Parts of the Android Studio Layout Designer

Using Kotlin with Android

Properties

Basic Types and Variable Declarations

Defining Types

Primary Constructor

Demo. CourseInfo & NoteInfo

Functions

Instance Initialization

Passing Parameters

Summary

Demo. DataManager Initialization

Demo. DataManager Properties

What Is an Activity

Demo. Working with ConstraintLayout - View Constraints

Activity Code Layout Relationship

Activity UI

Demo. Working with ConstraintLayout - Parent Constraints

Demo. Activity Code Layout Relationship

Populating a Spinner

ConstraintLayout Class

Summary

Demo. Populating a Spinner

What's Next for the App

Activity Interaction

Demo. Starting an Activity with an Intent

Demo. Adding the NoteList Activity

Singletons and Data Classes

Describing Operations with Intents

Demo. Populating the NoteList Activity

Demo. Using Data Classes

Summary

Demo. Handling Note Selection and Sending the Intent

Demo. Retrieving Intent Info and Displaying a Note

Options Menus

Demo. Adding Options Menu Items

Demo. Handling Options Menu Item Selections

Demo. Menu Items as App Bar Actions

Menu Items as App Bar Actions

Changing Menu Items at Runtime

Demo. Adding Support for Changing Menu Items

Null Safety

Demo. Changing Menu Item Appearance and State

Null Safety Operatiors

Demo. App Bar Actions with Text

App User Experience and Activity Lifecycle

Activity Lifecycle Methods

Demo. Saving Persistent Data Items

Demo. Creating a New Perstent Data Item

App Activity Flow and Tasks

Demo. Refreshing Displayed Content

Demo. The Importance of Instance State

Demo. Saving Restoring Instance State

Activity Instance State

Demo. Verifying Instance State Behavior

Overview and Demo App Resources

Creating a Project with Android Studio

Understanding Android Studios UI

Understanding the Android Studio Project Structure

Exploring and Configuring Tool Windows in Android Studio

Customize Android Studio Settings

Summary

Default Build Configuration for Android Projects

Understanding Gradle Build Files

Custom Build Variants

Understanding Android’s Gradle Build System

Configuring and Running Custom Build Variants for an Android Projec

Summary

Adding Dependencies to a Project

Enabling Debugging on a Device and Viewing Log Messages in Logcat

Analysing Stacktraces Using Logcat

Summary

Writing and Filtering Messages in Logcat

Using Android Studio Debugger and Breakpoints

Configuring Breakpoints and Using Code Stepping Options

Adding Conditional Breakpoints, Evaluating Expressions, and Watching Variables

Understanding the Testing Tools Landscape in Android

Setting up a Project for Unit Testing

Summary

Handling Dependencies in Unit Tests

Adding Local Unit Tests to Your App

Adding Instrumented Unit Tests to Your App

Summary

Adding Espresso UI Tests to Your App

Adding String Resources for Localization

Adding Dynamic Images & Resources

Project Overview

Adding Styles

Adding Themes

Handling Orientation Changes

Changing Resources Based on App State

Changing Layout for Landscape Use Pt 1

Changing Layout for Landscape Use Pt 2

UI vs. UX

GloboTour - App Overview

The Secret behind High-quality Apps

GloboTour - App Structure

Project Setup with Navigation Component

Exploring Project Structure

What Is a Preference

What Is the AndroidX Preference Library

App Structure - GloboChat

SharedPreferences and PreferenceDataStore

Exploring the Project Structure

Getting Started

Getting Started

Overview

Adding DrawerLayout and NavigationView

Connecting Navigation Drawer with Navigation Component

Adding Menu Items and Header Layout

Fixing a Bug - Improving User Experience

Summary and Up Next

Understanding the Role of an Adapter

Understanding ViewHolder Design Pattern

Setting up Resources - Data Source and List Item Layout

Exercise - Implement Favorite List RecyclerView with Adapter

Inspecting Adapter Behavior

Implementing Adapter - RecyclerView.AdapterViewHolder

Adding OnClickListener on List Items

Adding Functionality - Mark an Item as Favorite

Adding and Deleting Items from a List

Exercise Solution - Implementing RecyclerView for Favorites Screen

Improving User Experience and Module Wrap-up

GridLayoutManager and StaggeredGridLayoutManager

Connecting Bottom Navigation Bar with Navigation Component

Summary and Up Next

Adding BottomNavigationView - Bottom Navigation Tabs

Improving User Experience

Drag to Rearrange Items in RecyclerView

How to Verify Guidelines to Build High-quality Apps

Wrapping up - Other Important Courses to Explore

Swipe to Delete an Item from RecyclerView

Activities - More Than Just a Pretty Face

Managing Activity State with ViewModel

Adding a ViewModel and Build Dependencies

There's a Bug in Our App

That Bug's Fixed, but We Just Found Another One

Accessing Our ViewModel with a Lazy Property

Restoring the Activity State

Managing More Complex State with ViewModel

Verifying App Behavior

Activity Destruction Effects on State

Durable Activity State

Persisting State of a Simple Value

Restoring State of a Simple Value

Identifying the Need for Durable State

Summary

Activity State and Data Model Cooperation

Moving the Details to the ViewModel

We're Still Losing Some of Our Activity State

Verifying State Management Behavior

Persisting State of an Object Graph

Effectively Using ViewModel and Durable State Together

Cooperating with Activity Lifecycle

Our App's Get-together Feature

Managing Location with Activity Functions

Fixing the Location Resource Leak

Creating a Lifecycle Observer

Improving Lifecycle Handling with Events

Observing Lifecycle Events

Connecting the Observer to the Lifecycle

Summary

Introduction

Events Are Only Part of the Story

Lifecycle-driven Asynchronous Operations

Adding the Messaging Manager

Lifecycle State

We're Leaking Connections

Verifying State in Asynchronous Operations

The Leak Is Fixed

Summary

Steps Required to Build a Settings Screen

PreferenceScreen, PreferenceCategory, and SwitchPreferenceCompat

EditTextPreference, ListPreference, and PreferenceCategory

Preference and CheckBoxPreference

Accessing a Preference Object in a Fragment or Activity

Opening a Fragment from the Settings Screen

Opening an Activity from the Settings Screen

Reading Preference Values

Using the OnPreferenceChangeListener Interface

OnPreferenceChangeListener vs. OnSharedPreferenceChangeListener

Using the OnSharedPreferenceChangeListener Interface

Summary and Up Next

Creating a Sub-settings Screen

Building a Settings UI in Kotlin Code

Exploring MultiSelectListPreference

Opening a Webpage Using the Intent from Settings Screen

SummaryProvider - Dynamically Update Preference Summary

Controlling the Visibility of Preferences

When to Use PreferenceDataStore

Assignment - Do It Yourself

Using PreferenceDataStore

Course Summary and Wrap Up

Overview

External APIs

User Experience

Paging the Data

Android Paging Library

Android Paging Library Components

Data Sources Overview

Android Applications

Creating DataSource

Summary

Creating DataSource.Factory

Handling Data Requests

Creating RecyclerView and ViewHolder

PagedListAdapter and DiffUtil

Building ViewModel

Using BoundaryCallback

LiveData

Publishing Changes to DataSource

Room Dao

Querying Basics

Creating a Database

Testing Our Database

Querying Subsets

Parameterizing Queries and Joins

Overview of Data Access Best Practices

Designing a Repository Pattern

Implementing the Repository Pattern - Part 1

Implementing the Repository Pattern - Part 2

Using WorkManager

Work Constraints

Demo - Using WorkManager

Demo - Work Constraints

Retrying Work

Demo - Retrying Work

Demo - Work Chains

Work Chains

Coroutine Fundamentals

History of Android Background Tasks

Demo - Structured Concurrency and Coroutine Scopes

Structured Concurrency and Coroutine Scopes

Demo - Coroutine Fundamentals

Why You Should (Almost) Never Use runBlocking

Demo - Cancelling Coroutines

Coroutine Exception Handling

Cancelling Coroutines

Demo - Coroutine Exception Handling

Channels

Demo - Channels

Coroutines with Android Jetpack

Demo - Android Coroutine Basics

Demo - Coroutines with Android Jetpack

Return of the WorkManager

Android Notifications with Kotlin

Creating a Notification

Notification Anatomy

Notification Actions

Notification Channels

Starting the App from a Notification

The Back Stack

Starting Activities with Notifications

Regular vs. Special Activities

Pending Intents

Inbox Style

Big Picture Style

Styling Notifications

Messaging Style

Home Screen Widgets with Kotlin

Updating a Widget

Launching the App from a Widget

Showing a Collection in a Widget

Creating Compound Components

Intro to Compound Components

Communicating between View and Activity

A Kotlin Approach to Communication

Custom Attributes

Combining Views into a Compound Component

Extending Views

Intro to Extending Views

Customizing Existing Views

Intro to the Canvas

Coping with Clipping

Selecting No Color

Using Custom Attributes

Extended View Communication

Supporting Different Screen Sizes

Compound Component vs. Extended View

Considerations When Extending Views

Creating Custom Views

Padding and Positioning

Painting Circles

Drawing with Math

Creating a View from Scratch

Custom View Positioning and Sizing

Custom Sizing with Attributes

Understanding onMeasure()

Measuring Your View

Making Your View Size Flexible

Making Your Custom View Interactive

Handling Motion Events

Making the Color Dial Interactive

Tying It All Together

User Input Coordinates

Accessibility and Screen Readers

Setting Up TalkBack

Optimizing Content for TalkBack

Pain Points in Accessible Navigation

Navigating with TalkBack

Improving Contrast

Designing for Color Blindness