Jetpack Compose için Kotlin

Jetpack Compose, Kotlin'e göre tasarlanmıştır. Bazı durumlarda Kotlin, iyi Compose kodu yazmayı kolaylaştıran özel deyimler sağlar. Başka bir Kotlin'e çevirirseniz, kulağa hoş geldiniz, büyük olasılıkla Compose'un gücünden yararlanma fırsatından yararlanabilecektir ve anlamak zordur. Kotlin'in tarzını daha iyi öğrenmek bu tür hatalardan kaçınmanıza yardımcı olabilir.

Varsayılan bağımsız değişkenler

Bir Kotlin işlevi yazarken, işlev için varsayılan değerler belirtebilirsiniz bağımsız değişkenlerin çağrı yapan kullanıcı bu değerleri açıkça iletmezse kullanılır. Bu özellik, aşırı yüklenmiş işlevlere olan ihtiyacı azaltır.

Örneğin, kare çizen bir işlev yazmak istediğinizi varsayalım. O fonksiyonunun uzunluğunun belirtildiği sideLength adlı tek bir gerekli parametresi olabilir temsil eder. Bu parametrede thickness gibi isteğe bağlı parametreler kullanılabilir. edgeColor vb.; arayan kişi bunları belirtmezse işlevi varsayılan değerleri kullanır. Diğer dillerde ise bir veya daha fazla çeşitli işlevler:

// We don't need to do this in Kotlin!
void drawSquare(int sideLength) { }

void drawSquare(int sideLength, int thickness) { }

void drawSquare(int sideLength, int thickness, Color edgeColor) { }
JavaSnippets.java

Kotlin'de tek bir işlev yazabilir ve bağımsız değişkenler için varsayılan değerleri belirtebilirsiniz:

fun drawSquare(
    sideLength: Int,
    thickness: Int = 2,
    edgeColor: Color = Color.Black
) {
}
KotlinSnippets.kt

Bu, sizi gereksiz birden fazla işlev yazma zahmetinden kurtarmanın yanı sıra, özelliği, kodunuzun daha kolay okunmasını sağlar. Arayan kişi bir varsayılan değeri kullanmak istediklerini gösteren bir bağımsız değişken için değer. Ayrıca, adlandırılmış parametreler neler olduğunu daha kolay görmenizi sağlar. Kodu incelediğinizde aşağıdaki gibi bir işlev çağrısı görürseniz drawSquare() kodunu kontrol etmeden parametrelerin ne anlama geldiğini bilemeyebilirsiniz:

drawSquare(30, 5, Color.Red);
JavaSnippets.java

Bunun aksine, bu kod kendini belgelemektedir:

drawSquare(sideLength = 30, thickness = 5, edgeColor = Color.Red)
KotlinSnippets.kt

Çoğu Compose kitaplığı varsayılan bağımsız değişkenler kullanır. Yazdığınız birleştirilebilir işlevler için de aynısını yapmanız önerilir. Bu sayede, composable'ları özelleştirilebilir, ancak yine de varsayılan davranışın çağrılmasını basitleştirir. Örneğin, aşağıdaki gibi basit bir metin öğesi oluşturabilirsiniz:

Text(text = "Hello, Android!")
KotlinSnippets.kt

Bu kod aşağıdakiyle aynı etkiye sahiptir. Çok daha ayrıntılı olan bu kod, hakkında daha fazla Text Parametreler açık bir şekilde ayarlanır:

Text(
    text = "Hello, Android!",
    color = Color.Unspecified,
    fontSize = TextUnit.Unspecified,
    letterSpacing = TextUnit.Unspecified,
    overflow = TextOverflow.Clip
)
KotlinSnippets.kt

İlk kod snippet'i çok daha basit ve okunması kolay olmasının yanı sıra kendi belgeleme sürecidir. Yalnızca text parametresini belirterek diğer tüm parametreler için varsayılan değerleri kullanmak istediğinizi belirtirsiniz. Buna karşılık, ikinci snippet, diğer parametrelerin değerlerini açıkça ayarlamak istediğinizi ima eder. Ancak belirlediğiniz değerler işlevin varsayılan değerleridir.

Yüksek düzey işlevler ve lambda ifadeleri

Kotlin, parametre olarak diğer işlevleri alan üst düzey işlevleri destekler. Oluşturma, bu yaklaşımı temel alır. Örneğin, Button birleşebilir işlevi bir onClick lambda parametresi sağlar. Değer parametresi bir fonksiyondur ve kullanıcı tıkladığında düğme tarafından çağrılır:

