Mode lewati yang kuat

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

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

Catatan: Strong Skipping diaktifkan secara default di Kotlin 2.0.20.

Mengaktifkan mode skipping kuat

Untuk mengaktifkan lewati yang kuat untuk modul Gradle dalam rilis sebelumnya, 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 dalam hal fungsi lewati dan composable. 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 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 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. Kunci ini disertakan 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 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 akan 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 yang umum adalah bahwa lambda dengan rekaman 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 dicatat, gunakan anotasi @DontMemoize.

val lambda = @DontMemoize {
    ...
}

Ukuran APK

Jika dikompilasi, Composable yang dapat dilewati menghasilkan lebih banyak kode yang dihasilkan daripada composable yang tidak dapat dilewati. Dengan mengaktifkan pengabaian 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 pada ukuran APK aplikasi Anda.

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