Scrittura e altre librerie

Puoi utilizzare le tue librerie preferite in Scrivi. Questa sezione descrive come incorporare alcune delle librerie più utili.

Attività

Per utilizzare Compose in un'attività, devi utilizzare ComponentActivity, una sottoclasse di Activity che fornisce LifecycleOwner e componenti appropriati a Compose. Fornisce inoltre API aggiuntive che disaccoppiano il codice dalla sostituzione dei metodi nella classe dell'attività. Activity Compose espone queste API ai composabili in modo che non sia più necessario eseguire l'override dei metodi al di fuori dei composabili o recuperare un'istanza Activity esplicita. Inoltre, queste API assicurano di essere inizializzate una sola volta, di sopravvivere alla ricompozione e di essere ripulite correttamente se il composable viene rimosso dalla composizione.

Risultato attività

L'API rememberLauncherForActivityResult() ti consente di ottenere un risultato da un'attività nel tuo composable:

@Composable
fun GetContentExample() {
    var imageUri by remember { mutableStateOf<Uri?>(null) }
    val launcher = rememberLauncherForActivityResult(ActivityResultContracts.GetContent()) { uri: Uri? ->
        imageUri = uri
    }
    Column {
        Button(onClick = { launcher.launch("image/*") }) {
            Text(text = "Load Image")
        }
        Image(
            painter = rememberAsyncImagePainter(imageUri),
            contentDescription = "My Image"
        )
    }
}
ComposeWithOtherLibraries.kt

Questo esempio mostra un contratto GetContent() semplice. La richiesta viene avviata toccando il pulsante. La lambda finale per rememberLauncherForActivityResult() viene invocata quando l'utente seleziona un'immagine e torna all'attività di lancio. Viene caricata l'immagine selezionata utilizzando la funzione rememberImagePainter() di Coil.

Qualsiasi sottoclasse di ActivityResultContract può essere utilizzata come primo argomento di rememberLauncherForActivityResult(). Ciò significa che puoi utilizzare questa tecnica per richiedere contenuti dal framework e in altri pattern comuni. Puoi anche creare i tuoi contratti personalizzati e utilizzarli con questa tecnica.

Richiesta delle autorizzazioni di runtime

La stessa API Activity Result e rememberLauncherForActivityResult() spiegate sopra possono essere utilizzate per richiedere le autorizzazioni di runtime utilizzando il RequestPermission contratto per una singola autorizzazione o RequestMultiplePermissions contratto per più autorizzazioni.

La libreria Permissions Authenticator può essere utilizzata anche come livello sopra queste API per mappare lo stato corrente delle autorizzazioni concesse in uno stato che può essere utilizzato dall'interfaccia utente di Compose.

Gestione del pulsante Indietro del sistema

Per fornire la navigazione a ritroso personalizzata e sostituire il comportamento predefinito del pulsante Indietro di sistema dall'interno del composable, il composable può utilizzare un BackHandler per intercettare l'evento:

var backHandlingEnabled by remember { mutableStateOf(true) }
BackHandler(backHandlingEnabled) {
    // Handle back press
}
ComposeWithOtherLibraries.kt

Il primo argomento controlla se il gestore BackHandler è attualmente attivo. Puoi utilizzare questo argomento per disattivare temporaneamente il gestore in base allo stato del componente. La lambda finale verrà invocata se l'utente attiva un evento di ritorno di sistema e BackHandler è attualmente attivo.

ViewModel

Se utilizzi la libreria Architecture Components ViewModel, puoi accedere a un ViewModel da qualsiasi composable chiamando la funzione viewModel(). Aggiungi la seguente dipendenza al file Gradle:

Groovy

dependencies {
    implementation 'androidx.lifecycle:lifecycle-viewmodel-compose:2.8.5'
}

Kotlin

dependencies {
    implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.8.5")
}

Puoi quindi utilizzare la funzione viewModel() nel codice.

class MyViewModel : ViewModel() { /*...*/ }

// import androidx.lifecycle.viewmodel.compose.viewModel
@Composable
fun MyScreen(
    viewModel: MyViewModel = viewModel()
) {
    // use viewModel here
}
ComposeWithOtherLibraries.kt

