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

Compose'da en sevdiğiniz kitaplıkları kullanabilirsiniz. Bu bölümde, en kullanışlı kitaplıklardan bazılarının nasıl dahil edileceği açıklanmaktadır.

Etkinlik

Bir etkinlikte Compose'u kullanmak için ComponentActivity'u kullanmanız gerekir. Bu, Activity'ün bir alt sınıfıdır ve Compose 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 de sağlar. Activity Compose bu API'leri composable'lara sunar. Böylece, composable'larınızın dışındaki yöntemleri geçersiz kılmanız veya açık bir Activity örneği almanız gerekmez. Ayrıca bu API'ler, yalnızca bir kez başlatıldıklarından, yeniden oluşturma işleminden sonra çalışmaya devam ettiklerinden ve composable, kompozisyondan kaldırılırsa düzgün şekilde temizlendiklerinden emin olur.

Aktivite Sonucu

rememberLauncherForActivityResult() API, composable'ınızda 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 dokunulduğunda istek başlatılır. rememberLauncherForActivityResult() için sondaki lambda, kullanıcı bir resim seçip başlatma etkinliğine döndüğünde bir kez çağrılır. Bu işlem, Coil'in rememberImagePainter() işlevini kullanarak seçilen resmi yükler.

ActivityResultContract alt sınıflarının herhangi biri, rememberLauncherForActivityResult() için ilk bağımsız değişken olarak kullanılabilir. Bu teknikle, çerçeveden içerik istemek ve diğer yaygın desenlerde kullanmak mümkündür. Dilerseniz kendi özel sözleşmelerinizi oluşturup bu teknikle kullanabilirsiniz.

Dikkat: Bu örnekte, kullanıcı etkileşiminden nasıl istek başlatılacağı gösterilmektedir. Bu örnekte, onClick() dinleyicisinden. Composable'ın içinden bir istek başlatmaya çalışırsanız ActivityResultLauncher bu noktada başlatılmadığı için çalışma zamanı hatası alırsınız. Lansmanı kompozisyondan sonra tetiklemeniz gerekiyorsa launch() yöntemini 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şmesi veya birden fazla izin için RequestMultiplePermissions sözleşmesi kullanılarak çalışma zamanı izinleri istemek için kullanılabilir.

Accompanist Permissions kitaplığı, izinler için mevcut verilen durumu Compose kullanıcı arayüzünüzün kullanabileceği bir duruma eşlemek üzere bu API'lerin üzerinde bir katman olarak da kullanılabilir.

Sistemin geri düğmesini kullanma

Özel geri gezinme sağlamak ve composable'ınızdaki sistemin geri düğmesinin varsayılan davranışını geçersiz kılmak için composable'ınız bu etkinliği yakalamak üzere BackHandler kullanabilir:

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

İlk bağımsız değişken, BackHandler öğesinin 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ğini tetiklerse ve BackHandler şu anda etkinse sondaki lambda çağrılır.

Dikkat: Herhangi bir kompozisyona 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 kullanılır. Başka bir deyişle, herhangi bir zamanda en fazla bir BackHandler etkin olabilir.

ViewModel

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

Modern

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

Kotlin

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

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 değerini döndürür veya yeni bir değer oluşturur. Varsayılan olarak, döndürülen ViewModel, kapsayan etkinlik, parça veya gezinme hedefiyle sınırlanır ve kapsam etkin olduğu sürece korunur.

Örneğin, composable bir etkinlikte kullanılıyorsa 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 talimatları

ViewModel örneklerine genellikle ekran düzeyindeki birleştirilebilir işlevlerde erişirsiniz. Bu işlevler, bir etkinlikten, parçadan veya gezinme grafiğinin hedefinden çağrılan kök birleştirilebilir işlevlere yakındır. Bunun nedeni, ViewModel'ların varsayılan olarak bu ekran düzeyindeki nesnelerle kapsamlandırılmasıdır. ViewModel'nın yaşam döngüsü ve kapsamı hakkında daha fazla bilgiyi burada bulabilirsiniz.

ViewModel örneklerini diğer composable'lara aktarmaktan kaçının. Bu, composable'ların test edilmesini zorlaştırabilir ve önizlemelerin bozulmasına neden olabilir. Bunun yerine, yalnızca ihtiyaç duydukları verileri ve işlevleri parametre olarak iletin.

Alt ekran düzeyindeki composable'ların durumunu yönetmek için ViewModel örneklerini kullanabilirsiniz. Ancak ViewModel'nin yaşam döngüsü ve kapsamı hakkında bilgi sahibi olmanız gerekir. Composable bağımsızsa üst composable'lardan bağımlılıkları aktarmak zorunda kalmamak için ViewModel öğesini yerleştirmek üzere Hilt'i kullanmayı düşünebilirsiniz.

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

Oluşturma'daki ViewModel ve örneklerin Navigation Compose kitaplığı, etkinlikler ve parçalarla nasıl kullanıldığı hakkında daha fazla bilgi için Birlikte çalışabilirlik belgelerine bakın.

Veri akışları

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

• LiveData.observeAsState(), androidx.compose.runtime:runtime-livedata:$composeVersion yapısına dahil edildi.
• Flow.collectAsState() ek bağımlılıklar gerektirmez.
• Observable.subscribeAsState(), androidx.compose.runtime:runtime-rxjava2:$composeVersion veya androidx.compose.runtime:runtime-rxjava3:$composeVersion yapısına dahil edilmelidir.

Bu yapılar, dinleyici olarak kaydedilir ve değerleri State olarak gösterir. Yeni bir değer yayınlandığında Compose, kullanıcı arayüzünün söz konusu state.value değerinin kullanıldığı bölümlerini yeniden oluşturur. Örneğin, bu kodda ShowData, exampleLiveData her yeni değer yayınladığında 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

Compose'da eşzamansız işlemler

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

Daha fazla bilgi için yan etkilerle ilgili belgelere göz atarak LaunchedEffect, produceState ve rememberCoroutineScope API'lerini inceleyin.

Gezinme

Navigation 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 belgeler paylaştı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

Hilt ve Navigation

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

Modern

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

Kotlin

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

Navigation Compose'u kullanırken hiltViewModel composable işlevini kullanarak her zaman @HiltViewModel ek açıklamalı ViewModel öğenizin bir örneğini alın. Bu özellik, @AndroidEntryPoint ile açıklama eklenmiş parçalar veya etkinliklerle çalışır.

Örneğin, ExampleScreen bir gezinme grafiğindeki hedefse aşağıdaki kod snippet'inde gösterildiği gibi, hedefe kapsamı belirlenmiş bir ExampleViewModel örneği almak için hiltViewModel() işlevini ç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 ViewModel kapsamlı bir örneği gezinme rotaları veya gezinme grafiği için almanız gerekiyorsa hiltViewModel composable 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

Sayfalandırma

Paging kitaplığı, verileri kademeli olarak yüklemenizi kolaylaştırır ve Compose'da desteklenir. Paging sürüm sayfasında, projeye ve sürümüne eklenmesi gereken paging-compose bağımlılığı hakkında bilgi yer alır.

Paging kitaplığının Compose 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

Compose'da Sayfalandırma ö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 Maps Compose kitaplığını kullanabilirsiniz. Kullanım örneğini aşağıda bulabilirsiniz:

@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