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, jаvascript, 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 jаvascript, 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.


Homepage

https://www.udemy.com/course/build-modernize-and-troubleshoot-your-android-apps/

Related Downloads :

{related-news}