Oggi, la release di Jetpack Compose di aprile 2026 è stabile. Questa release contiene la versione 1.11 dei moduli Compose di base (vedi la mappatura completa della distinta base), strumenti di debug degli elementi condivisi, eventi del trackpad e altro ancora. Abbiamo anche alcune API sperimentali che ci piacerebbe che provassi e su cui ci fornissi un feedback.

Per utilizzare la release di oggi, esegui l'upgrade della versione della distinta base di Compose a:

implementation(platform("androidx.compose:compose-bom:2026.04.01"))

Modifiche in Compose 1.11.0

Esecuzione di coroutine nei test

Stiamo introducendo un aggiornamento importante al modo in cui Compose gestisce la tempistica dei test. Dopo il periodo di attivazione annunciato in Compose 1.10, le API di test v2 sono ora quelle predefinite e le API v1 sono state ritirate. La modifica principale è il passaggio al dispatcher di test predefinito. Mentre le API v1 si basavano su UnconfinedTestDispatcher, che eseguiva immediatamente le coroutine, le API v2 utilizzano StandardTestDispatcher. Ciò significa che quando una coroutine viene avviata nei test, viene messa in coda e non viene eseguita finché l'orologio virtuale non viene fatto avanzare.

In questo modo vengono simulate meglio le condizioni di produzione, eliminando efficacemente le condizioni di competizione e rendendo la suite di test notevolmente più robusta e meno instabile.

Per assicurarti che i test siano in linea con il comportamento standard delle coroutine ed evitare futuri problemi di compatibilità, ti consigliamo vivamente di eseguire la migrazione della suite di test. Consulta la nostra guida alla migrazione completa per le mappature delle API e le correzioni comuni.

Miglioramenti degli elementi condivisi e strumenti di animazione

Abbiamo anche aggiunto alcuni utili strumenti di debug visivo per gli elementi condivisi e Modifier.animatedBounds. Ora puoi vedere esattamente cosa succede dietro le quinte, ad esempio i limiti di destinazione, le traiettorie di animazione e il numero di corrispondenze trovate, il che rende molto più facile capire perché una transizione potrebbe non comportarsi come previsto. Per utilizzare i nuovi strumenti, racchiudi semplicemente SharedTransitionLayout con il LookaheadAnimationVisualDebugging composable. 

LookaheadAnimationVisualDebugging(
    overlayColor = Color(0x4AE91E63),
    isEnabled = true,
    multipleMatchesColor = Color.Green,
    isShowKeylabelEnabled = false,
    unmatchedElementColor = Color.Red,
) {
    SharedTransitionLayout {
        CompositionLocalProvider(
            LocalSharedTransitionScope provides this,
        ) {
            // your content
        }
    }
}

Eventi del trackpad

Abbiamo rinnovato il supporto di Compose per i trackpad, come i trackpad integrati dei laptop, i trackpad collegabili per i tablet o i trackpad esterni/virtuali. Gli eventi di base del trackpad verranno ora generalmente considerati eventi PointerType.Mouse, allineando il comportamento del mouse e del trackpad per soddisfare meglio le aspettative degli utenti. In precedenza, questi eventi del trackpad venivano interpretati come dita touchscreen finte di PointerType.Touch, il che portava a esperienze utente confuse. Ad esempio, fare clic e trascinare con un trackpad scorreva anziché selezionare. Modificando il tipo di puntatore di questi eventi nell'ultima release di Compose, fare clic e trascinare con un trackpad non scorrerà più.

Abbiamo anche aggiunto il supporto per i gesti del trackpad più complicati riconosciuti dalla piattaforma a partire dall'API 34, inclusi scorrimenti con due dita e pizzichi. Questi gesti vengono riconosciuti automaticamente da componenti come Modifier.scrollable e Modifier.transformable per un comportamento migliore con i trackpad.

Queste modifiche migliorano il comportamento dei trackpad nei componenti integrati, con la rimozione della soglia di scorrimento touch ridondante, un gesto di avvio di trascinamento più intuitivo, la selezione con doppio clic e triplo clic nei campi di testo e i menu contestuali in stile desktop nei campi di testo.

Per testare il comportamento del trackpad, sono disponibili nuove API di test con performTrackpadInput, che consentono di convalidare il comportamento delle app quando vengono utilizzate con un trackpad. Se hai rilevatori di gesti personalizzati, convalida il comportamento tra i tipi di input, inclusi touchscreen, mouse, trackpad e stili, e assicurati che siano supportate le rotelle di scorrimento del mouse e i gesti del trackpad.

Valori predefiniti dell'host di composizione (runtime di Compose)

Abbiamo introdotto HostDefaultProvider, LocalHostDefaultProvider, HostDefaultKey e ViewTreeHostDefaultKey per fornire i servizi a livello di host direttamente tramite compose-runtime. In questo modo, le librerie non devono dipendere da compose-ui per le ricerche, supportando meglio Kotlin Multiplatform. Per collegare questi valori all'albero di composizione, gli autori delle librerie possono utilizzare compositionLocalWithHostDefaultOf per creare un CompositionLocal che risolva i valori predefiniti dall'host.

