Mode lewati yang kuat

Pelewatan yang Kuat adalah mode yang tersedia di compiler Compose. Jika diaktifkan, mengubah perilaku compiler dengan dua cara:

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

Mengaktifkan mode skipping kuat

Untuk mengaktifkan pengabaian yang kuat untuk modul Gradle, sertakan opsi berikut di blok composeCompiler dalam konfigurasi Gradle Anda:

android { ... }

composeCompiler {
   enableStrongSkippingMode = true
}

Opsi dapat dilewati yang dapat dilewati

Mode lewati yang kuat melonggarkan beberapa aturan stabilitas yang biasanya diterapkan oleh compiler Compose untuk melewati dan menjalankan fungsi composable. Menurut secara default, compiler Compose menandai fungsi composable sebagai dapat dilewati jika semua argumennya memiliki nilai yang stabil. Mode lewati yang ketat mengubah ini.

Dengan mengaktifkan pengabaian kuat, semua fungsi composable yang dapat dimulai ulang akan menjadi 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 memilih untuk tidak mengaktifkan pengabaian yang kuat. Artinya, Anda mungkin ingin composable yang dapat dimulai ulang tetapi tidak dapat dilewati. Dalam hal ini, gunakan metode anotasi @NonSkippableComposable.

@NonSkippableComposable
@Composable
fun MyNonSkippableComposable {}

Menganotasi class sebagai stabil

Jika Anda ingin objek menggunakan persamaan objek, bukan kesetaraan instance, terus menganotasi class yang diberikan dengan @Stable. Contoh saat Anda mungkin harus dilakukan ketika mengamati seluruh daftar objek, sumber data seperti karena Room akan mengalokasikan objek baru untuk setiap item dalam daftar setiap kali mereka berubah.

Memoisasi lambda

Mode lewati yang kuat juga memungkinkan lebih banyak memoisasi lambda di dalam composable. Dengan tindakan lewati yang kuat yang diaktifkan, setiap lambda di dalam suatu dan fungsi composable tersebut akan diingat secara otomatis.

Contoh

Untuk mencapai memoisasi lambda di dalam composable saat menggunakan pengabaian yang kuat, compiler akan menggabungkan lambda dengan panggilan remember. Kunci ini dikunci dengan tangkapan lambda.

Pertimbangkan kasus saat Anda memiliki lambda seperti dalam contoh berikut:

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

Dengan mengaktifkan pengabaian kuat, compiler akan memompa lambda dengan menggabungkannya panggilan remember:

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

Kunci mengikuti aturan perbandingan yang sama seperti fungsi composable. Runtime membandingkan kunci yang tidak stabil menggunakan kesetaraan instance. Alat ini membandingkan kunci stabil yang menggunakan kesetaraan objek.

Memoisasi dan rekomposisi

Pengoptimalan ini sangat meningkatkan jumlah composable yang runtime akan dilewati selama rekomposisi. Tanpa memoisasi, {i>runtime<i} akan 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. Ini menghasilkan rekomposisi.

Hindari memoisasi

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

val lambda = @DontMemoize {
    ...
}

Ukuran APK

Saat dikompilasi, Composable yang dapat dilewati menghasilkan lebih banyak kode yang dihasilkan daripada composable yang tidak dapat dilewati. Dengan tindakan melewati secara ketat yang diaktifkan, compiler menandai hampir semua composable sebagai dapat dilewati dan menggabungkan semua lambda dalam remember{...}. Oleh karena itu, mengaktifkan mode lewati yang kuat memiliki memengaruhi ukuran APK aplikasi.

Mengaktifkan tindakan lewati yang kuat di Now In Android meningkatkan APK berukuran 4 kB. Perbedaan ukuran sangat tergantung pada jumlah composable yang tidak dapat dilewati yang ada di aplikasi tertentu, tetapi seharusnya relatif kecil.