(0:00:50) Create Your First Kotlin Project
(0:04:23) Hello World
(0:06:33) Working With Variables
(0:11:04) Type System
(0:15:00) Basic Control Flow
(0:21:31) Basic Kotlin Functions
(0:27:12) Function Parameters
(0:32:52) Arrays
(0:35:28) Iterating with forEach
(0:41:17) Lists
(0:42:47) Maps
(0:45:05) Mutable vs Immutable Collections
(0:49:24) Vararg Parameters
(0:54:21) Named Arguments
(0:56:26) Default Parameter Values
(1:00:27) Create A Simple Class
(1:03:35) Adding Class Properties
(1:05:15) Class Init Block
(1:06:40) Accessing Class Properties
(1:07:32) Primary Constructor Properties
(1:08:17) Secondary Constructors
(1:09:50) Working With Multiple Init Blocks
(1:11:30) Default Property Values
(1:11:59) Properties With Custom Getters/Setters
(1:16:52) Class Methods
(1:20:12) Visibility Modifiers — Public/Private/Protected/Public
(1:22:30) Interfaces
(1:24:21) Abstract Classes
(1:26:13) Implementing An Interface
(1:26:35) Overriding Methods
(1:28:30) Default Interface Methods
(1:29:30) Interface Properties
(1:31:40) Implementing Multiple Interfaces
(1:32:57) Type Checking And Smart Casts
(1:36:18) Inheritance
(1:43:07) Object Expressions
(1:45:06) Companion Objects
(1:49:51) Object Declarations
(1:52:41) Enum Classes
(1:58:16) Sealed Classes
(2:00:07) Data Classes
(2:12:25) Extension Functions/Properties
(2:16:40) Higher-Order Functions
(2:29:07) Using The Kotlin Standard Library
(2:00:07) Data Classes

1
(0:00) Introduction

2
(5:14) Model View ViewModel (MVVM) Architecture fundamentals and variations
(5:38) Is MVVM the perfect architecture?
(7:41) Overview of MVVM with whiteboard example
(12:11) Pros and Cons of MVVM
(18:58) Package structure

3
(23:22) How to create Vector Drawables
(24:22) Difference between Raster (PNG, JPG, BMP) and Vector (SVG) Images?
(27:55) Uh Oh!
(28:41) How to use Inkscape to create an SVG from a BMP/PNG
(30:07) How to convert an SVG into an Android Studio Vector Asset
(32:29) How to create simple animations using animation lists and fade animations

4
(38:19) Material Design User Interface using ConstraintLayout and Styles
(41:00) Building an XML Layout using ConstraintLayout
(51:09) Using ConstraintLayout Chains
(55:43) Some tips on using Styles to create a material design look

5
(56:51) How to use (and when not to use) the Android Navigation Component from Android Jetpack
(1:00:00) Adding Safe Args to gradle
(1:01:15) Building a Navigation Graph using the Navigation Editor (XML)
(1:11:00) Creating a NavHostFragment to host the Navigation Component and adding it to an Activity
(1:15:29) How to actually change destinations in our Fragments using the Navigation Component (with safe args)

6
(1:20:00) Setting up Fragments as Views in MVVM using Kotlin Synthetic Properties
(1:25:32) Starting point
(1:27:54) Importing an XML layout to an Activity/Fragment using Kotlin Synthetic Properties
(1:32:09) How to reference Views in the Fragment using synthetic properties
(1:33:41) Adding onClickListener to our views
(1:38:03) Intercepting OnBackPressed (NOTE: The API for this has changed since making this video. I have updated the Repository appropriately)
(1:39:40) How to observe the ViewModel using LiveData callbacks

7
(1:43:22) ViewModels in MVVM with Kotlin Coroutines for Concurrency
(1:45:26) A look at my BaseViewModel class which contains part of the Coroutines Implementation (Coroutine Scope)
(1:49:25) Starting point
(2:01:40) Handling events from the View in the ViewModel
(2:05:34) Using the launch Coroutine Builder to access data
(2:08:44) How to update the MutableLiveData fields to publish data to the View

8
(2:19:35) Modern RecyclerView implementation using LiveData to handle ItemTouchListener() callbacks
(2:22:49) Overview of the RecyclerView within the XML View with LinearLayoutManager
(2:26:53) What does the DiffUtil do?
(2:28:48) A look at the source code of ListAdapter to better understand how it works
(2:35:34) Writing the RecyclerView.ViewHolder class
(2:37:23) Why is it actually called a RecyclerView? What gets Recycled?
(2:37:58) Writing our RecyclerView.ListAdapter
(2:46:37) How to use a MutableLiveData object to publish events from the onClickListener in the ViewHolders
(2:48:09) Overview of the Fragment which manages the RecyclerView, and how to avoid memory leaks!

