E-posta oluşturma ve diğer kitaplıklar

Oluştur'da favori kitaplıklarınızı kullanabilirsiniz. Bu bölümde, en kullanışlı kitaplıklardan birkaçını nasıl dahil edebileceğiniz açıklanmaktadır.

Etkinlik

Bir etkinlikte Oluştur'u kullanmak için Activity alt sınıfı olan ComponentActivity'u kullanmanız gerekir. Bu sınıf, Oluştur için uygun LifecycleOwner ve bileşenleri sağlar. Ayrıca, kodunuzu etkinlik sınıfınızdaki geçersiz kılma yöntemlerinden ayıran ek API'ler sağlar. Activity Compose, bu API'leri composable'lara gösterir. Böylece, composable'larınızın dışındaki yöntemleri geçersiz kılmak veya açık bir Activity örneği almak artık gerekmez. Ayrıca bu API'ler, yalnızca bir kez başlatılmalarını, yeniden derlemeden sağ çıkmalarını ve bileşen kompozisyondan kaldırılırsa düzgün şekilde temizlenmelerini sağlar.

Etkinlik Sonucu

rememberLauncherForActivityResult() API, aşağıdakiler gibi bir bileşeninizde bir etkinlikten sonuç almanıza olanak tanır:

@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

Bu örnekte basit bir GetContent() sözleşmesi gösterilmektedir. Düğmeye dokunduğunuzda istek başlatılır. rememberLauncherForActivityResult() için son lambda, kullanıcı bir resim seçip başlatma etkinliğine döndükten sonra çağrılır. Bu işlem, Coil'in rememberImagePainter() işlevini kullanarak seçili resmi yükler.

ActivityResultContract sınıfının herhangi bir alt sınıfı, rememberLauncherForActivityResult() işlevinin ilk bağımsız değişkeni olarak kullanılabilir. Bu, bu tekniği çerçeveden ve diğer yaygın kalıplardan içerik istemek için kullanabileceğiniz anlamına gelir. Ayrıca kendi özel sözleşmelerinizi oluşturabilir ve bu teknikle kullanabilirsiniz.

Dikkat: Bu örnekte, kullanıcı etkileşiminden nasıl istek başlatılacağı gösterilmektedir. Bu durumda, onClick() dinleyicisinden. Bir isteği, bileşenin içinden başlatmayı denerseniz ActivityResultLauncher bu noktada başlatılmadığı için bir çalışma zamanı hatası alırsınız. Kompozisyonun başlatılmasını tetiklemeniz gerekiyorsa launch() yöntemini bir LaunchedEffect veya DisposableEffect bloğunun içinden çağırmanız gerekir.

Çalışma zamanı izinleri isteme

Yukarıda açıklanan aynı Activity Result API ve rememberLauncherForActivityResult(), tek bir izin için RequestPermission sözleşmesini veya birden fazla izin için RequestMultiplePermissions sözleşmesini kullanarak çalışma zamanında izin isteğinde bulunmak için kullanılabilir.

Eşlik Eden İzinleri kitaplığı, izinlerin mevcut izin verilen durumunu, Oluşturma kullanıcı arayüzünüzün kullanabileceği durumla eşlemek için bu API'lerin bir katmanı olarak da kullanılabilir.

Sistem geri düğmesini kullanma

Özel geri gezinme sağlamak ve bileşeninizden sistem geri düğmesinin varsayılan davranışını geçersiz kılmak için bileşeniniz bu etkinliği durdurmak üzere bir BackHandler kullanabilir:

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

İlk bağımsız değişken, BackHandler değerinin şu anda etkin olup olmadığını kontrol eder. Bu bağımsız değişkeni, bileşeninizin durumuna göre işleyicinizi geçici olarak devre dışı bırakmak için kullanabilirsiniz. Kullanıcı bir sistem geri etkinliği tetiklerse ve BackHandler şu anda etkinse son lambda çağrılır.

Dikkat: Herhangi bir bileşime birden fazla geri işleyici eklemek mümkün olsa da sistem geri etkinliği, en içteki etkin BackHandler tarafından işlenir ve tüketilir. Diğer bir deyişle, herhangi bir zamanda en fazla bir BackHandler etkindir.

ViewModel

Architecture Components ViewModel kitaplığını kullanıyorsanız viewModel() işlevini çağırarak herhangi bir bileşenden ViewModel'a erişebilirsiniz. Gradle dosyanıza aşağıdaki bağımlılığı ekleyin:

Groovy

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

Kotlin

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

Ardından kodunuzda viewModel() işlevini kullanabilirsiniz.

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

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

viewModel(), mevcut bir ViewModel döndürür veya yeni bir tane oluşturur. Varsayılan olarak, döndürülen ViewModel, kapsayıcı etkinlik, parça veya gezinme hedefi kapsamına alınır ve kapsam etkin olduğu sürece saklanır.

Örneğin, bir etkinlikte kullanılan viewModel(), etkinlik tamamlanana veya işlem sonlandırılana kadar aynı örneği döndürür.

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

Kullanım kuralları

ViewModel örneklerine genellikle ekran düzeyinde bileşenlerde, yani bir etkinlikten, parçadan veya gezinme grafiğinin hedefinden çağrılan bir kök bileşene yakın bir yerde erişirsiniz. Bunun nedeni, ViewModel'lerin varsayılan olarak bu ekran düzeyindeki nesnelerle kapsamlı olmasıdır. ViewModel'nin yaşam döngüsü ve kapsamı hakkında daha fazla bilgiyi burada bulabilirsiniz.

