Intermediate Android Development and Kotlin
4.2 (160 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
757 students enrolled

Intermediate Android Development and Kotlin

Building high quality Android applications with the latest technologies, software patterns, and languages available
4.2 (160 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
757 students enrolled
Created by Mickey Dang
Last updated 8/2020
English
English [Auto]
Current price: $13.99 Original price: $19.99 Discount: 30% off
5 hours left at this price!
30-Day Money-Back Guarantee
This course includes
  • 9.5 hours on-demand video
  • 8 articles
  • Full lifetime access
  • Access on mobile and TV
  • Assignments
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • Understand how to write a complex Android application to be scalable, readable, and modular for personal projects or a development job
  • Understand how Android view inflation actually works and make custom views
  • Understand industry programming concepts such as dependency injection and event driven programming
  • Stay current by learning the new Google Architecture Components, AndroidX, and JetPack
  • Learn about modern design patterns such as the Model-View-ViewModel (MVVM) architecture
  • Learn about Kotlin and its powerful features for Android development
  • Understand the 2 most popular Java libraries Mockito and JUnit to write automated tests
Course content
Expand all 67 lectures 09:45:56
+ Introduction
2 lectures 06:13

NOTE: This is a simple video that outlines how someone with PRIOR knowledge of Git can view sections without working on the sections before. This is NOT a video teaching git (that will be reserved for later sections) but merely an aid to help those who do not want to progress through everything in order - although that is still highly recommend in order for students to maintain context and awareness of the architecture and rationale behind the app.

How to Pick and Choose Lectures With Git
01:36
+ Starting Up a New Kotlin Project
11 lectures 01:39:42
Setting Up With Android Jetpack Explained
06:36
Adding and Registering the Navigation Activity
10:56
Building Data Models in Kotlin
15:32
Converting Navigation to Kotlin
09:21
Addendum on Navigation Bar Icon Tint
00:12
Fragments Explained
04:44
Creating Fragments in Navigation
13:34
Recycler Views Explained
03:13
Creating Recycler Views
15:39
Use the task adapter as a template to create the note adapter, xml file, view holder, and class!
Create the Note Adapter
1 question
Create the Note Adapter Solution
09:13
Refactoring Adapters
10:42
+ Custom Views
10 lectures 01:35:16
Inflating Todo Views Part 1
09:06
Inflating Todo Views Part 2
11:27
Creating Custom View in Java Part 1
07:34
Creating Custom View in Java Part 2
08:51
Boolean Logic Crash Course!
01:49
Converting Custom View to Kotlin
07:19
Nesting Custom Views Part 1
10:28
Nesting Custom Views Part 2
04:18
Hooking up the Add Button View
17:07
Adding the Create Activity
17:17
+ Model - View - ViewModel (MVVM) Architecture Pattern
8 lectures 01:18:28
Creating a ViewModel Using Arch Components
09:33
Working With LiveData Arch Component
15:18
Handling User Events With Contracts
13:35
Using Interfaces to Create Contracts
09:45
Use the previous video as a template to link the note view with the note view model.
Linking Note View & ViewModel
1 question
Linking the Note View & ViewModel
06:05
[March 2020] Updated ViewModel Instantiation
02:48
Creating a Barebones Model
04:46
+ Mini Bonus - Optional
3 lectures 17:23

Note: This is just a quick and rudimentary example of using DiffUtil to optimize list presentation. In a future video, we will be removing DiffUtil as it was causing bugs in more complex lists.

Using DiffUtil to Optimize Lists
07:42
A Note on DiffUtil For Complex Views
00:49
Extension Functions in Kotlin
08:52
+ Dependency Injection
5 lectures 34:46
Setting up Toothpick Library
00:48
The Inject Annotation and Scopes
06:45
Using Bindings and Modules
13:27
Organizing and Naming Scopes
07:29
+ Complete Create Task & Note Flow
8 lectures 01:10:39
Import Create Flow to Skip Section
02:10
Menu Inflation and Start of Create flow
10:53
Create Task Flow Part 1
10:51
Create Task Flow Part 2
09:34
Add Save Data Logic Part 1
11:52
Add Save Data Logic Part 2
09:53
Using Interfaces to Delegate Functionality
06:06
Create Note Flow
09:20
+ Room, SQLite, and Persistent Storage
8 lectures 01:19:13
Setting up Google Room Library
06:52
Creating a Database Client
10:35
Converting Models to Entities Part 1
14:43
Converting Models to Entities Part 2
06:37
Creating a DAO and Writing SQL
12:35
Linking Database to App Part 1
10:39
Linking Database to App Part 2
12:57
[CORRECTION] Fixing View Bug
04:15
+ Coroutines and Asynchronous Programming
4 lectures 45:54
Intro to Coroutines Part 1
10:26
Intro to Coroutines Part 2
11:10
Refactor Tasks Model to use Coroutines
11:48
Refactoring Into Suspend Functions
12:30
+ Sealed Classes
2 lectures 19:35
Custom DiffUtil With Sealed Classes Part 1
10:17
Custom DiffUtil With Sealed Classes Part 2
09:18
Requirements
  • Have Android Studio installed and ready
  • Have an Android emulator or Android phone with usb cable to be able to run apps from Android Studio
  • Understand Android concepts such as what is an Activity, and Intent, and the Activity Lifecycle
  • Be able to recognize java code and broadly understand what it does
Description

Why Am I Making This?

I wanted to make this course because when I was first learning mobile development, I tried going online and finding beginner videos and courses. What I found is that, they were great at teaching surface concepts as a starting point, but in and of themselves, they weren’t enough to explain how to build an app beyond a certain point of complexity. So, if you’re coming off of a beginner tutorial, you have some prior knowledge of Java and you understand some Android concepts such as the activities and lifecycles, then this is a great next step to further deepen your skillset and really stand out when applying for a job or trying to make a quality app by yourself.

 

What Are We Going to Make? 

We’re going to be making a “Google Notes” clone with the following features:

1.    Make tasks that are broken down into todos

2.    Todos can be checked off as completed or incomplete and appropriately displayed

3.    Notes will be displayed on a separate view from tasks and todos

4.    Both notes and tasks will be stored in a SQL database

Building this app is a great way to learn good software architecture and object-oriented principles. For example, we’ll be able to reuse a lot of our code within the adapters and the view models when displaying a task list and a notes list if properly architecture. 

 Also, this is just the no frills version of the app. Along the way after teaching each concept, I’ll have assignments followed by solutions on how to add deeper complexity into the app such as adding coloured tags for tasks, or making a list for only active tasks. By the end of it, you’ll have a clean and material design adherent app that you can customize to your delight and use as a reference point to implementing your own app idea.

 

What Is Different?

Apart from learning new trends in Android such as Kotlin, Google Architecture Components, and MVVM, I’ll also introduce you to a few popular libraries and tools that are widely used in industry to allow greater team collaboration and reusability of code. 

1.    Dependency Injection– If you’ve ever heard of Dagger or Toothpick as a library and wondered why it’s so cool, this will teach you!

2.    Coroutines– One of the biggest advancements in Kotlin is the ease of multi-threading and writing concurrent applications. Whether it’s making a database query or waiting for a network request, what used to be a very complex task in Java without the use of a third-party library is now fast and built into Kotlin. This is also one of the few courses to explain how multi-threading and concurrency works which is transferable to almost any field of programming, not just mobile development!

3. Google Architecture Components- Learning how to use pre-made templates for ViewModels will facilitate the MVVM architecture which greatly helps simplify code and speed up development time and using the Room SQL Database Library will enable developers to persist data at ease.

4. JUnit and Mockito Testing is a vital part of programming when working in the industry where apps need to be reliable and robust to serve a large number of users while keeping testing time as low as possible.

Who this course is for:
  • Beginner to intermediate Android developers who have just finished a beginner course and want "the next step"
  • Android developers who want to learn more detailed and complex concepts about Android to work in industry
  • Existing Android developers who previously worked with Java and want to stay updated and learn Kotlin, Android's newly supported language
  • Android developers who want to develop scalable and high quality applications
  • Prior knowledge of Java and basic understanding of Android is recommended to maximize learning through this course