Wrapper di anteprima

Anteprime personalizzate di Android Studio è una nuova funzionalità che ti consente di definire esattamente come vengono visualizzati i contenuti di un'anteprima di Compose.

Implementando l'interfaccia PreviewWrapperProvider e applicando la nuova annotazione @PreviewWrapper, puoi inserire facilmente logica personalizzata, ad esempio applicare un Theme specifico. L'annotazione può essere applicata a una funzione annotata con @Composable e @Preview o @MultiPreview, offrendo una soluzione generica e facile da usare che funziona con le funzionalità di anteprima e riduce significativamente il codice ripetitivo.

class ThemeWrapper: PreviewWrapper {
    @Composable
    override fun Wrap(content: @Composable (() -> Unit)) {
        JetsnackTheme {
            content()
        }
    }
}

@PreviewWrapperProvider(ThemeWrapper::class)
@Preview
@Composable
private fun ButtonPreview() {
    // JetsnackTheme in effect
    Button(onClick = {}) {
        Text(text = "Demo")
    }
}

Ritiri e rimozioni

• Come annunciato nel post del blog di Compose 1.10, stiamo ritirando Modifier.onFirstVisible(). Il suo nome spesso ha portato a interpretazioni errate, in particolare nei layout lazy, in cui veniva attivato più volte durante lo scorrimento. Ti consigliamo di eseguire la migrazione a Modifier.onVisibilityChanged(), che consente un monitoraggio manuale più preciso degli stati di visibilità personalizzati in base ai requisiti specifici del tuo caso d'uso.
• Il flag ComposeFoundationFlags.isTextFieldDpadNavigationEnabled è stato rimosso perché la navigazione con il D-pad per TextFields è ora sempre attiva per impostazione predefinita. Il nuovo comportamento garantisce che gli eventi del D-pad di un gamepad o di un telecomando TV spostino prima il cursore nella direzione indicata. Lo stato attivo può spostarsi su un altro elemento solo quando il cursore raggiunge la fine del testo.

API in arrivo

Nella prossima release di Compose 1.12.0, compileSdk verrà aggiornato a compileSdk 37, con AGP 9 e tutte le app e le librerie che dipendono da Compose che ereditano questo requisito. Ti consigliamo di rimanere aggiornato con le ultime versioni rilasciate, poiché Compose mira ad adottare rapidamente i nuovi compileSdks per fornire l'accesso alle funzionalità Android più recenti. Per ulteriori informazioni sulla versione di AGP supportata per i diversi livelli API, consulta la documentazione qui. 

In Compose 1.11.0, le seguenti API vengono introdotte come @Experimental e non vediamo l'ora di ricevere il tuo feedback mentre le esplori nelle tue app. Tieni presente che @Experimental APIs vengono fornite per la valutazione e il feedback iniziali e potrebbero subire modifiche o rimozioni significative nelle release future.

Stili (sperimentali)

Stiamo introducendo una nuova API di base sperimentale per lo stile. L'API Style è un nuovo paradigma per la personalizzazione degli elementi visivi dei componenti, che tradizionalmente veniva eseguita con i modificatori. È progettata per sbloccare una personalizzazione più approfondita e semplice esponendo un insieme standard di proprietà con stile con transizioni animate e basate sullo stato. Con questa nuova API, stiamo già riscontrando vantaggi in termini di prestazioni promettenti. Prevediamo di adottare gli stili nei componenti Material una volta che l'API Style sarà stabile.

Di seguito è riportato un esempio di base di sostituzione dello sfondo dello stile dello stato premuto:

@Composable
fun LoginButton(modifier: Modifier = Modifier) {
    Button(
        onClick = {
            // Login logic
        },
        modifier = modifier,
        style = {
            background(
                Brush.linearGradient(
                    listOf(lightPurple, lightBlue)
                )
            )
            width(75.dp)
            height(50.dp)
            textAlign(TextAlign.Center)
            externalPadding(16.dp)

            pressed {
                background(
                    Brush.linearGradient(
                        listOf(Color.Magenta, Color.Red)
                    )
                )
            }
        }
    ){
        Text(
            text = "Login",
        )
    }
}

Consulta la documentazione e segnala eventuali bug qui.

MediaQuery (sperimentale)

La nuova API mediaQuery fornisce un modo dichiarativo e performante per adattare l'interfaccia utente al suo ambiente. Estrae le informazioni complesse in condizioni semplici all'interno di un UiMediaScope, garantendo che la ricomposizione avvenga solo quando necessario.

Grazie al supporto di un'ampia gamma di segnali ambientali, dalle funzionalità del dispositivo come i tipi di tastiera e la precisione del puntatore agli stati contestuali come le dimensioni e la postura della finestra, puoi creare esperienze altamente reattive. Le prestazioni sono integrate con derivedMediaQuery per gestire gli aggiornamenti ad alta frequenza, mentre la possibilità di sostituire gli ambiti semplifica i test e le anteprime tra le configurazioni hardware. In precedenza, per accedere a determinate proprietà del dispositivo, ad esempio se un dispositivo era in modalità da tavolo, era necessario scrivere un sacco di codice boilerplate: 