viewModel() restituisce un ViewModel esistente o ne crea uno nuovo. Per impostazione predefinita,ViewModel restituito è limitato all'attività, al frammento o alla destinazione di navigazione che lo contiene e viene mantenuto attivo finché l'ambito è attivo.

Ad esempio, se il composable viene utilizzato in un'attività, viewModel() restituisce la stessa istanza finché l'attività non è terminata o il processo non viene interrotto.

class MyViewModel : ViewModel() { /*...*/ }
// import androidx.lifecycle.viewmodel.compose.viewModel
@Composable
fun MyScreen(
    // Returns the same instance as long as the activity is alive,
    // just as if you grabbed the instance from an Activity or Fragment
    viewModel: MyViewModel = viewModel()
) { /* ... */ }

@Composable
fun MyScreen2(
    viewModel: MyViewModel = viewModel() // Same instance as in MyScreen
) { /* ... */ }
ComposeWithOtherLibraries.kt

Linee guida per l'utilizzo

In genere, accedi alle istanze ViewModel ai composabili a livello di schermata, ovvero vicino a un composable principale chiamato da un'attività, un frammento o una destinazione di un grafico di navigazione. Questo perché ViewModels sono, per impostazione predefinita, limitati a questi oggetti a livello di schermata. Scopri di più sul ciclo di vita e sull'ambito di un'ViewModel qui.

Cerca di evitare di trasmettere le istanze ViewModel ad altri componenti composibili, in quanto ciò potrebbe renderli più difficili da testare e potrebbe interrompere le anteprime. Passa invece solo i dati e le funzioni di cui hanno bisogno come parametri.

Puoi utilizzare le istanze ViewModel per gestire lo stato dei composabili a livello di sottoschermata, ma tieni presente il ciclo di vita e l'ambito di ViewModel. Se il composable è autonomo, ti consigliamo di utilizzare Hilt per iniettare ViewModel per evitare di dover passare le dipendenze dai composable di primo livello.

Se ViewModel ha dipendenze, viewModel() accetta un parametro facoltativo ViewModelProvider.Factory.

Per saperne di più su ViewModel in Compose e su come vengono utilizzate le istanze con la libreria Navigation Compose o con attività e frammenti, consulta la documentazione sull'interoperabilità.

Stream di dati

Compose è dotato di estensioni per le soluzioni basate su stream più diffuse di Android. Ognuna di queste estensioni è fornita da un elemento diverso:

Questi elementi vengono registrati come ascoltatori e rappresentano i valori come State. Ogni volta che viene emesso un nuovo valore, Compose ricomponie le parti dell'interfaccia utente in cui viene utilizzato state.value. Ad esempio, in questo codice, ShowData si ricomponie ogni volta cheexampleLiveData emette un nuovo valore.

// import androidx.lifecycle.viewmodel.compose.viewModel
@Composable
fun MyScreen(
    viewModel: MyViewModel = viewModel()
) {
    val dataExample = viewModel.exampleLiveData.observeAsState()

    // Because the state is read here,
    // MyScreen recomposes whenever dataExample changes.
    dataExample.value?.let {
        ShowData(dataExample)
    }
}
ComposeWithOtherLibraries.kt

Operazioni asincrone in Compose

Jetpack Compose ti consente di eseguire operazioni asincrone utilizzando le coroutine all'interno dei tuoi composabili.

Per ulteriori informazioni, consulta le API LaunchedEffect, produceState e rememberCoroutineScope nella documentazione sugli effetti collaterali.

Il componente Navigation fornisce il supporto per le applicazioni Jetpack Compose. Per ulteriori informazioni, consulta Navigare con Compose e Eseguire la migrazione di Jetpack Navigation a Navigation Compose.

Hilt

Hilt è la soluzione consigliata per l'iniezione di dipendenze nelle app per Android e funziona perfettamente con Compose.

La funzione viewModel() menzionata nella sezione ViewModel utilizza automaticamente il ViewModel costruito da Hilt con l'annotazione @HiltViewModel. Abbiamo fornito la documentazione con informazioni sull'integrazione di ViewModel di Hilt.

@HiltViewModel
class MyViewModel @Inject constructor(
    private val savedStateHandle: SavedStateHandle,
    private val repository: ExampleRepository
) : ViewModel() { /* ... */ }

