Mode lewati yang kuat

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

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

Catatan: Strong Skipping diaktifkan secara default di Kotlin 2.0.20. Daftar lengkap opsi tersedia di referensi Plugin Gradle Compose Compiler.

Mengaktifkan mode skipping kuat

Pengabaian yang kuat diaktifkan secara default di Kotlin 2.0.20.

Untuk mengaktifkan lewati yang kuat untuk modul Gradle dalam rilis sebelum 2.0.20, sertakan opsi berikut dalam blok composeCompiler konfigurasi Gradle Anda:

android { ... }

composeCompiler {
   enableStrongSkippingMode = true
}

Kemampuan composable untuk dilewati

Mode lewati yang kuat melonggarkan beberapa aturan stabilitas yang biasanya diterapkan oleh compiler Compose terkait fungsi lewati dan composable. Secara default, compiler Compose menandai fungsi composable sebagai dapat dilewati jika semua argumennya memiliki nilai yang stabil. Mode skipping kuat akan mengubahnya.

Dengan mengaktifkan lewati yang kuat, semua fungsi composable yang dapat dimulai ulang menjadi dapat dilewati. Hal ini berlaku terlepas dari apakah parameternya 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 persamaan instance (===)
• Parameter stabil dibandingkan menggunakan persamaan objek (Object.equals())

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

Anda mungkin ingin composable memilih untuk tidak ikut dalam pengabaian yang kuat. Artinya, Anda mungkin ingin composable yang dapat dimulai ulang, tetapi tidak dapat dilewati. Dalam hal ini, gunakan anotasi @NonSkippableComposable.

@NonSkippableComposable
@Composable
fun MyNonSkippableComposable {}

Menambahkan anotasi class sebagai stabil

Jika Anda menginginkan objek yang menggunakan kesetaraan objek, bukan kesetaraan instance, lanjutkan 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 berubah.

Memoisasi lambda

Mode skipping kuat juga memungkinkan lebih banyak memoisasi lambda di dalam composable. Dengan mengaktifkan strong skipping, 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 Anda dengan panggilan remember. Key ini diberi kunci dengan rekaman 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 strong skipping, compiler akan memaketkan 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 kesetaraan objek.

Catatan: Hal ini sedikit berbeda dengan panggilan remember standar saat runtime Compose membandingkan semua kunci menggunakan kesetaraan objek.

Memoisasi dan rekomposisi

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

Catatan: Kesalahpahaman umum adalah lambda dengan pengambilan yang tidak stabil adalah objek yang tidak stabil. Hal ini tidak benar. Compiler Compose selalu menganggap lambda stabil. Namun, dengan menonaktifkan Strong skipping, compiler tidak akan menyimpannya dalam memori dan runtime akan mengalokasikannya selama rekomposisi. Dengan demikian, lambda dengan pengambilan yang tidak stabil menyebabkan Compose tidak melewati composable karena memiliki parameter yang tidak sama.

Menghindari memoisasi

Jika Anda memiliki lambda yang tidak ingin di-memo, gunakan anotasi @DontMemoize.

val lambda = @DontMemoize {
    ...
}

Ukuran APK

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

Mengaktifkan lewati yang kuat di Now In Android 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 harus relatif kecil.