Maintain Android Apps with Jetpack Architecture Components

Name: Maintain Android Apps with Jetpack Architecture Components
Rating: 4.1 (22 reviews)

Utilize Android Jetpack Architecture components to make your Android application development flexible and maintainable

Created byPackt Publishing

Last updated 2/2019

English

What you'll learn

Use the Data Binding library to bind data to the UI
Provide stability in your app by handling life cycles, view models, and live data
Implement effective in-app navigation by using the Navigation architecture component
Schedule tasks asynchronously by using Work Manager
Rebuild an Android application using these new practices as well using the new Jetpack group of libraries.
Understand Kotlin and experience how simple it is to write code using it as opposed to Java.
Stay up to date with the latest and greatest methods to implement common use cases that you will come across when developing future apps.

Course content

2 sections • 65 lectures • 7h 22m total length

The Course Overview4:29
This video gives glimpse of the entire course.
Why Architecture Components?3:38
Introduction to Android Architecture Components.
Get an overview of Architecture Components
Introduction to Android Jetpack
Explore the components of Android Architecture
Adding Components to Your Project1:42
How to easily integrate views with the data?
Enable the layout file for data binding
Bind layout and views with data
Handle events using data binding
Understand Data Binding3:00
What is data binding?
Understand what it is and its role in Android Architecture
Create a new Android Studio Project
Look at the steps to include data binding library in the android app
Layouts and Binding Expressions8:08
Learn how to easily integrate views with the data.
Enable the layout file for data binding
Bind layout and views with data
Handle events using data binding
Work with Observable Data Objects3:55
Make data objects observable and notify others about changes.
Inherit from the provided class for listener registration mechanism
Make the Object properties observable
Notify others about the property change
Loading Images from a URL Using Glide4:02
Load image from a URL using data binding library.
Update the UI as per the requirement
Define the property for loading the image in the data object class
Use the property as attribute in the layout file for data binding
Lifecycle-Aware Components1:57
What are lifecycle-aware components?
Understand activity/fragments as lifecycle owner
Learn that lifecycle observer observes lifecycle status of owner
Understand lifecycle events and states
Lifecycle-Aware Components Demo7:13
Demo on how lifecycle-aware components work.
Add lifecycle owner
Create lifecycle observer
Run the app and see the demo
Using ViewModel3:06
How to retain data on app configuration changes using ViewModel?
Understand ViewModel
Explore the Lifecycle of ViewModel
Learn how ViewModel survives configuration changes
Using ViewModel Demo6:35
Implementing ViewModel in demo App
Add dependencies for ViewModel
Create instance of ViewModel
Make a ViewModel class
Implementing LiveData6:38
How to observe changes in UI data?
Understand what LiveData is and how it works
Explore how LiveData can be used with ViewModel
Run the app and see the demo
Introduction5:06
What is Navigation Architecture Component?
Perceive the principles of Navigation Architecture Component
Understand why to use Navigation Architecture Component
Get an overview of the demo app
Implement the Navigation Architecture Component8:13
Create the set up for working on navigation.
Add Dependencies
Initialize the project setup
Explore the key parts of the Navigation Architecture Component
Update UI Components with NavigationUI7:37
How to use NavigationUI to add UI components to app?
Set up the bottom navigation bar
Set up the navigation drawer layout
Set up the toolbar
Navigate Using Actions3:05
How to use actions to navigate within the app?
Understand what is action and how to create it
Create action between destinations
Use actions to navigate within the app
Pass Data between Destinations Using SafeArgs5:34
How to pass data between destinations while using Navigation Architecture Component?
Add dependencies
Add a argument to the destination
Write a code to use SafeArgs to pass data
Understanding Paging Library8:12
What is paging architecture component?
Explore the advantages of paging architecture component
Add dependencies
Create a model class for API response
Set Up Backend API5:58
Fetch response from API.
Create the interface for API call
Create retrofit service builder class
Make API call from MainActivity and test the API call
Create PagedListAdapter and DataSource9:10
Create the Adapter and Datasource for paged data.
Create an Adapter class for paged data
Create the DataSource
Explain the functions of DataSource
Construct Observable List and Populate UI6:10
Fetch the paged data and display.
Create the DataSource Factory
Create a ViewModel
Set up the MainActivty to show the paged data
Introduction and Setup7:03
Overview of room database architecture component.
Know what a room is
Understand the difference between SQL and room
Add dependencies in project for room
Add Components of Room4:30
Create components of room in android project.
Create entity
Create DAO
Create database class
Perform Insert Operation6:43
Steps to perform insert operation.
Create the layout file and activity
Update the components of room
Connect UI to components of room
View Database from Android Studio1:54
Use SQLite Database browser to view data.
Install the package from the website
Find the database files in emulator/android device
See the database content on screen
Write Queries to Fetch and Display Data4:38
Steps to fetch data from the room database and display it in RecyclerView.
Update the components of room
Create the adapter class for RecyclerView
Populate the RecyclerView
Perform Update Operation6:58
Steps to perform update operation.
Update the components of room
Add the activity for editing note
Connect UI to components of room
Perform Delete Operation3:44
Steps to perform delete operation.
Update the components of room
Add interface for deleting the component
Connect UI to components of the room
Why WorkManager?4:53
What is WorkManager?
Get an overview of WorkManager
Know the advantages of using WorkManager
Understand the classes and concepts related to WorkManager
Implementing WorkManager to Schedule Tasks6:03
Steps to implement WorkManager in the Android project.
Add dependencies
Create worker class
Use WorkManager to create request for work
Running Tasks Under Specific Conditions3:14
Implementing constraints to tasks in WorkManager.
Create the constraint
Add it to the task
Implement one or multiple constraints
Working with Input Parameters and Return Values4:50
Passing data to and from tasks using WorkManager.
Create the data to be passed to task
Use setInputData to pass the data
Receive the data and return the result after the task is finished
Next Steps5:04
Get a summary of the course and know what are the next steps
Refresh the concepts learned throughout the course
List the websites to refer in case of any doubt
Test Your Knowledge

