How to Code a Navigation Drawer for an Android App

Final product image — What You'll Be Creating

The Material Design team at Google defines the functionality of a navigation drawer in Android as follows:

The navigation drawer slides in from the left and contains the navigation destinations for your app.

An example of a popular Android app that implements the navigation drawer menu design is the Inbox app from Google, which uses a navigation drawer to navigate different application sections. You can check it yourself by downloading the Inbox app from the Google Play store if you don't already have it on your device. The screenshot below shows Inbox with the navigation drawer pulled open.

The user can view the navigation drawer when they swipe a finger from the left edge of the activity. They can also find it from the home activity (the top level of the app) by tapping the app icon (also known as the Android "hamburger" menu) in the action bar.

Note that if you have many different destinations (more than six, say) in your app, it's recommended that you use a navigation drawer menu design.

In this post, you'll learn how to display navigation items inside a navigation drawer in Android. We'll cover how to use Jetpack navigation to perform this task. As a bonus, you'll also learn how to use the Android Studio templates feature to bootstrap your project with a navigation drawer quickly.

Prerequisites

To be able to follow this Android Studio navigation drawer tutorial, you'll need:

Create an Android Studio Project

Fire up Android Studio and create a new project (you can name it NavigationDrawer) with an empty activity called MainActivity. Make sure to also choose the Kotlin language.

Add Project Dependencies

Support for navigation requires some dependencies. Open the app build.gradle file and add the following dependencies.

dependencies {
    def lifecycle_version = "2.2.0"
    implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
    ...
}

Also add the material library to the project.

dependencies {
    ...
    implementation "com.google.android.material:material:$version"
    ...
}

Sync the project files for the changes to take effect.

Create the `DrawerLayout`

To display the drawer icon on all destinations in our app, we will use the DrawerLayout component. Open main_acivity.xml and add DrawerLayout as the root view. The drawer layout will host two child views, NavHostFragment and NavigationView.

<?xml version="1.0" encoding="utf-8"?>
<androidx.drawerlayout.widget.DrawerLayout xmlns:android="https://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/drawer_layout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:fitsSystemWindows="true"
    tools:openDrawer="start">

<!--TOOLBAR HERE-->


<!--NavHostFragment HERE-->
       
<!--NavigationView HERE-->
       
</androidx.drawerlayout.widget.DrawerLayout>


Here we created a DrawerLayout widget with the id drawer_layout. The tools:openDrawer property is used to display the navigation drawer toggle when the XML layout is open in Android Studio design view.

The official documentation says the following about DrawerLayout:

DrawerLayout acts as a top-level container for window content that allows for interactive "drawer" views to be pulled out from one or both vertical edges of the window.

After adding the DrawerLayout widget, we included a child layout, app_bar_main.xml which points to the toolbar layout.

<!--main_activity.xml-->
<?xml version="1.0" encoding="utf-8"?>
<androidx.drawerlayout.widget.DrawerLayout 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/drawer_layout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:fitsSystemWindows="true"
    tools:openDrawer="start">

    <include
        layout="@layout/app_bar_main"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />


<!--NavHostFragment HERE-->
       
<!--NavigationView HERE-->
       
</androidx.drawerlayout.widget.DrawerLayout>


Here is my app_bar_main.xml resource file. This file has a CoordinatorLayout, an AppBarLayout, and a Toolbar widget.

<!--tool_bar_layout.xml-->
<?xml version="1.0" encoding="utf-8"?>
<androidx.coordinatorlayout.widget.CoordinatorLayout 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:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <com.google.android.material.appbar.AppBarLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:theme="@style/Theme.NavigationDrawer.AppBarOverlay">

        <androidx.appcompat.widget.Toolbar
            android:id="@+id/toolbar"
            android:layout_width="match_parent"
            android:layout_height="?attr/actionBarSize"
            android:background="?attr/colorPrimary"
            app:popupTheme="@style/Theme.NavigationDrawer.PopupOverlay" />

    </com.google.android.material.appbar.AppBarLayout>

