लिखें और अन्य लाइब्रेरी

आप Compose में अपनी पसंदीदा लाइब्रेरी इस्तेमाल कर सकते हैं. इस सेक्शन में बताया गया है कि में कुछ सबसे उपयोगी लाइब्रेरी शामिल हैं.

गतिविधि

किसी गतिविधि में कंपोज़ की सुविधा इस्तेमाल करने के लिए, आपको ComponentActivity Activity की एक सब-क्लास जो सही LifecycleOwner और कॉम्पोनेंट शामिल करें. यह ऐसे अतिरिक्त एपीआई भी उपलब्ध कराता है जो आपके कोड को अलग-अलग कर देते हैं ओवरराइडिंग मेथड के ज़रिए अलग किया जाता है. गतिविधि लिखना इन एपीआई को कंपोज़ेबल में इस तरह ज़ाहिर करता है कि वे कंपोज़ेबल या साफ़ तौर पर Activity इंस्टेंस की ज़रूरत नहीं है. इसके अलावा, ये एपीआई यह पक्का करते हैं कि उन्हें सिर्फ़ एक बार शुरू किया जाए, और वे सुरक्षित रहें अगर कंपोज़ेबल को हटा दिया गया है, तो उसे सही तरीके से सेट अप और साफ़ किया जा सकता है कंपोज़िशन.

गतिविधि का नतीजा

कॉन्टेंट बनाने rememberLauncherForActivityResult() एपीआई की मदद से किसी गतिविधि से नतीजा पाना कंपोज़ेबल में:

@Composable
fun GetContentExample() {
    var imageUri by remember { mutableStateOf<Uri?>(null) }
    val launcher = rememberLauncherForActivityResult(ActivityResultContracts.GetContent()) { uri: Uri? ->
        imageUri = uri
    }
    Column {
        Button(onClick = { launcher.launch("image/*") }) {
            Text(text = "Load Image")
        }
        Image(
            painter = rememberAsyncImagePainter(imageUri),
            contentDescription = "My Image"
        )
    }
}
ComposeWithOtherLibraries.kt

इस उदाहरण में बताया गया है कि GetContent() कानूनी समझौता. बटन पर टैप करने से अनुरोध लॉन्च हो जाता है. इसके लिए ट्रेलिंग लैम्डा rememberLauncherForActivityResult() जब उपयोगकर्ता कोई इमेज चुनता है और लॉन्च की गतिविधि पर वापस जाता है, तो यह सेवा चालू हो जाती है. यह कॉइल के rememberImagePainter() का इस्तेमाल करके चुनी गई इमेज को लोड करता है फ़ंक्शन का इस्तेमाल करना होगा.

इसकी कोई भी सब-क्लास ActivityResultContract का इस्तेमाल पहले आर्ग्युमेंट के तौर पर किया जा सकता है rememberLauncherForActivityResult(). इसका मतलब है कि इस तकनीक का इस्तेमाल करके, फ़्रेमवर्क से कॉन्टेंट का अनुरोध किया जा सकता है और अन्य सामान्य पैटर्न में रहते हैं. अपना खुद का इंटरैक्शन भी बनाया जा सकता है कस्टम अनुबंधों और उनका इस्तेमाल इस तकनीक को अपनाएं.

रनटाइम की अनुमतियों का अनुरोध किया जा रहा है

एक जैसी ऐक्टिविटी के नतीजे का एपीआई और rememberLauncherForActivityResult() ऊपर बताई गई जानकारी का इस्तेमाल इन कामों के लिए किया जा सकता है रनटाइम की अनुमतियों का अनुरोध करें इसका इस्तेमाल करके RequestPermission एक बार की अनुमति के लिए अनुबंध करें या RequestMultiplePermissions .

कॉन्टेंट बनाने Accompanist की अनुमतियों की लाइब्रेरी के लिए वर्तमान प्रदान की गई स्थिति को मैप करने के लिए उन API के ऊपर परत का भी उपयोग किया जा सकता है अनुमतियां दें, जिनका उपयोग आपका Compose यूज़र इंटरफ़ेस (यूआई) कर सकता है.

सिस्टम के 'वापस जाएं' बटन का इस्तेमाल करना

पसंद के मुताबिक पीछे जाने का रास्ता उपलब्ध कराने के लिए और सिस्टम के 'वापस जाएं' बटन के डिफ़ॉल्ट व्यवहार को ओवरराइड कर सकते हैं कंपोज़ेबल, तो आपका कंपोज़ेबल, BackHandler इवेंट को रोकने के लिए:

var backHandlingEnabled by remember { mutableStateOf(true) }
BackHandler(backHandlingEnabled) {
    // Handle back press
}
ComposeWithOtherLibraries.kt

पहला तर्क यह कंट्रोल करता है कि BackHandler अभी चालू है; तो अपने हैंडलर को अस्थायी तौर पर बंद करने के लिए, इस आर्ग्युमेंट का इस्तेमाल किया जा सकता है आपके कॉम्पोनेंट की स्थिति के हिसाब से. ट्रेलिंग लैम्डा को तब शुरू किया जाएगा, जब जब कोई उपयोगकर्ता किसी सिस्टम बैक इवेंट को ट्रिगर करता है और BackHandler अभी चालू है.

ViewModel

अगर स्ट्रक्चर के कॉम्पोनेंट का इस्तेमाल किया जाता है ViewModel लाइब्रेरी, तो ViewModel कंपोज़ेबल कॉल करो viewModel() फ़ंक्शन का इस्तेमाल करना होगा. अपनी Gradle फ़ाइल में यह डिपेंडेंसी जोड़ें:

ग्रूवी

dependencies {
    implementation 'androidx.lifecycle:lifecycle-viewmodel-compose:2.6.1'
}

Kotlin

dependencies {
    implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.6.1")
}

इसके बाद, अपने कोड में viewModel() फ़ंक्शन का इस्तेमाल किया जा सकता है.

class MyViewModel : ViewModel() { /*...*/ }

// import androidx.lifecycle.viewmodel.compose.viewModel
@Composable
fun MyScreen(
    viewModel: MyViewModel = viewModel()
) {
    // use viewModel here
}
ComposeWithOtherLibraries.kt

viewModel() कोई मौजूदा ViewModel लौटाता है या नया बनाता है. डिफ़ॉल्ट रूप से, नतीजे के तौर पर दिखाया गया ViewModel, क्लोज़िंग ऐक्टिविटी, फ़्रैगमेंट या नेविगेशन डेस्टिनेशन के साथ होता है और उसे तब तक सेव रखा जाता है, जब तक स्कोप मौजूद रहता है.

उदाहरण के लिए, अगर किसी गतिविधि में कंपोज़ेबल का इस्तेमाल किया जाता है, तो viewModel() तब तक एक ही इंस्टेंस होता है, जब तक कि गतिविधि खत्म न हो जाए या प्रक्रिया खत्म न हो जाए.

class MyViewModel : ViewModel() { /*...*/ }
// import androidx.lifecycle.viewmodel.compose.viewModel
@Composable
fun MyScreen(
    // Returns the same instance as long as the activity is alive,
    // just as if you grabbed the instance from an Activity or Fragment
    viewModel: MyViewModel = viewModel()
) { /* ... */ }

@Composable
fun MyScreen2(
    viewModel: MyViewModel = viewModel() // Same instance as in MyScreen
) { /* ... */ }
ComposeWithOtherLibraries.kt

इस्तेमाल करने के लिए दिशा-निर्देश

आम तौर पर, स्क्रीन-लेवल पर ViewModel इंस्टेंस ऐक्सेस किए जाते हैं कंपोज़ेबल, जो किसी गतिविधि से कॉल किए जाने वाले रूट कंपोज़ेबल के आस-पास होते हैं, फ़्रैगमेंट या नेविगेशन ग्राफ़ का डेस्टिनेशन. ऐसा इसलिए हुआ, क्योंकि ViewModel से डिफ़ॉल्ट रूप से, उनका दायरा उन स्क्रीन लेवल ऑब्जेक्ट तक होता है. यहां दिए गए एक उदाहरण के बारे में ज़्यादा जानें: ViewModel की लाइफ़साइकल और दायरा यहां देखें.

नीचे जाने से बचने की कोशिश करें अन्य कंपोज़ेबल में ViewModel इंस्टेंस जोड़े गए, क्योंकि इससे वे कंपोज़ेबल बन सकते हैं परीक्षण करना ज़्यादा कठिन और ब्रेक हो सकता है झलक. इसके बजाय, सिर्फ़ ऑडियंस की मदद करने के लिए, और फ़ंक्शन की ज़रूरत होती है.

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

अगर ViewModel पर डिपेंडेंसी है, तो viewModel() ViewModelProvider.Factory पैरामीटर के तौर पर.