The Course Overview6:34
This video provides an overview of the entire course.
Layout Design and Management9:55
We will delve into traditional layout design methods and some of the problems with them.
Create a layout in the traditional way
Discuss some of the problems with it
Mention that we will make this better later in the course
Rotations and Recreations13:13
We will discuss common issues with traditional layouts when it comes to device rotations.
Rotate the device using the layout we’ve built
Show that some of the data gets removed
Mention that we will make this better later in the course
New Layouts20:53
We will go into ConstraintLayout as a better solution to building layouts than LinearLayout and RelativeLayout.
Convert the layouts to ConstraintLayout
Discuss the benefits of using ConstraintLayout
New Lists14:58
We will convert our ListView to a RecyclerView for more customization.
Convert the ListView to a RecyclerView
Convert the BaseAdapter implementation to a RecyclerView.Adapter
Discuss some of the advantages of RecyclerView
Old Code Profiling6:51
We will mention how hard/tedious it is to use old methods to measure performance and profile our code.
Discuss the importance of measuring performance and code profiling
Discuss how hard it is to use MAT
Discuss how hard it is to use DDMS
New Code Profiling9:17
We will show how much easier it is to measure performance and profile our code using the Android Profilers.
Discuss the Android memory profiler
Discuss the Android CPU profiler
Mention the Android power profiler
Memory Leaks6:02
We will define a memory leak and show some tools to locate them, and discuss fixing them.
Define what a memory leak is
Discuss LeakCanary as a good way to find memory leaks
Discuss ways to prevent them in the future
Converting Java to Kotlin16:51
We will show a quick way to convert Java code to Kotlin.
Show where the converter tool is in Android Studio
Manually change some Java code to Kotlin code
Extension Functions8:19
We will discuss what extension functions are.
Show how convenient it is to make an extension function
Show that they can be used in other classes
Operator Overload6:14
We will discuss what operator overload is.
Show how convenient it is to use overloaded operators once they are implemented
Discuss the various operators that we can overload
Kotlin Android Extensions6:22
We will discuss what Kotlin Android Extensions is.
Discuss how tedious it is to use findViewById
Show how to add Kotlin Android Extensions to our project
Show how easy it is to use Views in code with Kotlin Android Extensions
KTX13:04
We will discuss what the KTX library is used for.
Mention why KTX is needed in Android
Show some of the functions in the KTX library
Data Persistence the Old Way11:21
We will discuss how tedious it is to write SQL code.
Go through traditional-style SQLite code
Discuss how tedious it is to update anything in a SQLite DB
Mention that there is a better way, Room DB
Data Persistence the New Way11:09
We will setup a Room DB.
Discuss the various components of Room DB such as Entity and DAO
Show how to invoke a DAO function to make a DB transaction
Inserting Data and Writing Queries4:17
We will write some functions to insert data and other queries.
Show the format of a DAO function
Discuss some of the various queries we can write
Updating and Deleting Data4:37
We will write functions to update and delete data.
Discuss some of the parameters in updating data
Discuss some of the parameters in deleting data
Dynamic Data Loading3:42
We will discuss and show the traditional way of setting data to a View such as TextView or RecyclerView.
Discuss the traditional way of setting data on a View
Discuss some of the issues with it such as device rotation issues
Mention that there is a better way to do this: ViewModel
Handling Lifecycles Callbacks6:50
We will discuss Activity life cycles and how to check when each one is invoked.
Define each of the major life cycle events
Show the student how to log each of the life cycle events
Responding to State Changes5:32
Discuss what a state/configuration change is and how to handle it.
Discuss what some of the configuration changes are
Show how to handle configuration changes using SavedInstanceState
New Way to Respond to State Changes9:57
We will add LiveData to our project.
Discuss LifecycleOwner and LifecycleObserver
Discuss how to use a Lifecycle object to check an Activity’s state
Handle lifecycle events outside of an Activity
Using ViewModel to Restore and Manage Data6:10
Discuss ViewModel as a better, more modern alternative to traditional data loading.
Discuss how to add ViewModel into our app
Show why ViewModel is not affected by configuration changes
Show how to load data to a View from a ViewModel
Implementing LiveData8:59
Discuss how LiveData can help us update our View automatically.
Discuss how to add LiveData into our app
Show how to convert a ViewModel to being a LiveData object
Exploring Data Binding3:38
We will discuss what the DataBinding library is used for and set it up.
Discuss what DataBinding is
Show how to add the DataBinding library to our project
Adding Layouts and Binding Expressions7:44
We will set up a simple View to get its data using DataBinding.
Change the property of an EditText to get its data from an Automobile object
Discuss that we don’t need to write any Java/Kotlin code to update our View’s data
Bind Layout Views to Architecture Components6:17
We will combine DataBinding with a ViewModel to automatically update our View’s data when the DB updates.
Show how using a ViewModel isn’t much different from using a regular data object
Demonstrate that the View updates automatically under this setup
Implementing Paging Library4:32
We will discuss what the Paging library is used for and set it up.
Discuss what the Paging library is used for
Add the Paging library to our project
UI Components and Considerations5:50
We will set up the Paging components to get it ready to add to our RecyclerView.
Set up the DataSource
Set up the DataSource.Factory
Data Components and Considerations6:37
We will add the final pieces in implementing the Paging library by adding it into our RecyclerView.
Set up the PagedListAdapter and other components
Display the data loading in pages in our RecyclerView
Discuss changing some of the parameters such as page size
Implementing WorkManager to Schedule Tasks10:04
We will discuss what the WorkManager library is used for and set it up.
Discuss what the WorkManager library is used for
Show how to add the WorkManager library to our project
Set up a simple Worker task
Running Tasks Under Specific Conditions7:18
We will mention some of the constraints that we can run a task under.
Discuss the various constraints we can add to a Worker task
Run a sequence of Worker tasks
Discuss the problem with this technique
Setting Up Unique and Named Work Sequences6:19
We will discuss the situation where a task is scheduled to run but the previous one hasn’t completed yet.
Discuss chained tasks, which is the correct way to run tasks in sequence
Discuss the problem of running a task when the previous one isn’t yet complete
Discuss the solution to this, using Unique Named sequences
Test Your Knowledge

