Diagnostica i problemi di stabilità

Se stai riscontrando problemi di prestazioni dovuti a problemi non necessari ricomposizione eccessiva, dovresti eseguire il debug della stabilità della tua app. Questa guida illustra diversi metodi per farlo.

Layout Inspector

Layout Inspector in Android Studio ti consente di visualizzare quali elementi componibili che si ricompone nell'app. Mostra il numero di volte in cui Compose ha ricomposto o ignorato un componente.

Crea report del compilatore

Il compilatore Compose può restituire i risultati della sua inferenza di stabilità o un controllo. Utilizzando questo output, è possibile determinare quali sono ignorabili e quali non lo sono. Le seguenti sottosezioni riepilogano come utilizzare questi report, ma per informazioni più dettagliate consulta i documenti tecnici documentazione.

Configura

La creazione di report del compilatore non è abilitata per impostazione predefinita. Puoi attivarle con un flag di compilatore. La configurazione esatta varia a seconda del ma per i progetti che utilizzano il plug-in Gradle del compilatore Scrivi puoi aggiungi quanto segue in ogni file build.gradle dei moduli.

  android { ... }

  composeCompiler {
    reportsDestination = layout.buildDirectory.dir("compose_compiler")
    metricsDestination = layout.buildDirectory.dir("compose_compiler")
  }

Ora verrà generato un report del compilatore durante la creazione del progetto.

Output di esempio

reportsDestination restituisce tre file. Di seguito sono riportati output di esempio di JetSnack.

• <modulename>-classes.txt: un report sulla stabilità delle classi in questo in maggior dettaglio più avanti in questo modulo. Esempio.
• <modulename>-composables.txt: un report che illustra il livello di riavvio e ignorabile, gli elementi componibili sono nel modulo. Esempio.
• <modulename>-composables.csv: una versione CSV del report sui componibili che puoi importare in un foglio di lavoro o elaborare utilizzando uno script. Esempio

Report Componenti componibili

Il file composables.txt descrive in dettaglio ogni funzione componibile per l'elemento modulo, tra cui la stabilità dei relativi parametri e se sono riavviabili o ignorabili. Di seguito è riportato un esempio ipotetico JetSnack:

restartable skippable scheme("[androidx.compose.ui.UiComposable]") fun SnackCollection(
  stable snackCollection: SnackCollection
  stable onSnackClick: Function1<Long, Unit>
  stable modifier: Modifier? = @static Companion
  stable index: Int = @static 0
  stable highlight: Boolean = @static true
)

Questo componibile SnackCollection è completamente riavviabile, ignorabile e stabile. Questa opzione è generalmente preferibile, anche se sicuramente non è obbligatoria.

Esaminiamo un altro esempio.

restartable scheme("[androidx.compose.ui.UiComposable]") fun HighlightedSnacks(
  stable index: Int
  unstable snacks: List<Snack>
  stable onSnackClick: Function1<Long, Unit>
  stable modifier: Modifier? = @static Companion
)

Il componibile HighlightedSnacks non è ignorabile. Scrivi non lo salta mai durante la ricomposizione. anche se nessuno dei parametri è cambiato. Il motivo è il parametro unstable, snacks.

Report sui corsi

Il file classes.txt contiene un report simile sui corsi dello stesso in maggior dettaglio più avanti in questo modulo. Il seguente snippet è l'output per la classe Snack:

unstable class Snack {
  stable val id: Long
  stable val name: String
  stable val imageUrl: String
  stable val price: Long
  stable val tagline: String
  unstable val tags: Set<String>
  <runtime stability> = Unstable
}

Come riferimento, di seguito è riportata la definizione di Snack:

data class Snack(
    val id: Long,
    val name: String,
    val imageUrl: String,
    val price: Long,
    val tagline: String = "",
    val tags: Set<String> = emptySet()
)

Il compilatore Compose ha contrassegnato Snack come instabile. Ciò è dovuto al fatto che il tipo Il parametro tags è Set<String>. Si tratta di un tipo immutabile, dato che non è un MutableSet. Tuttavia, classi di raccolta standard come Set, List, e Map sono infine le interfacce. Di conseguenza, l'implementazione sottostante può sarà ancora modificabile.

Ad esempio, potresti scrivere val set: Set<String> = mutableSetOf("foo"). La è costante e il tipo dichiarato non è modificabile, ma la sua l'implementazione è ancora modificabile. Il compilatore Compose non può essere sicuro immutabilità di questa classe, in quanto vede solo il tipo dichiarato. Di conseguenza, tags come instabile.