@Composable
fun isTabletopPosture(
    context: Context = LocalContext.current
): Boolean {
    val windowLayoutInfo by
        WindowInfoTracker
            .getOrCreate(context)
            .windowLayoutInfo(context)
            .collectAsStateWithLifecycle(null)

    return windowLayoutInfo.displayFeatures.any { displayFeature ->
        displayFeature is FoldingFeature &&
            displayFeature.state == FoldingFeature.State.HALF_OPENED &&
            displayFeature.orientation == FoldingFeature.Orientation.HORIZONTAL
    }
}

@Composable
fun VideoPlayer() {
    if(isTabletopPosture()) {
        TabletopLayout()
    } else {
        FlatLayout()
    }
}

Ora, con UIMediaQuery, puoi aggiungere la sintassi mediaQuery per eseguire query sulle proprietà del dispositivo, ad esempio se un dispositivo è in modalità da tavolo:

@OptIn(ExperimentalMediaQueryApi::class)
@Composable
fun VideoPlayer() {
    if (mediaQuery { windowPosture == UiMediaScope.Posture.Tabletop }) {
        TabletopLayout()
    } else {
        FlatLayout()
    }
}

Consulta la documentazione e segnala eventuali bug qui.

Griglia (sperimentale)

Grid è una nuova potente API per la creazione di layout bidimensionali complessi in Jetpack Compose. Sebbene Row e Column siano ideali per i design lineari, Grid ti offre il controllo strutturale necessario per l'architettura a livello di schermo e i componenti complessi senza il sovraccarico di un elenco scorrevole. Grid ti consente di definire il layout utilizzando tracce, spazi e celle, offrendo opzioni di dimensionamento familiari come Dp, percentuali, dimensioni intrinseche dei contenuti e unità "Fr" flessibili. 

@OptIn(ExperimentalGridApi::class)
@Composable
fun GridExample() {
    Grid(
        config = {
            repeat(4) { column(0.25f) }
            repeat(2) { row(0.5f) }
            gap(16.dp)
        }
    ) {
        Card1(modifier = Modifier.gridItem(rowSpan = 2)
        Card2(modifier = Modifier.gridItem(colmnSpan = 3)
        Card3(modifier = Modifier.gridItem(columnSpan = 2)
        Card4()
    }
}

Puoi posizionare gli elementi automaticamente o estenderli esplicitamente su più righe e colonne per una maggiore precisione. La cosa migliore è che è altamente adattabile: puoi riconfigurare dinamicamente le tracce e le estensioni della griglia per rispondere agli stati del dispositivo, come la modalità da tavolo o le modifiche dell'orientamento, assicurandoti che l'interfaccia utente abbia un aspetto ottimale su tutti i fattori di forma.

Consulta la documentazione e segnala eventuali bug qui. 

FlexBox (sperimentale)

FlexBox è un contenitore di layout progettato per interfacce utente adattive e ad alte prestazioni. Gestisce il dimensionamento degli elementi e la distribuzione dello spazio in base alle dimensioni del contenitore disponibili.Gestisce attività complesse come il wrapping (wrap) e l'allineamento multi-asse degli elementi (justifyContent, alignItems, alignContent). Consente agli elementi di espandersi (grow) o ridursi (shrink) per riempire il contenitore. 

@OptIn(ExperimentalFlexBoxApi::class)
fun FlexBoxWrapping(){
    FlexBox(
        config = {
            wrap(FlexWrap.Wrap)
            gap(8.dp)
        }
    ) {
        RedRoundedBox()
        BlueRoundedBox()
        GreenRoundedBox(modifier = Modifier.width(350.dp).flex { grow(1.0f) })
        OrangeRoundedBox(modifier = Modifier.width(200.dp).flex { grow(0.7f) })
        PinkRoundedBox(modifier = Modifier.width(200.dp).flex { grow(0.3f) })
    }
}

Consulta la documentazione e segnala eventuali bug qui.

Nuova implementazione di SlotTable (sperimentale)

Abbiamo introdotto una nuova implementazione di SlotTable, che è disattivata per impostazione predefinita in questa release. SlotTable è la struttura dati interna utilizzata dal runtime di Compose per tenere traccia dello stato della gerarchia di composizione, tenere traccia delle invalidazioni/ricomposizioni, archiviare i valori memorizzati e tenere traccia di tutti i metadati della composizione in fase di runtime. Questa nuova implementazione è progettata per migliorare le prestazioni, principalmente per le modifiche casuali.

Per provare il nuovo SlotTable, attiva ComposeRuntimeFlags.isLinkBufferComposerEnabled. 

Inizia a programmare oggi stesso!

Con così tante nuove API entusiasmanti in Jetpack Compose e molte altre in arrivo, non è mai stato un momento migliore per eseguire la migrazione a Jetpack Compose.Come sempre, apprezziamo i tuoi feedback e le tue richieste di funzionalità (soprattutto per le funzionalità @Experimental ancora in fase di sviluppo). Inviaci i tuoi feedback qui. Buona composizione!