9
(2:53:17) FirebaseAuth for User Authentication using Google Sign In
(2:54:00) How to set up a new Firebase Project using Android Studio
(2:54:36) Enabling Authentication (FirebaseAuth) in the Firebase Console
(2:55:00) Setting up a debug signing certificate for your App in Firebase
(2:56:48) Gradle Configurations for FirebaseAuth
(2:58:00) Setting up GoogleSignInProvider
(2:59:24) Handling the result in onActivityResult
(3:01:06) Back FirebaseAuth Implementation using Coroutines

10
(3:05:31) Local Database with Room Persistence Library and Coroutines
(3:06:17) Entities and Primary Keys in Room
(3:08:50) Setting up a Dao (Data Access Object) in Room
(3:12:28) Overview of RoomDatabase implementation
(3:14:21) How to build your Database and get a reference to you Dao
(3:14:47) How to get data in and out of the Dao using suspend functions

11
(3:16:34) Setting up a Local and Remote Database using Firebase's Firestore NoSQL library
(3:17:33) Communicating with Firestore using a Repository, with Coroutines

12
(3:21:59) Dependency Injection using an AndroidViewModel, and ViewModelProvider.Factory
(3:22:29) What is dependency injection in simple terms?
(3:23:36) Implementing Dependency Injection using AndroidViewModel
(3:24:13) Quick look at using a ViewModelProvider.Factory to create our ViewModel with the Injected Repository
(3:24:27) How to use our Dependency Injector from within a Fragment or Activity

(0:00:00) Intro + app overview
(0:05:40) Create the main layout
(0:19:43) Setup the RecyclerView to show memory cards
(0:37:15) Add the BoardSize enum + create icons
(0:51:45) Create the memory card and game classes
(1:01:39) Implement the game logic
(1:20:20) Display game info
(1:27:45) Add menu options for game control
(1:41:59) Use an intent to navigate to the CreateActivity
(1:58:04) Build the image grid in the creation flow
(2:11:55) Choose image intent
(2:30:03) Image upload preparation
(2:39:07) Upload to Firebase Storage
(2:59:43) Save the memory game to Firebase
(3:16:00) Play memory with custom images
(3:34:30) Add menu option to download a game
(3:45:53) Style updates
(3:56:33) Creating a release build
(4:04:09) Publishing your app to Google Play
(4:19:53) Concept Review

Section 1
(0:00:00) Course Overview: About Me, You, and this Course
(0:09:23) How to Run the Examples
(0:10:59) Kotlin Syntax Practice for Beginners

Section 2
(0:39:26) Data Landscape: Memory Spaces and Named Addresses (References)
(0:44:21) How to use «val» and «const val» References to promote Immutability/Efficiency:
(0:51:55) Using «var» Reference Types, and the problems with Shared Mutable State!
(0:58:58) Giving Structure to Data with Classes

Section 3
(1:19:45) A Fundamental Divide: Computation and Control Logic
(1:22:52) Computing Data means Solving Problems
(1:32:11) Controlling the Flow of Data
(1:37:24) Event Driven Programs
(1:57:33) Functional versus Imperative Program Style (mild introduction)

Section 4
(2:18:38) What is Software Architecture?
(2:21:14) Separation of Concerns
(2:34:13) Dependency Inversion: Using Interfaces Effectively for Front End and Back End
(3:06:22) Extension versus Abstraction: Open/Closed Principle
(3:17:00) Dependency Injection: How, What, and Why?
(3:30:23) Inversion of Control via the Service Locator Pattern

Section 5
(3:44:25) Proving Programs with Tests (a light introduction to Testing)
(4:01:42) Solving Problem (Domains) by Analysis

