Mode lewati yang kuat

Skipping yang Kuat adalah mode yang tersedia di compiler Compose. Jika diaktifkan, fitur ini akan mengubah perilaku compiler dengan dua cara:

• Composable dengan parameter yang tidak stabil akan menjadi dapat dilewati
• Lambda dengan tangkapan yang tidak stabil diingat

Aktifkan mode lewati kuat

Guna mengaktifkan lewati yang kuat untuk modul Gradle, sertakan opsi berikut dalam blok composeCompiler konfigurasi Gradle Anda:

composeCompiler {
   enableStrongSkipping = true
}

Kemampuan melewati composable

Mode lewati yang kuat melonggarkan beberapa aturan stabilitas yang biasanya diterapkan oleh compiler Compose saat berhubungan dengan fungsi lewati dan composable. Secara default, compiler Compose menandai fungsi composable sebagai dapat dilewati jika semua argumennya memiliki nilai yang stabil. Mode lewati yang kuat akan mengubah ini.

Jika fitur lewati kuat diaktifkan, semua fungsi composable yang dapat dimulai ulang akan dapat dilewati. Hal ini berlaku terlepas dari apakah parameter tersebut memiliki parameter yang tidak stabil atau tidak. Fungsi composable yang tidak dapat dimulai ulang tetap tidak dapat dilewati.

Kapan harus melewati

Untuk menentukan apakah akan melewati composable selama rekomposisi, Compose membandingkan nilai setiap parameter dengan nilai sebelumnya. Jenis perbandingan bergantung pada stabilitas parameter.

• Parameter yang tidak stabil dibandingkan menggunakan kesetaraan instance (===)
• Parameter stabil dibandingkan menggunakan kesetaraan objek (Object.equals())

Jika semua parameter memenuhi persyaratan ini, Compose akan melewati composable selama rekomposisi.

Anda mungkin ingin composable tidak melakukan lewati secara signifikan. Artinya, Anda mungkin ingin composable yang dapat dimulai ulang tetapi tidak dapat dilewati. Dalam hal ini, gunakan anotasi @NonSkippableComposable.

@NonSkippableComposable
@Composable
fun MyNonSkippableComposable {}

Menganotasi class sebagai stabil

Jika Anda ingin objek menggunakan kesetaraan objek, bukan kesetaraan instance, teruslah menganotasi class yang diberikan dengan @Stable. Contoh saat Anda mungkin harus melakukannya adalah saat mengamati seluruh daftar objek, sumber data seperti Room akan mengalokasikan objek baru untuk setiap item dalam daftar setiap kali salah satu objek tersebut berubah.

Memoisasi Lambda

Mode lewati yang kuat juga memungkinkan lebih banyak pengingat lambda di dalam composable. Dengan mengaktifkan fungsi lewati kuat, setiap lambda di dalam fungsi composable akan otomatis diingat.

Contoh

Untuk mencapai memoisasi lambda di dalam composable saat menggunakan lewati yang kuat, compiler menggabungkan lambda dengan panggilan remember. Elemen ini dilengkapi dengan tangkapan lambda.

Pertimbangkan kasus saat Anda memiliki lambda seperti pada contoh berikut:

@Composable
fun MyComposable(unstableObject: Unstable, stableObject: Stable) {
    val lambda = {
        use(unstableObject)
        use(stableObject)
    }
}

Dengan mengaktifkan fungsi lewati kuat, compiler akan memoles lambda dengan menggabungkannya dalam panggilan remember:

@Composable
fun MyComposable(unstableObject: Unstable, stableObject: Stable) {
    val lambda = remember(unstableObject, stableObject) {
        {
            use(unstableObject)
            use(stableObject)
        }
    }
}

Kunci mengikuti aturan perbandingan yang sama dengan fungsi composable. Runtime membandingkan kunci yang tidak stabil menggunakan kesetaraan instance. Metode ini membandingkan kunci stabil menggunakan kesamaan objek.

Memoisasi dan rekomposisi

Pengoptimalan ini meningkatkan jumlah composable yang dilewati runtime selama rekomposisi. Tanpa memoisasi, runtime jauh lebih mungkin untuk mengalokasikan lambda baru ke composable mana pun yang menggunakan parameter lambda selama rekomposisi. Akibatnya, lambda baru memiliki parameter yang tidak sama dengan komposisi terakhir. Hal ini menyebabkan rekomposisi.

Menghindari memoisasi

Jika Anda memiliki lambda yang tidak ingin direkam, gunakan anotasi @DontMemoize.

val lambda = @DontMemoize {
    ...
}

Ukuran APK

Saat dikompilasi, Composable yang dapat dilewati menghasilkan kode yang lebih banyak dihasilkan daripada composable yang tidak dapat dilewati. Dengan mengaktifkan fungsi lewati kuat, compiler akan menandai hampir semua composable sebagai dapat dilewati dan menggabungkan semua lambda dalam remember{...}. Oleh karena itu, mengaktifkan mode lewati yang kuat memiliki dampak yang sangat kecil terhadap ukuran APK aplikasi Anda.

Mengaktifkan lewati yang kuat di Now In Android akan meningkatkan ukuran APK sebesar 4 kB. Perbedaan ukuran sebagian besar bergantung pada jumlah composable yang sebelumnya tidak dapat dilewati yang ada di aplikasi tertentu, tetapi seharusnya relatif kecil.