</androidx.coordinatorlayout.widget.CoordinatorLayout>

Create a Navigation Graph

A navigation graph is an XML resource file that contains all of your app's destinations and actions, and these destinations are connected via actions. Below is an example of a navigation graph showing five fragments.

To add a navigation graph, right-click on the res directory and select New > Android Resource File. In the next dialog, select Navigation as the Resource Type, and click OK. A new XML file, nav_graph.xml, will be created in the Navigation folder, as shown below.

create a navigation graph — Create navigation graph

Add `NavHostFragment`

A navigation host fragment acts as a host for the app's fragments and swaps fragments in and out as necessary when the user moves from one destination to the other. These destinations have to be defined in the navigation graph.

Add NavHostFragment to the main_activity.xml file and reference the navGraph.

<!--main_activity.xml-->
<?xml version="1.0" encoding="utf-8"?>
<androidx.drawerlayout.widget.DrawerLayout 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/drawer_layout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:fitsSystemWindows="true"
    tools:openDrawer="start">

    <include
        layout="@layout/app_bar_main"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />


<androidx.constraintlayout.widget.ConstraintLayout
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <fragment
        android:id="@+id/nav_host_fragment"
        android:name="androidx.navigation.fragment.NavHostFragment"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:defaultNavHost="true"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:navGraph="@navigation/nav_graph" />
</androidx.constraintlayout.widget.ConstraintLayout>
       
<!--NavigationView HERE-->
       
</androidx.drawerlayout.widget.DrawerLayout>


Add Fragments to the Destination Graph

Fragments represent all the destinations of your app. In our case, we will add three fragments to the navigation graph. Right-click the navigation folder and open nav_graph.xml. To add a fragment, click on Create New Destination and fill out the rest of the details.

Repeat the same steps and create two additional fragments, the profile fragment and the settings fragment. Your navigation graph should now look like this.

Add a `NavigationView` Component

Finally, let's create a NavigationView widget. The official documentation says the following about NavigationView:

NavigationView represents a standard navigation menu for application. The menu contents can be populated by a menu resource file.

Open main_activity.xml and add the NavigationView.

<!--main_activity.xml-->
<?xml version="1.0" encoding="utf-8"?>
<androidx.drawerlayout.widget.DrawerLayout 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/drawer_layout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:fitsSystemWindows="true"
    tools:openDrawer="start">

    <include
        layout="@layout/app_bar_main"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />


<androidx.constraintlayout.widget.ConstraintLayout
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <fragment
        android:id="@+id/nav_host_fragment"
        android:name="androidx.navigation.fragment.NavHostFragment"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:defaultNavHost="true"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:navGraph="@navigation/nav_graph" />
</androidx.constraintlayout.widget.ConstraintLayout>
       
<com.google.android.material.navigation.NavigationView
        android:id="@+id/nav_view"
        android:layout_width="wrap_content"
        android:layout_height="match_parent"
        android:layout_gravity="start"
        android:fitsSystemWindows="true"
        app:headerLayout="@layout/nav_header_main"
        app:menu="@menu/drawer_menu" />
       
</androidx.drawerlayout.widget.DrawerLayout>


In the NavigationView XML widget, you can see that we added an android:layout_gravity attribute with the value start. This is used to position the drawer—you want the navigation drawer menu design to come out from the left or right (the start or end on platform versions that support layout direction). In our own case, the drawer will come out from the left.

We also included an app:headerLayout attribute, which points to @layout/nav_header_main. This will add a View as a header of the navigation menu.

Here is my nav_header_main.xml layout resource file:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="@dimen/nav_header_height"
    android:gravity="bottom"
    android:orientation="vertical"
    android:theme="@style/ThemeOverlay.AppCompat.Dark">

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:paddingTop="@dimen/nav_header_vertical_spacing"
        android:text="@string/nav_header_title"
        android:textAppearance="@style/TextAppearance.AppCompat.Body1" />

