Open In App

UI Components of Android Jetpack

Last Updated : 01 Jun, 2021
Like Article

Android Jetpack is a set of software components, libraries, tools, and guidance to help in developing robust Android applications. Launched by Google in 2018, Jetpack comprises existing android support libraries, android architecture components with an addition of the Android KTX library as a single modular entity. Nowadays, nearly 99% of the apps present on the Google Play Store uses Android Jetpack libraries. The UI area includes widgets, animations, palettes, etc to improve the user experience. It also provides up-to-date emoji fonts to be used in the apps. This article explains each and every library of the UI component in detail. Jetpack consist of a wide collection of libraries that are built in a way to work together and make robust mobile applications. Its software components have been divided into 4 categories:

  1. Foundation Components
  2. Architecture Components
  3. Behavior Components
  4. UI Components

Further, the following are the list of all UI components:

  1. Animation & Transition
  2. Auto
  3. Emoji
  4. Fragment
  5. Layout
  6. Palette
  7. TV
  8. Wear

Ways to include Android Jetpack libraries in the application

  • Add google repository in the build.gradle file of the application project.

allprojects {

repositories {





  • All Jetpack components are available in the Google Maven repository, include them in the build.gradle file

allprojects {

repositories {


    maven { url ‘’ }



UI Components

1. Animation & Transition

Jetpack offers APIs to set up different kinds of animations available for Android apps. This framework imparts the ability to move widgets as well as switching between screens with animation and transition in an application. To improve the user experience, animations are used to animate the changes occurring in an app and the transition framework gives the power to configure the appearance of that change. Developers can manage the way in which the transition modifies the application appearance while switching from one screen to another. Jetpack Compose is the toolkit used for building native Android UI. It offers a more modular approach for developing the apps by organizing the code in smaller and reusable components. These components are easy to maintain and the code written in it describes the appearance of a UI in a declarative fashion i.e., based upon the available state. Developers use this declarative nature of Jetpack Compose to showcase complex animations in a beautiful and expressive manner.   

 A composable named Transition is used to create animations in Android. Its flexible nature allows developers to easily pass the information to the user through animating a component’s property. Following are the elements involved in Transition composable that controls the overall animation of a component:

  • TransitionDefinition: Includes definition of all animations as well as different states of animation required during the transition.
  • initState: Describe the initial stage of the transition. If it is undefined, it takes the value of the first toState available in the transition.
  • toState: Describe the next state of the transition. 
  • clock: Manage the animation with the change in time. It is an optional parameter.
  • onStateChangeFinished: An optional listener that notifies the completion of a state change animation.
  • children: It is composable that will be animated.

Method signature of Transition:


fun <T> Transition(

   definition: TransitionDefinition<T>,

   toState: T,

   clock: AnimationClockObservable = AnimationClockAmbient.current,

   initState: T = toState,

   onStateChangeFinished: ((T) -> Unit)? = null,

   children: @Composable() (state: TransitionState) -> Unit


Android Jetpack provides some predefined animation builders that developers can use directly in their app. The TransitionDefinition includes the code for all these animations.

  1. Tween: To animate the geometrical changes of an object like moving, rotating, stretching, etc.
  2. Physics: To define spring animations for an object by providing a damping ratio and stiffness.
  3. Keyframe: To create an animation in which the value of the target object changes over the course of time. 
  4. Snap: To animate the instant switch from one state to another.  
  5. Repeatable: Used to repeat an animation as many times as the developer wants.

2. Auto

Nowadays people are dependent upon smartphone apps up to such an extent that they need them even while driving. The reason for using the mobile phone can be an urgent call or to just enjoy music. Google realized this use case and developed Android Auto with a vision to minimize the driver’s interaction with the phone as well as to assure safety plus security on the road. The task is to bring the most practical applications to the user’s smartphone or on the compatible car display. Android Auto offers an extensive list of applications to use conveniently on the vehicle’s display. The following category of applications can be built, test, and distributed on Android Auto:      

  1. Navigation apps: The Google Maps navigation interface enables a user to set destinations, choose various routes, and view live traffic. It assists the driver through voice-guided driving directions at every turn and also estimates the arrival time of the destination. This application continues to run in the background even if the user switches to another screen. Moreover, users can also set other interest in this app like parking and location of gas stations, restaurants, etc.
  2. Messaging apps: Messaging or calling someone is likely the most dangerous thing while driving. To take care of this issue, Android Auto provides messaging apps that receive messages/notifications and read them aloud using the text-to-speech feature. Users can also send replies through voice input in the car. To activate the hands-free voice commands in Android Auto, one can press the “talk” button on the steering wheel or can trigger the device by saying “Ok Google”.
  3. Media apps: This kind of apps allows users to browse and play any type of audio content in the car. It accepts voice commands to play radio, music, or audiobooks.       

Note: Android Auto is compatible only with phones running on Android 6.0 (API level 23) or higher. 

Jetpack libraries offer two options for developing android apps for cars namely Android Auto and Android Automotive OS. Android Auto apps along with an Android phone are capable of providing a driver-optimized app experience. On the other hand, Android Automotive OS is an Android-based infotainment system that is embedded into vehicles. With this, the car becomes a self-supporting Android device that can run applications directly on the car’s screen. Developers prefer one app architecture while building applications to cover both use cases.     

3. Emoji

If an application is used to communicate between people, emojis are definitely going to be a part of that app. The Unicode standard is adding new emojis very frequently, thus it becomes important that the user should be able to see the latest Emoji irrespective of the android device version. Google has released a brand new library called EmojiCompat in order to handle emoji characters and to use downloadable font support. This library assures that an app is up to date with the latest emojis irrespective of the device OS version. EmojiCompat identifies an emoji using its CharSequence and replaces them with EmojiSpans(if required) to assure that the sender and receiver will observe the emoji in the exact same way. Users need to update this library dependency regularly to have the latest emojis. If an application is not using the EmojiCompat library, then the user will see an empty box with the cross sign(☒) in place of an emoji. The backward compatibility of this library is up to Android 4.4(API level 19). For the Android OS version lower than that, the emoji will be displayed exactly like a regular TextView.

Adding the EmojiCompat support library into the Project: 

  • Add the below-mentioned implementation in the app-level build.gradle file. 

   dependencies {



       implementation “androidx.emoji:emoji:28.0.0”


  • For using Emoji Widgets in AppCompat, add the AppCompat support library to the dependencies section

dependencies {



       implementation “androidx.emoji:emoji-appcompat:$version”


Emoji Views / Widgets:




4. Fragment

The Fragment support class of Android has shifted into this segment of Jetpack. Fragments allow separating the UI into discrete pieces that brings modularity and reusability into the UI of an activity. A part of the user interface is defined by a fragment which is then embedded into an activity. There is no existence of fragments without an activity. With the release of Android Jetpack, Google provided some major improvements and advanced features in using the fragments. Navigation, BottomNavigationView, and ViewPager2 library of the Jetpack are designed to work with fragments in a much more effective way. Moreover, the proper integration of the fragment class with the lifecycle class of the jetpack architecture component is also guaranteed. Following is the list of newly added features and improvements by Google for Android developers:

a. Sharing and communicating among fragments:

In order to maintain the independent fragments, developers write code in such a way that does not allow fragments to communicate directly with other fragments or with their host activity. The Jetpack fragment library provides two options to establish the communication namely Fragment Result API and shared ViewModel. The Fragment Rest API is suitable for one-time results with data that could be accommodated in a bundle. Further, if there is a requirement to share persistent data along with any custom APIs, ViewModel is preferred. It is also capable of storing and managing UI data. Developers can choose between the two approaches according to the requirement of the app. 

b. Constructor can hold the Layout resource ID:

The AndroidX AppCompat 1.1.0  and Fragment 1.1.0 enable the constructor to take the layout ID as a parameter. With this, a considerable decrease in the number of method overrides is observed in fragments. Now, the inflater can be called manually to inflate the view of a fragment, without overriding the onCreateView() method. This makes the classes more readable. 

class MyFragmentActivity: FragmentActivity(R.layout.my_fragment_activity)

class MyFragment : Fragment(R.layout.my_fragment)

c. FragmentManager and Navigation library:

All crucial task of a fragment like adding, removing, replacing as well as sending them back to the stack is carried out by the FragmentManager class. To handle all these navigation-related tasks, Jetpack recommends using the Navigation library. The framework of this library provides some best practices for developers so that they can work effectively with fragments, fragment manager, and the back stack. Every android application that contains fragments in its UI, have to use FragmentManager at some level. However, developers might not interact with the FragmentManager directly while using the Jetpack Navigation library.

d. FragmentFactory: 

Android developers had always raised the issue with Fragments that there is no scope of using a constructor with arguments. For instance, developers cannot annotate the fragment constructor with Inject and specify the arguments while using Dagger2 for dependency injection. The AndroidX library introduced along with Jetpack offers FragmentFactory class that is capable of handling this and similar issues related to fragment creation. The structure of this API is straightforward and generalized which facilitates developers to create the fragment instance in their own customized way. In order to override the default way of instantiating the Fragment, one has to register the FragmentFactory in the FragmentManager of the application.

class MyFragmentFactory : FragmentFactory() {

 override fun instantiate(classLoader: ClassLoader, className: String): Fragment {

   // loadFragmentClass() method is called to acquire the Class object

   val fragmentClass = loadFragmentClass(classLoader, className)


   // use className or fragmentClass as an argument to define the    

   // preferred manner of instantiating the Fragment object

   return super.instantiate(classLoader, className)



e. Testing fragments:

AndroidX Test has been launched by Google to make testing a necessary part of Jetpack. The existing libraries along with some new APIs and full Kotlin support of the AndroidX Test provides a way to write suitable and concise tests. FragmentScenario class of the AndroidX library construct the environment for performing tests on fragments. It consists of two major methods for launching fragments in a test, the first one is launchInContainer() that is used for testing the user interface of a fragment. Another method is the launch() that is used for testing without the fragment’s user interface. In some cases, fragments have some dependencies. To generate test versions of these dependencies, one has to provide a custom FragmentFactory to the launchInContainer() or launch() methods. Developers can choose one of the methods and can use Espresso UI tests to check out the information regarding the UI elements of the fragment. For using FragmentScenario class, one needs to define the fragment testing artifact in the app-level build.gradle file.

dependencies {

   def fragment_version = “1.2.5”

   debugImplementation “androidx.fragment:fragment-testing:$fragment_version”


f. FragmentContainerView:

AndroidX Fragment 1.2.0 brings FragmentContainerView that extends FrameLayout and provides customized layout design for the fragments in android apps. It is used as a parent to the fragment so that it can coordinate with fragment behavior and introduce flexibility in the tasks like Fragment Transactions. It also supports the <fragment> attributes and addresses the issues of window insets dispatching. Moreover, this container resolves some animation issues related to the z-ordering of fragments like exiting fragments no longer appear on the top of the view. 

5. Layout

User interface structure like the activity of an application is defined by Layout. It defines the View and ViewGroup objects. View and ViewGroup can be created in two ways: by declaring UI elements in XML or by writing code i.e., programmatically. This portion of Jetpack covers some of the most common layouts like LinearLayout, RelativeLayout, and the brand new ConstraintLayout. Moreover, the official Jetpack Layout documentation provides some guidance to create a list of items using RecyclerView and the card layout using CardView. A View is visible to the user. EditView, TextView, and Button are examples of View. On the other hand, a ViewGroup is a container object that defines layout structure for View(s) and thus it is invisible. Examples of ViewGroup are LinearLayout, RelativeLayout, and ConstraintLayout.

6. Palette

Providing the right color combination plays a major role in uplifting the user experience. Thus it is an important aspect during the app development process. Developers often build applications in which UI elements change their color according to the time(day and night). This type of practice gives the user a good kind of feeling and assure an immersive experience during app usage. To carry out these tasks, Android Jetpack provides a new Palette support library. It is capable of extracting a small set of colors from an image. The extracted color style the UI controls of the app and update the icons based on the background image’s color. The Material Design of android apps is the reason behind the popularity of dynamic use of color. The extracted color or palette contains vibrant and muted tones of the image. It also includes foreground text colors to ensure maximum readability.              

To include Palette API in a project, update the app-level build.gradle file in the following manner:

dependencies {



   implementation ‘androidx.palette:palette:1.0.0’  


The palette gives the choice to developers to select the number of colors they want to be generated from a certain image source. The default value of numberOfColors in the resulting palette is set as 16. However, the count can go up to 24-32. The time taken in generating the complete palette is directly proportional to the color count. Once the palette is generated, a swatch(a kind of method) is used to access those colors. Each color profile has an associated swatch that returns the color in that palette. Following are the color profiles generated by the palette API:



Light Vibrant Palette.getLightVibrantSwatch()
Vibrant Palette.getVibrantSwatch()
Dark Vibrant Palette.getDarkVibrantSwatch()
Light Muted Palette.getLightMutedSwatch()
Muted Palette.getMutedSwatch()
Dark Muted Palette.getDarkMutedSwatch()

7. TV

Jetpack offers several key components to assist developers in building apps for Android Smart TVs. The structure of the Android TV application is the same as the mobile/tablet apps, however, there are some obvious differences. The hardware and controllers of a TV are very much different than mobile devices. Further, the navigation system is to be handled through a d-pad on a TV remove(up, down, left, and right arrow buttons). To address these concerns, Jetpack offers Leanback library. This library also resolves the issue of searching as well as recommending content to the user on Android TV.

The dependency of the leanback library can be added in the app build.gradle file:

dependencies {

   def leanback_version = “1.0.0”

   implementation “androidx.leanback:leanback:$leanback_version”


8. Wear OS

Android version for wearable devices is called Wear OS. Android Jetpack includes the Wear UI library that enables developers to create apps that can play and control media from a watch. A standalone watch app or watch face can also be created using the UI component of the library. Jetpack assures that the user interface remains optimized and compatible across all apps. Wear OS also supports mobile device features like notifications and ‘actions on Google’. Developers can develop three kinds of systems under the Wear OS:

  1. Wear apps: Applications that will run on smartwatches or gears. It supports device features like sensors and the GPU.
  2. Watch faces: It is specially made for custom drawings, colors, animations, and contextual information.
  3. Complication data providers: Provides custom data such as text, images, etc. to watch faces.  

Wear UI Library can be used by adding the following dependency in the Wear module’s build.gradle file:

dependencies {



   compile ‘androidx.wear:wear:1.0.0’

Like Article
Suggest improvement
Share your thoughts in the comments

Similar Reads