Build, Modernize And Troubleshoot Your Android Apps

Build flexible and maintainable modern Android apps and overcome common performance issues with ease!

What you'll learn

Explore MVVM architecture to build scalable apps.

Perform integration tests that mock data persistence with dependency injections.

Understand Kotlin and experience how simple it is to write code using it as opposed to Java.

Overcome a lot of issues that were prevalent in the past using a variety of Jetpack libraries.

Stay up to date with the latest and greatest methods to implement common use cases that you will come across when developing future apps.

Debug your UI and manage the way you want it to look.

Ways to optimize your app for good battery usage.

Requirements

Basic Android Development Knowledge is assumed.

Description

Are you willing to modernize the Android application built on Java using Kotlin and common Android architecture patterns as well as enhance your applications by overcoming common performance issues with Android? Then this course is for you!As this course assumes basic android development knowledge, you will get started with learning to create a strong architectural background for your app, edit and customize the foundations of the app & much more. Then, you’ll learn to implement Life Cycle Aware Components, use the ViewModel LiveData framework, and perform data management and persistence with the Room persistence solution. Moving further you will delve into fixing issues such as memory management, where we will look at memory leaks and tracking allocations as well as look at optimizing your user experience when working with data on the cloud.By the end of the course, you’ll be able to build real-world applications more efficiently, modernize your Android apps using all the new features & deploy applications more efficiently, without having to worry about your code affecting the performance and user experience.Contents and OverviewThis training program includes 3 complete courses, carefully chosen to give you the most comprehensive training possible.The first course, Building Professional Android Applications we’ll create a strong architectural background for your app. You’ll be able to edit and customize the foundations of the app so it’s transferable between different projects. Then, you’ll learn the most productive ways to save and read data on Android with the Room framework, ObjectBox, and the Firebase database. The third section is about utilizing efficient data structures to maintain speed, even when the amount of data is huge. Finally, we’ll explore different ways to test Android applications such as: unit tests, integration tests, and end-to-end tests. The last section is about designing the front end of your app, including professional-level features, such as custom view development and explanatory user onboarding. Also, you’ll learn to upload your Android app to the Google Play store and discover advanced topics such as Payments, Android N Tiles, and voice interaction. By the end of the course, you’ll have the essential skills needed to build a real-world application.The second course, Modernizing Your Android Applications you’ll take an existing Android application build in Java and modernize it using the Kotlin language, seeing the importance of planning the architecture using SOLID principles and common Android Architecture using the MVP, MVC, and MVVM patterns. Moving on, you’ll implement Life Cycle Aware Components, use the ViewModel LiveData framework, and perform data management and persistence with the Room persistence solution. You’ll see how Kotlin efficiently accelerates the development by improving the code base. With the advanced Architectural Components, you’ll not only be able to improve the performance but also enhance the UI of your application to a whole new level. By the end of this course, you’ll have modernized your Android app using all the new features from coding it in Kotlin to implementing Architecture Components to enhancing the UI of your app, which gives you more control on your app and makes it easy to maintain.The third course, Troubleshooting Android Performance will help you overcome common performance issues on Android. In this course, we go over the important and common areas that can affect performance such as memory, network, UI, and battery. We delve into issues such as memory management, where we will look at memory leaks and tracking allocations. We also look at optimizing your user experience when working with data on the cloud. We also go into some common pitfalls when working with your UI and how to debug it. Finally, we look at ways to optimize and debug your app's battery usage to ensure that it doesn't annoy users when they've installed your app. When you're completed with this course, you will be developing applications more efficiently, without having to worry about your code affecting the performance that your users experience.About the Authors:Tadas Šubonis started coding roughly when he was thirteen. Since then, he has programmed with PHP, JavaScript, Python, C++, and Java (the language in which he has probably written the most code). He took up Android in 2014 and identified that Android lacks decent support for asynchronous programming (Async Task was/is a joke) while more reckless languages, such as JavaScript, had Promises for a long time. Furthermore, Java's standard library was lacking decent support for functional programming primitives (map, filter), but that was easily fixable with libraries such as Guava. This lead Tadas to a search for a library that would help him achieve a Promise-like functionality and interface. It didn't take long until he found ReactiveX and its family of implementations (including RxJava) that handle streams in Reactive fashion. It wasn't exactly the flow of Promised-like systems but soon enough, he realized that it's even more powerful. Since then, he has been using RxJava (and RxKotlin) for his daily Android programming. The quality of the code (the lack of bugs, readability, and maintainability) has improved ten-fold.Yusuf Saber is an Android developer with over 5 years' professional experience. Yusuf earned his master's degree in Computer Engineering from Ryerson University in 2011 and started his career as a .NET developer before quickly turning to Android. He has worked on a large range of Android apps, from social to multimedia to B2B and more!

