शेयर किए गए एलिमेंट की मदद से नेविगेट करना

पहली इमेज. शेयर किए गए एलिमेंट की मदद से नेविगेट करना.

शेयर किए गए एलिमेंट, स्क्रीन के बीच ट्रांज़िशन को ज़्यादा आसान और दिलचस्प बनाते हैं. ऐसा इसलिए होता है, क्योंकि ये एक विज़ुअल कनेक्शन बनाते हैं, जो उपयोगकर्ता को गाइड करता है. इस गाइड में बताया गया है कि Navigation 3 और Navigation 2, दोनों Jetpack लाइब्रेरी के साथ शेयर किए गए एलिमेंट वाले एपीआई का इस्तेमाल कैसे किया जाता है.

नीचे दिए गए स्निपेट में, DetailsScreen और HomeScreen कंपोज़ेबल शामिल हैं. ये ऐसे डेस्टिनेशन के तौर पर काम करते हैं जिनके बीच उपयोगकर्ता नेविगेट कर सकते हैं. हर स्क्रीन में, इमेज और टेक्स्ट, दोनों पर sharedElement मॉडिफ़ायर का इस्तेमाल किया जाता है. इससे हर एलिमेंट, स्क्रीन के बीच अलग-अलग तरीके से ऐनिमेट होता है.

@Composable
fun DetailsScreen(
    id: Int,
    snack: Snack,
    sharedTransitionScope: SharedTransitionScope,
    animatedVisibilityScope: AnimatedVisibilityScope,
    onBackPressed: () -> Unit
) {
    with(sharedTransitionScope) {
        Column(
            modifier = Modifier
                .fillMaxSize()
                .clickable { onBackPressed() },
        ) {
            Image(
                painterResource(id = snack.image),
                contentDescription = snack.description,
                contentScale = ContentScale.Crop,
                modifier = Modifier
                    .sharedElement(
                        sharedTransitionScope.rememberSharedContentState(key = "image-$id"),
                        animatedVisibilityScope = animatedVisibilityScope
                    )
                    .aspectRatio(1f)
                    .fillMaxWidth()
            )
            Text(
                text = snack.name,
                fontSize = 18.sp,
                modifier = Modifier
                    .sharedElement(
                        sharedTransitionScope.rememberSharedContentState(key = "text-$id"),
                        animatedVisibilityScope = animatedVisibilityScope
                    )
                    .fillMaxWidth(),
            )
        }
    }
}

@Composable
fun HomeScreen(
    sharedTransitionScope: SharedTransitionScope,
    animatedVisibilityScope: AnimatedVisibilityScope,
    onItemClick: (Int) -> Unit,
) {
    LazyColumn(
        modifier = Modifier
            .fillMaxSize()
            .padding(8.dp),
        verticalArrangement = Arrangement.spacedBy(8.dp)
    ) {
        itemsIndexed(listSnacks) { index, item ->
            Row(
                modifier = Modifier
                    .fillMaxWidth()
                    .clickable { onItemClick(index) },
            ) {
                Spacer(modifier = Modifier.width(8.dp))
                with(sharedTransitionScope) {
                    Image(
                        painterResource(id = item.image),
                        contentDescription = item.description,
                        contentScale = ContentScale.Crop,
                        modifier = Modifier
                            .sharedElement(
                                sharedTransitionScope.rememberSharedContentState(key = "image-$index"),
                                animatedVisibilityScope = animatedVisibilityScope
                            )
                            .size(100.dp)
                    )
                    Spacer(modifier = Modifier.width(8.dp))
                    Text(
                        item.name,
                        fontSize = 18.sp,
                        modifier = Modifier
                            .align(Alignment.CenterVertically)
                            .sharedElement(
                                sharedTransitionScope.rememberSharedContentState(key = "text-$index"),
                                animatedVisibilityScope = animatedVisibilityScope,
                            )
                    )
                }
            }
        }
    }
}

Navigation 3 के साथ शेयर किए गए एलिमेंट वाले एपीआई का इस्तेमाल करने के लिए, आपको सबसे पहले अपने ऐप्लिकेशन के NavDisplay को SharedTransitionLayout में रैप करना होगा. इसके बाद, स्क्रीन कंपोज़ेबल को दिए गए SharedTransitionScope पास किए जा सकते हैं.

AnimatedVisibilityScope के लिए, LocalNavAnimatedContentScope कंपोज़िशन लोकल का इस्तेमाल करें. यह AnimatedContent से AnimatedContentScope उपलब्ध कराता है. NavDisplay इसका इस्तेमाल सीन के बीच ऐनिमेशन के लिए करता है.