Button(
    // ...
    onClick = myClickFunction
)
// ...
KotlinSnippets.kt

Daha yüksek düzeydeki işlevler lambda ifadeleri ve ifadelerle doğal bir şekilde eşlenir. bu da bir fonksiyona dönüşüyor. İşleve yalnızca bir kez ihtiyacınız varsa işlevi daha yüksek düzeyli işleve iletmek için başka bir yerde tanımlamanız gerekmez. Bunun yerine fonksiyonu bir lambda ifadesiyle tanımlamanız yeterlidir. Önceki örnek myClickFunction() parametresinin başka bir yerde tanımlandığını varsayar. Ancak burada yalnızca bu işlevi kullanıyorsanız işlevi bir lambda ifadesiyle satır içi olarak tanımlamak daha basittir:

Button(
    // ...
    onClick = {
        // do something
        // do something else
    }
) { /* ... */ }
KotlinSnippets.kt

Sonraki lambdalar

Kotlin, son parametresi bir lambda parametresidir. Bu şekilde bir lambda ifadesi iletmek parametresini kullanmak için trailing lambda söz dizimini kullanın. Lambda ifadesini parantez içine koymak yerine, ifadeyi parantezin sonuna koyarsınız. Bu durum, Compose'da sık karşılaşılan bir durumdur. ile uyumlu hale getirebilirsiniz.

Örneğin, tüm düzenlerin son parametresi; Column() composable işlev, content, alt kullanıcı arayüzünü yayan bir işlevdir öğeler. Üç metin öğesi içeren bir sütun oluşturmak istediğinizi ve bazı biçimlendirmeler uygulamanız gerektiğini varsayalım. Bu kod işe yarar ancak çok zahmetli:

Column(
    modifier = Modifier.padding(16.dp),
    content = {
        Text("Some text")
        Text("Some more text")
        Text("Last text")
    }
)
KotlinSnippets.kt

content parametresi, işlev imzasında son parametre olduğundan ve değerini lambda ifadesi olarak ilettiğimizde parantezlerden çıkarabiliriz:

Column(modifier = Modifier.padding(16.dp)) {
    Text("Some text")
    Text("Some more text")
    Text("Last text")
}
KotlinSnippets.kt

İki örneğin anlamı tamamen aynıdır. Küme ayraçları lambda'yı tanımlar content parametresine aktarılan bir ifadedir.

Aslında ilettiğiniz tek parametre sondaki lambda ise yani son parametre bir lambda ise ve parantezleri tamamen çıkarabilirsiniz. Örneğin, Column için değiştirici iletmeniz gerekmediğini varsayalım. Kodu şu şekilde yazabilirsiniz:

Column {
    Text("Some text")
    Text("Some more text")
    Text("Last text")
}
KotlinSnippets.kt

Bu söz dizimi, özellikle Column gibi düzen öğeleri için Oluştur'da oldukça yaygındır. Son parametre, öğenin alt öğeleri (alt öğeler) ise fonksiyon çağrısından sonra küme ayraçları içinde belirtilir.

Nişan dürbünleri ve alıcılar

Bazı yöntemler ve özellikler yalnızca belirli bir kapsamda kullanılabilir. Sınırlı kapsam, gerektiğinde işlevsellik sunmanızı ve kazara erişimi önlemenizi sağlar. o işlevin uygun olmadığı durumlarda kullanmayı düşünebilirsiniz.

Oluştur'da kullanılan bir örneği ele alalım. Row düzenini çağırdığınızda composable, içeriğinizin lambda değeri bir RowScope içinde otomatik olarak çağrılır. Bu, Row'ün yalnızca Row içinde geçerli olan işlevleri göstermesini sağlar. Aşağıdaki örnekte, Row öğesinin bir satıra özgü değeri nasıl gösterdiği align değiştiricisi:

Row {
    Text(
        text = "Hello world",
        // This Text is inside a RowScope so it has access to
        // Alignment.CenterVertically but not to
        // Alignment.CenterHorizontally, which would be available
        // in a ColumnScope.
        modifier = Modifier.align(Alignment.CenterVertically)
    )
}
KotlinSnippets.kt

Bazı API'ler, alıcı kapsamında çağrılan lambdaları kabul eder. Bu lambdalar, parametre beyanına göre başka bir yerde tanımlanan özelliklere ve işlevlere erişebilir:

Box(
    modifier = Modifier.drawBehind {
        // This method accepts a lambda of type DrawScope.() -> Unit
        // therefore in this lambda we can access properties and functions
        // available from DrawScope, such as the `drawRectangle` function.
        drawRect(
            /*...*/
            /* ...
        )
    }
)
KotlinSnippets.kt

Daha fazla bilgi için şununla birlikte işlev değişmez değerleri: alıcı hakkındaki makalemizi incelemenizi öneririz.

Yetki verilen mülkler

Kotlin, devredilmiş özellikleri destekler. Bu mülkler alan gibi çağrılır ancak değerleri bir ifadenin değerlendirilmesiyle dinamik olarak belirlenir. Bunları tanıyabilirsiniz özelliklerini kullanarak by söz dizimini kullanır:

class DelegatingClass {
    var name: String by nameGetterFunction()

    // ...
}
KotlinSnippets.kt

Diğer kodlar aşağıdaki gibi bir kodla mülke erişebilir:

val myDC = DelegatingClass()
println("The name property is: " + myDC.name)
KotlinSnippets.kt

println() yürütüldüğünde, dizenin değerini döndürmek için nameGetterFunction() çağrılır.

Bu yetki verilmiş mülkler, özellikle devlet destekli mülklerle çalışırken kullanışlıdır:

var showDialog by remember { mutableStateOf(false) }

// Updating the var automatically triggers a state change
showDialog = true
KotlinSnippets.kt

Not: remember ve mutableStateOf hakkında daha fazla bilgiyi şurada bulabilirsiniz: Jetpack Compose dokümanlarında belirtin.

Veri sınıflarını imha etme

Bir verileri tanımlarsanız sınıfına girip bu verilere erişimi indirim aracı beyan başlıklı makaleyi inceleyin. Örneğin, bir Person sınıfı tanımladığınızı varsayalım:

data class Person(val name: String, val age: Int)
KotlinSnippets.kt

Bu türde bir nesneniz varsa değerlerine aşağıdaki gibi bir kodla erişebilirsiniz:

val mary = Person(name = "Mary", age = 35)

// ...

val (name, age) = mary
KotlinSnippets.kt

Bu tür kodları genellikle Oluştur işlevlerinde görürsünüz:

Row {

    val (image, title, subtitle) = createRefs()

    // The `createRefs` function returns a data object;
    // the first three components are extracted into the
    // image, title, and subtitle variables.

    // ...
}
KotlinSnippets.kt

Veri sınıfları birçok yararlı işlev sunar. Örneğin, bir veri sınıfı tanımlarsanız derleyici, equals() ve copy(). Daha fazla bilgiyi veriler sınıfları dokümanlarına göz atın.

Singleton nesneleri

Kotlin, her zaman tek bir örneği olan sınıflar olan tekil nesneleri tanımlamayı kolaylaştırır. Bu single'lar, object anahtar kelimesiyle belirtilir. Oluşturma işlemi genellikle bu tür nesnelerden yararlanır. Örneğin, MaterialTheme tek bir nesne olarak tanımlanır; MaterialTheme.colors, shapes ve typography özelliklerinin tümü geçerli temanın değerlerini içerir.

Tür güvenli derleyiciler ve DSL'ler

Kotlin, tür açısından güvenli oluşturucularla alana özgü diller (DSL'ler) oluşturmanıza olanak tanır. DSL'ler, karmaşık hiyerarşik veri yapılarının daha sürdürülebilir ve okunabilir bir şekilde oluşturulmasına olanak tanır.

Jetpack Compose, LazyRow ve LazyColumn gibi bazı API'ler için DSL'leri kullanır.

@Composable
fun MessageList(messages: List<Message>) {
    LazyColumn {
        // Add a single item as a header
        item {
            Text("Message List")
        }

        // Add list of messages
        items(messages) { message ->
            Message(message)
        }
    }
}
KotlinSnippets.kt

Kotlin, alıcıyla işlev literalleri kullanarak tür açısından güvenli oluşturucular sağlar. Canvas bileşenini örnek olarak alırsak bu bileşen, onDraw: DrawScope.() -> Unit alıcı olarak DrawScope içeren bir işlevi parametre olarak alır. Bu sayede kod bloğu, DrawScope içinde tanımlanan üye işlevlerini çağırabilir.

Canvas(Modifier.size(120.dp)) {
    // Draw grey background, drawRect function is provided by the receiver
    drawRect(color = Color.Gray)

    // Inset content by 10 pixels on the left/right sides
    // and 12 by the top/bottom
    inset(10.0f, 12.0f) {
        val quadrantSize = size / 2.0f

        // Draw a rectangle within the inset bounds
        drawRect(
            size = quadrantSize,
            color = Color.Red
        )

        rotate(45.0f) {
            drawRect(size = quadrantSize, color = Color.Blue)
        }
    }
}
KotlinSnippets.kt

Tür güvenli derleyiciler ve DSL'ler hakkında daha fazla bilgi için Kotlin belgeleri.

Kotlin eş yordamları

Eş yordamlar, Kotlin. Eş yordamlar, ileti dizilerini engellemeden yürütmeyi askıya alabilir. Duyarlı kullanıcı arayüzü doğası gereği asenkrondur. Jetpack Compose, geri çağırma işlevleri kullanmak yerine API düzeyinde coroutine'leri benimseyerek bu sorunu çözer.

Jetpack Compose, kullanıcı arayüzü katmanında eş yordamların güvenli bir şekilde kullanılmasını sağlayan API'ler sunar. rememberCoroutineScope işlevi, etkinlik işleyicilerde veCoroutineScope Askıya alma API'leri oluşturun. ScrollState'ın animateScrollTo API'sini kullanan aşağıdaki örneğe bakın.

// Create a CoroutineScope that follows this composable's lifecycle
val composableScope = rememberCoroutineScope()
Button(
    // ...
    onClick = {
        // Create a new coroutine that scrolls to the top of the list
        // and call the ViewModel to load data
        composableScope.launch {
            scrollState.animateScrollTo(0) // This is a suspend function
            viewModel.loadData()
        }
    }
) { /* ... */ }
KotlinSnippets.kt

İşaretçili rutinler, kod bloğunu varsayılan olarak sıralı olarak yürütür. Askıya alma işlevini çağıran çalışan bir coroutine, askıya alma işlevi döndürülene kadar yürütmesini askıya alır. Bu durum, askıya alma işlevi yürütmeyi farklı bir CoroutineDispatcher'ye taşısa bile geçerlidir. Önceki örnekte, animateScrollTo işlevi döndürülene kadar loadData yürütülmez.

Kodu eşzamanlı olarak yürütmek için yeni iş parçacığı ortak işlemleri oluşturulmalıdır. Örnekte ekranın üst kısmına doğru kaydırmak ve viewModel, iki eş yordam gerekli.

// Create a CoroutineScope that follows this composable's lifecycle
val composableScope = rememberCoroutineScope()
Button( // ...
    onClick = {
        // Scroll to the top and load data in parallel by creating a new
        // coroutine per independent work to do
        composableScope.launch {
            scrollState.animateScrollTo(0)
        }
        composableScope.launch {
            viewModel.loadData()
        }
    }
) { /* ... */ }
KotlinSnippets.kt

Eş yordamlar, eşzamansız API'lerin birleştirilmesini kolaylaştırır. Sonraki örneğin, pointerInput değiştiricisini animasyon API'leriyle birleştirerek Kullanıcı ekrana dokunduğunda bir öğenin konumuna animasyon uygulayın.

@Composable
fun MoveBoxWhereTapped() {
    // Creates an `Animatable` to animate Offset and `remember` it.
    val animatedOffset = remember {
        Animatable(Offset(0f, 0f), Offset.VectorConverter)
    }

    Box(
        // The pointerInput modifier takes a suspend block of code
        Modifier
            .fillMaxSize()
            .pointerInput(Unit) {
                // Create a new CoroutineScope to be able to create new
                // coroutines inside a suspend function
                coroutineScope {
                    while (true) {
                        // Wait for the user to tap on the screen
                        val offset = awaitPointerEventScope {
                            awaitFirstDown().position
                        }
                        // Launch a new coroutine to asynchronously animate to
                        // where the user tapped on the screen
                        launch {
                            // Animate to the pressed position
                            animatedOffset.animateTo(offset)
                        }
                    }
                }
            }
    ) {
        Text("Tap anywhere", Modifier.align(Alignment.Center))
        Box(
            Modifier
                .offset {
                    // Use the animated offset as the offset of this Box
                    IntOffset(
                        animatedOffset.value.x.roundToInt(),
                        animatedOffset.value.y.roundToInt()
                    )
                }
                .size(40.dp)
                .background(Color(0xff3c1361), CircleShape)
        )
    }
KotlinSnippets.kt

Eş yordamlar hakkında daha fazla bilgi edinmek için Android'de Kotlin eş yordamları rehberi.