'लिखें' विंडो में मौजूद ViewModel के बारे में ज़्यादा जानकारी पाने और इंस्टेंस इस्तेमाल करने का तरीका जानने के लिए नेविगेशन कंपोज़ लाइब्रेरी, ऐक्टिविटी और फ़्रैगमेंट, इंटरऑपरेबिलिटी दस्तावेज़ देखें.

डेटा की स्ट्रीम

लिखें, Android के सबसे लोकप्रिय स्ट्रीम-आधारित समाधानों के लिए एक्सटेंशन के साथ आता है. इनमें से हर एक्सटेंशन एक अलग आर्टफ़ैक्ट से मिला है:

  • LiveData.observeAsState(), androidx.compose.runtime:runtime-livedata:$composeVersion आर्टफ़ैक्ट में शामिल है.
  • Flow.collectAsState() के लिए अतिरिक्त डिपेंडेंसी की ज़रूरत नहीं होती.
  • Observable.subscribeAsState(), androidx.compose.runtime:runtime-rxjava2:$composeVersion या androidx.compose.runtime:runtime-rxjava3:$composeVersion आर्टफ़ैक्ट में शामिल है.

ये आर्टफ़ैक्ट, लिसनर के तौर पर रजिस्टर होते हैं और वैल्यू को State. जब भी कोई नया मान सर्च इंजन इस्तेमाल करता है, तो कंपोज़ की सुविधा, यूज़र इंटरफ़ेस (यूआई) के उन हिस्सों को फिर से बनाती है जहां state.value इस्तेमाल किया गया. उदाहरण के लिए, इस कोड में ShowData हर बार प्रॉम्प्ट को फिर से कंपोज़ करता है exampleLiveData से नई वैल्यू निकलती है.

// import androidx.lifecycle.viewmodel.compose.viewModel
@Composable
fun MyScreen(
    viewModel: MyViewModel = viewModel()
) {
    val dataExample = viewModel.exampleLiveData.observeAsState()

    // Because the state is read here,
    // MyScreen recomposes whenever dataExample changes.
    dataExample.value?.let {
        ShowData(dataExample)
    }
}
ComposeWithOtherLibraries.kt

Compose में एसिंक्रोनस कार्रवाइयां

Jetpack Compose की मदद से एसिंक्रोनस कार्रवाइयां करने के लिए, इसके कोरूटीन का इस्तेमाल किया जा सकता है कंपोज़ेबल में सेव किया जा सकता है.

LaunchedEffect, produceState, और rememberCoroutineScope एपीआई को इसमें देखें ज़्यादा जानकारी के लिए, साइड इफ़ेक्ट दस्तावेज़ जानकारी.

नेविगेशन कॉम्पोनेंट से Jetpack Compose ऐप्लिकेशन काम करते हैं. लिखें की मदद से नेविगेट करना देखें और ज़्यादा जानकारी के लिए, Jetpack नेविगेशन को नेविगेशन कंपोज़ पर माइग्रेट करें.

हिल्ट

Android ऐप्लिकेशन में डिपेंडेंसी इंजेक्शन के लिए, Hilt एक सुझाया गया तरीका है और यह Compose के साथ आसानी से काम करता है.

ViewModel सेक्शन में बताया गया viewModel() फ़ंक्शन अपने-आप उस ViewModel का इस्तेमाल करता है जिसे Hilt, @HiltViewModel के साथ बनाता है एनोटेशन. हमने Hilt के ViewModel के बारे में जानकारी के साथ दस्तावेज़ उपलब्ध कराए हैं इंटिग्रेशन के लिए बनाया गया है.

@HiltViewModel
class MyViewModel @Inject constructor(
    private val savedStateHandle: SavedStateHandle,
    private val repository: ExampleRepository
) : ViewModel() { /* ... */ }

// import androidx.lifecycle.viewmodel.compose.viewModel
@Composable
fun MyScreen(
    viewModel: MyViewModel = viewModel()
) { /* ... */ }

ComposeWithOtherLibraries.kt

हिल्ट और नेविगेशन

Hilt, नेविगेशन Compose लाइब्रेरी के साथ भी इंटिग्रेट हो जाता है. इन्हें जोड़ें आपकी Gradle फ़ाइल के लिए अतिरिक्त डिपेंडेंसी:

ग्रूवी

dependencies {
    implementation 'androidx.hilt:hilt-navigation-compose:1.0.0'
}

Kotlin

dependencies {
    implementation("androidx.hilt:hilt-navigation-compose:1.0.0")
}