</LinearLayout>

To include the menu items for the navigation drawer, we can use the attribute app:menu with a value that points to a menu resource file.

1	app:menu="@menu/drawer_menu" />

Here is the res/menu/drawer_menu.xml menu resource file:

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    tools:showIn="navigation_view">

    <group android:checkableBehavior="single">
        <item
            android:id="@+id/nav_home"
            android:icon="@drawable/home"
            android:title="@string/menu_home" />
        <item
            android:id="@+id/nav_gallery"
            android:icon="@drawable/person"
            android:title="@string/menu_gallery" />
        <item
            android:id="@+id/nav_slideshow"
            android:icon="@drawable/settings"
            android:title="@string/menu_slideshow" />
    </group>
</menu>

Here we have defined a Menu using the <menu> which serves as a container for menu items. An <item> creates a MenuItem, which represents a single item in a menu. It's also important to note that the ids of the menu items correspond to the ids of the matching fragment.

Note that when showing the navigation list items from a menu resource, we could use a ListView instead. But, by configuring the navigation drawer with a menu resource, we get the material design styling on the navigation drawer for free! If you used a ListView, you'd have to maintain the list and also style it to meet the recommended material design specs for the navigation drawer.

Initialization of Components

Next, we are going to initialize instances of all our components. Initialization is going to happen inside onCreate() in MainActivity.kt.

The AppBarConfiguration object is used to manage the behavior of the navigation drawer button.

1	private lateinit var appBarConfiguration: AppBarConfiguration

First, we use the setSupportActionBar() method to set the toolbar as the app bar for the activity.

1	val toolbar: Toolbar = findViewById(R.id.toolbar)
2	setSupportActionBar(toolbar)

Next, we set all fragments as top-level destinations, this means that they will remain in the back stack when navigating.

1	// Passing each menu ID as a set of Ids because each
2	// menu should be considered as top level destinations.
3	appBarConfiguration = AppBarConfiguration(setOf(
4	R.id.home_menu, R.id.profile_menu, R.id.settings_menu), drawerLayout)

The method setupActionBarWithNavController automatically updates the title in the action bar when the destination changes.

1	setupActionBarWithNavController(navController, appBarConfiguration)

Set up the navigation drawer.

1	val navView: NavigationView = findViewById(R.id.nav_view)
2	val navController = findNavController(R.id.nav_host_fragment)
3	navView.setupWithNavController(navController)

Lastly, show the up button that appears at the top left of the app bar. This is done by integrating the navigation controller withe app bar using the onSupportNavigateUp method.

The final code for MainActivity.kt should look like this.

package com.example.navigationdrawer

// imports

class MainActivity : AppCompatActivity() {

    private lateinit var appBarConfiguration: AppBarConfiguration

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val toolbar: Toolbar = findViewById(R.id.toolbar)
        setSupportActionBar(toolbar)
        ///
        val drawerLayout: DrawerLayout = findViewById(R.id.drawer_layout)
        val navView: NavigationView = findViewById(R.id.nav_view)
        val navController = findNavController(R.id.nav_host_fragment)
        // Passing each menu ID as a set of Ids because each
        // menu should be considered as top level destinations.
        appBarConfiguration = AppBarConfiguration(setOf(
                R.id.nav_home, R.id.nav_gallery, R.id.nav_slideshow), drawerLayout)
        setupActionBarWithNavController(navController, appBarConfiguration)
        navView.setupWithNavController(navController)
    }


    override fun onSupportNavigateUp(): Boolean {
        val navController = findNavController(R.id.nav_host_fragment)
        return navController.navigateUp(appBarConfiguration) || super.onSupportNavigateUp()
    }
}


Testing the App

At this point, we can run the app!

Bonus: Using Android Studio Templates

