Mastering Immersive Mode: Make Your Android Navigation Bar Appear Using Kotlin and Jetpack Compose

Welcome to the world of immersive Android app development! In this comprehensive guide, we’ll dive into the fascinating realm of immersive mode, where the navigation bar magically appears and disappears. You’ll learn how to harness the power of Kotlin and Jetpack Compose to create an incredible user experience. Buckle up, and let’s get started!

Why Immersive Mode Matters?

Immersive mode is a game-changer for Android app developers. By hiding the navigation bar, you can:

• Maximize screen real estate, providing a more immersive experience for users.
• Enhance visual appeal, making your app stand out from the competition.
• Optimize app performance, reducing distractions and increasing engagement.

Preparation is Key

Before we dive into the code, make sure you have the following tools and libraries installed:

• Kotlin 1.5 or higher
• Jetpack Compose 1.0 or higher
• Android Studio 4.2 or higher

Step 1: Create a New Compose Project

Open Android Studio and create a new project using the “Empty Compose Activity” template. Name your project, e.g., “ImmersiveModeDemo”. Once the project is created, navigate to the “MainActivity.kt” file.

// MainActivity.kt
import androidx.compose.foundation.layout.*
import androidx.compose.material.*
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview

@Composable
fun MainScreen() {
    Box(modifier = Modifier.fillMaxSize()) {
        // We'll add our immersive mode code here
    }
}

@Preview
@Composable
fun DefaultPreview() {
    MainScreen()
}

Step 2: Add the Window Flags

To enable immersive mode, we need to add the necessary window flags. Update the “MainActivity.kt” file by adding the following code:

// MainActivity.kt
import android.os.Build
import android.view.WindowInsets
import android.view.WindowInsetsController

@Composable
fun MainScreen() {
    val window = (LocalContext.current as Activity).window
    val insetsController = window.insetsController

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
        insetsController?.hide(WindowInsets.Type.systemBars())
    } else {
        window.decorView.systemUiVisibility = (
                View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
                        or View.SYSTEM_UI_FLAG_FULLSCREEN
                        or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
                        or View.SYSTEM_UI_FLAG_LAYOUT_STABLE
                        or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                        or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                )
    }

    Box(modifier = Modifier.fillMaxSize()) {
        // We'll add our navigation bar code here
    }
}

Step 3: Create a Custom Navigation Bar

In immersive mode, the default navigation bar is hidden. We need to create a custom navigation bar that will appear and disappear as needed. Add the following code to the “MainActivity.kt” file:

// MainActivity.kt
@Composable
fun CustomNavigationBar(modifier: Modifier = Modifier) {
    val navBarController = rememberNavController()
    val navBackStackEntry by navBarController.currentBackStackEntryAsState()

    val navBarPadding = remember {
        mutableStateOf(PaddingValues())
    }

    Box(modifier = modifier) {
        NavigationBar(
            modifier = Modifier
                .fillMaxWidth()
                .padding(navBarPadding.value),
            backgroundColor = Color.White,
            elevation = 4.dp
        ) {
            NavBarItem(
                icon = {
                    Icon(
                        imageVector = Icons.Filled.ArrowBack,
                        contentDescription = "Back"
                    )
                },
                onClick = navBarController::popBackStack
            )
        }
    }
}

Step 4: Add Navigation Bar Logic

We need to add logic to show and hide the custom navigation bar based on user interactions. Update the “MainActivity.kt” file with the following code:

// MainActivity.kt
@Composable
fun MainScreen() {
    // ...

    val navBarVisible = remember {
        mutableStateOf(false)
    }

    Box(modifier = Modifier.fillMaxSize()) {
        if (navBarVisible.value) {
            CustomNavigationBar()
        }

        // Add a button to toggle the navigation bar
        Button(
            modifier = Modifier
                .padding(16.dp)
                .fillMaxWidth(),
            onClick = {
                navBarVisible.value = !navBarVisible.value
            }
        ) {
            Text("Toggle Navigation Bar")
        }
    }
}

Step 5: Handle Window Inset Changes

To ensure our custom navigation bar adapts to window inset changes, we need to add a listener to the window insets controller. Update the “MainActivity.kt” file with the following code:

// MainActivity.kt
import android.view.View

@Composable
fun MainScreen() {
    // ...

    val windowInsets = WindowInsets.asPaddingValues()
    val navBarPadding = remember {
        mutableStateOf(PaddingValues())
    }

    LaunchedEffect(windowInsets) {
        navBarPadding.value = windowInsets
    }

    Box(modifier = Modifier.fillMaxSize()) {
        // ...
    }
}

Conclusion

Congratulations! You’ve successfully implemented an Android navigation bar that appears in immersive mode using Kotlin and Jetpack Compose. With this comprehensive guide, you’ve mastered the art of creating an immersive user experience. Remember to explore and customize the code to fit your app’s unique needs.

Keyword	Description
Android Navigation Bar	A system-provided navigation bar that appears at the bottom of the screen.
Immersive Mode	A feature that hides the navigation bar, providing a more immersive user experience.
Kotlin	A modern programming language for Android app development.
Jetpack Compose	A declarative UI framework for building Android apps.

If you have any questions or need further assistance, don’t hesitate to ask. Happy coding!

Frequently Asked Questions

Get ready to dive into the world of Android Navigation bar and immersive mode using Kotlin and Jetpack Compose!