Overview

Section 1: Building Professional Android Applications

Lecture 1 The Course Overview

Lecture 2 Introduction to Version Control

Lecture 3 Structuring Packages by Features

Lecture 4 Purpose of the Activity

Lecture 5 Understanding MVVM Architecture

Lecture 6 Introduction to ButterKnife

Lecture 7 Data Binding API

Lecture 8 Reactive APIs

Lecture 9 Dependency Injection

Lecture 10 Introduction to Job Scheduler Framework

Lecture 11 SQLite and Frameworks

Lecture 12 Using Room Framework

Lecture 13 Using ObjectBox Framework

Lecture 14 Content Providers

Lecture 15 Getting Started with Firebase

Lecture 16 Big O Notation

Lecture 17 Data Structures

Lecture 18 Introduction to Testing and Mockito

Lecture 19 Testing UI with Espresso

Lecture 20 Integration Tests

Lecture 21 End-to-End Tests and UI Automator

Lecture 22 Hallway Testing

Lecture 23 Creating Intro Tutorial with ViewPager and Fragments

Lecture 24 Deploying to Google Play

Lecture 25 Working with Canvas

Lecture 26 Working with Payments

Lecture 27 Integrating Analytics

Lecture 28 Working with Quick Tiles

Lecture 29 Basics of Marketing

Section 2: Modernizing Your Android Applications

Lecture 30 The Course Overview

Lecture 31 Layout Design and Management

Lecture 32 Rotations and Recreations

Lecture 33 New Layouts

Lecture 34 New Lists

Lecture 35 Old Code Profiling

Lecture 36 New Code Profiling

Lecture 37 Memory Leaks

Lecture 38 Converting Java to Kotlin

Lecture 39 Extension Functions

Lecture 40 Operator Overload

Lecture 41 Kotlin Android Extensions

Lecture 42 KTX

Lecture 43 Data Persistence the Old Way

Lecture 44 Data Persistence the New Way

Lecture 45 Inserting Data and Writing Queries

Lecture 46 Updating and Deleting Data

Lecture 47 Dynamic Data Loading

Lecture 48 Handling Lifecycles Callbacks

Lecture 49 Responding to State Changes

Lecture 50 New Way to Respond to State Changes

Lecture 51 Using ViewModel to Restore and Manage Data

Lecture 52 Implementing LiveData

Lecture 53 Exploring Data Binding

Lecture 54 Adding Layouts and Binding Expressions

Lecture 55 Bind Layout Views to Architecture Components

Lecture 56 Implementing Paging Library

Lecture 57 UI Components and Considerations

Lecture 58 Data Components and Considerations

Lecture 59 Implementing WorkManager to Schedule Tasks

Lecture 60 Running Tasks Under Specific Conditions

Lecture 61 Setting Up Unique and Named Work Sequences

Section 3: Troubleshooting Android Performance

Lecture 62 The Course Overview

Lecture 63 Optimizing Your Loops

Lecture 64 StackOverflowException

Lecture 65 Loading Images

Lecture 66 Analyzing Memory Using the Memory Profiler

Lecture 67 Tracking Allocations

Lecture 68 What Are Memory Leaks?

Lecture 69 Find Memory Leaks with LeakCanary

Lecture 70 Common Memory Leak: Static References

Lecture 71 Common Memory Leak: Anonymous Inner-Classes

Lecture 72 Common Memory Leak: Non-Static Inner Classes

Lecture 73 Making Requests Asynchronously on a Background Thread

Lecture 74 Analyzing Results with the Network Profiler

Lecture 75 Using Your App While a Request Is in Progress

Lecture 76 UI Thread As a Whole

Lecture 77 View Hierarchies

Lecture 78 Debug Your Layout with the Layout Inspector

Lecture 79 Using Developer Options to Get More Information on Your UI

Lecture 80 Doze Mode and App Stand-By

Lecture 81 Lazy First

Lecture 82 Android: An Ecosystem

This course is for Android developers, mobile developer, looking to enhance the UI of your application & accelerate your development skills with less code in a more structured way.