ViewModel örneklerini diğer bileşenlere aktarmaktan kaçının. Aksi takdirde, bu bileşenlerin test edilmesi daha zor hale gelebilir ve önizlemeler bozulabilir. Bunun yerine, yalnızca ihtiyaç duydukları verileri ve işlevleri parametre olarak iletin.

Alt ekran düzeyindeki bileşenlerin durumunu yönetmek için ViewModel örneklerini kullanabilir ancak ViewModel'nin yaşam döngüsü ve kapsamına dikkat edin. Kompozit bağımsızsa üst kompozitlerden bağımlılık aktarmak zorunda kalmamak için ViewModel'yi eklemek üzere Hilt'i kullanmayı düşünebilirsiniz.

ViewModel öğenizin bağımlılıkları varsa viewModel(), parametre olarak isteğe bağlı bir ViewModelProvider.Factory alır.

Oluşturma'daki ViewModel hakkında daha fazla bilgi edinmek ve örneklerin Gezinme Oluşturma kitaplığıyla veya etkinliklerle ve parçalarla nasıl kullanıldığını öğrenmek için İlişkilendirme Dokümanları'na bakın.

Veri akışları

Oluştur, Android'in en popüler akış tabanlı çözümleri için uzantılarla birlikte gelir. Bu uzantıların her biri farklı bir yapı tarafından sağlanır:

• LiveData.observeAsState(), androidx.compose.runtime:runtime-livedata:$composeVersion yapısını içerir.
• Flow.collectAsState() için ek bağımlılık gerekmez.
• androidx.compose.runtime:runtime-rxjava2:$composeVersion veya androidx.compose.runtime:runtime-rxjava3:$composeVersion yapılarına dahil edilen Observable.subscribeAsState().

Bu yapı taşları bir dinleyici olarak kaydedilir ve değerleri State olarak temsil eder. Yeni bir değer her yayınlandığında Compose, state.value değerinin kullanıldığı kullanıcı arayüzü bölümlerini yeniden oluşturur. Örneğin, bu kodda ShowData, exampleLiveData her yeni değer gönderdiğinde yeniden oluşturulur.

// 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

Oluşturma'daki eşzamansız işlemler

Jetpack Compose, kompozisyonlarınızdan coroutine'leri kullanarak eşzamansız işlemler yürütmenize olanak tanır.

Daha fazla bilgi için yan etki dokümanlarındaki LaunchedEffect, produceState ve rememberCoroutineScope API'lerine bakın.

Navigasyon

Gezinme bileşeni, Jetpack Compose uygulamaları için destek sağlar. Daha fazla bilgi için Compose ile gezinme ve Jetpack Navigation'ı Navigation Compose'a taşıma başlıklı makaleleri inceleyin.

Hilt

Hilt, Android uygulamalarında bağımlılık ekleme için önerilen çözümdür ve Compose ile sorunsuz bir şekilde çalışır.

ViewModel bölümünde bahsedilen viewModel() işlevi, Hilt'in @HiltViewModel ek açıklamasıyla oluşturduğu ViewModel'i otomatik olarak kullanır. Hilt'in ViewModel entegrasyonu hakkında bilgi içeren dokümanlar sağladık.

@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

Sap ve Gezinme

Hilt, Navigation Compose kitaplığıyla da entegre edilebilir. Gradle dosyanıza aşağıdaki ek bağımlılıkları ekleyin:

Groovy

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

Kotlin

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

Gezinme Oluşturma'yı kullanırken, @HiltViewModel ek açıklamalı ViewModel öğenizin bir örneğini almak için daima hiltViewModel composable işlevini kullanın. Bu, @AndroidEntryPoint ile ek açıklama eklenmiş parçalar veya etkinliklerde çalışır.

Örneğin, ExampleScreen bir gezinme grafiğindeki bir hedefse aşağıdaki kod snippet'inde gösterildiği gibi hedefe özel bir ExampleViewModel örneği almak için hiltViewModel()'i çağırın:

// 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

Bunun yerine gezinme rotalarına veya gezinme grafiğine kapsamlı bir ViewModel örneğini almanız gerekiyorsa hiltViewModel birleştirilebilir işlevini kullanın ve ilgili backStackEntry öğesini parametre olarak iletin:

// 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

Sayfa ayırma

Sayfalama kitaplığı, verileri kademeli olarak yüklemenizi kolaylaştırır ve Oluştur'da desteklenir. Sayfa yayınlama sayfası, projeye ve sürümüne eklenmesi gereken paging-compose bağımlılığı hakkında bilgi içerir.

Sayfalama kitaplığının Oluşturma API'leri örneğini aşağıda bulabilirsiniz:

@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

Oluşturma'da Sayfalama özelliğini kullanma hakkında daha fazla bilgi için Listeler ve ızgaralar dokümanlarına göz atın.

Haritalar

Uygulamanızda Google Haritalar'ı sağlamak için Haritalar Compose kitaplığını kullanabilirsiniz. Aşağıda bir kullanım örneği verilmiştir:

@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 = remember { MarkerState(position = singapore) },
            title = "Singapore",
            snippet = "Marker in Singapore"
        )
    }
}
ComposeWithOtherLibraries.kt