(0:00:16) Introduction & Overview: Topics, Source
(0:02:39) App Design Approach: 3rd Party Library Minimalism & MV-Whatever Architecture
(0:04:50) Domain package: Repository Pattern, Enum, Data Class, Sealed Class, Hash Code, Interfaces
(0:34:39) Common package: Extension Functions & Variables, Open-Closed Principle (OCP), Abstract Class, Singleton
(0:50:20) Persistence (Storage) package: Clean Architecture Back End w/ Java File System Storage, Jetpack Proto Datastore
(1:28:07) UI package: Jetpack Compose UI Basics, Styles, Typography, Light & Dark Themes
(1:39:56) UI Components package: Modifiers, Reusable Toolbar & Loading Screens
(1:52:08) UI Active Game Feature package: Presentation Logic & ViewModel w/ Coroutines, Kotlin Function Types
(2:30:55) UI Active Game Feature package: Sudoku Game with Jetpack Compose UI & Activity Container
Note: In a larger App, I'd suggest using Fragments as Containers; didn't make sense to with this app though
(3:15:58) Computation Logic package: Overview, design, and testing of Graph DS & Algos for n-sized *square* Sudokus

(00:00) Intro
(01:07) App architecture
(09:05) Firebase Authentication logic
(29:25) User sign up Cloud Function
(42:31) Display user emoji list
(57:13) Update emoji status
(1:07:15) Restrict input to emoji

(00:00) Intro
(03:41) Retrieving data from the API
(21:43) Building the layout
(31:25) Render the spark line chart
(40:13) Add chart interaction
(54:26) Add colors and state spinner
(1:11:01) Ticker view + radio button styling
(1:23:47) Color update + conclusion

00:30 MacOS Install
02:49 Windows Install
04:30 Data Types
12:07 Casting
13:45 Strings
20:43 Arrays
25:52 Ranges
29:54 Conditionals
30:24 If
32:21 When
34:02 For
35:18 While
40:23 Functions
50:44 Higher Order Functions
56:40 Collection Operators
1:01:00 Exception Handling
1:03:05 Lists
1:08:00 Maps
1:10:50 Classes
1:16:00 Inheritance
1:18:12 Interfaces
1:22:22 Null Safety

00:00 — Intro
00:33 — What we will build
01:42 — Why choose Kotlin for Android Development?
03:29 — Android Studio Setup
07:17 — Creating the project
08:57 — Android Studio Roundtrip
16:17 — Building the app's layout
35:07 — Writing the Kotlin code for our app
01:03:04 — Recap of what we've done
01:06:25 — Setting up the Android emulator
01:08:15 — Running our app

0:00:00 — Introduction
0:01:10 — Installing Android Studio
0:05:47 — Our First Project — The UI and how to change it
0:15:08 — Setting up the AVD (Android Virtual Device)
0:24:22 — Starting our first app
0:33:04 — Our First App — People Counter App
0:49:05 — Testing on our phone
0:54:49 — Outro for this chapter
0:55:42 — Intro — Fundamentals Chapter
0:57:08 — Basic Concepts of OOP Languages
1:03:13 — Val vs Var
1:11:07 — Datatypes of Numbers
1:19:57 — Datatypes bool, char and string
1:26:41 — Arythmetic operators
1:35:24 — Comparison operators and string interpolation
1:43:51 — assignment operators
1:50:24 — If Statements
2:02:45 — If Statements part 2
2:06:28 — When Expressions
2:18:58 — While Loops
2:26:33 — Do While Loops
2:29:51 — Another way to use while loops
2:33:32 — For Loops
2:38:44 — Functions — Parameters and arguments
2:52:00 — Nullables in Kotlin
3:02:01 — Nullables — elvis operator
3:07:26 — Outro Basics 1
3:08:57 — Intro Basics of OOP
3:10:21 — Classes and Objects
3:15:11 — Classes and Initializers
3:22:16 — Scope and Shadowing
3:27:32 — Member Variables, Functions and Constructors
3:42:00 — Lateinit — Setters and Getters
3:50:57 — Data Classes
4:00:37 — Inheritance
4:15:53 — Interfaces
4:27:07 — Abstract Classes
4:33:07 — Typecasting
4:40:55 — Outro OOP
4:42:19 — Intro more on Kotlin Basics
4:43:51 — Arraylists
4:49:37 — Lambda expressions
4:54:11 — Visibility modifiers
5:05:06 — Nested and Inner Classes
5:09:54 — Safe Casting
5:14:59 — Exception Handling with try and catch
5:30:35 — Outro More Basics
5:32:08 — Intro Age in Minutes App
5:33:39 — Setting up the UI for the App
5:48:22 — Difference of SP, DP Px
6:03:45 — Finalizing the UI
6:08:51 — Adding a DatePickerDialog and OnDateSetListener
6:22:13 — Using the selected Date to Display it
6:33:30 — Outro Age in Minutes
6:34:46 — Intro Calculator App
6:40:46 — Building the UI
6:55:34 — Using onClick and implementing the CLR
7:01:33 — Adding the onDecimalPoint
7:06:41 — Adding the onOperatorFunctionality
7:14:47 — Adding Subtraction — using substring and other string methods
7:27:47 — adding the missing operations
7:38:04 — Outro