Now that you've learnt about the APIs involved to create a navigation drawer, I'll show you a shortcut that will make it faster next time. You can simply use a template instead of coding a navigation drawer Activity from scratch.

Android Studio provides code templates that follow the Android design and development best practices. These existing code templates (available in Java and Kotlin) can help you quickly kick-start your project. One such template can be used to create a navigation drawer activity.

I'll show you how to use this handy feature in Android Studio.

For a new project, fire up Android Studio.

Android Navigation Drawer Design Tutorial Create Android Project dialog

Enter the application name and click the Next button.

You can leave the defaults as they're in the Target Android Devices dialog. Click the Next button again.

Android Navigation Drawer Design Tutorial Add an Activity to Mobile dialog

In the Add an Activity to Mobile dialog, scroll down and select Navigation Drawer Activity. Click the Next button after that.

Android Navigation Drawer Design Tutorial Configure Activity dialog

In the last dialog, you can rename the Activity name, layout name, or title if you want. Finally, click the Finish button to accept all configurations.

Android Studio has now helped us to create a project with a navigation drawer activity. Really cool! You're strongly advised to explore the code generated.

You can use templates for an already existing Android Studio project too. Simply go to File > New > Activity > Navigation Drawer Activity.

Android Navigation Drawer Design Tutorial Navigation from file menu too Navigation Drawer Activity

Top Android App Templates With Navigation Drawers From CodeCanyon

The templates that come included with Android Studio are good for simple layouts and making basic apps, but if you want to kick-start your app even further, you might consider some of the app templates available from Envato Market.

They’re a huge time-saver for experienced developers, helping them to cut through the slog of creating an app from scratch and focus their talents instead on the unique and customised parts of creating a new app.

Here are just a small handful of the thousands of Android app templates available on CodeCanyon. If there's one that piques your interest, you can easily get started by making a purchase.

Grocery and Vegetable Delivery Android App with Admin Panel

If you or your client have a food delivery business, getting an app up and running is crucial. That's why you should consider this multi-store grocery service app template. It includes three templates with stunning layouts and Android hamburger menus. There's no limit to the categories you can add, and you can also use SMS and email order notifications.

Grocery and Vegetable Delivery Android App Template

Universal: Full Multi-Purpose Android App

Buying the Universal Android app template is just like downloading a Swiss Army knife. It can do it all, from WordPress and Facebook to Twitter and SoundCloud. In fact, there is a list of more than 15 content providers that this template supports. Users can access important information from the slick side menu design and easily make their way around their favorite sites.

Universal Multi Purpose Android App Template

MaterialX: Android Material Design UI Components 2.7

MaterialX is a recommended download for any app developer. It includes more than 315 unique UI components across more than 31 categories. Create stunning Android side menu designs, buttons, dialog boxes, and more from this single download. If you want a quick way to add some much-needed style to your new project, get this template.

MaterialX Android Material Design UI Components Download

Universal Android WebView App

Do you have content hosted online that you want to turn into a mobile experience? Then check out the Universal Android WebView App template. It was developed in Android Studio and supports phones and tablets running Android 4.1 and above. The Android navigation drawer menu design is completely customizable, as are other components. It also supports AdMob for monetization.

Universal Android WebView App Template

Android Wallpapers App

Here's a cool Android app template that's useful if you want to get your creative designs out into the world. The Android Wallpapers app supports static images, GIFs, and 4K photos. This template also includes useful features like:

pinch to zoom
push notifications
AdMob advertisement support
Android Studio code

Android Wallpapers App Template

Conclusion

In this tutorial, you learned how to create a navigation drawer menu design in Android from scratch, using Jetpack navigation. We also explored how easy and quick it is to use Android Studio templates to create a navigation drawer.

I highly recommend checking out the official material design guidelines for navigation drawers to learn more about how to properly design and use navigation drawers in Android.

To learn more about coding for Android, check out some of our other courses and tutorials here on Envato Tuts+!