नेविगेशन कंपोज़ेबल का इस्तेमाल करते समय, हमेशा hiltViewModel कंपोज़ेबल का इस्तेमाल करें फ़ंक्शन का इस्तेमाल करके, एनोटेशन ViewModel के @HiltViewModel का एक इंस्टेंस पाएं. यह उन फ़्रैगमेंट या गतिविधियों के साथ काम करता है जिनके साथ एनोटेट किया गया है @AndroidEntryPoint.

उदाहरण के लिए, अगर नेविगेशन ग्राफ़ में ExampleScreen एक डेस्टिनेशन है, तो ExampleViewModel स्कोप का इंस्टेंस पाने के लिए, hiltViewModel() को कॉल करें गंतव्य पर भेजना होगा, जैसा कि नीचे कोड स्निपेट में दिखाया गया है:

// import androidx.hilt.navigation.compose.hiltViewModel

@Composable
fun MyApp() {
    val navController = rememberNavController()
    val startRoute = "example"
    NavHost(navController, startDestination = startRoute) {
        composable("example") { backStackEntry ->
            // Creates a ViewModel from the current BackStackEntry
            // Available in the androidx.hilt:hilt-navigation-compose artifact
            val viewModel = hiltViewModel<MyViewModel>()
            MyScreen(viewModel)
        }
        /* ... */
    }
}
ComposeWithOtherLibraries.kt

अगर आपको ViewModel के स्कोप वाले इंस्टेंस को वापस लाना है, तो नेविगेशन रूट या नेविगेशन ग्राफ़ इसके बजाय, hiltViewModel कंपोज़ेबल फ़ंक्शन का इस्तेमाल करें और पैरामीटर के तौर पर backStackEntry:

// import androidx.hilt.navigation.compose.hiltViewModel
// import androidx.navigation.compose.getBackStackEntry

@Composable
fun MyApp() {
    val navController = rememberNavController()
    val startRoute = "example"
    val innerStartRoute = "exampleWithRoute"
    NavHost(navController, startDestination = startRoute) {
        navigation(startDestination = innerStartRoute, route = "Parent") {
            // ...
            composable("exampleWithRoute") { backStackEntry ->
                val parentEntry = remember(backStackEntry) {
                    navController.getBackStackEntry("Parent")
                }
                val parentViewModel = hiltViewModel<ParentViewModel>(parentEntry)
                ExampleWithRouteScreen(parentViewModel)
            }
        }
    }
}
ComposeWithOtherLibraries.kt

पृष्ठांकन

पेजिंग लाइब्रेरी इससे आपके लिए डेटा को धीरे-धीरे लोड करना आसान हो जाता है. साथ ही, यह Compose में काम करती है. पेजिंग रिलीज़ पेज में शामिल है अतिरिक्त paging-compose डिपेंडेंसी के बारे में जानकारी, जिसे जोड़ना है प्रोजेक्ट और उसके वर्शन पर लागू होता है.

यहां पेजिंग लाइब्रेरी के Compose API का एक उदाहरण दिया गया है:

@Composable
fun MyScreen(flow: Flow<PagingData<String>>) {
    val lazyPagingItems = flow.collectAsLazyPagingItems()
    LazyColumn {
        items(
            lazyPagingItems.itemCount,
            key = lazyPagingItems.itemKey { it }
        ) { index ->
            val item = lazyPagingItems[index]
            Text("Item is $item")
        }
    }
}
ComposeWithOtherLibraries.kt

ज़्यादा जानकारी के लिए, सूची और ग्रिड से जुड़े दस्तावेज़ देखें Compose में पेजिंग इस्तेमाल करने के बारे में जानकारी.

Maps

आप Maps Compose का इस्तेमाल कर सकते हैं लाइब्रेरी का इस्तेमाल करें, ताकि आप ऐप्लिकेशन में Google Maps उपलब्ध करा सकें. यहां इस्तेमाल का एक उदाहरण दिया गया है:

@Composable
fun MapsExample() {
    val singapore = LatLng(1.35, 103.87)
    val cameraPositionState = rememberCameraPositionState {
        position = CameraPosition.fromLatLngZoom(singapore, 10f)
    }
    GoogleMap(
        modifier = Modifier.fillMaxSize(),
        cameraPositionState = cameraPositionState
    ) {
        Marker(
            state = MarkerState(position = singapore),
            title = "Singapore",
            snippet = "Marker in Singapore"
        )
    }
}
ComposeWithOtherLibraries.kt