Add Navigation Components to the Project

Navigation helps the users navigate inside the application between fragments and the activity. Navigation Component, on the other hand, is part of Android Jetpack and helps us (the developers) build navigation for component clicks, deep links and more.

Navigation Component consists of Navigation Graph, Nav Host and the Nav Controller. We will talk about them in detail throughout the article and implement it.

navigation_component_android

1. First, add the dependencies to the module level build.gradle file.

implementation 'androidx.navigation:navigation-fragment-ktx:2.2.0'
implementation 'androidx.navigation:navigation-ui-ktx:2.2.0'

2. Create a Nav Host

The Nav Host is a container for all the fragments to be shown on. With the help of Nav Controller, the developer can navigate the user between fragments and nested nav graphs.

<fragment android:layout_width="match_parent"
    android:id="@+id/nav_host_fragment"
    app:defaultNavHost="true"
    app:navGraph="@navigation/main_navigation"
    android:name="androidx.navigation.fragment.NavHostFragment"
    android:layout_height="match_parent"/>

In the above implementation, three attributes are important namely, android:name, app:navGraph and app:defaultNavHost.

android:name contains the name of the NavHostFragment. app:navGraph contains the path to the navigation graph. Set app:defaultNavHost to true which ensures appropriate behavior for back button clicks.

3. Create a Navigation Graph and add Fragments

Create a Navigation Graph with the name main_navigation.xml inside the navigation folder. Navigation Graph contains the destinations and actions. Destinations are the fragments the user interacts with and the action shows user navigation inside the app (as shown in the figure above).

navigation_component_create

<navigation xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/main_navigation"
    app:startDestination="@id/loginFragment">

    <fragment
        android:id="@+id/loginFragment"
        android:name="com.gsrikar.ecommerce.ui.login.LoginFragment"
        android:label="Login"
        tools:layout="@layout/login_fragment" />
</navigation>

To add LoginFragment to the Navigation Graph, set fragment class name to the android:name attribute and toolbar title as android:label.

Set any fragment id to the app:startDestination and this is the first and the last screen the user sees when opening the application or closing it.

Finally, you can remove the fragment transactions from the activity or other fragments like below.

if (savedInstanceState == null) {
    supportFragmentManager.beginTransaction()
        .replace(R.id.container, LoginFragment.newInstance())
        .commitNow()
}

Run the application and you should see the Login Fragment.

Popular posts from this blog

Run the Emulator directly in Android Studio

Image
In Android Studio 4.1, a minor feature is released to reduce the screen (or window) switching between Android Studio and the Emulator. Using this feature, we can now run the Emulator directly inside the Android Studio. We can make the changes to the code and see the changes reflect in the emulator in the same window similar to layout XML and its preview. To achieve this, open the Preferences window and select the Emulator menu item under the Tools expandable menu. Here we can check the option Launch in a tool window and click OK . Now run the Emulator to see it inside the Android Studio window.
Read more

Listen to Back Button Clicks in Fragment

Listening to the back button click event inside the fragments, comprised of a painful implementation of the interfaces and the onBackPressed method calls in both Activity and Fragment, prior to the introduction of the OnBackPressedDispatcher . But now, inside a Fragment, the back button behaviour can be controlled by listening to the callback returned by the OnBackPressedDispatcher . This callback listener is implemented inside the  onCreate overridden method. override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // Listen to Back button clicks val callback = requireActivity().onBackPressedDispatcher.addCallback(this) { // Handle the back button event } } Use onBackPressedDispatcher method to get the OnBackPressedDispatcher and add the callback using the addCallback method. This callback method takes a lifecycle owner. Handle the back button events whenever the callback gets triggered. The same implementation can be d...
Read more

How to Read Metadata from AndriodManifest File

Metadata tags are key-value pairs and one of the decent ways to access the API keys from the libraries. They are added to the AndroidManifest.xml under the application tag and are available through the PackageManager . If you have worked with third-party libraries or even with App shortcuts, Downloadable Fonts, Firebase MLKit, you may have come across metadata tags. In the article, let’s add the metadata tags to the app module’s Manifest file and read the metadata key-values and the key-resource from a library module both in kotlin and java. Add meta-data: Add metadata to the app module's AndroidManifest.xml file under the application tag. You can add as many metadata elements as you want and you can also add metadata under the activity, service, broadcast receiver, content provider tags. <meta-data android:name= "com.gsrikar.library.LIBRARY_ACCESS_KEY" android:value= "masndfiu4er9funwikesd" /> <meta-data and...
Read more

Create Assets Folder, Add Files and Read Data From It

Image
Sometimes, we need to read the data stored in the files during runtime and want to make sure the data is not tampered by the Android build system. In this article, we will take a look at how to create the assets folder using Android Studio and read the stored data from it. First, Right-click on the module name or the package name. This opens an option window where we need to select the Assets Folder option by hovering over New and then on the Folder option. Now, we will see a window where we change the folder location and the source set. Change the values if necessary otherwise keep the defaults and click Finish. It may trigger a Gradle Sync. Irrespective of the sync, the Assets folder is created and is visible in the module. Now, Right-click on the Assets folder and click on the File option by hovering over the New option. Enter the name of the file name and click Enter to create the file. The file with the name user_details.json is created under the assets folder. Add some JSON...
Read more

The Kano Method in Product Management: A Comprehensive Guide

Image
Introduction Understanding what truly delights customers is one of the biggest challenges in product management. While some features are essential, others can significantly enhance customer satisfaction or even exceed expectations. The Kano Method is a powerful prioritization framework that helps product managers classify product features based on how they impact customer satisfaction. Developed by Professor Noriaki Kano in the 1980s, this method categorizes product features into different types of customer needs—ranging from basic expectations to features that create excitement. By using the Kano model, product managers can prioritize features that maximize customer satisfaction while balancing essential functionality. In this article, we'll dive deep into the Kano Method, its categories, how to apply it, and why it’s a game-changer for product prioritization. What? The Kano Method is a customer satisfaction framework that helps product managers categorize product features based o...
Read more