1. Introduction – 04:13
2. Hello World Program – 08:31
3. How to create Android Project Using Kotlin – 18:38
4. Class & Object – 24:18
5. Var Val – 29:56
6. Kotlin & Java together – 32:51
7. Convert Java & Kotlin – 38:07
8. Decompile Bytecode – 40:06
9. Operators – 46:07
10. String Template – 50:41
11. If Else Expression – 54:11
12. String Comparison – 57:47
13. Null Handling – 01:02:11
14. When Expression – 01:07:04
15. Loop & Range – 01:14:34
16. List & Map – 01:27:20
17. Function Expression – 01:35:23
18. Function calling from Java – 01:44:34
19. Default and Named Parameters – 01:51:20
20. String to Integer – 02:03:21
21. Try Expression – 02:07:32
22. Extension Function – 02:12:17
23. Infix and Operator Overloading – 02:20:20
24. Recursion – 02:27:05
25. Recursion | Factorial – 02:34:46
26. Tail Recursion – 02:41:12
27. Constructor – 02:46:46
28. Secondary Constructor – 02:53:29
29. Inheritance – 02:58:46
30. Constructor in Inheritance – 03:09:35
31. Abstract class – 03:14:21
32. Interface – 03:20:17
33. Data Class – 03:29:32
34. Object Keyword – 03:40:09
35. Anonymous inner class – 03:46:54
36. Companion Object – 03:53:31
37. Companion Object | Factory Pattern – 03:59:08
38. Backtick As Escape Character – 04:03:18
39. User Input in Kotlin – 04:06:42
40. Array – 04:11:48
41. List – 04:21:53
42. List of Objects – 04:30:01
43. Higher Order Function – 04:35:15
44. Filter and Map – 04:49:06

00:00:37 — Intro to Kotlin
00:04:28 — Installing Android Studio on macOS
00:17:12 — Installing Android Studio on Windows
00:27:21 — Installing Intellij for Kotlin on macOS
00:36:00 — Installing Intellij for Kotlin on Windows
00:44:35 — Kotlin Variables
01:01:09 — Kotlin Strings
01:23:03 — Kotlin Numbers & Operators
01:27:31 — Kotlin Functions
01:44:33 — Kotlin Conditional Logic
02:03:41 — Kotlin Collections
02:23:04 — Kotlin Loops
02:31:44 — Kotlin Nullability
02:50:05 — Kotlin Classes & Inheritance
03:18:17 — Kotlin Lambda
03:41:12 — Setting Up Android Emulator
03:53:02 — Dinner Decider App Part 1
04:14:24 — Dinner Decider App Part 2
04:38:07 — Dinner Decider App Part 3
04:49:01 — Installing to a Real Device from macOS
04:55:42 — Installing to a Real Device from Windows