@Composable
fun SharedElement_Nav3() {
    SharedTransitionLayout {
        val backStack = rememberNavBackStack(HomeRoute)

        // Note: NavDisplay accepts a `sharedTransitionScope` parameter, which is used to animate
        // NavEntry instances between scenes. This parameter *isn't* required for shared element
        // or shared bounds transitioning elements between different NavEntry, as demonstrated in
        // this sample.
        // See https://developer.android.com/guide/navigation/navigation-3/animate-destinations#transition-nav-entries
        NavDisplay(
            modifier = Modifier.safeDrawingPadding(),
            backStack = backStack,
            entryProvider = entryProvider {
                entry<HomeRoute> {
                    HomeScreen(
                        sharedTransitionScope = this@SharedTransitionLayout,
                        animatedVisibilityScope = LocalNavAnimatedContentScope.current,
                        onItemClick = { backStack.add(DetailsRoute(it)) })
                }
                entry<DetailsRoute> { detailsRoute ->
                    val id = detailsRoute.item
                    val snack = listSnacks[id]

                    DetailsScreen(
                        id = id,
                        snack = snack,
                        sharedTransitionScope = this@SharedTransitionLayout,
                        animatedVisibilityScope = LocalNavAnimatedContentScope.current,
                        onBackPressed = {
                            backStack.removeLastOrNull()
                        },
                    )
                }
            })
    }
}

Navigation 2 के साथ शेयर किए गए एलिमेंट के एपीआई का इस्तेमाल करने के लिए, आपको सबसे पहले अपने ऐप्लिकेशन के NavHost को SharedTransitionLayout में रैप करना होगा. इसके बाद, स्क्रीन कंपोज़ेबल को उपलब्ध कराया गया SharedTransitionScope पास किया जा सकता है.

composable बिल्डर का content पैरामीटर, AnimatedContentScope को रिसीवर के तौर पर इस्तेमाल करता है. इसलिए, उस स्कोप को रेफ़रंस करने के लिए this@composable का इस्तेमाल किया जा सकता है.

@Composable
fun SharedElement_Nav2() {
    SharedTransitionLayout {
        val navController = rememberNavController()
        NavHost(
            navController = navController,
            startDestination = "home",
            modifier = Modifier.safeDrawingPadding()
        ) {
            composable("home") {
                HomeScreen(
                    sharedTransitionScope = this@SharedTransitionLayout,
                    animatedVisibilityScope = this@composable,
                    onItemClick = { navController.navigate("details/$it") })
            }
            composable(
                "details/{item}", arguments = listOf(navArgument("item") { type = NavType.IntType })
            ) { backStackEntry ->
                val id = backStackEntry.arguments?.getInt("item") ?: 0
                val snack = listSnacks[id]
                DetailsScreen(
                    id = id,
                    snack = snack,
                    sharedTransitionScope = this@SharedTransitionLayout,
                    animatedVisibilityScope = this@composable,
                    onBackPressed = {
                        navController.popBackStack()
                    }
                )
            }
        }
    }
}

शेयर किए गए एलिमेंट के साथ पीछे जाने पर झलक दिखाने वाला हाथ का जेस्चर

शेयर किए गए एलिमेंट के साथ पीछे जाने पर झलक दिखाने वाले हाथ के जेस्चर का इस्तेमाल करने के लिए, यह तरीका अपनाएं:

  1. Navigation 3 के सभी वर्शन में, पीछे जाने पर झलक दिखाने वाले हाथ के जेस्चर की सुविधा काम करती है. Navigation 2 के लिए, navigation-compose का 2.8.0-alpha02 वर्शन या इसके बाद का वर्शन इस्तेमाल करें:

    [versions]
    androidx-navigation = "2.8.0-alpha02" # Or newer
    
    [libraries]
    androidx-navigation-compose = { module = "androidx.navigation:navigation-compose", version.ref = "androidx-navigation" }
    
    dependencies {
        implementation(libs.androidx.navigation.compose)
    }
    
  2. Android 15 (एपीआई लेवल 35) या इसके बाद के वर्शन वाले डिवाइसों पर, पीछे जाने की झलक दिखाने वाले ऐनिमेशन की सुविधा डिफ़ॉल्ट रूप से चालू होती है. Android 14 (एपीआई लेवल 34) पर काम करने वाले डिवाइसों के लिए, आपको डेवलपर के लिए सेटिंग और टूल में जाकर, अनुमानित बैक सेटिंग चालू करनी होगी.

  3. अगर आपका ऐप्लिकेशन Android 14 या इससे पहले के वर्शन को टारगेट करता है, तो आपको अपनी AndroidManifest.xml फ़ाइल में <application> या खास <activity> एलिमेंट में android:enableOnBackInvokedCallback="true" जोड़ना होगा. अगर आपका ऐप्लिकेशन Android 15 या इसके बाद के वर्शन को टारगेट करता है, तो आपको इस फ़्लैग की ज़रूरत नहीं है.

    <manifest xmlns:android="http://schemas.android.com/apk/res/android">
      <application
          ...
          android:enableOnBackInvokedCallback="true">
      </application>
    </manifest>
    
दूसरी इमेज. पीछे जाने पर झलक दिखाने वाले हाथ के जेस्चर के साथ शेयर किए गए एलिमेंट.