// import androidx.lifecycle.viewmodel.compose.viewModel
@Composable
fun MyScreen(
    viewModel: MyViewModel = viewModel()
) { /* ... */ }

ComposeWithOtherLibraries.kt

Hilt e navigazione

Hilt si integra anche con la libreria Navigation Compose. Aggiungi le seguenti dipendenze aggiuntive al tuo file Gradle:

Groovy

dependencies {
    implementation 'androidx.hilt:hilt-navigation-compose:1.2.0'
}

Kotlin

dependencies {
    implementation("androidx.hilt:hilt-navigation-compose:1.2.0")
}

Quando utilizzi Navigation Compose, usa sempre la funzione composable hiltViewModel per ottenere un'istanza del tuo @HiltViewModel annotato ViewModel. Questo funziona con frammenti o attività annotati con @AndroidEntryPoint.

Ad esempio, se ExampleScreen è una destinazione in un grafo di navigazione, chiama hiltViewModel() per ottenere un'istanza di ExampleViewModel limitata alla destinazione, come mostrato nello snippet di codice seguente:

// import androidx.hilt.navigation.compose.hiltViewModel

@Composable
fun MyApp() {
    val navController = rememberNavController()
    val startRoute = "example"
    NavHost(navController, startDestination = startRoute) {
        composable("example") { backStackEntry ->
            // Creates a ViewModel from the current BackStackEntry
            // Available in the androidx.hilt:hilt-navigation-compose artifact
            val viewModel = hiltViewModel<MyViewModel>()
            MyScreen(viewModel)
        }
        /* ... */
    }
}
ComposeWithOtherLibraries.kt

Se invece devi recuperare l'istanza di un ViewModel limitata ai percorsi di navigazione o al grafo di navigazione, utilizza la funzione componibile hiltViewModel e passa il corrispondente backStackEntry come parametro:

// import androidx.hilt.navigation.compose.hiltViewModel
// import androidx.navigation.compose.getBackStackEntry

@Composable
fun MyApp() {
    val navController = rememberNavController()
    val startRoute = "example"
    val innerStartRoute = "exampleWithRoute"
    NavHost(navController, startDestination = startRoute) {
        navigation(startDestination = innerStartRoute, route = "Parent") {
            // ...
            composable("exampleWithRoute") { backStackEntry ->
                val parentEntry = remember(backStackEntry) {
                    navController.getBackStackEntry("Parent")
                }
                val parentViewModel = hiltViewModel<ParentViewModel>(parentEntry)
                ExampleWithRouteScreen(parentViewModel)
            }
        }
    }
}
ComposeWithOtherLibraries.kt

Paging

La libreria di Paginazione consente di caricare più facilmente i dati gradualmente ed è supportata in Componi. La pagina di release della paginazione contiene informazioni sulla dipendenza paging-compose aggiuntiva che deve essere aggiunta al progetto e alla relativa versione.

Ecco un esempio delle API Compose della libreria Paging:

@Composable
fun MyScreen(flow: Flow<PagingData<String>>) {
    val lazyPagingItems = flow.collectAsLazyPagingItems()
    LazyColumn {
        items(
            lazyPagingItems.itemCount,
            key = lazyPagingItems.itemKey { it }
        ) { index ->
            val item = lazyPagingItems[index]
            Text("Item is $item")
        }
    }
}
ComposeWithOtherLibraries.kt

Consulta la documentazione su elenchi e griglie per saperne di più sull'utilizzo della paginazione in Compose.

Maps

Puoi utilizzare la libreria Maps Compose per fornire Google Maps nella tua app. Ecco un esempio di utilizzo:

@Composable
fun MapsExample() {
    val singapore = LatLng(1.35, 103.87)
    val cameraPositionState = rememberCameraPositionState {
        position = CameraPosition.fromLatLngZoom(singapore, 10f)
    }
    GoogleMap(
        modifier = Modifier.fillMaxSize(),
        cameraPositionState = cameraPositionState
    ) {
        Marker(
            state = remember { MarkerState(position = singapore) },
            title = "Singapore",
            snippet = "Marker in Singapore"
        )
    }
}
ComposeWithOtherLibraries.kt