0:00:00 Welcome
0:02:07 Installing IntelliJ
0:03:20 Creating your First Kotlin File
0:04:38 Updating the Kotlin Plugin
0:05:43 Hello World
0:06:49 Creating a Variable
0:10:06 Creating a Read only Variable
0:12:19 Providing a Type on a Variable
0:14:00 Basic Types: Numbers
0:21:14 Basic Types: String and Char
0:24:11 String Interpolation and Triple Quotes
0:29:26 Basic Types: Boolean
0:31:18 If/Else Conditionals
0:36:25 One Line If/Else Conditional
0:40:17 Understanding Truth Tables
0:46:08 Structural Equality
0:48:19 Referential Equality
0:50:46 Nullable Types
0:52:12 Nullable Safe Calls
0:55:48 The Elvis Operator
0:57:49 Your First Kotlin Function
1:03:29 Functions with Return Types
1:08:49 Functions inside of Functions
1:11:51 Single Line Expressions
1:15:59 Function Arguments
1:21:49 Named Parameters
1:26:14 Default Function Arguments
1:30:44 IDE Refactoring to New LInes and Named Arguments
1:32:13 Multiple Args with varargs
1:34:57 Function Overloading
1:38:30 Creating your First Kotlin Class
1:45:31 Class Primary Constructors
1:49:18 Multiple Class Constructors
1:57:18 Constructor Init Blocks
2:00:57 Class Properties
2:04:00 Read Class Properties
2:04:54 Overriding a Property Getter
2:06:35 Overriding a Property Setter
2:09:42 Multiple Properties in a Class
2:11:11 Class Functions
2:15:51 Companion Objects
2:21:32 How to Create a Singleton
2:29:09 Declaring Constants
2:36:09 The lateinit modifier
2:40:23 How to Nest Classes
2:43:57 Inner Classes
2:46:56 Creating an Enum
2:51:36 Enum Constructor Parameters
2:55:27 Abstract Functions in Kotlin
2:58:51 Iterating over Enum Values
3:00:04 Adding Static Methods to Enums
3:01:37 The When Statement (Kotlin Switch Statement)
3:08:19 Exhaustive vs Non-Exhaustive When
3:15:09 Data Classes
3:19:27 Data Class with Parameterless Constructor
3:20:40 Data Class: Component1-N functions
3:24:15 Destructuring Data Classes
3:27:47 Copying Data Class Instances
3:31:17 The Pair and Triple Data Classes
3:33:50 Protected Modifier for Variables
3:40:53 Protected Modifier for Functions
3:47:02 Internal Modifier for Classes
3:55:07 Abstract Classes
3:59:45 Implementing an Abstract Class
4:13:30 Understanding Abstractions with Abstract Classes
4:17:52 What interfaces are used for
4:26:28 Creating an Interface
4:27:32 Implementing an Interface
4:28:51 Real World Interface Example
4:35:39 Anonymous Interfaces
4:40:34 Creating Arrays
4:47:06 Creating Immutable Lists
4:52:46 Creating Mutable Lists
5:00:47 Filtering a List
5:06:28 Finding Items in a List
5:12:44 Using «filterNot» on a List
5:14:10 filterTo and filterNotTo on Lists
5:16:40 Flattening Lists and Arrays
5:19:39 Combining Immutable Lists
5:21:21 List vs Map
5:29:40 Map vs FlatMap
5:34:15 Set Data Structure (a List with no Duplicates)
5:39:05 For Loops
5:44:13 While Loops
5:47:59 For Each Loops
5:51:03 Combining Lists with the Union Operator
5:53:53 Iterating over a List with an Index
5:55:28 Ranges
5:56:59 Immutable Maps
6:00:49 Mutable Maps
6:08:29 Filtering and Transforming Maps
6:16:30 Using mapNotNull on a Map
6:20:22 Generating Large Sequences
6:23:11 Measuring Performance
6:31:33 Kotlin Sequences
6:44:19 List vs Set vs Map vs Sequence
6:49:25 Kotlin Ternary Operator: Single Line If
6:50:51 Double Bang!!! Operator
6:54:58 Using requireNotNull()
6:59:04 Using checkNotNull()
7:01:05 Filtering a List with filterNotNull()
7:02:20 Type Checking with 'is'
7:08:52 Casting
7:11:36 Safe Casting with 'as'
7:14:58 Generic Lists and Maps
7:19:50 Your First Generic Class
7:27:06 Throwing Exceptions
7:29:54 Creating a Custom Exception
7:32:44 Catching Exceptions with Try/Catch
7:36:09 Catching Multiple Exception Types
7:40:43 Try/Catch/Finally blocks
7:44:52 Try/Catch vs Try/Finally
7:47:27 Creating a typealias
7:50:38 Extension Functions
7:59:14 Lazy Evaluation
8:02:26 Lazy Initializer Block
8:05:42 Packages and Imports
8:14:04 Type Inference
8:21:09 Simple Lambda Expressions
8:34:29 Lambdas as Function Parameters
8:40:23 Passing Values to Lambda Function Parameters
8:51:37 Underscore Parameters in Lamba Functions
8:54:24 The 'it' Paramter in Lambda Functions
8:56:38 Calling Kotlin from Java
8:59:39 Calling Java from Kotlin
9:04:51 Calling an Extension Function from Java
9:07:50 @JvmName Annotation
9:10:21 Top Level Main Functions
9:11:15 Kotlin REPL
9:13:52 Project: Setup
9:15:54 Project: Reading Input
9:20:16 Project: Calculator Logic
9:28:04 Project: Adding Validation
9:35:54 Project: Compiling to a Jar File and Execution
9:38:21 Kotlin Koans
9:40:09 Congratulations