What is Android Jetpack?
In the last few years, android development has been moving at breathtaking pace. Features and tools are being released year in year out. This is making android development much easier and android apps more powerful and reliable. However we developers must also keep learning to stay in tune and enjoy these new features and tools.
Android engineers released Jetpack a few years back, a collection of libraries and tools that allow us write high quality maintenable applications. Jetpack easens some complex tasks and allow us avoid boilerplate code by guiding us to write apps with best practices in mind.
Making up the Jetpack is the androidx
package. Thus Jetpack respects backward compatibility.Android documentation furthermore claims that it gets updated even more frequently than the android platform itself.
Advantages of Jetpack
- Through Jetpack we get free management of intensive activities like background tasks, navigation and lifecycle. Through this we are allowed to focus our efforts on ideas and how to implement and not the nitty gritty of the framework.
- Apps based on Jetpack are standing on a firm foundation due to the modern practices on which Jetpack components are built on. Thus they are less likely to crash or encounter memory leaks.
- The components making up Jetpack are designed to seamlessly integrate with each other.You can use one, two or all of them. They are also designed to allow to take advantage of modern language features. Thus you end up becoming more productive.
- Jetpack’s Arch Foundation components provide backward compatibility as well. Moreover you can use Kotlin if you so desire.
- Jetpack’s Arch or Architecture allow you write easily testable code by employing modern best practices.Thus this easens maintenance.
Categories of Jetpack Components
Jetpack components are divided in the following categories:
- Foundation Components
- Architecture Components
- Behavior Components
- UI Components.
Let’s look at them one by one.
1. Foundation Components
According to Android’s documentation, these provide cross cutting functionality like backwards compatibility, testing and Kotlin language support.
They include:
No. | Name | Description |
---|---|---|
1. | Android KTX | Through this we can write concise,idiomatic code in Kotlin |
2. | AppCompat | Provides us with features with backward compatibility |
3. | Auto | Provides us components for Android Auto development |
4. | Benchmark | You can use this to benchmark your code, be it Java or Kotlin |
5. | MultiDex | To provide support for apps with multiple DEX files. |
6. | Test | A framework for unit and runtime UI tests |
7. | TV | To be used for Android TV development. |
8. | Wear OS by Google | For android wear development |
2. Architecture Components
This category is probably the most flashy.
You may have already heard or used these components. Through arch components you can create highly robust, testable and maintenable apps.
They include:
No. | Name | Description |
---|---|---|
1. | Data Binding | Data Binding allows you to bind your data to the UI declaratively. |
2. | Lifecycles | Provides management of activity and fragment lifecycles. Thus your app is able to survive configuration changes and avoid memory leaks. |
3. | LiveData | To notify views when the underlying data source changes. LiveData allows us build data objects which inform views when the data source changes. This allows us UI to update itself reactively. |
4. | Navigation | To provide handling of in app navigation |
5. | Paging | To allow you load data in chunks from a data source. |
6. | Room | To provide abstraction over SQLite database in a fluent manner. Room provides classes and interfaces that map to SQLite. Thus we don’t have to write boilerplate code to do that.Furthermore Rooms gives us compile-time checks of SQLite statements. |
7. | ViewModel | Allows you manage UI related data with lifecycle changes in mind. Thorugh ViewMdel you can store UI related data which isn’t destroyed by the system on configuration changes. |
8. | WorkManager | To allow you flexibly manage android background jobs. |
Adding Architecture Components
Architecture Components are available from Google’s Maven repository. So go to your root level build.gradle
and add the following:
allprojects { repositories { google() jcenter() } }
NB/= Root level build.gradle is located in your project’s root folder.
Then you move to your app level(located in app folder) build.gradle and add the specific artifacts you need. Here is an example:
dependencies { implementation fileTree(dir: 'libs', include: ['*.jar']) // Room components implementation 'androidx.room:room-runtime:2.0.0' annotationProcessor 'androidx.room:room-compiler:2.0.0' // Lifecycle components implementation 'androidx.lifecycle:lifecycle-extensions:2.0.0' annotationProcessor 'androidx.lifecycle:lifecycle-compiler:2.0.0'
3. Behavior Components
In Behavior Components you get a more flexible integration with android services like notifications, permissions, sharing and assistant.
No. | Name | Description |
---|---|---|
1. | CameraX | To allow you add camera capabilities to your apps easily. |
2. | Download Manager | To help you manage downloads of large files. |
3. | Media and PlayBack | To provide you with backwards compatible media playback and routing APIs. |
4. | Notifications | To provide a backwards compatible API for notifications. This includes Auto and Wear support. |
5. | Permissions | To provide compatibility APIs for checking and requesting permissions. |
6. | Preferences | To allow you create preference or settings screens. |
7. | Sharing | To provide a share action suitable for an app’s actionbar. |
8. | Slices | Create flexible UI elements that can display app data outside the app |
4. UI Components
Lastly we have UI Components. These are a set of widgets and helpers not only to easen the UI creation process but also make UI more modern.
No. | Name | Description |
---|---|---|
1. | Animations and Transitions | To allow controlled movement of UI widgets within and between the screens. |
2. | Emoji | To allow for emoji font usage even on older devices. |
3. | Fragment | Units of UI. |
4. | Layouts | To allow arrangement of UI widgets using various algorithms. |
5. | Palette | To allow for pulling of useful information out of Color palettes. |