Requirements

No previous knowledge with Android Architecture Components is assumed.

Description

Are you willing to learn all new Android Jetpack Architecture components and features in order to deliver an extendable, maintainable, and testable codebase? Then this course is for you!

With this comprehensive guide, you'll first get started with understanding Architecture Components & exploring data binding library. Then you will learn to handle lifecycles, ViewModel, navigation architecture component & much more. Moving further, you’ll not only be able to improve the performance but also enhance the UI of your application to a whole new level using advanced Architectural Components. to enhance the UI of your app, which gives you more control on your app and makes it easy to maintain.

By end of this course, you'll be able to develop professional grade apps for the latest Android version and become a pro-Android developer with reduce the lines of code and efficiently writing your Android application in a modern way.

Contents and Overview

This training program includes 2 complete courses, carefully chosen to give you the most comprehensive training possible.

The first course, Android Jetpack Architecture Components will show you all new Android Jetpack Architecture components and features. You will develop Android applications by making use of all the architecture components available with Jetpack to reduce bugs in your codebase and provide seamless and smooth application development. Adding architectural components to your projects will increase their scalability and reduce code bugs. By the end of the course, you will know how to use Jetpack to manage background tasks, navigation, paging, life-cycle management, and much more.

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.

About the Authors:

Annapurna Agrawal is an Android developer. She has also tried her hands on JavaScript, Kotlin, PHP, jQuery, CSS, and HTML. She is a software engineer from India and likes teaching. She is one of the trainers in the Google Developers Group at Bhubaneswar, Odisha in India. Besides all this, she practices yoga and meditation, YouTubing, and hanging out with friends. We are definitely going to get the best of quality here from her.
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!

Who this course is for:

This course is for the android developer, who are willing to accelerate their development skills with less code in a more structured way & deliver maintainable, bug-free code which is achieved by using Architectural components.

Maintain Android Apps with Jetpack Architecture Components

What you'll learn

Explore related topics

Course content

Android Jetpack Architecture Components33 lectures • 2hr 53min

Modernizing Your Android Applications32 lectures • 4hr 29min

Requirements

Description

Who this course is for: